预测比赛的赢家|斯普拉格-格兰迪

给定一个 4×4 的二进制矩阵。两个玩家 A 和 B 正在玩游戏，在每一步，玩家都可以选择任何一个全为 1 的矩形并将所有 1 替换为 0。不能选择任何矩形的玩家输掉游戏。假设他们都以最佳方式玩游戏并且 A 开始游戏，则预测游戏中的获胜者。

例子：

Input :
0 1 1 0
0 0 0 0
0 0 0 0
0 0 0 1
Output : A
Step 1: Player A chooses the rectangle with a single one at position (1, 2), so the new matrix becomes
0 0 1 0
0 0 0 0
0 0 0 0
0 0 0 1

Step 2: Player B chooses the rectangle with a single one at position (1, 3), so the new matrix becomes
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 1

Step 3: Player A chooses the rectangle with a single one at position (4, 4), so the new matrix becomes
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0

Step 4: Player B cannot move, hence A wins the game.

Input :
0 0 1 0
0 0 0 0
0 0 0 0
0 0 0 1
Output : B

编程需要懂一点英语

方法：该问题可以使用 sprague-grundy 定理解决。 Sprague-Grundy 的基本情况是 Grundy[0] = 0，即矩阵中的所有位置都填充为 0，然后 B 获胜，因此为 0。在 grundy 中，我们递归地将所有状态称为 grundy函数可能的。

4×4 矩阵可以表示为一个二进制的 16 位数字，在 int 中为 65535，其中每一位代表矩阵中的位置。下面是解决上述问题的步骤。

将矩阵转换为 int val。
使用 val 调用递归函数，使用记忆生成 grundy 值。
在递归函数内部，可以通过生成所有可能的矩形(使用四个 for 循环)来访问所有 grundy 状态。
检查生成的矩形，如果它是矩阵的矩形。那么这是grundy要访问的状态。
要使用 MEX 获得 Grundy 值，请参阅此内容。
如果递归返回 0，则玩家 B 获胜，否则玩家 A 获胜。

下面是上述方法的实现

#include 
using namespace std;
  
// Gets the max value
int getMex(const unordered_set& s)
{
    int mex = 0;
    while (s.find(mex) != s.end())
        mex++;
    return mex;
}
  
// Find check if the rectangle is a part of the
// the original rectangle
int checkOne(int mat, int i, int j, int k, int l)
{
  
    // initially create the bitset
    // of original intValue
    bitset<16> m(mat);
  
    // Check if it is a part of the rectangle
    for (int x = i; x <= j; x++) {
        for (int y = k; y <= l; y++) {
            int pos = 15 - ((x * 4) + y);
  
            // If not set, then not part
            if (!m.test(pos)) {
                return -1;
            }
            m.reset(pos);
        }
    }
  
    // If part of rectangle
    // then convert to int again and return
    int res = m.to_ullong();
    return res;
}
  
// Recursive function to get the grundy value
int getGrundy(int pos, int grundy[])
{
  
    // If state has been visited
    if (grundy[pos] != -1)
        return grundy[pos];
  
    // For obtaining the MEX value
    unordered_set gSet;
  
    // Generate all the possible rectangles
    for (int i = 0; i <= 3; i++) {
        for (int j = i; j <= 3; j++) {
            for (int k = 0; k <= 3; k++) {
                for (int l = k; l <= 3; l++) {
  
                    // check if it is part of the original
                    // rectangle, if yes then get the int value
                    int res = checkOne(pos, i, j, k, l);
  
                    // If it is a part of original matrix
                    if (res != -1) {
  
                        // Store the grundy value
                        // Memorize
                        grundy[res] = getGrundy(res, grundy);
  
                        // Find MEX
                        gSet.insert(grundy[res]);
                    }
                }
            }
        }
    }
  
    // Return the MEX
    return getMex(gSet);
}
  
// Conver the matrix to INT
int toInt(int matrix[4][4])
{
    int h = 0;
  
    // Traverse in the matrix
    for (int i = 0; i < 4; ++i)
        for (int j = 0; j < 4; ++j)
            h = 2 * h + matrix[i][j];
    return h;
}
  
// Driver Code
int main()
{
    int mat[4][4] = { { 0, 1, 1, 0 },
                      { 0, 0, 0, 0 },
                      { 0, 0, 0, 0 },
                      { 0, 0, 0, 1 } };
  
    // Get the int value of the matrix
    int intValue = toInt(mat);
  
    int grundy[intValue + 1];
  
    // Initially with -1
    // used for memoization
    memset(grundy, -1, sizeof grundy);
  
    // Base case
    grundy[0] = 0;
  
    // If returned value is non-zero
    if (getGrundy(intValue, grundy))
        cout << "Player A wins";
    else
        cout << "Player B wins";
  
    return 0;
}

输出：

Player A wins

时间复杂度：

在)
辅助空间： O(N)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。