usaco 4.1 Cryptcowgraphy 剪枝

 这道题目需要大量优化，要用到ELFhash字符串哈希，空间不能开太大，否则会很慢，但是在我的机器上试，空间不影响速度，有可能是因为usaco服务器的问题
总结一下错误的地方
1）下标错误：把c,o,w搞混了
2）边界错误：对于字符数组，需要判断0<=i && i < n，一般在有+-的时候容易出错，更一般的，加法和乘法注意溢出，减法注意负数，除法注意除数为0的情况

 

优化措施总结如下

1）字符串的字符个数应该等于（目标字符串的长度）+3*k。如果不满足就可直接判断无解。
2）除了COW三个字符外，其他的字符的个数应该和目标串相一致。如果不一致也可直接判断无解。前两项都可以在搜索前进行 .
3）搜索中间肯定会出现很多字符串相同的情况，因此需要开一个hash来判断是否搜索过，用ELFhash可以对字符串很好的处理 ，这里哈希数组大小为131071
4）一个有解的字符串中，COW三个字母最早出现的应该是C，最后出现的应该是W，如果不满足则剪枝。
5）当前字符串被COW分为几个子串，每个子串一定也是目标串的子串，如果不符合可立即剪枝， 也可以用hash来存储。
6）需要优化搜索顺序。先枚举O，并且W要逆序枚举

经过上述优化，程序对于极端数据也可以在1s以内出解。

 

以下是我的代码

1. #include <iostream>
2. #include <algorithm>
3. #include <string>
4. #include <map>
5. using namespace std;
7. /*
8. PROG: cryptcow
9. LANG: C++
10. ID: heben991
11. */
14. const int N = 80, M = 256, D = 80, hash_size = 131071;
15. // too large hash_size will be slow!!
16. char code[N] = "Begin the Escape execution at the Break of Dawn";
17. int len = strlen(code);
18. int code_cnt[M], str_cnt[M];
19. char s[D][N], ss[N], *p, ch, cow[5]="COW";
20. bool hash[hash_size], code_hash[hash_size];
22. int ELFhash(char *key)
23. {
24.     unsigned long h=0,g;
25.     while(*key)
26.     {
27.         h=(h<<4) + *key++;
28.         g=h & 0xF0000000L;
29.         if(g) h^= g>>24;
30.         h &= ~g;
31.     }
32.     return h % hash_size;
33. }
36. bool impossible(char *s, int n)
37. {
38.     int i=0, j, c, w;
39.     for(c = 0; c < n && s[c]!='C'; ++c);
40.     for(w = n-1; w >=0 && s[w]!='W'; --w);
41.     if(c < n && w >= 0 && c >= w)return true;
43.     strcpy(ss,s);
45.     p = strtok(ss,cow);
46.     while(p)
47.     {
48.         if(!code_hash[ELFhash(p)])return true;
49.         p = strtok(0,cow);
50.     }
51.     return false;
52. }
54. bool ok(int deep, int n)
55. {
56.     int i, t, c, o, w;
57.     if(strcmp(s[deep],code)==0)
58.     {
59.         return true;
60.     }
61.     if(n<=len)return false;
63.     t = ELFhash(s[deep]);
64.     if(!hash[t]) hash[t]=true;
65.     else return false;
67.     if(impossible(s[deep],n)) return false;
69.     s[deep+1][n-3] = 0;
70.     for(o = 1; o < n-1; ++o)
71.     if(s[deep][o]=='O')
72.     {
73.         for(c = 0; c < o; ++c)
74.         {
75.             if(c>0) s[deep+1][c-1] = s[deep][c-1];
77.             if(s[deep][c]=='C')
78.             for(w = n-1; w > o; --w)
79.             {
80.                 if(w<n-1 && w-2>=0) s[deep+1][w-2] = s[deep][w+1];
81.                 // hint: if(w<n-1 && w-2>=0)  w-2!!
83.                 if(s[deep][w]=='W')
84.                 {
85.                     t = c;
86.                     for(i = o+1; i < w; ++i) s[deep+1][t++] = s[deep][i];
87.                     for(i = c+1; i < o; ++i) s[deep+1][t++] = s[deep][i];
88.                     if( ok(deep+1,n-3) ) return true;
89.                 }
91.             }
92.         }
93.     }
95.     return false;
96. }
98. bool all_in_code(char *s, int n)
99. {
100.     int i, j;
101.     for(i = len-1; i >= 0; --i)
102.     {
103.         for(j = i+1; j <= len; ++j)
104.         {
105.             ch = code[j];
106.             code[j] = 0;
107.             code_hash[ELFhash(code+i)] = true;
108.             code[j] = ch;
109.         }
110.     }
112.     for(i = 0; i < n; ++i) str_cnt[s[i]]++;
113.     for(i = 0; i < len; ++i) code_cnt[code[i]]++;
114.     for(ch = 'A'; ch <= 'z'; ++ch)
115.         if(ch!='C' && ch!='O' && ch!='W' && code_cnt[ch]!=str_cnt[ch])
116.         {
117.             printf("%c %d %d/n", ch, code_cnt[ch],str_cnt[ch]);
118.             return 0;
119.         }
120.     return 1;
121. }
122. int main()
123. {
124.     int n;
126.     freopen("cryptcow.in", "r", stdin);
127.     freopen("cryptcow.out","w",stdout);
128.     gets(s[0]);
129.     n = strlen(s[0]);
130.     if( (n-len)%3==0 && all_in_code(s[0],n) && ok(0,n) )
131.     {
132.         int ans=0;
133.         for(p=s[0];*p;++p) if(*p=='C')++ans;
134.         printf("%d %d/n", 1,ans);
135.     }
136.     else puts("0 0");
137.     return 0;
138. }