nicholas

SRM 424 div1 900 ProductOfPrices 翻译

Code
 price = x[i] * (sum(cnt, 1, x[i]-1) - sum(cnt, x[i]+1, L)) +
        sum(dst, x[i]+1, L) - sum(dst, 1, x[i]-1

Code
class ProductOfPrices {
public:
    int product(int, int, int, int, int);
};
int L;
int64 cnt[200001], dst[200001];
int64 x[200001];
void add(int64 a[], int64 i, int64 x)
{
    while (i <= L)
    {
        a[i] += x;
        i |= i-1;
        i++;
    }
}
int64 getSum(int64 a[], int64 i)
{
    int64 res = 0;
    while (i > 0)
    {
        res += a[i];
        i &=i-1;
    }
    return res;
}
int64 getSum(int64 a[], int64 i, int64 j)
{
    if (j >= i)
        return getSum(a, j) - getSum(a, i-1);
    else
        return 0;
}
int ProductOfPrices::product(int N, int l, int X0, int A, int B) 
{
    L = l;
    x[0] = X0%L;
    for (int i = 1; i < N; i++)
        x[i] = ((int64(x[i-1])*int64(A))+int64(B)) % int64(L);
    memset(cnt, 0, sizeof(cnt));
    memset(dst, 0, sizeof(dst));
    add(cnt, x[0]+1, 1);
    add(dst, x[0]+1, x[0]+1);
    int64 res = 1;
    for (int i = 1; i < N; i++)
    {
        int64 price = (x[i]+1) * getSum(cnt, 1, x[i]) - getSum(dst, 1, x[i])
                       + getSum(dst, x[i]+1, L) - getSum(cnt, x[i]+1, L) * (x[i]+1);
        price %= 1000000007;
        res = (res * price) % 1000000007;
        add(cnt, x[i]+1, 1);
        add(dst, x[i]+1, x[i]+1);
    }

    return (int)res;

..

Code
#include <iostream>
#include <memory.h>
using namespace std;
const int maxn = 310;
const int maxe = 2048;
const int QSIZE = 1000000;
const bool db = false;
#define INSERT(x,y,z) p[top].j=y,p[top].value=z,p[top].next=head[x],head[x]=top++

struct data
{
    int j, value, next;
};

struct queue
{
    int a[QSIZE], head, tail;
    queue():head(0), tail(0){}
    bool empty(){return head == tail;}
    void set_empty(){head=tail=0;}
    int front(){return a[head];};
    void pop(){head=(head+1)%QSIZE;};
    void push(int x){a[tail]=x;tail=(tail+1)%QSIZE;}
}Q;


data p[maxe];
int head[maxn], top;
int Count[maxn],  pre[maxn], E[maxn];
int f[maxn];
int V[maxn];
int n, m;


void ini()
{
    memset(head, -1, sizeof(head));
    top = 0;
}
int cnt = 0;


void Calc(int& a, int& b, int x)
{
    int cnt = 0;
    a=V[x];b=E[x];
    int tmp = pre[x];
    while (tmp != x)
        {
            cnt++;
            if (cnt > 200) break;
            a += V[tmp];
            b += E[tmp];
            tmp = pre[tmp];
        }
}

bool Bellman_ford(int& a, int& b)
{
    Q.set_empty();
    Q.push(0);
    memset(f, 63, sizeof(f));
    memset(pre, -1, sizeof(pre));
    memset(E, 0, sizeof(E));
    memset(Count, 0, sizeof(0));
    Count[0]=1;
    f[0]=0;
    while (!Q.empty())
    {
        int cur = Q.front();
        Q.pop();
        int i;
        for (i = head[cur]; i != -1; i = p[i].next)
        {
        
            int next = p[i].j;
            int next_f = f[cur] + a*p[i].value-b*V[next];
            if (next_f < f[next])
            {
                f[next] = next_f;
                
                E[next] = p[i].value;
                Count[next] = Count[cur]+1;
                Q.push(next);
                if (pre[next] == cur) 
                {
                    pre[next] = cur;
                    Calc(a,b,next);
                    return true;
                }
                pre[next] = cur;
            }
        }
    }
    return false;
}



int main()
{
    int i, j, k;

    //freopen("input.txt", "r", stdin);
    while (scanf("%d%d", &n, &m) == 2)
    {
        ini();
        for (i = 0; i < n; i++)
            scanf("%d", &V[i]);
        for (i = 0; i < m; i++)
        {
            int x, y, z;
            scanf("%d%d%d", &x, &y, &z);
            x--,y--;
            INSERT(x,y,z);
        }
        
        int a1 = 0, b1 = 1, a2 = 1, b2 = 0;
        int cnt = 0;

        while (a1!=a2 || b1!=b2)
        {
             int a = a1+a2, b = b1+b2;
             printf("%d/%d %d/%d\n", a1, b1, a2, b2);
             if (!Bellman_ford(a, b)) a2=a,b2=b;
             else
                 a1=a,b1=b;
        }
    
        printf("%d %d\n", a1, b1);
    }
    return 0;
}

emacs的c++mode

C/C++ 模式

指定为C++模式的方法：一般根据扩展名自动设定，不用指定，不过有时候你希望.h文件是C++模式的（缺省是C模式），

在文件第一行（或其末尾）上加入 

// -- C++ -- 

语法高亮：不是C模式专有，顺便提一下，M-x global-font-lock-mode RET 或在.emacs中加入(global-font-lock-mode t)。

在console下，Emacs21才支持语法高亮。（语法高亮，不同关键字用不同的颜色来突出） 

子模式： 

• auto-state 当你输入时自动缩进，自动换行 

• hungry-state 当你Backspace时，自动删除尽可能多的空白和空行 

• C-c C-t 同时转换(开/关)auto-state和hungry-state子模式 

• C-c C-a 转换 auto-state 子模式 

• C-c C-d 转换 hungry-state 子模式 

• C-c . 设置缩进风格（按TAB键可列出可用的风格，缺省的为gnu，其缩进为2个字符；linux为8个；k&r为5个...） 

• TAB 重新缩进当前行 

• M-/ 自动补齐（缓冲区中能找得到的串） 

• M-; 行尾加入注释 

• C-c C-e 扩展宏 

• C-c C-c 注释掉整个区域 

• C-c C-" 将区域中的每一行结尾都加入一个'"'字符 

编译和调试

• -x compile RET 编译 

• M-x gdb RET 调试 

• C-x ` （出错信息中）下一个错误，一个窗口显示错误信息，另一个显示源码的出错位置 

• C-c C-c 转到出错位置 

启动gdb调试器后，光标在源码文件缓冲区中时： 

• C-x SPC 在当前行设置断点 

• C-x C-a C-s step 

• C-x C-a C-n next 

• C-x C-a C-t tbreak 

• C-x C-a C-r continue 

contest

contest

我的2-sat模板

Code
/*
建立图2*i, 2*i+1是两个对立的
结果中如果color[j] = RED表示取该点
*/
#include <iostream>
#include <queue>
using namespace std;
const bool db = false;
const int MAXN = 2000+10;
const int MAXV = 4000000+10;
#define EMPTY -1
#define RED 0
#define BLUE 1
#define ADD(head, data, next, top, x, y) data[top]=y,next[top]=head[x],head[x]=top,top++
#define FOREACH(head, data, next, x, y) for (int _i=head[x];y=data[_i],_i>0;_i=next[_i])
#define MIN(x, y) x=x<y?x:y
#define CHANGE(x) x&1?x-1:x+1
struct stack{
    int top, data[MAXN];
    stack(){top=0;}
    void push(int x){data[top++]=x;}
    int pop(){return data[--top];}
}S;
int dfn[MAXN], low[MAXN], color[MAXN], color2[MAXN],cnt, mark,N,head[MAXN],data[MAXV], next[MAXV],top,nhead[MAXN];
int ndata[MAXV], nnext[MAXV],ntop,shead[MAXN],sdata[MAXN], snext[MAXN],stop,in_degree[MAXN],ncolor[MAXN];
int DFS(int x){
    dfn[x]=low[x]=mark++;int y;    S.push(x);
    FOREACH(head, data, next, x, y){if(dfn[y] == -1)DFS(y);
        if (color[y] == -1)    MIN(low[x], dfn[y]),MIN(low[x], low[y]);
    }
    if (dfn[x]==low[x])    {
        int tmp;do     tmp = S.pop(),color[tmp] = cnt;while (tmp != x);cnt++;                                                                    
    }return 1;
}
void Gabow(){
    memset(dfn, -1, sizeof(dfn));memset(color, -1, sizeof(color));
    cnt = 0,mark = 0;    for (int i = 0; (i<N&&dfn[i]==-1)&&DFS(i), i < N; i++);
}
void ColorToBlue(int x){
    int y;color2[x] = BLUE;    FOREACH(nhead, ndata, nnext, x, y)
    if (color2[y] == EMPTY)    ColorToBlue(y);
}
bool TwoSat(){
    Gabow();
    for (int i = 0; i+1 < N; i+=2)    if (color[i] == color[i+1]) return false;
    memset(in_degree, 0, sizeof(in_degree));memset(color2, EMPTY, sizeof(color2));
    stop = 1;memset(shead, -1, sizeof(shead));
    for (int i = 0; i < N; i++)    ADD(shead, sdata, snext, stop, color[i], i);
    ntop = 1;memset(nhead, -1, sizeof(nhead));
    for (int i = 0; i < N; i++)    {int x;
        FOREACH(head, data,next, i, x)    if (color[i] != color[x])
                ADD(nhead, ndata, nnext, ntop, color[x], color[i]),in_degree[color[i]]++;
    }queue<int> Q;
    for (int i = 0; i < cnt; i++)if (in_degree[i] == 0)    Q.push(i);
    while (!Q.empty()){int x = Q.front();Q.pop();
        if (color2[x] != EMPTY) continue;color2[x] = RED;int y;
        FOREACH(nhead, ndata, nnext, x, y){in_degree[y]--;    if (in_degree[y] == 0)Q.push(y);
        }int tmp;
        FOREACH(shead, sdata, snext, x, y) if (color2[ color[ tmp = CHANGE(y)] ] == EMPTY)
                ColorToBlue(color[ CHANGE(y) ]);
    }memset(color, RED, sizeof(color));
    for (int i = 0; i < cnt; i++)if (color2[i] == BLUE){int y;
            FOREACH(shead, sdata, snext, i, y)    color[y] = BLUE;}  return true;
}

Solution to GCJ Practice Contest Problem C, Cycles

GCJ Practice Contest Problem C:

In this problem, u r asked to calculate the number of all the Hamiltonian Circles in complete graph only with at most 15 forbidden edges.

We know, finding the Hamiltonian Circles is a NP problem, how can we count all the Hamiltonian Circles in a graph with so many edges?

First, let us think about this problem. Give u a complete graph with N vertexes , can u tell me how many Hamiltonian Circles exist in it?

We can easily find that number will be (N-1)! / 2.

And back to the original problem, we find that the forbidden edges are very small. So we come up with an idea, we can use the number of Hamiltonian Circles in a complete graph minus those circles using forbidden edges.

Code
#include <iostream>
#include <vector>
using namespace std;

const int MOD = 9901;
const bool DB = false;

struct Edge
{
  int s, t;
};

vector<int> edge[310];
Edge forb[16];
int N, K;
bool vis[310];
int fact[310];

int DFS(int now, int parent)
{
  for (int i = 0; i < edge[now].size(); ++i)
    if (!vis[ edge[now][i] ] && edge[now][i] != parent)
      {
    vis[ edge[now][i] ] = true;
    return DFS(edge[now][i], now) + 1;
      }
  return 1;
}

int Solve()
{

  memset(vis, false, sizeof(vis));

  for (int i = 0; i < N; i++)
    if (edge[i].size() > 2) return 0;

  int comp = 0;
  for (int i = 0; i < N; i++)
    if (edge[i].size() == 1 && !vis[i])
      {
    vis[i] = true;
    DFS(i, -1);
    ++comp;
      } 

  int zeros = 0;
  for (int i = 0; i < N; ++i)
    if (edge[i].size() == 0)
      ++zeros;

  for (int i = 0; i < N; ++i)
    {
      if (edge[i].size() == 2 && !vis[i])
    {
      int depth = 0;
      // vis[i] = true;
      depth = DFS(i, -1);
      if (DB) printf("depth = %d\n", depth);
      if (depth == N+1) return 1;
      else
        {
          if (DB) 
        printf("exit when i = %d\n", i);
          return 0;
        }
    }
    }
  if (DB)  
    printf("zeros = %d, comp = %d\n", zeros, comp);
  int totn = zeros + comp;
  if (comp) return fact[totn - 1] * (1LL << (comp-1)) % MOD;
  else
    return (fact[totn - 1] / 2) % MOD;
}

int main()
{
  int t;

  freopen("C-large-practice.in", "r", stdin);
  freopen("C-large_parctice.out", "w", stdout);
  fact[1] = 1;fact[0] = 1;
  for (int i = 2; i <= 301; i++)
    fact[i] = fact[i-1] * i % MOD;

  scanf("%d", &t);
  for (int ctr = 1; ctr <= t; ctr++)
    {

      scanf("%d%d", &N, &K);

      for (int i = 0; i < K; i++)
    {
      scanf("%d%d", &forb[i].s, &forb[i].t);
      forb[i].s--, forb[i].t--;
    }

      int ans = 0, ret;
      for (int i = 0; i < (1<<K); i++)
    {

      if (DB)
        printf("*****************\n");
      for (int j = 0; j < N; j++)
        edge[j].clear();

      int mult = 1;
      for (int j = 0; j < K; j++)
        if (i&(1<<j))
          edge[forb[j].s].push_back(forb[j].t), edge[forb[j].t].push_back(forb[j].s), mult *= -1;

      ret = Solve();
      if (DB)
        printf("with mask %d, ret = %d, mult = %d\n", i, ret, mult);
      
      ans = (ans + mult * ret) % MOD;
      if (DB)
        printf("ans = %d\n", ans);
    }

      printf("Case #%d: %d\n", ctr, ans < 0 ? ans + MOD : ans );
    }
  return 0;
}

约瑟夫问题的数学方法

我的模板

图的应用