俄罗斯方块（2018网易游戏校招补招第三题）

题目

小M最近迷上了一款叫做《俄罗斯方块》的游戏。与传统的俄罗斯方块不同，这个游戏是在一个由六边形格子组成的棋盘上进行消除，棋盘的形状如下图所示。

玩家需要将游戏提供的方块放置在棋盘上，方块是由互相连接的六边形格子组成的，例如下图便展示了部分方块的形状。

游戏开始时棋盘为空，每个回合游戏提供一个方块，玩家将其放在一个合法位置（方块不能旋转）。合法是指这个方块可以放在棋盘上，组成其的每一个六边形格子不超出棋盘，且棋盘上对应的位置为空。放置后，棋盘上对应的格子被占据。每当一行或一列(列有2个方向)全部被占据时，这一行或这一列便被消除，同时玩家得分，得分为消除的格子数量。需要注意的是存在当一个方块放置后，同时使得多个行列被消除的情况。
下图展示了一个得分的例子，将方块放在红框位置，则同时有两行和一列被消除，得18分。

为了便于描述，我们将棋盘格子的坐标记为下图所示：

有了上述坐标系，我们便可以将一个包含m个格子的方块用一个整数m和m对坐标来进行描述。假设其中一个格子的坐标为(x,y)，那么其他格子均是相对这个格子的偏移量。如果我们给这m个坐标同时加上一个相同的偏移量(dx,dy)，那么它们依然表示的是同一个方块。
例如下图的方块：

便可以使用 4 0 0 1 0 -1 -1 0 -1 或者 4 0 -3 1 -3 -1 -4 0 -4 来描述。

现在问题来了，棋盘上当前已经有若干方块（即已经有部分格子被占据），再额外给你一个方块，最多能够消除多少格子呢？
注意：本题只允许C++、Java语言提交，其他语言提交得分无效
输入描述:
每个输入数据包含多个测试点。
第一行为测试点的个数T(T<=100)。
每个测试点的第一行为M(0<=M<=61)，表示棋盘上已经有多少个格子被占据。
接下来M行，每行是两个整数x y，表示被占据格子的坐标。
下一行是一个方块描述。
输入数据保证坐标合法，方块是合法方块，且初始局面不存在能够消除的情况。每个方块的格子数不超过10。
输出描述:
对于每个测试点，输出一行，表示通过将输入方块放到棋盘上，最多能够消除多少格子。如果方块无法放置在棋盘上，输出-1。
示例1
输入

1
29
0 4
0 3
1 3
0 2 
1 2 
0 1 
1 1
-2 0
0 0 
1 0 
2 0 
4 0 
-3 -1
-2 -1
-1 -1
0 -1
1 -1
-4 -2
-3 -2 
-2 -2
-1 -2 
0 -2 
-4 -3 
-3 -3 
-2 -3 
-1 -3 
-4 -4 
-3 -4 
-2 -4
4 0 0 1 0 -1 -1 0 -1

输出

18

思路

（1）六边形的方程表达式，

x - 4 <= y <= x + 4, -4 <= x <= 4, -4 <= y <= 4

为了将坐标映射成非负整数，所有点(x, y)加上偏移OFFSET = 4；
用9*9的数组A表示该棋盘，其中-1表示无效（在六边形以外的坐标），0表示空，1表示已放置方块；
（2）遍历棋盘数组A，坐标为(x, y)，包含m个格子的方块为K，方块第i个方块坐标为(kix, kiy)，在棋盘A中找到令A(x + kix, x + kiy), 0<=i < m均为0的位置(x0, y0)，表示方块K可以放置在该位置；
（3）将A中放置方块K的坐标值设为1；
（4）分行列遍历数组A，如果当前行或列（不包含无效的坐标，值为-1）以填满，则将该行或列的坐标放入std::set中（去重），记录可以消除的方块数NUM；
（5）将（3）中置为1的坐标值还原为0；
（6）重复（2）~（6）找到最大的NUM，即为所求；

代码

代码已通过样例，不知道是否可以AC，仅供参考，若有问题，还望指出~

#include <algorithm>
#include <iostream>
#include <vector>
#include <set>

const int OFFSET = 4;   //坐标偏移，将坐标全部映射至0~8之间

bool isValid(int x, int y){
    if (x < 0 || x > 8 || y < 0 || y > 8){
        return false;
    }
    if (y >  x + 4 || y < x - 4){
        return false;
    }
    return true;
}

inline bool isEmpty(const std::vector<std::vector<int>>& map, int x, int y){
    return map[x][y] == 0;
}

struct Point{
    Point(int x, int y) : x(x), y(y){}
    //为set做排序用, 不可缺少
    bool operator<(const Point& point) const {
        if (x != point.x){
            return x < point.x;
        }
        return y < point.y;
    }
    int x, y;
};

int canVanishNum(const std::vector<std::vector<int>>& map){
    std::set<Point> result;
    //行
    for (int i = 0; i <= 8; ++i){
        bool isAllOccupied = true;
        for (int k = 0; k <= 8; ++k){
            if (map[i][k] == -1){
                continue;
            }
            if (map[i][k] == 0){
                isAllOccupied = false;
                break;
            }
        }
        if (isAllOccupied == false){
            continue;
        }
        for (int k = 0; k <= 8; ++k){
            if (map[i][k] == -1){
                continue;
            }
            result.insert(Point(i, k));
        }
    }
    //列
    for (int i = 0; i <= 8; ++i){
        bool isAllOccupied = true;
        for (int k = 0; k <= 8; ++k){
            if (map[k][i] == -1){
                continue;
            }
            if (map[k][i] == 0){
                isAllOccupied = false;
                break;
            }
        }
        if (isAllOccupied == false){
            continue;
        }
        for (int k = 0; k <= 8; ++k){
            if (map[k][i] == -1){
                continue;
            }
            result.insert(Point(k, i));
        }
    }
    return result.size();
}

void setMapPointNum(std::vector<std::vector<int>>& map, const std::vector<Point>& coords,
    int x, int y, int num){
    for (int i = 0; i < coords.size(); ++i){
        int newX = x + coords[i].x;
        int newY = y + coords[i].y;
        map[newX][newY] = num;
    }
}

int calcMax(std::vector<std::vector<int>>& map, std::vector<Point>& coords){
    int rows = map.size();
    int cols = map.front().size();
    int x = coords.front().x;
    int y = coords.front().y;

    int result = -1;
    //如果无法放置，则会返回-1
    for (int i = 0; i < rows; ++i){
        for (int k = 0; k < cols; ++k){
            int newX = i + x;
            int newY = k + y;
            if (isValid(newX, newY) && isEmpty(map, newX, newY)){
                bool mark = true;
                for (int j = 1; j < coords.size(); ++j){
                    int tmpX = i + coords[j].x;
                    int tmpY = k + coords[j].y;
                    if (!(isValid(tmpX, tmpY) && isEmpty(map, tmpX, tmpY))){
                        mark = false;
                        break;
                    }
                }
                if (mark == false){
                    continue;
                }
                setMapPointNum(map, coords, i, k, 1);
                result = std::max(result, canVanishNum(map));
                setMapPointNum(map, coords, i, k, 0);
            }
        }
    }
    return result;
}

int main()
{
    //-1表示不可用点，0表示空点，1表示已占用点
    std::vector<std::vector<int>> map(9, std::vector<int>(9, 0));
    for (int i = 0; i <= 8; ++i){
        for (int k = 0; k <= 8; ++k){
            if (isValid(i, k) == false){
                map[i][k] = -1;
            }
        }
    }
    //输入数据
    int loopTime = 0;
    std::cin >> loopTime;
    while (loopTime--){
        int pointNum = 0;
        std::cin >> pointNum;
        int x = 0, y = 0;
        for (int i = 0; i < pointNum; ++i){
            std::cin >> x >> y;
            x += OFFSET;
            y += OFFSET;
            map[x][y] = 1;
        }

        std::vector<Point> coords;
        int coordNum = 0;
        std::cin >> coordNum;
        for (int i = 0; i < coordNum; ++i){
            std::cin >> x >> y;
            coords.push_back(Point(x, y));
        }

        std::cout << calcMax(map, coords) << std::endl;
    }

    system("pause");
    return 0;
}