day08-算法热题10题

LeetCode 热题 Hot 100

• 279. 完全平方数

class Solution {
  /**
     * dp[i] 表示i的完全平方和的最少数量，dp[i - j * j] + 1表示减去一个完全平方数j的完全平方之后的数量加1就等于dp[i]，
     * 只要在dp[i], dp[i - j * j] + 1中寻找一个较少的就是最后dp[i]的值。
     */
    public int numSquares(int n) {
        int[] dp = new int[n + 1];
        dp[0] = 0;
        for (int i = 1; i <= n; i++) {
            // 最坏的情况 比如 dp[3] = 1 + 1 + 1
            dp[i] = i;
            // 枚举前一个状态
            for (int j = 1; i - j * j >= 0; j++) {
                // 动态转移方程
                dp[i] = Math.min(dp[i], dp[i - j * j] + 1);
            }
        }
        return dp[n];
    }
}

• 283. 移动零

class Solution {
   public void moveZeroes(int[] nums) {
        // 去除 nums 中的所有 0
        // 返回去除 0 之后的数组长度
        int len = removeElement(nums, 0);
        while (len < nums.length) {
            nums[len] = 0;
            len++;
        }
    }

    /**
     * 双指针技巧，复用 [27. 移除元素] 的解法。
     */
    private int removeElement(int[] nums, int val) {
        /**
         * fast遍历用
         * slow记录应该到哪个位置放0
         */
        int fast = 0, slow = 0;
        while (fast < nums.length) {
            if (nums[fast] != val) {
                nums[slow] = nums[fast];
                slow++;
            }
            fast++;
        }
        return slow;
    }
}

• 287. 寻找重复数

class Solution {
  public int findDuplicate(int[] nums) {
        /**
         * 把数组中的数全部当做下标处理
         * 值为1的放在下标为1的地方
         * ..
         */
        while (true) {
            int idx = nums[0];
            if (nums[idx] == nums[0]) {
                return nums[0];
            } else {
                int t = nums[idx];
                nums[idx] = nums[0];
                nums[0] = t;
            }
        }
    }
}

• 297. 二叉树的序列化与反序列化

暂时不写

• 300. 最长递增子序列

class Solution {
    /**
     * 动态规划
     */
    public int lengthOfLIS(int[] nums) {
        int n = nums.length;
        // dp[i] 表示以 nums[i] 这个数结尾的最长递增子序列的长度
        int[] dp = new int[n];
        // base case：dp 数组全都初始化为 1
        Arrays.fill(dp, 1);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
        }
        int res = 0;
        for (int i = 0; i < n; i++) {
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

• 301. 删除无效的括号

暂时不写

• 309. 最佳买卖股票时机含冷冻期

class Solution {
/**
     * dp[i][k][0 or 1]
     * 0 <= i <= n - 1, 1 <= k <= K
     * n 为天数，大 K 为交易数的上限，0 和 1 代表是否持有股票。
     *
     * dp[i][0]: 持有1股票的最大利润
     * dp[i][1]: 持有0股票当天卖掉
     * dp[i][2]: 持有0股票非当天卖掉
     *
     * dp[i][0] = max ( dp[i-1][0],dp[i-1][2] - prices[i] )
     * dp[i][1] = dp[i-1][0] + prices[i]
     * dp[i][2] =  max ( dp[i-1][1] , dp[i-1][2])
     *
     * dp[0][0] = 0 - prices[0]
     * dp[0][1] = 0
     * dp[0][2] = 0
     */
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n][3];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        dp[0][2] = 0;
        for (int i = 1; i < n; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][2] - prices[i]);
            dp[i][1] = dp[i - 1][0] + prices[i];
            dp[i][2] = Math.max(dp[i - 1][1], dp[i - 1][2]);
        }
        return Math.max(dp[n - 1][0], Math.max(dp[n - 1][1], dp[n - 1][2]));
    }
}

• 312. 戳气球

暂时不写

• 322. 零钱兑换

class Solution {
  /**
     * coins = [1, 2, 5], amount = 11
     * 确定 base case，显然目标金额 amount 为 0 时算法返回 0，因为不需要任何硬币就已经凑出目标金额了。
     * 确定「状态」，也就是原问题和子问题中会变化的变量。由于硬币数量无限，硬币的面额也是题目给定的，
     * 只有目标金额会不断地向 base case 靠近，所以唯一的「状态」就是目标金额 amount。
     * 确定「选择」，也就是导致「状态」产生变化的行为。目标金额为什么变化呢，因为你在选择硬币，你每选择一枚硬币，
     * 就相当于减少了目标金额。所以说所有硬币的面值，就是你的「选择」。
     */
    public int coinChange(int[] coins, int amount) {
        // 存放每个金额使用硬币个数
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        // corner case
        dp[0] = 0;
        for (int curAmount = 1; curAmount <= amount; curAmount++) {
            for (int coin : coins) {
                // 剩余金额
                int leftAmount = curAmount - coin;
                if (leftAmount < 0 || dp[leftAmount] == Integer.MAX_VALUE) continue;
                dp[curAmount] = Math.min(dp[leftAmount] + 1, dp[curAmount]);
            }
        }
           return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];
    }
}

• 337. 打家劫舍 III

/**
 * 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 rob(TreeNode root) {
        if (root == null) return 0;
        // rob root
        int res1 = root.val;
        if (root.left != null) {
            // 走下一层
            res1 += rob(root.left.left) + rob(root.left.right);
        }
        if (root.right != null) {
            res1 += rob(root.right.left) + rob(root.right.right);
        }

        // not rob root
        int res2 = 0;
        res2 += rob(root.left) + rob(root.right);
        return Math.max(res1, res2);
    }*/


    public int rob(TreeNode root) {
        if (root == null) return 0;
        // TreeNode,当前最大值
        Map<TreeNode, Integer> map = new HashMap<>();
        return rob(root, map);
    }

    private int rob(TreeNode root, Map<TreeNode, Integer> map) {
        if (root == null) return 0;
        if (map.containsKey(root)) return map.get(root);
        // rob root
        int res1 = root.val;
        if (root.left != null) {
            // 走下一层
            res1 += rob(root.left.left, map) + rob(root.left.right, map);
        }
        if (root.right != null) {
            res1 += rob(root.right.left, map) + rob(root.right.right, map);
        }

        // not rob root
        int res2 = 0;
        res2 += rob(root.left, map) + rob(root.right, map);
        int res = Math.max(res1, res2);
        map.put(root, res);
        return res;
    }
}