SRM 471

    下载了个KawigiEdit，挺好用的，虽然我还不大会用，那个G++的的路径不知道指向哪才行。

    茫茫长的头文件，略去略去。

    250p :

　 直接开一个10^7的 int 数组和 bool 数组来进行素数判定，然后从后面开始扫，若 >= D则可以跳出来

const int maxn = 10000001;

 bool nums[maxn];
int prime[maxn];

void init()
{
    int i , j;
    int pl = 0;
    nums[0] = 1 , nums[1] = 1;
    memset(prime , true , sizeof(prime));
    for(i = 2; i < maxn; i ++) {
        if(!nums[i]) 
            prime[pl ++] = i;
        for(j = 0; j < pl && i * prime[j] < maxn; j++) 
        {
            nums[i * prime[j]] = 1;
            if(!( i % prime[j] ) )
                break;
        }
    }
}

class PrimeSequences {
public:
    int getLargestGenerator(int N, int D) 
    {
        init();
        for(int i=N; i >= 2; i--) {
            int len = 0, ans = i;
            while( !nums[ans] ) {
                len ++;
                ans >>= 1;
            }
            if(len >= D)
                return i;
        }
        return -1;
    }
};

    500p：

    一开始开了一个hash[ 25 ][ 1 << 13 ]的数组进行判重，硬是过不了case 94 , 原因是，同个state的点有可能由不同的模13值所得来，若此时由于该点所存的路径长度较长而被删除，就会导致删除可行解，因为最小值并非可行解。所以要开成hash[ 25 ][1 << 13][13]进行判重。

    其中1 << 13的目的是记录sum值在模13后的值，如果重叠，则表示这个路径上有连续的点使得 mod 13 == 0 (鸽巢原理)

const int inf  = 19999999;
struct node { int v , w , state; } ;

queue< node > que;
int path[26][26], row , clo;
int hash[26][1 << 13][13];

class ThirteenHard {
public:
    int solve() 
    {
        for(int i=0; i < row; i++)
            for(int j=0; j < (1 << 13); j++)
                for(int k=0; k < 13; k++)
                    hash[i][j][k] = inf ;
        node tt , nn;
        tt.v = tt.w = tt.state = 0;
        que.push(tt);
        while(!que.empty()) 
        {
            tt = que.front(); que.pop();
            int u = tt.v , w = tt.w , state = tt.state;
            for(int i=0; i < row; i++)
            { 
                if(path[u][i]) 
                {
                    nn.v = i;
                    nn.w = w + path[u][i];
                    if(nn.w % 13 == 0 || ((1 << (nn.w % 13)) & state))
                        continue;
                    nn.state = state + (1 << (nn.w % 13));
                    int k = nn.w % 13;
                    if(hash[nn.v][nn.state][k] > nn.w) 
                    {
                        hash[nn.v][nn.state][k] = nn.w;
                        que.push(nn);
                    }
                }
            }
        }
        int ans = inf;
        for(int i=0; i < (1 << 13); i++)
            for(int j=0; j < 13; j++)
                ans = min(hash[row - 1][i][j] , ans);
        if(ans == inf) 
            return -1;
        return ans;
    }

    int getc(char c) 
    {
        if(c >= 'A' && c <= 'Z')
            return c - 'A' + 1;
        if(c >= 'a' && c <= 'z')
            return c - 'a' + 27;
        return 0;
    }

    int calcTime(vector <string> city) 
    {
        row = city.size() ;
        clo = city[0].size();
        for(int i=0; i < row; i++)
            for(int j=0;  j < clo; j++)
                path[i][j] = getc( city[i][j] );
        return solve();
    }
};