【Leetcode】P5506 奇怪的打印机II

Leetcode P5506 奇怪的打印机II

给你一个奇怪的打印机，它有如下两个特殊的打印规则：

• 每一次操作时，打印机会用同一种颜色打印一个矩形的形状，每次打印会覆盖矩形对应格子里原本的颜色。
• 一旦矩形根据上面的规则使用了一种颜色，那么 相同的颜色不能再被使用 。

给你一个初始没有颜色的 m x n 的矩形 targetGrid ，其中 targetGrid[row][col] 是位置 (row, col) 的颜色。如果你能按照上述规则打印出矩形 targetGrid ，请你返回 true ，否则返回 false 。

示例1:

输入：targetGrid = [[1,1,1,1],[1,2,2,1],[1,2,2,1],[1,1,1,1]]
输出：true

示例2:

输入：targetGrid = [[1,1,1,1],[1,1,3,3],[1,1,3,4],[5,5,1,4]]
输出：true

示例3:

输入：targetGrid = [[1,2,1],[2,1,2],[1,2,1]]
输出：false
解释：没有办法得到 targetGrid ，因为每一轮操作使用的颜色互不相同。

示例 4:

输入：targetGrid = [[1,1,1],[3,1,3]]
输出：false

提示：

• m == targetGrid.length
• n == targetGrid[i].length
• 1 <= m, n <= 60
• 1 <= targetGrid[row][col] <= 60

这是9.19双周赛最后一题。前三题做的还是挺快的，正常发挥，结果第四题居然没做出来。。sigh

当时比赛时想的思路是，找到颜色之间的依赖关系。通过某种条件判断出，某个颜色必须在某个颜色之后涂，然后连边，最后判断是否有环。当时一方面是这个条件判断错了，我是去寻找一个点，如果周边四个点里有两个颜色相同，那么说明这两个点的矩形应该先生成。但其实这是漏情况的，比如1221，2肯定也在1之后，但如果用我当时的方法是判断不出来的。然后当时也想了很久找到依赖关系之后如何证明只要打印一次，比如最后一个例子。

其实一开始的条件就找错了。我们对于每一个颜色，去找到出现的最上/下/左/右的坐标，那么说明这个颜色打印的矩形至少是这个范围。然后遍历这个范围，如果里面有其他颜色，说明这个“其他颜色”需要在之后涂。这就是图连边的条件，并不需要额外判断是否只要涂一次，这个条件在之前已经用过了。代码如下：

• ind是入度数组，vis记录是否有某个颜色，graph作图，a[i]存储的是颜色i的最上/左/下/右的坐标
• 初始化完毕，遍历颜色i所在的最大矩形，如果发现里面有不同颜色，就连边
• 最后拓扑排序判断一下是否有环。colors是颜色数量

class Solution {
public:
    bool isPrintable(vector<vector<int>>& targetGrid) {
        int m = targetGrid.size(), n = targetGrid[0].size(), colors = 0;
        int ind[61], vis[61];
        int graph[61][61];
        int a[61][4];
        memset(ind, 0, sizeof(ind));
        memset(vis, 0, sizeof(vis));
        memset(graph, 0, sizeof(graph));
        for(int i = 1; i <= 60; i++) {
            a[i][0] = INT_MAX;
            a[i][1] = INT_MAX;
            a[i][2] = -1;
            a[i][3] = -1;
        }
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                vis[targetGrid[i][j]] = 1;
                a[targetGrid[i][j]][0] = min(a[targetGrid[i][j]][0], i);
                a[targetGrid[i][j]][1] = min(a[targetGrid[i][j]][1], j);
                a[targetGrid[i][j]][2] = max(a[targetGrid[i][j]][2], i);
                a[targetGrid[i][j]][3] = max(a[targetGrid[i][j]][3], j);
            }
        }
        for(int i = 1; i <= 60; i++) {
            if(!vis[i]) continue;
            colors++;
            for(int ii = a[i][0]; ii <= a[i][2]; ii++) {
                for(int jj = a[i][1]; jj <= a[i][3]; jj++) {
                    if(targetGrid[ii][jj] != i) {
                        if(!graph[i][targetGrid[ii][jj]]) ind[targetGrid[ii][jj]]++;
                        graph[i][targetGrid[ii][jj]] = 1;
                    }
                }
            }
        }
        queue<int> q;
        int cnt = 0;
        for(int i = 1; i <= 60; i++) {
            if(vis[i] && ind[i] == 0) {
                q.push(i);
                cnt++;
            }
        }
        while(!q.empty()) {
            int tmp = q.front();
            q.pop();
            for(int j = 1; j <= 60; j++) {
                if(graph[tmp][j]) {
                    ind[j]--;
                    if(ind[j] == 0) {
                        cnt++;
                        q.push(j);
                    }
                }
            }
        }
        return cnt == colors;
    }
};