LeetCode 115th Weekly Contest 总结

总体来说，这周题目比较难。以后还是每周都来总结下周赛。

1. 957. Prison Cells After N Days

题意

类似于细胞生命的游戏，每天细胞会根据前一天的状态进行演变，演变规则:

Each day, whether the cell is occupied or vacant changes according to the
following rules:
If a cell has two adjacent neighbors that are both occupied or both vacant,
then the cell becomes occupied.
Otherwise, it becomes vacant.

思路

开始比较直接的做法就是遍历n天，再遍历n个细胞:

public int[] prisonAfterNDays(int[] cells, int N) {
        while (N > 0) {
            N--;
            int[] cells2 = new int[8];
            for (int i = 1; i < 7; ++i)
                cells2[i] = cells[i - 1] == cells[i + 1] ? 1 : 0;
            cells = cells2;
        }
        return cells;
}

但是这个解答在N很大时超时，于是必须考虑优化方案了。

• 我们来思考一下，这个状态中可能出现重复的吗？也就是如果存在循环，就会好办很多，我们就可以取周期的余，就到了跳过一次循环后的状态了；其实一共8个细胞，出去首尾两个状态始终是0，其余6个组成的状态数一共是2^6=64种，所以变化那么多天，肯定是存在循环的（其实就是也可以猜测如果没有循环这题就没法解了= =)
• 下一步，怎么判断出现过的状态呢？并且还需要知道是在之前哪天出现的，因为今天减去上一期相同状态出现的那天，就等于循环的周期啦。自然而然想到应该用hash table存储。
• 还需要注意的点就是，hash table中的key的存储，应该是用字符串化后的数组，不然hash table判断的时候用的是数组的reference，每次都不会一样.

代码：

class Solution {
    public int[] prisonAfterNDays(int[] cells, int N) {
        int[] tmp = new int[8];
        Map<String, Integer> map = new HashMap<>();
        while (N > 0) {
            map.put(Arrays.toString(cells), N);
            N--;
            for (int i = 1; i < 7; i++) {
                tmp[i] = cells[i - 1] == cells[i + 1] ? 1 : 0;
            }
            for (int i = 0; i < 8; i++) cells[i] = tmp[i];
            if (map.containsKey(Arrays.toString(cells))) {
                int T = map.get(Arrays.toString(cells)) - N;  //周期
                N %= T;
            }
        }
        return cells;
    }
}

总结：

这种状态转换，且n还很大，一般就是需要找循环，然后取余mod，来减少循环长度。
这样的就遍历数组，再加上一个优化步骤的题目，面试也会将常考

2. 958. Check Completeness of a Binary Tree

题意

判断一棵树是否是完全二叉树

思路

根据完全二叉树的性质，最下层节点应该都在左边；

• 可以考虑下层序遍历，如果是完全二叉树的话，那么当遇到空节点的时候，中后就不应该再遇到空节点了。
• 层序遍历，无论是否为空节点都add进队列，当队列头是空节点时，说明遇到第一个空节点了；然后再判断队列中剩下的节点，如果有非空的，则不是完全二叉树

代码：

class Solution {
    public boolean isCompleteTree(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (queue.peek() != null) {
            TreeNode cur = queue.poll();
            queue.add(cur.left);
            queue.add(cur.right);
        }
        while (!queue.isEmpty() && queue.peek() == null) {
            queue.poll();
        }
        return queue.isEmpty();
    }
}

总结

树的层序遍历的扩展

3. 959. Regions Cut By Slashes

哈哈比赛时这题题目都没看懂 = =

题意

In a N x N grid composed of 1 x 1 squares, each 1 x 1 square consists of a /
, or blank space. These characters divide the square into contiguous
regions.

大概就是给一个字符串代表矩形的分割方式，求在矩形区域的个数。

思路

什么鬼题目？？大脑一片空白？莫急，让我们慢慢分析一下。

• 怎么才能判断这块区域是一块呢？这种图形题，又不可能考计算几何 = =，所以唯一可能就是通过染色的方法，我们可以标记对吧；
• 那么怎么染色呢？是不是想到了并查集？就是将相连的区域都染为同一个颜色，最后颜色的树木不就是的区域的数目吗？
• 有了基本的思路，方法是可行的，到了具体实现了；这里一个难想到的点就是，根据、/这两个字符，去分割矩形小框框，怎么去分呢？这里需要把每个小矩形再分成四个小区域：如下图所示：
  这样，我们就可以根据当前是什么符号，去将不同的区域进行连接了

代码：

class Solution {
    class UF {
        int[] parent;
        public UF(int n) {
            parent = new int[n];
            for (int i = 0; i < n; i++) parent[i] = i;
        } 
        public int  find(int x) {
            if (parent[x] != x) parent[x] = find(parent[x]);
            return parent[x];
        }
        public void union(int x, int y) {
            parent[find(x)] = find(y);
        }
    }
    
    int count = 0;
    UF uf;
    public int regionsBySlashes(String[] grid) {
        int n = grid.length;
        uf = new UF(n * n * 4);
        count = n * n * 4;
        //四个小区块：top: 0, right: 1, bottom: 2, left: 3
        for (int r = 0; r < n; r++) {
            for (int  c = 0; c < n; c++) {
                if (r > 0) {
                    check(changeIndex(n, r-1, c, 2), changeIndex(n, r, c, 0));
                }
                if (c > 0) {
                    check(changeIndex(n, r, c - 1, 1), changeIndex(n, r, c, 3));
                }
                if (grid[r].charAt(c) != '/') {
                    check(changeIndex(n, r, c, 3), changeIndex(n, r, c, 2));
                    check(changeIndex(n, r, c, 1), changeIndex(n, r, c, 0));
                }
                if (grid[r].charAt(c) != '\') {
                    check(changeIndex(n, r, c, 0), changeIndex(n, r, c, 3));
                    check(changeIndex(n, r, c, 1), changeIndex(n, r, c, 2));
                }
            }
        }
        return count;
    }
    
    private int changeIndex(int n, int x, int y, int k) {
        return (x * n + y) * 4 + k;
    }
    
    private void check(int n1, int n2) {
        if (uf.find(n1) != uf.find(n2)) {
            uf.union(n1, n2);
            count--;
        }
    }
}

总结

并查集的考察越来多多了

4. 960. Delete Columns to Make Sorted III

题意

这题是之前几题的延续
删除某些列后，每行的元素都是按字母排序的

Suppose we chose a set of deletion indices D such that after deletions, the
final array has every element (row) in lexicographic order.

思路

• 求每个字符串最少删掉的字符，使得每个字符串中的字符都是递增的；我们可以先考虑考虑1个字符串的情况：
  也就是说，比如"edcba"，求它最少减少的字符，使得它自增，是不是觉得很熟悉呢？问题可以转化为最长递增子序列LIS，n - LIS
  即为所求了！回忆LIS的基本解法是：

for j : 0 -> n
  for i : 0 -> j
     if (A[i] < A[j]) dp[j] = max(dp[j], dp[i] + 1)

• 想清楚了一个字符串的case，再来想想多个字符串怎么办？
  这里的一个思路就是 将每列看成一个元素,那么只要判断在每个case下，是不是每行元素都满足递增，如果满足，则更新dp；否则跳过;

代码：

class Solution {
    public int minDeletionSize(String[] A) {
        int m = A.length, n = A[0].length();
        int[] dp = new int[n];  //每列看成一个元素！
        int res = Integer.MAX_VALUE;
        Arrays.fill(dp, 1);
        for (int j = 0; j < n; j++) {
            for (int i = 0; i < j; i++) {
                boolean valid = true;
                //检查每个字符串是不是都满足
                for (int r = 0; r < m; r++) {
                    if (A[r].charAt(i) > A[r].charAt(j)) {
                        valid = false;
                        break;
                    }
                }
                if (valid) dp[j] = Math.max(dp[j], dp[i] + 1);
            }
            res = Math.min(res, n - dp[j]);
        }
        return res;
    }
}

总结

其实这题就是LIS的变种

总体来说，这次周赛除了第三题，其他都可以做出来的，其他的都比较常规，但是...emmm 加油吧