Leetcode刷题 2021.01.06

Leetcode1080 根到叶路径上的不足节点

第一次写博客，也不知道从哪里开始写起。最近在憋毕业论文，空余时间刷刷力扣。这几天拼多多猝死事件很火，但是还是很想去互联网。在上海买房压力真大╮(╯▽╰)╭。

中等题目里面二叉树还算是比较简单的吧。

给定一棵二叉树的根 root，请你考虑它所有 从根到叶的路径：从根到任何叶的路径。（所谓一个叶子节点，就是一个没有子节点的节点）

假如通过节点 node 的每种可能的 “根-叶” 路径上值的总和全都小于给定的 limit，则该节点被称之为「不足节点」，需要被删除。

请你删除所有不足节点，并返回生成的二叉树的根。

人话就是如果一个子树的和如果路径和没可能大于等于给定的阈值，就把他删掉。
二叉树递归题首先想一想对于一颗子树要做什么吧。想象一颗子树，如果左子树要删除，那就让根节点指向null，右子树同理。所以辅助函数返回一个布尔值。既然要求路径和，那就从底往上递归，如果要删除了，就返回false，然后删除即可。对于结点为null的值，再想想该返回什么。

class Solution {
    public TreeNode sufficientSubset(TreeNode root, int limit) {
        boolean flag = helper(root, limit);
        //根节点也是false的话就返回null
        return flag == false ? null : root;
    }

    private boolean helper(TreeNode root, int limit){
    	//叶子结点返回false
        if (root == null) return false;
        //左右子树的布尔值
        boolean l = helper(root.left, limit - root.val);
        boolean r = helper(root.right, limit - root.val);
        //对于叶子结点，判断一下直接返回
        if (root.left == null && root.right == null){
            return root.val >= limit;
        }
        //如果返回false，就删除
        if (!l) root.left = null;
        if (!r) root.right = null;
		//左右子树有一个为true就不用删除
        return l || r;
    }
}

Leetcode1008 前序遍历构造二叉搜索树

又是二叉树的题，中等题其他都费脑子，就二叉树容易点。
每天刷三道新题，加上每日一题，一天能有30积分。还差3000分能换力扣三件套。要是中等题都是二叉树就好了。

输入：[8,5,1,7,10,12]
输出：[8,5,10,1,7,null,12]

图就不放了，比较简单，类似于从前序中序构建二叉树那题。既然是二叉搜索树，又是前序遍历。那根节点就是每次递归的第一个节点，然后找第一个大于头元素的位置就行了。

class Solution {
    public TreeNode bstFromPreorder(int[] preorder) {
        return helper(preorder, 0, preorder.length - 1);
    }

    private TreeNode helper(int[] preorder, int i, int j){
        if (i > j) return null;
        TreeNode root = new TreeNode(preorder[i]);
        int index = i;
        //找第一个大于头元素的位置，就是右子树的位置
        while(index <= j && preorder[index] <= preorder[i]) index++;
        root.left = helper(preorder, i + 1, index - 1);
        root.right = helper(preorder, index, j);

        return root;
    }
}

Leetcode990 等式方程的可满足性

今天的每日一题是leetcode399，好像是带权并查集。晚上没时间看了，先看了前导题990，基本就是并查集模板了。之前一直想学并查集，但是面试又不怎么考，所以就一直拖，果然是面向面试编程。

输入：[“a==b”,“b!=a”]
输出：false
解释：如果我们指定，a = 1 且 b = 1，那么可以满足第一个方程，但无法满足第二个方程。没有办法分配变量同时满足这两个方程。

思路就是并查集，构建一个数组。数组下标表示自己，数组的值表示父节点的下标。先遍历”==“的字符，把她们归为一类。再遍历”!=“的字符，如果出现矛盾，就返回false。
其实会了还是比较简单，关键要怎么看出来是并查集。还有并查集查找时候的路径压缩，记一记，看看怎么写的。

class Solution {
    public boolean equationsPossible(String[] equations) {
        int[] arr = new int[26];
        for(int i = 0; i < arr.length; i++){
            arr[i] = i;
        }
        for(String s :equations){
       		//相等，就是一类，合并
            if (s.charAt(1) == '='){
                int index1 = s.charAt(0) - 'a';
                int index2 = s.charAt(3) - 'a';
                union(arr, index1, index2);
            }
        }
        for(String s :equations){
        	//不等，查出来是一类，返回false
            if (s.charAt(1) == '!'){
                int index1 = s.charAt(0) - 'a';
                int index2 = s.charAt(3) - 'a';
                if (find(arr, index1) == find(arr, index2)){
                    return false;
                }
            }
        }
        return true;
    }

    private int find(int[] arr, int index){
    	//路径压缩，拿个例子好好想一想
        while (arr[index] != index){
            arr[index] = arr[arr[index]];
            index = arr[index];
        }
        return index;
    }

    private void union(int[] arr, int index1, int index2){
    	//合并
        arr[find(arr, index1)] = find(arr, index2);
    }
}