Leetcode-782之变为棋盘

题目：

一个 N x N的 board 仅由 0 和 1 组成 。每次移动，你能任意交换两列或是两行的位置。

输出将这个矩阵变为 “棋盘” 所需的最小移动次数。“棋盘” 是指任意一格的上下左右四个方向的值均与本身不同的矩阵。如果不存在可行的变换，输出 -1。

示例:
输入: board = [[0,1,1,0],[0,1,1,0],[1,0,0,1],[1,0,0,1]]
输出: 2
解释:
一种可行的变换方式如下，从左到右：

0110     1010     1010
0110 --> 1010 --> 0101
1001     0101     1010
1001     0101     0101

第一次移动交换了第一列和第二列。
第二次移动交换了第二行和第三行。
输入: board = [[0, 1], [1, 0]]
输出: 0
解释:
注意左上角的格值为0时也是合法的棋盘，如：

01
10

也是合法的棋盘.

输入: board = [[1, 0], [1, 0]]
输出: -1
解释:
任意的变换都不能使这个输入变为合法的棋盘。

提示：

board 是方阵，且行列数的范围是[2, 30]。
board[i][j] 将只包含 0或 1。

代码：

class Solution {
private:
    // 记录列数和列数（因为方阵是相等的）
    int n;

    // 计算时候最大的范围，避免引入不再考虑范围的计算值
    int mask;

    // 计算bit为1的数量
    int CntOneBit(int num)
    {
        int cnt = 0;
        while (num > 0)
        {
            if ((num & 1) == 1)
            {
                ++cnt;
            }
            num >>= 1;
        }

        return cnt;
    }

    // 计算最小步数的函数
    // codex,numx对应的就是排列类型和对应的数量
    int CalculateSteps(unordered_map<int, int>& code2num)
    {
        int codes[2];
        int nums[2];
        int cnt = 0;
        // 从map获得num和code,这里正好2个（之前已经判断了）
        for (auto iter = code2num.begin(); iter != code2num.end(); ++iter)
        {
            codes[cnt] = iter->first;
            nums[cnt] = iter->second;
            ++cnt;
        }
        // cout << "CalculateSteps " << codes[0] << "," << codes[1] << " " << nums[0] << "," << nums[1] << endl;

        // 判断数量是否符合预期: 默认第一个计数更大
        if (nums[0] < nums[1])
        {
            swap(nums[0], nums[1]);
            swap(codes[0], codes[1]);
        }
        if (nums[0] != (n+1)/2 || nums[1] != n/2)
        {
            // cout << "wrong n" << endl;
            return -1;
        }

        // 正好需要异或互补：长度为n的数量
        if ((codes[0] ^ codes[1]) != mask)
        {
            // cout << "wrong xor " << (codes[0] ^ codes[1]) << endl;
            return -1;
        }
        // 开始计算最小步数，考虑两种情况 0x55555555 或 0xaaaaaaaa
        // 最小步数即计算异或后的1的位数/2（记得即考虑mask范围内的1）
        // 
        if (n % 2 == 0)
        {
            return min(CntOneBit((codes[0] ^ 0x55555555) & mask), CntOneBit((codes[0] ^ 0xaaaaaaaa) & mask)) >> 1;
        }
        else
        {
            int code = CntOneBit(codes[0]) > (n/2) ? codes[0] : codes[1];
            return CntOneBit((code ^ 0x55555555) & mask) / 2;
        }
    }
public:
    int movesToChessboard(vector<vector<int>>& board) {
        n = board.size();
        mask = (1 << n)-1;

        // 两种排列类型
        unordered_map<int, int> code2num;

        // 先计算行的情况
        for (int i = 0; i < n; ++i)
        {
            // 当前的排列类型
            int curr = 0;
            for (int j = 0; j < n; ++j)
            {
                curr = (curr << 1) + board[i][j];
            }
            // 排除出现第三种排列情况，直接返回失败 -1
            ++code2num[curr];
            if (code2num.size() > 2)
            {
                return -1;
            }
        }
        int stepsRow = CalculateSteps(code2num);
        if (stepsRow == -1)
        {
            return -1;
        }

        code2num.clear();
        // 按照列的情况
        for (int j = 0; j < n; ++j)
        {
            // 当前的排列类型
            int curr = 0;
            for (int i = 0; i < n; ++i)
            {
                curr = (curr << 1) + board[i][j];
            }
            // 排除出现第三种排列情况，直接返回失败 -1
            ++code2num[curr];
            if (code2num.size() > 2)
            {
                return -1;
            }
        }

        int stepsCol = CalculateSteps(code2num);
        if (stepsCol == -1)
        {
            return -1;
        }

        return stepsRow + stepsCol;
    }
};

思路：

先搞明白什么情况是不满足的？

1、对于行和列正好有两个不同的排列类型，其他都不行，为什么？

        a. 一个类型，那显然不对。

        b. 三个类型，最终没法变为3个类型。

        c. 而最终满足条件的也只能是两种类型，正好交错的情况。

        d. 排列类型表示：范围是[2,30]，用一个int类型正好，对应bit为1则表示为1，否则为0；

2、前面也提到了，正好交错，两种类型彼此正好是互补的；

• 数学表达就是 a^b 全1 （长度为 board.size()）

3、两种排列的个数要相等；

        偶数：n/2； 奇数：n/2和(n+1)/2

接着是如何计算最小的步数？

1、其实目标是两种010101和101010

2、对于当前数字，如011010转换为010101步数其实就是(差异数)/2，差异数其实就是用异或来计算bit one的差异/2；

        -偶数的时候，考虑两种情况，取最小；

        -奇数的时候，只计算需要差异更大的一种情况，使用1数量>n/2的code，而对应目标就是奇数情况下1更多的0x55555555;

3、将行需要转移的数加上列转移的数，返回

4、如果其中有一个是-1，那么返回-1。无法生成棋盘。