HDU - 4431 Mahjong (模拟+搜索+哈希+中途相遇)

题目链接

基本思路：最理想的方法是预处理处所有胡牌的状态的哈希值，然后对于每组输入，枚举每种新加入的牌，然后用哈希检验是否满足胡牌的条件。然而不幸的是，由于胡牌的状态数过多（4个眼+一对将），预处理的复杂度太高（$O(34^5)$），因此需要想办法优化一下。

我们可以预处理出所有“加上一对将之后可以胡牌”的状态，这样预处理的复杂度就成了$O(34^4)$，在可接受的范围内了。在检验的时候，只需要枚举去掉哪一对将，就可以$O(1)$检验是否能胡牌了（有种中途相遇的感觉），另外两种特殊情况单独判断即可。

玄学优化方法：

1.在dfs和枚举检验的时候动态维护哈希值，而不是每次重复计算，这样可以节省很大一部分计算哈希值的时间。

2.dfs的时候，每一层的初始下标都不小于上一层，这样可以避免很多重复状态。

3.用哈希表代替set，可以大幅缩短存取哈希值的时间。

4.预处理处所有不少于2张的牌，这样就不用每次枚举的时候都从头开始找了。

综上，总复杂度约为$O(34^4+20000*34*7)$，应该接近极限了吧。

其实这道题也没这么复杂，直接枚举将暴力吃碰就行了，但为了锻炼自己搜索的玄学优化能力还是选择了扬长避短o(￣▽￣)ｄ

 #include<bits/stdc++.h>
 using namespace std;
 typedef unsigned long long ll;
 const int N=+,inf=0x3f3f3f3f,M=;
 const char* s="mspc";
 int id[],a[][N];
 ll p[][N],pm[],h;
 struct D {int x,y;};
 vector<D> vec,vv;
 struct Hashset {
     static const int N=4e5,M=1e6+;
     int hd[M],nxt[N],tot;
     ll p[N];
     void clear() {memset(hd,-,sizeof hd),tot=;}
     void insert(ll x) {
         int u=x%M;
         for(int i=hd[u]; ~i; i=nxt[i])if(p[i]==x)return;
         p[tot]=x,nxt[tot]=hd[u],hd[u]=tot++;
     }
     int count(ll x) {
         int u=x%M;
         for(int i=hd[u]; ~i; i=nxt[i])if(p[i]==x)return ;
         return ;
     }
 } st;
 void dfs(int dep,int x,int y) {
     if(st.count(h))return;
     if(dep==) {st.insert(h); return;}
     for(int i=x; i<=; ++i)
         for(int j=(i==x?y:); j<=(i==?:); ++j) {
             if(a[i][j]<=) {
                 a[i][j]+=,h+=*p[i][j];
                 dfs(dep+,i,j);
                 a[i][j]-=,h-=*p[i][j];
             }
             if(j<=&&i!=&&a[i][j]<=&&a[i][j+]<=&&a[i][j+]<=) {
                 a[i][j]++,a[i][j+]++,a[i][j+]++,h+=p[i][j]+p[i][j+]+p[i][j+];
                 dfs(dep+,i,j);
                 a[i][j]--,a[i][j+]--,a[i][j+]--,h-=p[i][j]+p[i][j+]+p[i][j+];
             }
         }
 }
 bool Chii() {
     for(int i=; i<=; ++i)
         for(int j=; j<=(i==?:); ++j)if(a[i][j]&&a[i][j]!=)return ;
     return ;
 }
 bool Kokushi() {
     for(int i=; i<=; ++i)
         for(int j=; j<=(i==?:); ++j) {
             if((i!=&&(j==||j==))||(i==)) {if(!a[i][j])return ;}
             else if(a[i][j])return ;
         }
     return ;
 }
 bool Hu() {
     for(D t:vv)if(st.count(h-*p[t.x][t.y]))return ;
     return ;
 }
 bool ok() {return Chii()||Kokushi()||Hu();}
 int main() {
     st.clear();
     id['m']=,id['s']=,id['p']=,id['c']=;
     pm[]=;
     for(int i=; i<; ++i)pm[i]=pm[i-]*M;
     for(int i=,k=; i<=; ++i)
         for(int j=; j<=(i==?:); ++j,--k)p[i][j]=pm[k];
     dfs(,,);
     int T;
     for(scanf("%d",&T); T--;) {
         memset(a,,sizeof a),h=;
         for(int i=; i<; ++i) {
             int x;
             char ch;
             scanf("%d%c",&x,&ch);
             a[id[ch]][x]++,h+=p[id[ch]][x];
         }
         vec.clear(),vv.clear();
         for(int i=; i<=; ++i)
             for(int j=; j<=(i==?:); ++j)if(a[i][j]>=)vv.push_back({i,j});
         for(int x=; x<=; ++x)
             for(int y=; y<=(x==?:); ++y)if(a[x][y]<=) {
                     a[x][y]++,h+=p[x][y];
                     if(a[x][y]==)vv.push_back({x,y});
                     if(ok())vec.push_back({x,y});
                     if(a[x][y]==)vv.pop_back();
                     a[x][y]--,h-=p[x][y];
                 }
         if(vec.size()) {
             printf("%d",vec.size());
             for(D t:vec)printf(" %d%c",t.y,s[t.x]);
             puts("");
         } else puts("Nooten");
     }
     return ;
 }

还有一种极限优化的方法，因为不同花色的牌是可以独立考虑的，因此单独判断出每种花色的牌是否合法（全为3或者111），如果能胡的话，则必然有三种花色合法，一种花色不合法，其中不合法的一组必然有一对将，枚举这对将，然后判断剩下的牌是否合法即可。

 #include<bits/stdc++.h>
 using namespace std;
 typedef unsigned long long ll;
 const int N=+,inf=0x3f3f3f3f,M=;
 const char* s="mspc";
 int id[],a[][N],c[N];
 ll pm[],h[],hh;
 struct D {int x,y;};
 vector<D> vec;
 struct Hashset {
     static const int N=4e5,M=1e6+;
     int hd[M],nxt[N],tot;
     ll p[N];
     void clear() {memset(hd,-,sizeof hd),tot=;}
     void insert(ll x) {
         int u=x%M;
         for(int i=hd[u]; ~i; i=nxt[i])if(p[i]==x)return;
         p[tot]=x,nxt[tot]=hd[u],hd[u]=tot++;
     }
     int count(ll x) {
         int u=x%M;
         for(int i=hd[u]; ~i; i=nxt[i])if(p[i]==x)return ;
         return ;
     }
 } st1,st2;
 void dfs1(int dep,int u) {
     st1.insert(hh);
     if(dep==)return;
     for(int i=u; i<=; ++i) {
         if(c[i]<=) {
             c[i]+=,hh+=*pm[i];
             dfs1(dep+,i);
             c[i]-=,hh-=*pm[i];
         }
         if(c[i]<=&&c[i+]<=&&c[i+]<=) {
             c[i]++,c[i+]++,c[i+]++,hh+=pm[i]+pm[i+]+pm[i+];
             dfs1(dep+,i);
             c[i]--,c[i+]--,c[i+]--,hh-=pm[i]+pm[i+]+pm[i+];
         }
     }
 }
 void dfs2(int dep,int u) {
     st2.insert(hh);
     if(dep==)return;
     for(int i=u; i<=; ++i)if(c[i]<=) {
             c[i]+=,hh+=*pm[i];
             dfs2(dep+,i);
             c[i]-=,hh-=*pm[i];
         }
 }
 bool Chii() {
     for(int i=; i<=; ++i)
         for(int j=; j<=(i==?:); ++j)if(a[i][j]&&a[i][j]!=)return ;
     return ;
 }
 bool Kokushi() {
     for(int i=; i<=; ++i)
         for(int j=; j<=(i==?:); ++j) {
             if((i!=&&(j==||j==))||(i==)) {if(!a[i][j])return ;}
             else if(a[i][j])return ;
         }
     return ;
 }
 bool Hu() {
     int x=-;
     for(int i=; i<; ++i)if(!st1.count(h[i])) {
             if(~x)return ;
             x=i;
         }
     if(!st2.count(h[])) {
         if(~x)return ;
         x=;
     }
     if(x!=) {for(int i=; i<=; ++i)if(a[x][i]>=&&st1.count(h[x]-*pm[i]))return ;}
     else {for(int i=; i<=; ++i)if(a[x][i]>=&&st2.count(h[]-*pm[i]))return ;}
     return ;
 }
 bool ok() {return Chii()||Kokushi()||Hu();}
 int main() {
     st1.clear(),st2.clear();
     pm[]=;
     for(int i=; i<; ++i)pm[i]=pm[i-]*M;
     id['m']=,id['s']=,id['p']=,id['c']=;
     dfs1(,),dfs2(,);
     int T;
     for(scanf("%d",&T); T--;) {
         memset(a,,sizeof a);
         memset(h,,sizeof h);
         for(int i=; i<; ++i) {
             int x;
             char ch;
             scanf("%d%c",&x,&ch);
             a[id[ch]][x]++,h[id[ch]]+=pm[x];
         }
         vec.clear();
         for(int x=; x<=; ++x)
             for(int y=; y<=(x==?:); ++y)if(a[x][y]<=) {
                     a[x][y]++,h[x]+=pm[y];
                     if(ok())vec.push_back({x,y});
                     a[x][y]--,h[x]-=pm[y];
                 }
         if(vec.size()) {
             printf("%d",vec.size());
             for(D t:vec)printf(" %d%c",t.y,s[t.x]);
             puts("");
         } else puts("Nooten");
     }
     return ;
 }