【每周N题】回文对，恢复二叉搜索树，克隆图，移除盒子

截至2020/08/20
文章的主题还是分为学习算法和学习Java两个部分。由于一些题目都是老题，因此主要学习思路和Java写法。

336.回文对 H

这道题目是比较难的，官方题解也给的比较清楚，这里我们辅助注释理解就可以。
Java方法：

• map.getOrDefault(a, -1);,在字典中查找a，如果找到返回值，否则返回-1；
• String s = new StringBuffer(words[i]).reverse().toString(); 得到一个字符串，这里采用了SrtingBuffer类的toString方法

class Solution {
    Map<String, Integer> indices = new HashMap<String, Integer>();

    public List palindromePairs(String[] words) {
        int n = words.length;
        for (int i = 0; i < n; ++i) {
            String s = new StringBuffer(words[i]).reverse().toString();
            indices.put(s, i);
        }
        List<int[]> ret = new ArrayList<>();
        //List<List<Integer>> ret = new ArrayList<List<Integer>>();
        for (int i = 0; i < n; i++) {
            String word = words[i];
            int m = words[i].length();
            for (int j = 0; j <= m; j++) {
                // 回文对的拼接，右半段自身是，左半对的反转在字典中存在
                 这里需要注意细节！！！考虑空字符串，j = m的情况
                if (isPalindrome(word, j, m - 1)) {
                    int leftId = findWord(word, 0, j);
                    // 返回-1表示不存在，并且不能相同
                    if (leftId != -1 && leftId != i) {
                        ret.add(new int[]{i, leftId});
                    }
                }
                // 左边段自身是，右半段的反转存在
                if (j != 0 && isPalindrome(word, 0, j - 1)) {
                    int rightId = findWord(word, j, m);
                    if (rightId != -1 && rightId != i) {
                        ret.add(new int[]{rightId, i});
                    }
                }
            }
        }
        return ret;
    }

    public boolean isPalindrome(String s, int left, int right) {
        int len = right - left + 1;
        for (int i = 0; i < len / 2; i++) {
            if (s.charAt(left + i) != s.charAt(right - i)) {
                return false;
            }
        }
        return true;
    }

    public int findWord(String s, int left, int right) {
        return indices.getOrDefault(s.substring(left, right), -1);
    }
}

99.恢复二叉搜索树 H

关键在于找到核心的思路，我们首先对树进行遍历，中序遍历，如果是二叉搜索树，可以保证数组最后是单调递增的。但是由于存在交换，因此我们可以想到，存在两个特殊的点。第一个A点应该是大于后一个点，第二个点自然是大于A的前一个数字。特别考虑清楚边界的情况，如B点位于结尾。

然后我们得到两个点的位置之后，只需要再遍历树进行替换。注意这里的替换还是很有意思的。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int count = 0;
    public void recoverTree(TreeNode root) {
        List<Integer> nums = new ArrayList<Integer>();
        inorder(root, nums);
        int[] err = finderr(nums);
        recover(err[0],err[1],root);
    }

    public void inorder(TreeNode root,List<Integer> nums){
        if (root != null){
            inorder(root.left, nums);
            nums.add(root.val);
            inorder(root.right, nums);
        }
        return;
    }

    public int[] finderr(List<Integer> nums){
        int n = nums.size();
        int x = 0, y = nums.get(n-1);
        int flag = 0;
        for(int i = 1; i < n; i++){
            if (flag == 0 && nums.get(i-1)>nums.get(i)){
                flag ++;
                x = nums.get(i-1);
            }
            else if(flag == 1 && nums.get(i)>x){
                flag ++;
                y = nums.get(i-1);
            }
        }
        return new int[]{x,y};
    }

    public void recover(int err1, int err2, TreeNode root){
        if (root == null) return;
        if (count<2 && (root.val == err1 || root.val == err2)){
            root.val = root.val == err1?err2:err1;
            count++;
        }
        if (count == 2) return;
        recover(err1, err2, root.left);
        recover(err1, err2, root.right);
    }
}

133.克隆图

题目其实很简单，但是这里重点考察了深拷贝的问题。

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> neighbors;
    public Node() {
        val = 0;
        neighbors = new ArrayList<Node>();
    }
    public Node(int _val) {
        val = _val;
        neighbors = new ArrayList<Node>();
    }
    public Node(int _val, ArrayList<Node> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
}
*/

class Solution {
    public Node cloneGraph(Node node) {
        if (node == null) return node;
        Queue<Node> queue = new LinkedList<>();
        HashMap<Node, Node> dic = new HashMap();
        queue.offer(node);
        // 这里考虑清楚，我们是要克隆一个新的，因此首先克隆第一个
        dic.put(node, new Node(node.val, new ArrayList<Node>()));
        while(!queue.isEmpty()){
            Node n = queue.poll(); 
            for (Node neighbor:n.neighbors){
                if (!dic.containsKey(neighbor)){
                    dic.put(neighbor, new Node(neighbor.val, new ArrayList<Node>()));
                    queue.offer(neighbor);
                }
                // 更新所有的克隆节点的邻居
                dic.get(n).neighbors.add(dic.get(neighbor));
            }
        }  
        return dic.get(node);
    }
}

546.移出盒子 H

这道题第一眼感觉就是类似扎气球，但是仔细分析还不太一样。虽然基本思想还是区间dp但是这次的dp设置真是不太一样。这里我们采用了记忆化的搜索方法。

我们考虑某个区间[6,2,6,3,6,7,8,6,6]，考虑区间[6,2,6,3,6]和后面的区间，这个区间的坐标是[l, r]但是还可以和后面的两个6组合成为更大的消除方法。因此定义dp[i][j][k],表示区间左端点i，右端点j，连同区间外的k个点，其中这k个点的数值等于nums[j]。这样可以变为dp[l][r][k] = dp[i][j-1][0]+(k+1)*(k+1)。

由于区间中还存在其他等于6的点，因此还可以dp[l][i][k+1]+dp[i+1][r][0]其中k+1是因为，把最后一个也就是num[r]这个位置的数字也考虑了，之后的空间就无法考虑了只能是dp[i+1][r][0]。

核心在于记忆化搜索其实更直观，只要考虑清楚最后一个状态可能如何转换得到就可以。

class Solution {
    public int removeBoxes(int[] boxes) {
        int[][][] dp = new int[100][100][100];
        return calculatePoints(boxes, dp, 0, boxes.length - 1, 0);
    }

    public int calculatePoints(int[] boxes, int[][][] dp, int l, int r, int k) {
        if (l > r) return 0;
        if (dp[l][r][k] != 0) return dp[l][r][k];
        while (r > l && boxes[r] == boxes[r - 1]) {
            r--;
            k++;
        }
        dp[l][r][k] = calculatePoints(boxes, dp, l, r - 1, 0) + (k + 1) * (k + 1);
        for (int i = l; i < r; i++) {
            if (boxes[i] == boxes[r]) {
                dp[l][r][k] = Math.max(dp[l][r][k], calculatePoints(boxes, dp, l, i, k + 1) + calculatePoints(boxes, dp, i + 1, r - 1, 0));
            }
        }
        return dp[l][r][k];
    }
}