[NOIP2011] 玛雅游戏

问题 A: [NOIP2011] 玛雅游戏

时间限制: 3 Sec  内存限制: 128 MB
提交: 73  解决: 25
[提交][状态][讨论版]

题目描述

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 开始顺序编号，相同数字表示相同颜色）。
输入数据保证初始棋盘中没有可以消除的方块。

输出

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

样例输入

31 02 1 02 3 4 03 1 02 4 3 4 0

样例输出

2 1 13 1 13 0 1

提示

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

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

【数据范围】

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

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

玛雅游戏：

算法分析:dfs

1.主函数:读入数据,并判断dfs中是否找到解,没找到输出-1。

2.dfs:对7?5中每个非0的点按照x从小到大,y从小到大，先右后左进行枚举，注意右边界点不能向右，左边界点不能向左，枚举时调用move函数并记录相应操作；每次枚举前要把原来的矩阵copy一份，便于回溯；当超过n时，判断是否为空，如果为空就输出记录的操作。

3.move:首先是交换两个变量的位置，调用时用一个记号记录是向左还是向右。然后调用fall函数、wipe函数（消块）。注意，如果wipe函数生效，则要对所有点重新调用fall函数和wipe函数，直到wipe函数中没有消掉任何块。

4.fall:判断该点下方是否有0，如果有0就向下移，反之则无。

5.wipe:按横和纵两种情况，判断是否是超过3个同样的颜色连接在一起，如果有就标记它们为true。需要注意，等所有点都判断完再消去，防止一个点被用两次的情况。

爆爆

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

#include<iostream>

#include<cmath>

#include<cstring>

#include<cstdio>

#include<set>

#include<deque>

#include<cstdlib>

#include<algorithm>

#define V 500005

#define LL long long

usingnamespacestd;

intn,mod;

intyu;

ints[5][7],sd[25];

intt[100][10],st;

intsx,sy,sf;

inlineintcheck()

{

  for(inti=0;i<=4;i++)

   for(intj=0;j<=6;j++)

   if(s[i][j])

   {

    return0;

   }

   return1;      

}

inlinevoidfall(inti)

{

     inthh;

     for(intj=0;j<=6;j++)

      {

        if(s[i][j]==0)

        {

             for(intp=j+1;j<=6&&p<=6;p++)

             if(s[i][p]&&!s[i][j])

             {

               hh=s[i][p];

               s[i][p]=0;

               s[i][j]=hh;

               j++;

             }

            // s[i][j-1]=s[i][j];

             //s[i][j]=0;

        }       

      }

       

}

inlineintwipe()

{

   boolxx[5][7]={0};

   intvis=0;

  for(inti=0;i<=4;i++)

  {

    for(intj=0;j<=6;j++)

    {

          if(i>0&&i<4)

          {

            if(s[i-1][j]==s[i][j]&&s[i+1][j]==s[i][j]&&s[i][j]!=0)

            {

              xx[i-1][j]=xx[i][j]=xx[i+1][j]=1;

              vis=1;

            }

          }

          if(j>0&&j<6)

          {

            if(s[i][j-1]==s[i][j]&&s[i][j]==s[i][j+1]&&s[i][j]!=0)

            {

              xx[i][j-1]=xx[i][j]=xx[i][j+1]=1;

              vis=1;

            }          

          }    

    }       

  }

    for(inti=0;i<=4;i++)

    {

      for(intj=0;j<=6;j++)

        if(xx[i][j])

        {

         s[i][j]=0;

        }  

        fall(i);

      }  

        returnvis;  

}

inlinevoidmove(intx,inty,inta,intb)

{

     intzz;

     zz=s[a][b];

     s[a][b]=s[x][y];

     s[x][y]=zz;

     fall(x);

     fall(a);

     while(wipe())

     {           

     }        

}

 

inlinevoiddfs(intx)

{

    sx=x;

    if(x==n)

    {

        if(!check())return;

         for(inti=1;i<=n;i++)

         cout<<t[i][0]<<" "<<t[i][1]<<" "<<t[i][2]<<endl;             

         exit(0);    

    }

     

    intg[5][7],f[5][7];

    memcpy(g,s,sizeof(g));

  for(inti=0;i<=4;i++)

   for(intj=0;j<=6;j++)

   {

            if(i<4&&s[i][j]&&s[i][j]!=s[i+1][j])

            {

                 move(i,j,i+1,j);

                 t[0][0]++;

                 t[t[0][0]][0]=i;

                 t[t[0][0]][1]=j;

                 t[t[0][0]][2]=1;

                 dfs(x+1);

                 memcpy(s,g,sizeof(s));

                 t[0][0]--;

            }

            if(i>0&&s[i][j]&&s[i][j]!=s[i-1][j]&&s[i-1][j]==0)

            {

                 t[0][0]++;

                 t[t[0][0]][0]=i;

                 t[t[0][0]][1]=j;

                 t[t[0][0]][2]=-1;

                 move(i,j,i-1,j);

                 dfs(x+1);

                 memcpy(s,g,sizeof(s));

                 t[0][0]--;

            }

  }

}

inlineinthaha()

{

    //freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);

   // freopen("mayan.in","r",stdin); //freopen("mayan.out","w",stdout);

    cin>>n;

    intx;

    intpp=0;

    for(inti=0;i<=4;i++)

    {

      for(intj=0;j<=7;j++)

      {

            cin>>x;

            if(x==0)break;

            s[i][j]=x;

            sd[x]++;

            sd[0]=max(x,sd[0]);      

      }       

    }

    dfs(0);

    if(!t[0][0])cout<<-1<<endl;

    //cout<<t[0][0]<<endl;

}

intgg=haha();

intmain()

{;}