洛古 P1312 Mayan游戏（dfs+剪枝）

题目链接

这道题和俄罗斯方块很像

很明显，我们可以看出这是一个dfs，但是，我们需要几条剪枝：

1.如果只剩下1个或2个同样颜色的方块，那么直接退出

2.相同的块不用交换

3.注意优先性，优先左边换右边

但是这题就这么样就完了吗

显然，并没有这么简单：剪枝清楚了，你确定就能写出来吗（这是我写过最长的dfs）

接下来讲一下我的程序架构：

init函数：输入，存储数据

fall函数：模拟方块下落

printans函数：输出答案

clear函数：清除棋盘

isempty函数：判断是否为空

judge函数：剪枝1

dfs函数：搜索

下面是代码，看不懂上面的话，代码里也有注释

 #include <bits/stdc++.h>
 using namespace std;

 const int N = ;
 const int M = ;

 int maxstep, chess[N][M];
 int cnt[];
 int answer[][];

 void init()
 {
     cin>>maxstep;
     for(int i=; i<N; i++)
     {
         int j=,x;
         cin>>x;
         while(x!=)
         {
             chess[i][j]=x;
             j++;
             cin>>x;
         }
     }
 }

 void fall()    //清除后方块下落
 {
     for(int i=; i<N; i++)
         for(int j=; j<M; j++)
         {
             if(chess[i][j]!=)
                 continue;
             int k;
             for(k=j+; k<M; k++)
                 if(chess[i][k]!=)
                 {
                     swap(chess[i][j],chess[i][k]);
                     break;
                 }
             if(k==M)
                 break;
         }
 }

 void printans()     //输出
 {
     for(int i=; i<maxstep; i++)
         printf("%d %d %d\n",answer[i][],answer[i][],answer[i][]);
     return;
 }

 bool clear()        //清除棋盘
 {
     bool empty[N][M];
     memset(empty,false,sizeof(empty));
     for(int i=; i<N-; i++)
         for(int j=; j<M; j++)
             if(chess[i][j]!= && chess[i][j]==chess[i+][j]
                 && chess[i+][j]==chess[i+][j]) {
                     empty[i][j]=empty[i+][j]=empty[i+][j]=true;
                 }

     for(int i=; i<N; i++)
         for(int j=; j<M-; j++)
             if(chess[i][j]!= && chess[i][j]==chess[i][j+]
                 && chess[i][j+]==chess[i][j+]) {
                     empty[i][j]=empty[i][j+]=empty[i][j+]=true;
                 }

     bool res=false;
     for(int i=; i<N; i++)
         for(int j=; j<M; j++)
             if(empty[i][j])
             {
                 chess[i][j]=;
                 res=true;
             }
     return res;
 }

 bool isempty()      // 判断棋盘是否为空
 {
     for(int i=; i<N; i++)
         for(int j=; j<M; j++)
             if(chess[i][j]!=)
                 return false;
     return true;
 }

 bool judge()        //判断是否有一种颜色的块数量为1或2
 {
     memset(cnt,,sizeof(cnt));
     for(int i=; i<N; i++)
         for(int j=; j<M; j++)
             cnt[chess[i][j]]++;
     for(int i=; i<=; i++)
         if(cnt[i]==||cnt[i]==)
             return false;
     return true;
 }

 bool dfs(int step)      //搜索
 {
     if(isempty())       //发现一组解
     {
         printans();
         return true;
     }
     if(step>=maxstep || !judge())     //剪枝与结束条件
         return false; 

     int now[N][M];      // 记录当前状态，回溯时候用
     for(int i=; i<N; i++)      //复制棋盘
         for(int j=; j<M; j++)
             now[i][j]=chess[i][j];

     for(int i=; i<N; i++)
         for(int j=; j<M; j++)      //枚举每一个方块
         {
             //右移
             if(i!=N- && chess[i][j]!= && chess[i][j]!=chess[i+][j])
             {
                 swap(chess[i][j], chess[i+][j]);
                 answer[step][]=i;
                 answer[step][]=j;
                 answer[step][]=;
                 fall();
                 while(clear())
                     fall();
                 if(dfs(step+))
                     return true;
             }

             for(int k1=; k1<N; k1++)
                 for(int k2=; k2<M; k2++)
                     chess[k1][k2]=now[k1][k2];

             //左移
             if(i!= && chess[i][j]!= && chess[i-][j]==)
             {
                 swap(chess[i][j], chess[i-][j]);
                 answer[step][]=i;
                 answer[step][]=j;
                 answer[step][]=-;
                 fall();
                 while(clear())
                     fall();
                 if(dfs(step+))
                     return true;
             }

             for(int k1=; k1<N; k1++)
                 for(int k2=; k2<M; k2++)
                     chess[k1][k2]=now[k1][k2];
         }
     return false;
 }

 /*
 搜索+剪枝
 剪枝原则：
 1，交换两个相同颜色的块没有意义。
 2，如果一种颜色的块数量为1或2，则当前局面无解。
 3，因为要求字典序最小的解，所以一个块仅当左边为空时尝试左移
 （若左面有方块，那么在搜i-1列时将其右移，和在i列时左移是等效的，故可以剪枝）
 */
 int main()
 {
     ios::sync_with_stdio(false);
     cin.tie();

     init();
     if(!dfs())
         cout<<-<<endl;
     return ;
 }

补充：说到俄罗斯方块，我又想起来USACO的这道题，有兴趣的同学可以去做做