#1070. 「NOIP2011 提高组」Mayan 游戏

题目描述

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

1. 每步移动可以且仅可以沿横向（即向左或向右）拖动某一方块一格：当拖动这一方块时，如果拖动后到达的位置（以下称目标位置）也有方块，那么这两个方块将交换位置（参见输入输出样例说明中的图  到图 ）；如果目标位置上没有方块，那么被拖动的方块将从原来的竖列中抽出，并从目标位置上掉落（直到不悬空，参见下面图  和图 ）；
2. 任一时刻，如果在一横行或者竖列上有连续三个或者三个以上相同颜色的方块，则它们将立即被消除（参见图  到图 ）。 注意：(1) 如果同时有多组方块满足消除条件，几组方块会同时被消除（例如下面图 ，三个颜色为  的方块和三个颜色为  的方块会同时被消除，最后剩下一个颜色为  的方块）。 (2) 当出现行和列都满足消除条件且行列共享某个方块时，行和列上满足消除条件的所有方块会被同时消除（例如下面图  所示的情形， 个方块会同时被消除）。
3. 方块消除之后，消除位置之上的方块将掉落，掉落后可能会引起新的方块消除。注意：掉落的过程中将不会有方块的消除。上面图  到图  给出了在棋盘上移动一块方块之后棋盘的变化。棋盘的左下角方块的坐标为 ，将位于  的方块向左移动之后，游戏界面从图  变成图  所示的状态，此时在一竖列上有连续三块颜色为  的方块，满足消除条件，消除连续  块颜色为  的方块后，上方的颜色为  的方块掉落，形成图  所示的局面。

输入格式

输入文件共  行。
第一行有一个整数 ，表示要求游戏通关的步数。
接下来的  行，描述  的游戏界面。每行若干个整数，每两个整数之间用一个空格隔开，每行以一个  结束，自下向上表示每竖列方块的颜色编号（颜色不多于  种，从  开始顺序编号，相同数字表示相同颜色）。
输入数据保证初始棋盘中没有可以消除的方块。

输出格式

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

样例

样例输入复制

3 
1 0 
2 1 0 
2 3 4 0 
3 1 0 
2 4 3 4 0 

样例输出复制

2 1 1 
3 1 1 
3 0 1 

样例解释

输入输出样例说明：按箭头方向的顺序分别为图  到图 。样例输入的游戏局面如上面第一个图片所示，依次移动的三步是： 处的方格向右移动， 处的方格向右移动， 处的方格向右移动，最后可以将棋盘上所有方块消除。

数据范围与提示

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

注意：题目解答要求执行  步操作。

分类标签

9018 题目 NOIP 提高组 / CSP-S2 2011 

题解：

/*
OI:9019
Problem:#1070. ?NOIP2011 ????Mayan ??
by Ex_sky
*/
#include <bits/stdc++.h>
using namespace std;
struct zt {
    int a[6][8], cnt[6], cz[6][4], d;
} z, ans;
int n, b[15];
bool bo[6][8];

void output(zt a) {
    for (int i = 1; i <= 5; ++i) {
        for (int j = 1; j <= 7; ++j) cout << a.a[i][j] << ' ';
        cout << a.cnt[i] << endl;
    }
    cout << a.d << endl;
}

zt drop(zt z) {
    zt t = z;
    memset(t.a, 0, sizeof(t.a));
    memset(t.cnt, 0, sizeof(t.cnt));
    for (int i = 1; i <= 5; ++i) {
        t.cnt[i] = 0;
        for (int j = 1; j <= 7; ++j)
            if (z.a[i][j] != 0)
                t.a[i][++t.cnt[i]] = z.a[i][j];
    }
    return t;
}

bool xiao(zt &z) {
    bool flag = 0;
    memset(bo, 0, sizeof(bo));
    for (int i = 1; i <= 5; ++i)
        for (int j = 1; j <= 5; ++j)
            if (z.a[i][j] && z.a[i][j] == z.a[i][j + 1] && z.a[i][j] == z.a[i][j + 2])
                for (int k = j; k <= 7 && z.a[i][j] == z.a[i][k]; ++k) bo[i][k] = 1;
    for (int i = 1; i <= 3; ++i)
        for (int j = 1; j <= 7; ++j)
            if (z.a[i][j] && z.a[i][j] == z.a[i + 1][j] && z.a[i][j] == z.a[i + 2][j])
                for (int k = i; k <= 5 && z.a[i][j] == z.a[k][j]; ++k) bo[k][j] = 1;
    for (int i = 1; i <= 5; ++i)
        for (int j = 1; j <= 7; ++j)
            if (bo[i][j])
                z.a[i][j] = 0, flag = 1;
    return flag;
}

zt move(zt z, int x, int y, int fx) {
    z.cz[++z.d][1] = x;
    z.cz[z.d][2] = y;
    z.cz[z.d][3] = fx;
    swap(z.a[x][y], z.a[x + fx][y]);
    z = drop(z);
    while (xiao(z)) z = drop(z);
    return z;
}

bool clear(zt z) {
    for (int i = 1; i <= 5; ++i)
        if (z.cnt[i])
            return 0;
    return 1;
}

bool check(zt z) {
    memset(b, 0, sizeof(b));
    for (int i = 1; i <= 5; ++i)
        for (int j = 1; j <= 7; ++j) ++b[z.a[i][j]];
    for (int i = 1; i <= 10; ++i)
        if (b[i] && b[i] < 3)
            return 1;
    return 0;
}

bool dfs(zt z) {
    zt t;
    if (check(z))
        return 0;

    for (int i = 1; i <= 5; ++i)
        for (int j = 1; j <= z.cnt[i]; ++j) {
            if (i != 5) {
                t = move(z, i, j, 1);
                if (clear(t) && t.d == n) {
                    ans = t;
                    return 1;
                }
                if (!clear(t) && t.d < n)
                    if (dfs(t))
                        return 1;
            }
            if (i != 1 && z.a[i - 1][j] == 0) {
                t = move(z, i, j, -1);
                ;
                if (clear(t) && t.d == n) {
                    ans = t;
                    return 1;
                }
                if (!clear(t) && t.d < n)
                    if (dfs(t))
                        return 1;
            }
        }
    return 0;
}

int main() {
    cin >> n;
    for (int i = 1, x; i <= 5; ++i) {
        cin >> x;
        while (x != 0) z.a[i][++z.cnt[i]] = x, cin >> x;
    }
    //	output(move(z,1,1,1));
    dfs(z);
    if (!ans.d) {
        cout << -1 << endl;
        return 0;
    }
    for (int i = 1; i <= n; ++i)
        cout << ans.cz[i][1] - 1 << ' ' << ans.cz[i][2] - 1 << ' ' << ans.cz[i][3] << endl;
    return 0;
}