1 import java.util.HashMap;
 2 
 3 /**
 4  * 
 5  *原文链接: https://wx.abbao.cn/a/4736-4b66e5f9ec584ee0.html
 6  * 
 7  * 走楼梯问题:有一座高度是10级台阶的楼梯,从下往上走,每跨一步只能向上1级或者2级台阶。要求用程序来求出一共有多少种走法。
 8  * 
 9  * 這是一道入门级的动态递归问题
10  * 
11  * 问题分析:
12  * 
13  * 最有子结构: 最后一步走到第十层有多少种方法?2种:8-》10;9-》10 那么如果走到 8 有x种情况,走到9有y中情况 走到10可以看成x+y
14  * 
15  * 状态转移方程 若用公式表达f(10)=f(9)+f(8) 既 f(n) = f(n-1) + f(n-2)
16  * 
17  * 边界 走到第二层可以走一步,也可以走俩步。即f(2) = 2 第一层只能走一步 f(1) =1
18  * 
19  * 以上是问题建模 解析来是问题求解
20  */
21 public class WalkStair {
22     public static void main(String[] args) {
23         System.out.println(getWayStair1(10));
24         System.out.println(getWayStair2(10, new HashMap<Integer, Integer>()));
25         System.out.println(getWayStair3(10));
26     }
27 
28     /**
29      * 第一种思路:用递归的方式
30      * 
31      * @param n n层楼梯
32      * 
33      *          这里需要注意一下复杂度问题 这个二叉树长度n-1,节点2^n-1,时间复杂度2^n
34      */
35     public static int getWayStair1(int n) {
36         if (n == 1) {
37             return 1;
38         }
39         if (n == 2) {
40             return 2;
41         }
42         return getWayStair1(n - 1) + getWayStair1(n - 2);
43     }
44 
45     /**
46      * 第二种思路:还是递归,但是重复的计算几点可以不在计算,叫做备忘录算法 利用map将已经计算过的节点保存
47      * 
48      * 时间复杂度是 o(n)
49      * 
50      * @param n
51      * @param map
52      * @return
53      */
54     public static int getWayStair2(int n, HashMap<Integer, Integer> map) {
55         if (n == 1) {
56             return 1;
57         }
58         if (n == 2) {
59             return 2;
60         }
61         if (map.containsKey(n)) {
62             return map.get(n);
63         } else {
64             int value = getWayStair1(n - 1) + getWayStair1(n - 2);
65             map.put(n, value);
66             return value;
67         }
68     }
69 
70     /**
71      * 第三种思路:动态规划,每次得到的结果只是上俩次结果的和 时间复杂度o(n) 空间复杂度o(1)
72      * 
73      * @param n
74      * @return
75      */
76     public static int getWayStair3(int n) {
77         if (n == 0) {
78             return 0;
79         }
80         if (n == 1) {
81             return 1;
82         }
83         if (n == 2) {
84             return 2;
85         }
86 
87         int a = 1;
88         int b = 2;
89         int temp = 0;
90         for (int i = 3; i <= n; i++) {
91             temp = a + b;
92             a = b;
93             b = temp;
94         }
95         return temp;
96     }
97 }

 

 1 /**
 2  * 问题描述:十个人挖五座金矿,求挖到的最多的金子个数
 3  * 
 4  * 思路: 最优子结构: ‘1:第五座金矿挖 ’2:第五座金矿不挖 边界: ‘1:挖一座金矿 人数够 ’2:挖一座金矿人数不够 状态转移方程
 5  *
 6  */
 7 public class GoldMiner {
 8     /**
 9      * 
10      * @param n 前 n 座矿
11      * @param w 工人个数
12      * @param p 每座矿需要的工人个数
13      * @param g 每座矿的金子个数
14      * @return
15      */
16     public static int getMaxGold(int n, int w, int p[], int g[]) {
17 
18         // ‘前三个if是边界值
19         if (n < 1) {
20             return 0;
21         }
22         if (n == 1 && w < p[0]) {
23             return 0;
24         }
25         if (n == 1 && w >= p[0]) {
26             return g[0];
27         }
28 
29         // ’这里是初始化结果
30         int[] preResult = new int[w + 1];
31         int[] result = new int[w + 1];
32         for (int i = 0; i < w; i++) {
33             if (w >= p[0]) {
34                 preResult[i] = g[0];
35             } else {
36                 preResult[i] = 0;
37             }
38         }
39 
40         /**
41          * ‘外层循环控制挖第几座金矿,内层第一层循环控制可能挖的最优结果,内层第二层循环刷新可能获得最优结果,最後返回當前人人数能挖的最优结果
42          */
43         for (int i = 0; i < n; i++) {
44             for (int j = 0; j <= w; j++) {
45                 if (j < p[i]) {
46                     result[j] = preResult[j];
47                 } else {
48                     result[j] = Math.max(preResult[j], preResult[j - p[i]] + g[i]);
49                 }
50             }
51             for (int j = 0; j <= w; j++) {
52                 preResult[j] = result[j];
53             }
54         }
55         return result[w];
56     }
57 
58     public static void main(String[] args) {
59         int[] g = { 400, 500, 200, 300, 350 };
60         int[] p = { 5, 5, 3, 4, 3 };
61         System.out.println(getMaxGold(5, 10, p, g));
62     }
63 }

 

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 
 4 /**
 5  * 问题:
 6  * Given a non-empty string s and a dictionary wordDict containing a list of
 7  * non-empty words, determine if s can be segmented into a space-separated
 8  * sequence of one or more dictionary words.
 9  *
10  */
11 public class Lc139 {
12     /**
13      * 思路:dp 上一个串的位置到当前截取串的位置恰好是一个字典串
14      * @param s
15      * @param wordDict
16      * @return
17      */
18     public static boolean wordBreak(String s, List<String> wordDict) {
19         boolean[] dp = new boolean[s.length() + 1];
20         dp[0] = true;
21 
22         for (int i = 1; i < dp.length; i++) {
23             for (int j = 0; j < i; j++) {
24                 if (true == dp[j] && wordDict.contains(s.substring(j, i))) {
25                     dp[i] = true;
26                 }
27             }
28         }
29         return dp[s.length()];
30     }
31 
32     public static void main(String[] args) {
33         String s = "leetcode";
34         String s1 = "leet";
35         String s2 = "code";
36         List<String> wordDict = new ArrayList<String>();
37         wordDict.add(s1);
38         wordDict.add(s2);
39         System.out.println(wordBreak(s, wordDict));
40     }
41 }