add dp code

Author: imwwjh

.idea/encodings.xml

@@ -0,0 +1,25 @@
+package Dp;
+
+import java.math.BigDecimal;
+
+public class Hanoi {
+    // 递归方法解决汉诺塔问题
+    public static void hanoi(int n, char source, char auxiliary, char target) {
+        if (n == 1) {
+            System.out.println("Move disk 1 from " + source + " to " + target);
+            return;
+        }
+        // 先将 n-1 个盘子从源柱子借助目标柱子移动到辅助柱子
+        hanoi(n - 1, source, target, auxiliary);
+        // 移动第 n 个盘子到目标柱子
+        System.out.println("Move disk " + n + " from " + source + " to " + target);
+        // 再将 n-1 个盘子从辅助柱子借助源柱子移动到目标柱子
+        hanoi(n - 1, auxiliary, source, target);
+    }
+
+    public static void main(String[] args) {
+        int n = 3; // 汉诺塔的层数，可以修改这个值来测试不同层数
+        hanoi(n, 'A', 'B', 'C');
+    }
+}
+

BackTrack/Q51/Q51.java

@@ -0,0 +1,24 @@
+package Dp.Q118;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+    public List<List<Integer>> generate(int numRows) {
+        List<List<Integer>> triangle = new ArrayList<>();
+
+        for (int i = 0; i < numRows; i++) {
+            List<Integer> row = new ArrayList<>();
+            for (int j = 0; j <= i; j++) {
+                if (j == 0 || j == i) {
+                    row.add(1);
+                } else {
+                    List<Integer> prevRow = triangle.get(i - 1);
+                    row.add(prevRow.get(j - 1) + prevRow.get(j));
+                }
+            }
+            triangle.add(row);
+        }
+        return triangle;
+    }
+}

Dp/Hanoi.java

@@ -17,6 +17,23 @@ public static int rob(int[] nums) {
         return dp[nums.length - 1];
     }
 
+    public int rob2(int[] nums) {
+        int prev = 0;
+        int curr = 0;
+
+        // 每次循环，计算“偷到当前房子为止的最大金额”
+        for (int i : nums) {
+            // 循环开始时，curr 表示 dp[k-1]，prev 表示 dp[k-2]
+            // dp[k] = max{ dp[k-1], dp[k-2] + i }
+            int temp = Math.max(curr, prev + i);
+            prev = curr;
+            curr = temp;
+            // 循环结束时，curr 表示 dp[k]，prev 表示 dp[k-1]
+        }
+
+        return curr;
+    }
+
     public static void main(String[] args) {
         int[] nums = {1, 2, 3, 1};
         System.out.println("能够偷窃到的最高金额是: " + rob(nums));

Dp/Q118/Solution.java

@@ -0,0 +1,30 @@
+package Dp.Q198;
+
+import java.util.Arrays;
+
+
+//记忆化搜索
+class Solution {
+    private int[] nums, memo;
+
+    public int rob(int[] nums) {
+        this.nums = nums;
+        int n = nums.length;
+        memo = new int[n];
+        Arrays.fill(memo, -1); // -1 表示没有计算过
+        return dfs(n - 1); // 从最后一个房子开始思考
+    }
+
+    // dfs(i) 表示从 nums[0] 到 nums[i] 最多能偷多少
+    private int dfs(int i) {
+        if (i < 0) { // 递归边界（没有房子）
+            return 0;
+        }
+        if (memo[i] != -1) { // 之前计算过
+            return memo[i];
+        }
+        int res = Math.max(dfs(i - 1), dfs(i - 2) + nums[i]);
+        memo[i] = res; // 记忆化：保存计算结果
+        return res;
+    }
+}

Dp/Q198/HouseRobber.java

@@ -0,0 +1,17 @@
+package Dp.Q322;
+
+import java.util.Arrays;
+
+class Solution {
+    public int coinChange(int[] coins, int amount) {
+        int[] dp = new int[amount + 1];
+        Arrays.fill(dp, 10001);
+        dp[0] = 0;
+        for(int coin : coins){
+            for(int j = coin; j < amount + 1; j++){
+                    dp[j] = Math.min(dp[j], dp[j - coin] + 1);
+            }
+        }
+        return dp[amount] != 10001 ? dp[amount] : -1;
+    }
+}

Dp/Q198/Solution.java

@@ -0,0 +1,16 @@
+package Dp.Q70;
+
+
+//¿Õ¼äÓÅ»¯µÄ´úÂë
+class Solution {
+    public int climbStairs(int n) {
+        int f0 = 1;
+        int f1 = 1;
+        for (int i = 2; i <= n; i++) {
+            int newF = f1 + f0;
+            f0 = f1;
+            f1 = newF;
+        }
+        return f1;
+    }
+}

Dp/Q322/Solution.java

@@ -0,0 +1,7 @@
+### 动态规划的四步走
+
+
+1. 定义子问题
+2. 写出子问题的递推关系
+3. 确定DP数组的计算顺序
+4. 空间优化 （可选）

Dp/Q70/Solution.java

@@ -0,0 +1,7 @@
+### 动态规划的四步走
+
+
+1. 定义子问题
+2. 写出子问题的递推关系
+3. 确定DP数组的计算顺序
+4. 空间优化 （可选）