LeetCode三則

三道動態規劃

62. 不同路徑

一個機器人位於一個 m x n 網格的左上角 （起始點在下圖中標記為 “Start” ）。

機器人每次只能向下或者向右移動一步。機器人試圖達到網格的右下角（在下圖中標記為 “Finish” ）。

問總共有多少條不同的路徑？

輸入：m = 3, n = 7
輸出：28

輸入：m = 3, n = 2
輸出：3
解釋：
從左上角開始，總共有 3 條路徑可以到達右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

public class Solution {
    public static void main(String[] args) {
        Solution solution = new Solution();
        int result = solution.uniquePaths(3, 2);
        System.out.println(result);

        result = solution.uniquePaths(7, 3);
        System.out.println(result);
    }

    /**
     * @author XiSoil
     * @date 2024/04/18 23:18
     *執行分佈用時0ms,擊敗的100.00%Java使用者
     *消耗記憶體分佈33.98MB,擊敗的65.54%Java使用者
     **/
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }
        for (int j = 0; j < n; j++) {
            dp[0][j] = 1;
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i == 0 || j == 0) {
                    continue;
                }
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
}

64. 最小路徑和

給定一個包含非負整數的 m x n 網格 grid ，請找出一條從左上角到右下角的路徑，使得路徑上的數字總和為最小。

說明：每次只能向下或者向右移動一步。

示例 1：

輸入：grid = [[1,3,1],[1,5,1],[4,2,1]]
輸出：7
解釋：因為路徑 1→3→1→1→1 的總和最小。

示例 2：

輸入：grid = [[1,2,3],[4,5,6]]
輸出：12
解釋：因為路徑 1→3→5→2→1 的總和最小。

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 200
0 <= grid[i][j] <= 100

public class Solution {
    public static void main(String[] args) {
        int[][] grid = {{1, 3, 1}, {1, 5, 1}, {4, 2, 1}};
        System.out.println(new Solution().minPathSum(grid));

        grid = new int[][]{{1, 2, 3}, {4, 5, 6}};
        System.out.println(new Solution().minPathSum(grid));
    }

    /**
     * @author XiSoil
     * @date 2024/04/18 23:26
     *執行分佈用時2ms,擊敗的94.88%Java使用者
     *消耗記憶體分佈44.30MB,擊敗的86.89%Java使用者
     **/
    public int minPathSum(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] dp = new int[m][n];
        dp[0][0] = grid[0][0];
        for (int i = 1; i < m; i++) {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }
        for (int i = 1; i < n; i++) {
            dp[0][i] = dp[0][i - 1] + grid[0][i];
        }
        for (int i = 1; i < m; i++)
            for (int j = 1; j < n; j++) {
                dp[i][j] = Math.min(dp[i - 1][j] + grid[i][j], dp[i][j - 1] + grid[i][j]);
            }
        return dp[m - 1][n - 1];
    }
}

740. 刪除並獲得點數
給你一個整數陣列 nums ，你可以對它進行一些操作。

每次操作中，選擇任意一個 nums[i] ，刪除它並獲得 nums[i] 的點數。之後，你必須刪除 所有 等於 nums[i] - 1 和 nums[i] + 1 的元素。

開始你擁有 0 個點數。返回你能透過這些操作獲得的最大點數。

示例 1：
輸入：nums = [3,4,2]
輸出：6
解釋：
刪除 4 獲得 4 個點數，因此 3 也被刪除。
之後，刪除 2 獲得 2 個點數。總共獲得 6 個點數。

示例 2：
輸入：nums = [2,2,3,3,3,4]
輸出：9
解釋：
刪除 3 獲得 3 個點數，接著要刪除兩個 2 和 4 。
之後，再次刪除 3 獲得 3 個點數，再次刪除 3 獲得 3 個點數。
總共獲得 9 個點數。


提示：
1 <= nums.length <= 2 * 104
1 <= nums[i] <= 104

public class Solution {
    public static void main(String[] args) {
        int[] nums = {3, 4, 2};
        System.out.println(new Solution().deleteAndEarn(nums));
        nums = new int[]{2, 2, 3, 3, 3, 4};
        System.out.println(new Solution().deleteAndEarn(nums));
    }
    /**
     * @author XiSoil
     * @date 2024/04/18 23:11
     *執行分佈用時3ms,擊敗的52.91%Java使用者
     *消耗記憶體分佈44.61MB,擊敗的6.65%Java使用者
     **/
    public int deleteAndEarn(int[] nums) {
        int[] earns = new int[10001];
        int maxNum = 0;
        for (int num : nums) {
            earns[num] += num;
            maxNum = Math.max(maxNum, num);
        }
        int[] earnList = new int[10001];
        earnList[0] = earns[0];
        earnList[1] = Math.max(earns[0], earns[1]);
        for (int i = 2; i <= maxNum; i++) {
            earnList[i] = Math.max(earnList[i-1],earns[i]+earnList[i-2]);
        }
        return earnList[maxNum];
    }
}