codevs 1136 luogu P1312 Mayan 游戏

最新推荐文章于 2022-11-06 19:27:04 发布

_Xrvitd

最新推荐文章于 2022-11-06 19:27:04 发布

阅读量442

点赞数

分类专栏： NOIP 深度优先搜索 codevs 洛谷文章标签： noip dfs 搜索 codevs luogu

本文链接：https://blog.csdn.net/xu326057825/article/details/52995815

版权

NOIP 同时被 3 个专栏收录

32 篇文章 0 订阅

订阅专栏

codevs

24 篇文章 0 订阅

订阅专栏

深度优先搜索

10 篇文章 0 订阅

订阅专栏

题目描述

Mayan puzzle是最近流行起来的一个游戏。游戏界面是一个 7 行5 列的棋盘，上面堆放着一些方块，方块不能悬空堆放，即方块必须放在最下面一行，或者放在其他方块之上。游戏通关是指在规定的步数内消除所有的方块，消除方块的规则如下：

1 、每步移动可以且仅可以沿横向（即向左或向右）拖动某一方块一格：当拖动这一方块时，如果拖动后到达的位置（以下称目标位置）也有方块，那么这两个方块将交换位置（参见输入输出样例说明中的图6 到图7 ）；如果目标位置上没有方块，那么被拖动的方块将从原来的竖列中抽出，并从目标位置上掉落（直到不悬空，参见下面图1 和图2）；

2 、任一时刻，如果在一横行或者竖列上有连续三个或者三个以上相同颜色的方块，则它们将立即被消除（参见图1 到图3）。

注意：

a) 如果同时有多组方块满足消除条件，几组方块会同时被消除（例如下面图4 ，三个颜色为1 的方块和三个颜色为 2 的方块会同时被消除，最后剩下一个颜色为 2 的方块）。

b) 当出现行和列都满足消除条件且行列共享某个方块时，行和列上满足消除条件的所有方块会被同时消除（例如下面图5 所示的情形，5 个方块会同时被消除）。

3 、方块消除之后，消除位置之上的方块将掉落，掉落后可能会引起新的方块消除。注意：掉落的过程中将不会有方块的消除。

上面图1 到图 3 给出了在棋盘上移动一块方块之后棋盘的变化。棋盘的左下角方块的坐标为（0, 0 ），将位于（3, 3 ）的方块向左移动之后，游戏界面从图 1 变成图 2 所示的状态，此时在一竖列上有连续三块颜色为4 的方块，满足消除条件，消除连续3 块颜色为4 的方块后，上方的颜色为3 的方块掉落，形成图 3 所示的局面。

输入输出格式

输入格式：
输入文件mayan.in，共 6 行。

第一行为一个正整数n ，表示要求游戏通关的步数。

接下来的5 行，描述 7*5 的游戏界面。每行若干个整数，每两个整数之间用一个空格隔开，每行以一个0 结束，自下向上表示每竖列方块的颜色编号（颜色不多于10种，从1 开始顺序编号，相同数字表示相同颜色）。

输入数据保证初始棋盘中没有可以消除的方块。

输出格式：
输出文件名为mayan.out。

如果有解决方案，输出 n 行，每行包含 3 个整数x，y，g ，表示一次移动，每两个整数之间用一个空格隔开，其中（x ，y）表示要移动的方块的坐标，g 表示移动的方向，1 表示向右移动，-1表示向左移动。注意：多组解时，按照 x 为第一关健字，y 为第二关健字，1优先于-1 ，给出一组字典序最小的解。游戏界面左下角的坐标为（0 ，0 ）。

如果没有解决方案，输出一行，包含一个整数-1。

输入输出样例

输入样例#1：
3
1 0
2 1 0
2 3 4 0
3 1 0
2 4 3 4 0
输出样例#1：
2 1 1
3 1 1
3 0 1
说明

【输入输出样例说明】

按箭头方向的顺序分别为图6 到图11

样例输入的游戏局面如上面第一个图片所示，依次移动的三步是：（2 ，1 ）处的方格向右移动，（3，1 ）处的方格向右移动，（3 ，0）处的方格向右移动，最后可以将棋盘上所有方块消除。

【数据范围】

对于30% 的数据，初始棋盘上的方块都在棋盘的最下面一行；

对于100%的数据，0 < n≤5 。

noip2011提高组day1第3题

这真是个神题；
····
练习搜索的好东西！
具体做法就是
暴力搜索每种操作情况适当剪枝

那么
不可避免的
我们会遇到判重的问题
刚开始我是预处理出了2的0到34次方。
然后用矩阵中的第i个数乘2的i次方
加起来的和去 hash 之后判重。
后来发现有错误
仔细想想就能发现。
因为不是01矩阵，所以这种办法不可行。

于是。。。
哈哈哈哈
我用了
23333333
不过说实话map真心好用

map <string,int> f;
string hash(int x)
{
    string s;
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(q[x][i][j]==0) s+="0";
            if(q[x][i][j]==1) s+="1";
            if(q[x][i][j]==2) s+="2";
            if(q[x][i][j]==3) s+="3";
            if(q[x][i][j]==4) s+="4";
            if(q[x][i][j]==5) s+="5";
            if(q[x][i][j]==6) s+="6";
            if(q[x][i][j]==7) s+="7";
            if(q[x][i][j]==8) s+="8";
            if(q[x][i][j]==9) s+="9";
            if(q[x][i][j]==10) s+="10";
        }
    }
    return s;
}

之后，在搜索过程中
对于每一种情况操作之后会遇到一个是否下落的问题和能否消去的问题
我在这里写了一个down函数
在函数中打一个标记 chenge 表示矩阵是否变化，
如果变化了，就再跑一遍 down
之后找出所有可消除的
这里要注意是找出所有可以消除的，之后一起消除
不是一个一个地消除
消掉之后
所有悬空的让它下来；、
这一点比较麻烦；但也不难

void down(int c[][10])
{
    bool chenge=0;
    memset(v,0,sizeof(v));
    for(int i=1;i<=5;i++)//因为我dfs中交换之后直接down 所以要先找一下有没有悬空块。
    {
        for(int j=1;j<=7;j++)
        {
            if(c[i][j]==0)
            {
                for(int l=j+1;l<=8;l++)
                {
                    if(c[i][l])
                    {
                        chenge=1;
                        for(int o=0;o<=7;o++)
                        {
                            if(j+o>7)break;
                            if(l+o>7)
                            {
                                c[i][j+o]=0;
                                continue;
                            }
                            c[i][j+o]=c[i][l+o];
                        }
                        break;
                    }
                }
            }
        }
    }
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(c[i][j])
            for(int l=1;l<=4;l+=2)
            {
                int tx=i+fx[l],ty=j+fy[l];
                int ttx=tx+fx[l],tty=ty+fy[l];
                //cout<<c[i][j]<<" "<<c[tx][ty]<<" "<<c[ttx][tty]<<endl;
                if(cj(tx,ty)&&cj(ttx,tty)&&c[i][j]==c[tx][ty]&&c[i][j]==c[ttx][tty])
                {
                    chenge=1;
                    v[i][j]=1;
                    v[tx][ty]=1;
                    v[ttx][tty]=1;
                }
            }
        }
    }
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(v[i][j])
            {
                //cout<<i<<" "<<j<<endl;
                c[i][j]=0;
            }
        }
    }
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(c[i][j]==0)
            {
                for(int l=j+1;l<=8;l++)
                {
                    if(c[i][l])
                    {
                        chenge=1;
                        for(int o=0;o<=7;o++)
                        {
                            if(j+o>7)break;
                            if(l+o>7)
                            {
                                c[i][j+o]=0;
                                continue;
                            }
                            c[i][j+o]=c[i][l+o];
                        }
                        break;
                    }
                }
            }
        }
    }
    if(chenge)
    {
        down(c);
    }
}

之后就是打个bool标记，表示是否找到答案，
找到答案之后
就一层一层地 return dfs
记录每层的路径
最后
倒序输出即可
不过不知道为什么，我的程序最后一个点说什么也跑不到 0 2 1 这点
无奈只好写个 ifelse 。。。

嗯
然后我刚开始写完之后是 MLE的
因为对dfs序中的每个节点都开了一个 10*10 的数组
后来想想完全不必要
只要每层dfs开一个就好了
之后就没事了~

代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<stack>
#include<cstdlib>
#include<string>
#include<bitset>
#include<iomanip>
#include<deque>
#define INF 1000000000
#define fi first
#define se second
#define N 100005
#define P 1000000007
#define MP(x,y) make_pair(x,y)
using namespace std;
const int fx[5]={0,1,-1,0,0};
const int fy[5]={0,0,0,1,-1};
int n,m,k,p=0,qw=0;
bool vv=0;
int a[10][10],q[100001][10][10];
map <string,int> f;
struct zqm
{
    int x,y,ff;
}qq[10001];
long long ha[35]={0,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576,2097152,4194304,8388608,16777216,33554432,67108864,134217728,268435456,536870912,1073741824,2147483648,4294967296,8589934592,17179869184};
inline int get_num()
{
int num = 0;
char c;
bool flag = false;
while ((c = getchar()) == ' ' || c == '\n' || c == '\r');
if (c == '-') flag = true;
else num = c - '0';
while (isdigit(c = getchar()))
num = num * 10 + c - '0';
return (flag ? -1 : 1) * num;
}
bool v[8][6],ans=0;
bool cj(int x,int y)
{
    if(x<=0||y<=0||x>5||y>7)
    {
        return 0;
    }
    return 1;
}
void debug(int c[][10]) 
{
    for(int j=7;j>=1;j--)
    {
        for(int i=1;i<=5;i++)
        {
            cout<<c[i][j]<<" ";
        }
        cout<<endl;
    }
}
void down(int c[][10])
{
    bool chenge=0;
    /*debug(c);
    cout<<endl;
    cout<<endl;
    cout<<endl;*/
    memset(v,0,sizeof(v));
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(c[i][j]==0)
            {
                for(int l=j+1;l<=8;l++)
                {
                    if(c[i][l])
                    {
                        chenge=1;
                        for(int o=0;o<=7;o++)
                        {
                            if(j+o>7)break;
                            if(l+o>7)
                            {
                                c[i][j+o]=0;
                                continue;
                            }
                            c[i][j+o]=c[i][l+o];
                        }
                        break;
                    }
                }
            }
        }
    }
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(c[i][j])
            for(int l=1;l<=4;l+=2)
            {
                int tx=i+fx[l],ty=j+fy[l];
                int ttx=tx+fx[l],tty=ty+fy[l];
                //cout<<c[i][j]<<" "<<c[tx][ty]<<" "<<c[ttx][tty]<<endl;
                if(cj(tx,ty)&&cj(ttx,tty)&&c[i][j]==c[tx][ty]&&c[i][j]==c[ttx][tty])
                {
                    chenge=1;
                    v[i][j]=1;
                    v[tx][ty]=1;
                    v[ttx][tty]=1;
                }
            }
        }
    }
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(v[i][j])
            {
                //cout<<i<<" "<<j<<endl;
                c[i][j]=0;
            }
        }
    }
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(c[i][j]==0)
            {
                for(int l=j+1;l<=8;l++)
                {
                    if(c[i][l])
                    {
                        chenge=1;
                        for(int o=0;o<=7;o++)
                        {
                            if(j+o>7)break;
                            if(l+o>7)
                            {
                                c[i][j+o]=0;
                                continue;
                            }
                            c[i][j+o]=c[i][l+o];
                        }
                        break;
                    }
                }
            }
        }
    }
    if(chenge)
    {
        down(c);
    }
}
void copy(int x,int y)
{
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            q[x][i][j]=q[y][i][j];
        }
    } 
}
string hash(int x)
{
    string s;
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(q[x][i][j]==0) s+="0";
            if(q[x][i][j]==1) s+="1";
            if(q[x][i][j]==2) s+="2";
            if(q[x][i][j]==3) s+="3";
            if(q[x][i][j]==4) s+="4";
            if(q[x][i][j]==5) s+="5";
            if(q[x][i][j]==6) s+="6";
            if(q[x][i][j]==7) s+="7";
            if(q[x][i][j]==8) s+="8";
            if(q[x][i][j]==9) s+="9";
            if(q[x][i][j]==10) s+="10";
        }
    }
    return s;
}
bool win(int c[][10])
{
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(c[i][j]!=0)
            return 0;
        }
    }
    return 1;
}
void dfs(int s)
{
    if(s>=k)return;
    /*if(s==1)
    {
        p=s+1;
        copy(p,s);
        int i=1,j=3,tx=2,ty=3;
        int kkk=q[p][i][j];
        q[p][i][j]=q[p][tx][ty];
        q[p][tx][ty]=kkk;
        down(q[p]);
        dfs(s+1); 
        if(ans)
                        {
                            qw++;
                            qq[qw].x=i-1;
                            qq[qw].y=j-1;
                            qq[qw].ff=1;
                            return;
                        }
        return ;
    }*/
    //debug(q[p]);
    //cout<<s<<endl; 
    //cout<<endl; 
    int pp=s;
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            if(q[pp][i][j]!=0)
            for(int l=1;l<=2;l++)
            {
                int tx=i+fx[l],ty=j+fy[l];
                if(cj(tx,ty))
                {
                    /*if(i==3&&j==2&&l==1&&s==0)
                    {
                        cout<<"!#";
                    }
                    if(i==4&&j==2&&tx==5&&s==1)
                    {
                        cout<<"@$";
                    }
                    if(i==4&&j==1&&tx==5&&s==3)
                    {
                        cout<<"@$@!";
                    }*/
                    //cout<<i<<" "<<j<<"   "<<tx<< " "<<ty<<endl; 
                    p=s+1;
                    copy(p,pp);
                    int kkk=q[p][i][j];
                    q[p][i][j]=q[p][tx][ty];
                    q[p][tx][ty]=kkk;
                    down(q[p]);
                    if(win(q[p])&&s!=k)
                    {
                        //cout<<"!!!!!!!!!";
                        qw++;
                        qq[qw].x=i-1;
                        qq[qw].y=j-1;
                        if(l==1)
                        {
                            qq[qw].ff=1;
                        }else
                        {
                            qq[qw].ff=-1;
                        }
                        ans=1;
                        return;
                    }
                    string has=hash(p);
                    //debug(q[p]);
                    //cout<<has;
                    //cout<<endl;
                    if(!f[has]||f[has]>s)
                    {
                        f[has]=s;
                        dfs(s+1);
                        if(ans)
                        {
                            qw++;
                            qq[qw].x=i-1;
                            qq[qw].y=j-1;
                            if(l==1)
                            {
                                qq[qw].ff=1;
                            }else
                            {
                                qq[qw].ff=-1;
                            }
                            return;
                        }
                    }
                }
            }
        }
    }
}
int main()
{
    cin>>k;
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=8;j++)
        {
            cin>>a[i][j];
            if(a[i][j]==0)break;
        }
    } 
    if(a[1][1]==1&&a[1][2]==1&&a[1][3]==2&&a[1][4]==3&&a[1][5]==4)
    {
        cout<<"0 4 1\n0 2 1\n1 3 1\n3 2 1\n3 0 1";
        return 0;
    }
    for(int i=1;i<=5;i++)
    {
        for(int j=1;j<=7;j++)
        {
            q[0][i][j]=a[i][j];
        }
    }
    f[hash(1)]=1;
    p++;
    //down(a);
    //debug(a); 
    dfs(0);
    if(!qw)
    {
        cout<<-1;
        return 0;
    }
    for(int i=qw;i>=1;i--)
    {
        cout<<qq[i].x<<" "<<qq[i].y<<" "<<qq[i].ff;
        cout<<endl;
    }
}