day10-算法热题10题

LeetCode 热题 Hot 100

• 242. 有效的字母异位词

class Solution {
   public boolean isAnagram(String s, String t) {
        int sLen = s.length();
        int tLen = t.length();
        if (sLen != tLen) return false;
        // 若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
        // 用数组来做
        int[] sArray = new int[26], tArray = new int[26];
        for (int i = 0; i < sLen; i++) {
            // 当前这个char相对于'a'的位置0~25,
            // sArray[0]++ "anagram",
            sArray[s.charAt(i) - 'a']++;
            tArray[t.charAt(i) - 'a']++;
        }
        return Arrays.equals(sArray,tArray);
    }
}

• 567. 字符串的排列

class Solution {
    
    /**
     * s1 = "ab" s2 = "eidbaooo"
     * 滑动窗口
     * 一开始我们都以小的字符串数量进行匹配
     */
    public boolean checkInclusion(String s1, String s2) {
        int s1Len = s1.length();
        int s2Len = s2.length();
        if (s1Len > s2Len) return false;
        int[] s1Array = new int[26];
        int[] s2Array = new int[26];
        for (int i = 0; i < s1Len; i++) {
            s1Array[s1.charAt(i) - 'a']++;
            s2Array[s2.charAt(i) - 'a']++;
        }
        int left = 0, right = s1Len - 1;
        while (right < s2Len) {
            if (Arrays.equals(s1Array, s2Array)) return true;
            right++;
            if (right != s2Len) {
                // 频率++
                s2Array[s2.charAt(right) - 'a']++;
            }
            // 把之前出现过的清空掉
            s2Array[s2.charAt(left) - 'a']--;
            // 窗口往前移动
            left++;
        }
        return false;
    }
}

• 438. 找到字符串中所有字母异位词

class Solution {
      /**
     * 滑动窗口
     * 输入: s = "cbaebabacd", p = "abc"
     * 输出: [0,6]
     */
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> res = new ArrayList<>();
        int sLen = s.length();
        int pLen = p.length();
        if (pLen > sLen) return res;
        int[] sArray = new int[26], pArray = new int[26];
        // 初始化
        for (int i = 0; i < pLen; i++) {
            sArray[s.charAt(i) - 'a']++;
            pArray[p.charAt(i) - 'a']++;
        }
        // 窗口长度为p的长度
        int left = 0, right = pLen - 1;
        while (right < sLen) {
            // 比较两个是否相等
            if (Arrays.equals(pArray, sArray)) {
                res.add(left);
            }
            // 右边的移动
            right++;
            if (right != sLen) {
                sArray[s.charAt(right) - 'a']++;
            }
            sArray[s.charAt(left) - 'a']--;
            left++;
        }
        return res;
    }
}

• 448. 找到所有数组中消失的数字

class Solution {
  public List<Integer> findDisappearedNumbers(int[] nums) {
        var res = new ArrayList<Integer>();
        boolean[] hasNum = new boolean[nums.length + 1];
        for (int num : nums) {
            hasNum[num] = true;
        }
        for (int i = 1; i <= nums.length; i++) {
            if (!hasNum[i]) res.add(i);
        }
        return res;
    }
}

• 461. 汉明距离

class Solution {
   public int hammingDistance(int x, int y) {
        return bitCount(x ^ y);
    }

    private int bitCount(int i) {
        int count = 0;
        while (i > 0) {
            if (i % 2 == 1) {
                count++;
            }
            i >>= 1;
        }
        return count;
    }
}

• 494. 目标和

class Solution {
       /**
     * 输入：nums = [1,1,1,1,1], target = 3
     * 输出：5
     * 解释：一共有 5 种方法让最终目标和为 3 。
     * -1 + 1 + 1 + 1 + 1 = 3
     * +1 - 1 + 1 + 1 + 1 = 3
     * +1 + 1 - 1 + 1 + 1 = 3
     * +1 + 1 + 1 - 1 + 1 = 3
     * +1 + 1 + 1 + 1 - 1 = 3
     * 有多种解法，可以用回溯算法剪枝求解，也可以用转化成背包问题求解，这里用前者吧，
     * 容易理解一些，背包问题解法可以查看详细题解。
     * 对于每一个 1，要么加正号，要么加符号，把所有情况穷举出来，即可计算结果。
     */
    Map<String, Integer> memo = new HashMap<>();

    public int findTargetSumWays(int[] nums, int target) {
        if (nums.length == 0) return 0;
        return backtrace(nums, 0, target);
    }

    private int backtrace(int[] nums, int idx, int target) {
        // base case
        if (idx == nums.length) {
            return target == 0 ? 1 : 0;
        }
        // 把它俩转成字符串才能作为哈希表的键
        // 0,3
        String key = idx + "," + target;
        // 避免重复计算
        if (memo.containsKey(key)) {
            return memo.get(key);
        }
        // 还是穷举
        int result = backtrace(nums, idx + 1, target - nums[idx]) + backtrace(nums, idx + 1, target + nums[idx]);
        memo.put(key, result);
        return result;
    }
}

• 538. 把二叉搜索树转换为累加树

/**
 * 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 {
 /**
     * 维护一个外部累加变量 sum，在遍历 BST 的过程中增加 sum，
     * 同时把 sum 赋值给 BST 中的每一个节点，就将 BST 转化成累加树了。
     */

     int sum = 0;
    public TreeNode convertBST(TreeNode root) {
        if (root == null) return null;
        // 先看right
        convertBST(root.right);
        root.val += sum;
        sum = root.val;
        convertBST(root.left);
        return root;
    }
}

• 543. 二叉树的直径

/**
 * 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 {
    /**
     * 所谓二叉树的直径，就是左右子树的最大深度之和，那么直接的想法是对每个节点计算左右子树的最大高度，
     * 得出每个节点的直径，从而得出最大的那个直径。
     */
    int max = Integer.MIN_VALUE;

    public int diameterOfBinaryTree(TreeNode root) {
        depth(root);
        return max;
    }

    public int depth(TreeNode root) {
        if (root == null) return 0;
        int leftDepth = depth(root.left);
        int rightDepth = depth(root.right);
        max = Math.max(max, leftDepth + rightDepth);
        return Math.max(leftDepth, rightDepth) + 1;
    }
}

• 560. 和为 K 的子数组

class Solution {
     /**
     * 子数组求和的经典技巧就是前缀和，原理就是对数组进行预处理，
     * 计算前缀和数组，从而在 O(1) 时间计算子数组和。
     * 0 <= i <= j <= n
     * sum(i,j) = k
     * <p>
     * <p>
     * s(0,j) - sum(0,i-1) = k
     * prefix_sum(0,i-1)
     */
    public int subarraySum(int[] nums, int k) {
        if (nums == null || nums.length == 0) return 0;
        // 前缀和一共出现了几次
        Map<Integer, Integer> map = new HashMap<>();
        // 一开始0出现了一次
        map.put(0, 1);
        int count = 0;
        int prefixSum = 0;
        for (int num : nums) {
            prefixSum += num;
            // diff = prefixSum(i-1)
            int diff = prefixSum - k;
            count += map.getOrDefault(diff, 0);
            map.put(prefixSum, map.getOrDefault(prefixSum, 0) + 1);
        }
        return count;
    }
}

• 581. 最短无序连续子数组

class Solution {
   public int findUnsortedSubarray(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        int[] newArray = Arrays.copyOf(nums, nums.length);
        Arrays.sort(newArray);
        int start = 0;
        int end = nums.length - 1;
        while (start < end) {
            if (nums[start] == newArray[start]) {
                start++;
            } else if (nums[end] == newArray[end]) {
                end--;
            } else {
                return end - start + 1;
            }
        }
        return 0;
    }

}

• 617. 合并二叉树

/**
 * 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 TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if (root1 == null && root2 == null) return null;
        if (root1 == null) return root2;
        if (root2 == null) return root1;
        // 两棵树都有的节点，叠加节点值
        TreeNode root = new TreeNode(root1.val + root2.val);
        // 递归合并左右子树
        root.left = mergeTrees(root1.left, root2.left);
        root.right = mergeTrees(root1.right, root2.right);
        return root;
    }
}

• 621. 任务调度器

暂时不写

• 647. 回文子串

class Solution {
  public int countSubstrings(String s) {
        if (s == null || s.length() == 0) return 0;
        int len = s.length();
        // 从第i~j位是不是回文串 状态容器
        boolean[][] dp = new boolean[len][len];
        //回文串的数量
        int count = 0;
        for (int i = len - 1; i >= 0; i--) {
            for (int j = i; j < len; j++) {
                //如果i和j指向的字符不一样，那么dp[i][j]就
                //不能构成回文字符串
                if (s.charAt(i) != s.charAt(j)) continue;
                dp[i][j] = j - i <= 2 || dp[i + 1][j - 1];
                if (dp[i][j]) count++;
            }
        }
        return count;
    }
}

• 739. 每日温度

  /**
     * temperatures = [73,74,75,71,69,72,76,73]
     * index value
     * 2   ->  75
     * <p>
     * <p>
     * 输出: [1,1,4,2,1,1,0,0]
     * 单调栈
     */
    public int[] dailyTemperatures(int[] temperatures) {
        if (temperatures == null || temperatures.length == 0) return new int[]{};
        int[] answer = new int[temperatures.length];
        // 存下标
        Stack<Integer> idxStack = new Stack<Integer>();
        for (int i = 0; i < temperatures.length; i++) {
            // 当前值大于栈顶元素?大于的话就是 当前索引减去栈顶的索引 否则 是0
            while (!idxStack.isEmpty() && temperatures[i] > temperatures[idxStack.peek()]) {
                // 然后出栈
                answer[idxStack.peek()] = i - idxStack.pop();
            }
            idxStack.push(i);
        }
        return answer;
    }