目錄
1 暴力遞歸到動態規划
本篇是算法基礎筆記的最后一篇，前面所記錄的和該篇共同覆蓋了平時刷題常用的數據結構和算法，之后就是通過刷題量來鞏固所學的內容。接下來我准備針對基礎數據結構和算法做一些刷題記錄，主要是分類別刷leetcode上的題，傳送門為：https://github.com/Dairongpeng/leetcode 一起刷題吧_。
轉載注明出處，源碼地址： https://github.com/Dairongpeng/algorithm-note ，歡迎star
動態規划最核心的是暴力遞歸的嘗試過程，一旦通過嘗試寫出來暴力遞歸的解法，那么動態規划在此基礎上就很好改了
1、暴力遞歸之所以暴力，是因為存在大量的重復計算。加入我們定義我們的緩存結構，用來查該狀態有沒有計算過，那么會加速我們的遞歸
2、在我們加入緩存結構之后，消除了大量的重復計算，緩存表就是我們的dp表。那么這種去除重復計算的遞歸，就是最粗糙的動態規划，也叫記憶化搜索
3、如果我們把我們的dp表，從簡單到復雜列出來，那么就是經典的動態規划。我們無需考慮轉移方程怎么寫，而是根據我們的遞歸來推導。看下面例子：
1.1 例一 : 機器人運動問題(2018阿里面試題目)
認識暴力遞歸改動態規划的過程
假設有排成一行的N個位置，記為1N,N一定大於等於2。開始時機器人在其中的M位置上（M一定是1N中的一個）。
如果機器人來到1位置，那么下一步只能往右來到2位置；
如果機器人來到N位置，那么下一步只能往左來到N-1的位置；
如果機器人來到中間位置，那么下一步可以往左走或者往右走；
規定機器人必須走K步，最終能來到P位置（P也是1~N中的一個）的方法有多少種？
給定四個參數N,M,K,P。返回方法數
暴力遞歸ways1調用的walk函數，就是暴力遞歸過程，存在重復計算。waysCache方法對應的walkCache就是在純暴力遞歸的基礎上加了緩存
假設我們的參數N=7，M=2,K=5,P=3。我們根據我們的遞歸加緩存的過程來填我們的dp表：
1、int[][] dp = new int[N+1][K+1];是我們的DP表的范圍
2、當rest = 0的時候，dp[cur][rest] = cur == P ? 1 : 0; 我們只有cur=P的時候為1,其他位置都為0。
3、當cur=1的時候，dp[cur][rest] = walkCache(N, 2, rest - 1, P, dp); 我們的dp當前的值，依賴於cur的下一個位置，rest的上一個位置
4、當cur = N的時候，dp[cur][rest] =walkCache(N, N - 1, rest - 1, P,dp); 我們dp當前位置依賴於N-1位置，和rest - 1位置
5、當cur在任意中間位置時。dp[cur][rest] = walkCache(N, cur + 1, rest - 1, P,dp) + walkCache(N, cur - 1, rest - 1, P, dp); dp的當前位置依賴於dp的cur+1和rest-1位置加上dp的cur-1和rest-1的位置
那么我們可以得到我們的DP表為：
0 1 2 3 4 5 K 坐標
0 x x x x x x
1 0 0 1 0 3 0
2 0 1 0 3 0 9
3 1 0 2 0 6 0
4 0 1 0 3 0 10
5 0 0 1 0 5 0
6 0 0 0 1 0 5
7 0 0 0 0 1 0
cur
坐
標
所以任何的動態規划，都可以由暴力遞歸改出來。也就是所任意的動態規划都來自於某個暴力遞歸。反之任何暴力遞歸不一定能改成動態規划，jia'ru某暴力遞歸並沒有重復計算，沒有緩存的必要
動態規划實質就是把參數組合完成結構化的緩存
package class12;
public class Code01_RobotWalk {
public static int ways1(int N, int M, int K, int P) {
// 參數無效直接返回0
if (N < 2 || K < 1 || M < 1 || M > N || P < 1 || P > N) {
return 0;
}
// 總共N個位置，從M點出發，還剩K步可以走，返回最終能達到P的方法數
return walk(N, M, K, P);
}
// N : 位置為1 ~ N，固定參數
// cur : 當前在cur位置，可變參數
// rest : 還剩res步沒有走，可變參數
// P : 最終目標位置是P，固定參數
// 該函數的含義：只能在1~N這些位置上移動，當前在cur位置，走完rest步之后，停在P位置的方法數作為返回值返回
public static int walk(int N, int cur, int rest, int P) {
// 如果沒有剩余步數了，當前的cur位置就是最后的位置
// 如果最后的位置停在P上，那么之前做的移動是有效的
// 如果最后的位置沒在P上，那么之前做的移動是無效的
if (rest == 0) {
return cur == P ? 1 : 0;
}
// 如果還有rest步要走，而當前的cur位置在1位置上，那么當前這步只能從1走向2
// 后續的過程就是，來到2位置上，還剩rest-1步要走
if (cur == 1) {
return walk(N, 2, rest - 1, P);
}
// 如果還有rest步要走，而當前的cur位置在N位置上，那么當前這步只能從N走向N-1
// 后續的過程就是，來到N-1位置上，還剩rest-1步要走
if (cur == N) {
return walk(N, N - 1, rest - 1, P);
}
// 如果還有rest步要走，而當前的cur位置在中間位置上，那么當前這步可以走向左，也可以走向右
// 走向左之后，后續的過程就是，來到cur-1位置上，還剩rest-1步要走
// 走向右之后，后續的過程就是，來到cur+1位置上，還剩rest-1步要走
// 走向左、走向右是截然不同的方法，所以總方法數要都算上
return walk(N, cur + 1, rest - 1, P) + walk(N, cur - 1, rest - 1, P);
}
public static int waysCache(int N, int M, int K, int P) {
// 參數無效直接返回0
if (N < 2 || K < 1 || M < 1 || M > N || P < 1 || P > N) {
return 0;
}
// 我們准備一張緩存的dp表
// 由於我們的cur范圍是1~N，我們准備N+1。
// rest范圍在1~K。我們准備K+1。
// 目的是把我們的可能結果都能裝得下
int[][] dp = new int[N+1][K+1];
// 設置這張表的初始值都為-1，代表都還沒用過
for(int row = 0; row <= N; row++) {
for(int col = 0; col <= K; col++) {
dp[row][col] = -1;
}
}
return walkCache(N, M, K, P,dp);
}
// HashMap<String, Integer> (19,100) "19_100"
// 我想把所有cur和rest的組合，返回的結果，加入到緩存里
public static int walkCache(int N, int cur, int rest, int P, int[][] dp) {
// 當前場景已經計算過，不要再暴力展開，直接從緩存中拿
if(dp[cur][rest] != -1) {
return dp[cur][rest];
}
if (rest == 0) {
// 先加緩存
dp[cur][rest] = cur == P ? 1 : 0;
return dp[cur][rest];
}
if (cur == 1) {
// 先加緩存
dp[cur][rest] = walkCache(N, 2, rest - 1, P, dp);
return dp[cur][rest];
}
if (cur == N) {
// 先加緩存
dp[cur][rest] =walkCache(N, N - 1, rest - 1, P,dp);
return dp[cur][rest];
}
// 先加緩存
dp[cur][rest] = walkCache(N, cur + 1, rest - 1, P,dp)
+ walkCache(N, cur - 1, rest - 1, P, dp);
return dp[cur][rest];
}
public static int ways2(int N, int M, int K, int P) {
// 參數無效直接返回0
if (N < 2 || K < 1 || M < 1 || M > N || P < 1 || P > N) {
return 0;
}
int[][] dp = new int[K + 1][N + 1];
dp[0][P] = 1;
for (int i = 1; i <= K; i++) {
for (int j = 1; j <= N; j++) {
if (j == 1) {
dp[i][j] = dp[i - 1][2];
} else if (j == N) {
dp[i][j] = dp[i - 1][N - 1];
} else {
dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j + 1];
}
}
}
return dp[K][M];
}
public static int ways3(int N, int M, int K, int P) {
// 參數無效直接返回0
if (N < 2 || K < 1 || M < 1 || M > N || P < 1 || P > N) {
return 0;
}
int[] dp = new int[N + 1];
dp[P] = 1;
for (int i = 1; i <= K; i++) {
int leftUp = dp[1];// 左上角的值
for (int j = 1; j <= N; j++) {
int tmp = dp[j];
if (j == 1) {
dp[j] = dp[j + 1];
} else if (j == N) {
dp[j] = leftUp;
} else {
dp[j] = leftUp + dp[j + 1];
}
leftUp = tmp;
}
}
return dp[M];
}
// ways4是你的方法
public static int ways4(int N, int M, int K, int P) {
if (N < 2 || K < 1 || M < 1 || M > N || P < 1 || P > N) {
return 0;
}
return process(N, 0, P, M, K);
}
// 一共N個位置，從M點出發，一共只有K步。返回走到位置j，剩余步數為i的方法數
public static int process(int N, int i, int j, int M, int K) {
if (i == K) {
return j == M ? 1 : 0;
}
if (j == 1) {
return process(N, i + 1, j + 1, M, K);
}
if (j == N) {
return process(N, i + 1, j - 1, M, K);
}
return process(N, i + 1, j + 1, M, K) + process(N, i + 1, j - 1, M, K);
}
// ways5是你的方法的dp優化
public static int ways5(int N, int M, int K, int P) {
if (N < 2 || K < 1 || M < 1 || M > N || P < 1 || P > N) {
return 0;
}
int[][] dp = new int[K + 1][N + 1];
dp[K][M] = 1;
for (int i = K - 1; i >= 0; i--) {
for (int j = 1; j <= N; j++) {
if (j == 1) {
dp[i][j] = dp[i + 1][j + 1];
} else if (j == N) {
dp[i][j] = dp[i + 1][j - 1];
} else {
dp[i][j] = dp[i + 1][j + 1] + dp[i + 1][j - 1];
}
}
}
return dp[0][P];
}
public static void main(String[] args) {
System.out.println(ways1(7, 4, 9, 5));
System.out.println(ways2(7, 4, 9, 5));
System.out.println(ways3(7, 4, 9, 5));
System.out.println(ways4(7, 4, 9, 5));
System.out.println(ways5(7, 4, 9, 5));
}
}
1.2 例二：背包問題改動態規划
暴力遞歸過程中，我們如何組織我們的決策過程。實質就是動態規划的狀態轉移
package class12;
public class Code03_Knapsack {
public static int getMaxValue(int[] w, int[] v, int bag) {
// 主函數需要0 bag的返回值
return process(w, v, 0, 0, bag);
}
// index... 最大價值
public static int process(int[] w, int[] v, int index, int alreadyW, int bag) {
if (alreadyW > bag) {
return -1;
}
// 重量沒超
if (index == w.length) {
return 0;
}
int p1 = process(w, v, index + 1, alreadyW, bag);
int p2next = process(w, v, index + 1, alreadyW + w[index], bag);
int p2 = -1;
if (p2next != -1) {
p2 = v[index] + p2next;
}
return Math.max(p1, p2);
}
public static int maxValue(int[] w, int[] v, int bag) {
return process(w, v, 0, bag);
}
// 只剩下rest的空間了，
// index...貨物自由選擇，但是不要超過rest的空間
// 返回能夠獲得的最大價值
public static int process(int[] w, int[] v, int index, int rest) {
if (rest < 0) { // base case 1
return -1;
}
// rest >=0
if (index == w.length) { // base case 2
return 0;
}
// 有貨也有空間
int p1 = process(w, v, index + 1, rest);
int p2 = -1;
int p2Next = process(w, v, index + 1, rest - w[index]);
if(p2Next!=-1) {
p2 = v[index] + p2Next;
}
return Math.max(p1, p2);
}
// dpWay就是把上述的暴力遞歸改為動態規划
public static int dpWay(int[] w, int[] v, int bag) {
int N = w.length;
// 准備一張dp表，行號為我們的重量范圍。列為我們的價值范圍
int[][] dp = new int[N + 1][bag + 1];
// 由於暴力遞歸中index==w.length的時候，總是返回0。所以：
// dp[N][...] = 0。整形數組初始化為0，無需處理
// 由於N行已經初始化為0，我們從N-1開始。填我們的dp表
for (int index = N - 1; index >= 0; index--) {
// 剩余空間從0開始，一直填寫到bag
for (int rest = 0; rest <= bag; rest++) { // rest < 0
// 通過正常位置的遞歸處理
// 我們轉而填寫dp表格,注釋位置是正常遞歸處理
// int p1 = process(w, v, index + 1, rest);
// int p2 = -1;
// int p2Next = process(w, v, index + 1, rest - w[index]);
// if(p2Next!=-1) {
// p2 = v[index] + p2Next;
// }
// return Math.max(p1, p2);
// 所以我們p1等於dp表的下一層向上一層返回
int p1 = dp[index+1][rest];
int p2 = -1;
// rest - w[index] 不越界
if(rest - w[index] >= 0) {
p2 = v[index] + dp[index + 1][rest - w[index]];
}
// p1和p2取最大值
dp[index][rest] = Math.max(p1, p2);
}
}
// 最終返回dp表的0，bag位置，就是我們暴力遞歸的主函數調用
return dp[0][bag];
}
public static void main(String[] args) {
int[] weights = { 3, 2, 4, 7 };
int[] values = { 5, 6, 3, 19 };
int bag = 11;
System.out.println(maxValue(weights, values, bag));
System.out.println(dpWay(weights, values, bag));
}
}
1.3 動態規划解題思路
1、拿到題目先找到某一個暴力遞歸的寫法（嘗試）
2、分析我們的暴力遞歸，是否存在重復解。沒有重復解的遞歸沒必要改動態規划
3、把暴力遞歸中的可變參數，做成緩存結構，不講究組織。即沒算過加入緩存結構，算過的直接拿緩存，就是記憶化搜索
4、如果把緩存結構做精細化組織，就是我們經典的動態規划
5、以背包問題舉例，我們每一個重量有要和不要兩個選擇，且都要遞歸展開。那么我們的遞歸時間復雜度尾O(2^N)。而記憶化搜索，根據可變參數得到的長為N價值為W的二維表，那么我們的時間復雜度為O(N*bag)。如果遞歸過程中狀態轉移有化簡繼續優化的可能，例如枚舉。那么經典動態規划可以繼續優化，否則記憶化搜索和動態規划的時間復雜度是一樣的
1.3.1 湊貨幣問題（重要）
該題是對動態規划完整優化路徑的演示
有一個表示貨幣面值的數組arr，每種面值的貨幣可以使用任意多張。arr數組元素為正數，且無重復值。例如[7,3,100,50]這是四種面值的貨幣。
問：給定一個特定金額Sum，我們用貨幣面值數組有多少種方法，可以湊出該面值。例如P=1000,用這是四種面值有多少種可能湊出1000
ways1為暴力遞歸的解題思路及實現
ways2為暴力遞歸改記憶化搜索的版本
ways3為記憶化搜索版本改動態規划的版本
package class12;
public class Code09_CoinsWay {
// arr中都是正數且無重復值，返回組成aim的方法數，暴力遞歸
public static int ways1(int[] arr, int aim) {
if (arr == null || arr.length == 0 || aim < 0) {
return 0;
}
return process1(arr, 0, aim);
}
public static int process1(int[] arr, int index, int rest) {
// base case
// 當在面值數組的arr.length，此時越界，沒有貨幣可以選擇。
// 如果當前目標金額就是0，那么存在一種方法，如果目標金額不為0，返回0中方法
if(index == arr.length) {
return rest == 0 ? 1 : 0 ;
}
// 普遍位置
int ways = 0;
// 從0號位置開始枚舉，選擇0張，1張，2張等
// 條件是張數乘以選擇的面值，不超過木匾面值rest
for(int zhang = 0; zhang * arr[index] <= rest ;zhang++) {
// 方法數加上除去當前選擇后所剩面額到下一位置的選擇數，遞歸
ways += process1(arr, index + 1, rest - (zhang * arr[index]) );
}
return ways;
}
// ways1暴力遞歸，改為記憶化搜索。ways2為記憶化搜索版本
public static int ways2(int[] arr, int aim) {
if (arr == null || arr.length == 0 || aim < 0) {
return 0;
}
// 緩存結構，且只和index和rest有關，跟arr無關
int[][] dp = new int[arr.length+1][aim+1];
// 一開始所有的過程，都沒有計算呢，dp二維表初始化為-1
// dp[..][..] = -1
for(int i = 0 ; i < dp.length; i++) {
for(int j = 0 ; j < dp[0].length; j++) {
dp[i][j] = -1;
}
}
// 緩存結構向下傳遞
return process2(arr, 0, aim , dp);
}
// 如果index和rest的參數組合，是沒算過的，dp[index][rest] == -1
// 如果index和rest的參數組合，是算過的，dp[index][rest] > - 1
public static int process2(int[] arr,
int index, int rest,
int[][] dp) {
if(dp[index][rest] != -1) {
return dp[index][rest];
}
if(index == arr.length) {
dp[index][rest] = rest == 0 ? 1 :0;
return dp[index][rest];
}
int ways = 0;
for(int zhang = 0; zhang * arr[index] <= rest ;zhang++) {
// 返回之前加入緩存
ways += process2(arr, index + 1, rest - (zhang * arr[index]) , dp );
}
// 返回之前加入緩存
dp[index][rest] = ways;
return ways;
}
// 記憶化搜索改造為動態規划版本，ways3。
// 如果沒有枚舉行為，該動態該規划為自頂向下的動態規划和記憶化搜索等效，但這題存在枚舉行為。
public static int ways3(int[] arr, int aim) {
if (arr == null || arr.length == 0 || aim < 0) {
return 0;
}
int N = arr.length;
// dp表
int[][] dp = new int[N + 1][aim + 1];
// 根據遞歸方法，N為arr的越界位置，但是我們的dp表定義的是N+1。
// N位置，如果aim為0，則dp[N][0] = 1;
dp[N][0] = 1;// dp[N][1...aim] = 0;
// 每個位置依賴自己下面的位置，那么我們從下往上循環
for(int index = N - 1; index >= 0; index--) {
// rest從左往右
for(int rest = 0; rest <= aim; rest++) {
int ways = 0;
for(int zhang = 0; zhang * arr[index] <= rest ;zhang++) {
ways += dp[index + 1] [rest - (zhang * arr[index])];
}
dp[index][rest] = ways;
}
}
// 最終我們需要[0,aim]位置的解
return dp[0][aim];
}
// 由於存在枚舉行為，我們可以進一步優化我們的動態規划。ways4是優化的動態規划
// 根據枚舉，用具體化例子來找出規律，省掉枚舉
public static int ways4(int[] arr, int aim) {
if (arr == null || arr.length == 0 || aim < 0) {
return 0;
}
int N = arr.length;
int[][] dp = new int[N + 1][aim + 1];
dp[N][0] = 1;// dp[N][1...aim] = 0;
for(int index = N - 1; index >= 0; index--) {
for(int rest = 0; rest <= aim; rest++) {
dp[index][rest] = dp[index+1][rest];
if(rest - arr[index] >= 0) {
dp[index][rest] += dp[index][rest - arr[index]];
}
}
}
return dp[0][aim];
}
public static void main(String[] args) {
int[] arr = { 5, 10,50,100 };
int sum = 1000;
System.out.println(ways1(arr, sum));
System.out.println(ways2(arr, sum));
System.out.println(ways3(arr, sum));
System.out.println(ways4(arr, sum));
}
}
1.3.2 貼紙問題
給定一個字符串str，給定一個字符串類型的數組arr。arr里的每一個字符串，代表一張貼紙，你可以把單個字符剪開使用，目的是拼出str來。
返回需要至少多少張貼紙可以完成這個任務。
例如：str="babac"，arr={"ba","c","abcd"}
至少需要兩張貼紙"ba"和"abcd"，因為使用這兩張貼紙，把每一個字符串單獨剪開，含有2個a，2個b，1個c。是可以拼出str的，所以返回2。
思路1 minStickers1：由於任何貼紙都可以剪切的很碎，跟貼紙的順序沒關系。那么目標str我們先進行排序，那么也不會有影響。babac排序為aabbc，我們再去選擇貼紙，str被貼紙貼好后，剩下的接着排序，再選擇......
由於我們的可變參數，只有一個目標字符串。但是目標字符串的可能性太多，沒辦法精細化動態規划。傻緩存的暴力遞歸已經是最優解了。所以只有一個可變參數，又存在重復解，那么傻緩存就是最優解。
思路2 minStickers2，我們每一張貼紙枚舉所有可能的張數，后續過程不再考慮這張貼紙。但是方法一會好一點，因為只有一個可變參數。而方法二有兩個可變參數，我們在設計遞歸的時候，盡量少的使用可變參數，這樣我們緩存結構的命中率會提升
package class12;
import java.util.Arrays;
import java.util.HashMap;
public class Code02_StickersToSpellWord {
// 暴力遞歸加緩存dp
public static int minStickers1(String[] stickers, String target) {
int n = stickers.length;
// stickers -> [26] [26] [26]
// 表示把每張貼紙轉化為26個字母的詞頻數組
int[][] map = new int[n][26];
// 把每一張貼紙轉化的字母26個字母有多少個
for (int i = 0; i < n; i++) {
char[] str = stickers[i].toCharArray();
for (char c : str) {
map[i][c - 'a']++;
}
}
HashMap<String, Integer> dp = new HashMap<>();
dp.put("", 0);
return process1(dp, map, target);
}
// dp 傻緩存，如果rest已經算過了，直接返回dp中的值
// rest 剩余的目標
// 0..N每一個字符串所含字符的詞頻統計
// 返回值是-1，map 中的貼紙 怎么都無法rest
public static int process1(
HashMap<String, Integer> dp,
int[][] map,
String rest) {
if (dp.containsKey(rest)) {
return dp.get(rest);
}
// 以下就是正式的遞歸調用過程
int ans = Integer.MAX_VALUE; // ans -> 搞定rest，使用的最少的貼紙數量
int n = map.length; // N種貼紙
int[] tmap = new int[26]; // tmap 去替代 rest
// 把目標target剩余的rest進行詞頻統計
char[] target = rest.toCharArray();
for (char c : target) {
tmap[c - 'a']++;
}
// map表示所有貼紙的詞頻信息，tmap表示目標字符串的詞頻信息
// 用map去覆蓋tmap
for (int i = 0; i < n; i++) {
// 枚舉當前第一張貼紙是誰？
// 第一張貼紙必須包含當前目標字符串的首字母。和所有貼紙去選等效
// 目的是讓當前貼紙的元素有在目標字符串的對應個，否則試過之后仍然是原始串，棧會溢出
if (map[i][target[0] - 'a'] == 0) {
continue;
}
StringBuilder sb = new StringBuilder();
// i 貼紙， j 枚舉a~z字符
for (int j = 0; j < 26; j++) { //
if (tmap[j] > 0) { // j這個字符是target需要的
for (int k = 0; k < Math.max(0, tmap[j] - map[i][j]); k++) {
// 添加剩余
sb.append((char) ('a' + j));
}
}
}
// sb -> i 此時s就是當前貼紙搞定之后剩余的
String s = sb.toString();
// tmp是后續方案需要的貼紙數
int tmp = process1(dp, map, s);
// 如果-1表示貼紙怎么都無法覆蓋目標字符串
if (tmp != -1) {
// 不是-1，最終返回當前后續貼紙數，加上當前貼紙數與ans的最小值
ans = Math.min(ans, 1 + tmp);
}
}
// 經過上述循環，ans仍然系統最大，表示怎么都無法覆蓋rest，返回-1
dp.put(rest, ans == Integer.MAX_VALUE ? -1 : ans);
return dp.get(rest);
}
public static int minStickers2(String[] stickers, String target) {
int n = stickers.length;
int[][] map = new int[n][26];
for (int i = 0; i < n; i++) {
char[] str = stickers[i].toCharArray();
for (char c : str) {
map[i][c - 'a']++;
}
}
char[] str = target.toCharArray();
int[] tmap = new int[26];
for (char c : str) {
tmap[c - 'a']++;
}
HashMap<String, Integer> dp = new HashMap<>();
int ans = process2(map, 0, tmap, dp);
return ans;
}
public static int process2(int[][] map, int i, int[] tmap, HashMap<String, Integer> dp) {
StringBuilder keyBuilder = new StringBuilder();
keyBuilder.append(i + "_");
for (int asc = 0; asc < 26; asc++) {
if (tmap[asc] != 0) {
keyBuilder.append((char) (asc + 'a') + "_" + tmap[asc] + "_");
}
}
String key = keyBuilder.toString();
if (dp.containsKey(key)) {
return dp.get(key);
}
boolean finish = true;
for (int asc = 0; asc < 26; asc++) {
if (tmap[asc] != 0) {
finish = false;
break;
}
}
if (finish) {
dp.put(key, 0);
return 0;
}
if (i == map.length) {
dp.put(key, -1);
return -1;
}
int maxZhang = 0;
for (int asc = 0; asc < 26; asc++) {
if (map[i][asc] != 0 && tmap[asc] != 0) {
maxZhang = Math.max(maxZhang, (tmap[asc] / map[i][asc]) + (tmap[asc] % map[i][asc] == 0 ? 0 : 1));
}
}
int[] backup = Arrays.copyOf(tmap, tmap.length);
int min = Integer.MAX_VALUE;
int next = process2(map, i + 1, tmap, dp);
tmap = Arrays.copyOf(backup, backup.length);
if (next != -1) {
min = next;
}
for (int zhang = 1; zhang <= maxZhang; zhang++) {
for (int asc = 0; asc < 26; asc++) {
tmap[asc] = Math.max(0, tmap[asc] - (map[i][asc] * zhang));
}
next = process2(map, i + 1, tmap, dp);
tmap = Arrays.copyOf(backup, backup.length);
if (next != -1) {
min = Math.min(min, zhang + next);
}
}
int ans = min == Integer.MAX_VALUE ? -1 : min;
dp.put(key, ans);
return ans;
}
public static void main(String[] args) {
String[] arr = {"aaaa","bbaa","ccddd"};
String str = "abcccccdddddbbbaaaaa";
System.out.println(minStickers1(arr, str));
System.out.println(minStickers2(arr, str));
}
}
1.4 什么暴力遞歸可以繼續優化？
1、有重復調用同一個子問題的解，這種遞歸可以優化
2、如果每一個子問題都是不同的解，無法優化也不用優化
1.5 暴力遞歸和動態規划的關系
1、某個暴力遞歸，有解的重復調用，就可以把這個暴力遞歸優化成動態規划
2、任何動態規划問題，都一定對應着某一個有解的重復調用的暴力遞歸
3、不是所有的暴力遞歸，都一定對應着動態規划
1.6 面試題中和動態規划的關系
1、解決一個問題，可能有很多嘗試方法
2、可能在很多嘗試方法中，又有若干個嘗試方法有動態規划的方式
3、一個問題，可能有若干種動態規划的解法
1.7 如何找到某個問題的動態規划方式？
1、設計暴力遞歸：重要原則+4中常見嘗試模型！重點
2、分析有沒有重復解：套路解決
3、用記憶化搜索 -> 用嚴格表結構實現動態規划：套路解決
4、看看能否繼續優化：套路解決
1.8 面試中設計暴力遞歸過程的原則
怎么猜是不對的？
1、每一個可變參數，一定不要比int類型更加復雜
比如可變參數是int a和int b 那么我們的緩存結構可以是a*b的二維數組。大小取決於a和b的范圍
但是如果我們的可變參數是一個數組，int[] a。那么如果過多，我們不太容易設計那么大的緩存結構。如果只有一個這種可變參數就是原則2
不管什么問題，我們在腦海中想象可變參數就不會突破整形范圍
2、原則1可以違反，讓類型突破到一維線性結構，那必須是唯一可變參數。例如上述貼紙問題
3、如果發現原則1被違反，但沒違反原則2。只需要做到記憶化搜索就是最優解
3、可變參數個數，能少則少
1.9 筆試面試過程中怎么設計暴力遞歸？
1、一定逼自己找到不違反1.8原則情況下的暴力嘗試！
2、如果你找到暴力嘗試，不符合原則，馬上舍棄，找新的！
3、如果某個題目突破了設計原則，一定極難極難，面試中出現的概率低於5%
1.10 常見的4種嘗試模型
每一個模型背后都有很多題目
1.10.1 從左往右的嘗試模型
例如背包問題
1.10.2 范圍上的嘗試模型
例如紙牌博弈問題
1.10.3 多樣本位置全對應的嘗試模型
1.10.3.1 兩個字符串的最長公共子序列問題
例如“ab1cd2ef345gh”和“opq123rs4tx5yz”的最長公共子序列為“12345”。即在兩個字符串所有相等的子序列里最長的。所以返回子序列的長度5
假如"a123bc"和"12dea3fz"兩個字符串，我們把這兩個樣本的下標一個作為行，一個作為列。觀察這樣的結構所表示的意義。dp表這樣設計就是str1從0到i位置，str2從0到j位置，兩個位置的最長公共子序列。
dp[i][j] 表示的含義是，str1字符串在i位置，
str2在j位置，兩個最長公共子序列多長。
那么str1和str2的最長公共子序列，就是dp[str1.length][str2.length]
對於任何位置dp[i][j]:
- 如果str1的i位置和str2的j位置的最長公共子序列跟str1的i位置字符和str2的j位置字符無關，那么此時的最長公共子序列長度就是dp[i-1][j-1]
- 此時與str1的i位置結尾的字符有關系，和str2的j位置結尾的字符沒關系。此時跟str2的j位置沒關系，最長公共子序列式dp[i][j-1]
- 此時與str1的i位置結尾的字符沒關系，和str2的j位置結尾的字符有關系。此時跟str1的j位置沒關系，最長公共子序列式dp[i-1][j]
- 此時即與str1的i字符結尾，有關系。又與str2的j位置結尾，有關系。只有str1[i]==str2[j]才有可能存在這種情況，且為dp[i-1][j-1] + 1
0 1 2 3 4 5 6 7 str2
0 0 0 0 0 1 1 1 1
1 0
2 1
3 1
4 1
5 1
str1
package class12;
public class Code05_PalindromeSubsequence {
public static int lcse(char[] str1, char[] str2) {
int[][] dp = new int[str1.length][str2.length];
dp[0][0] = str1[0] == str2[0] ? 1 : 0;
// 填第0列的所有值
// 一旦st1r的i位置某個字符等於str2的0位置，那么之后都是1
for (int i = 1; i < str1.length; i++) {
dp[i][0] = Math.max(dp[i - 1][0], str1[i] == str2[0] ? 1 : 0);
}
// 填第0行的所有值
// 一旦str2的j位置某個字符等於str1的0位置，那么之后都是1
for (int j = 1; j < str2.length; j++) {
dp[0][j] = Math.max(dp[0][j - 1], str1[0] == str2[j] ? 1 : 0);
}
for (int i = 1; i < str1.length; i++) {
for (int j = 1; j < str2.length; j++) {
// dp[i - 1][j]表示可能性2
// dp[i][j - 1] 表示可能性3
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
if (str1[i] == str2[j]) {
dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - 1] + 1);
}
}
}
return dp[str1.length - 1][str2.length - 1];
}
public static void main(String[] args) {
}
}
1.10.4 尋找業務限制的嘗試模型
四種模型中最難的一種，暫時只看process方法，process更改為動態規划的dp方法。后面會展開說明其他方法，
例題：給定一個數組，代表每個人喝完咖啡准備刷杯子的時間，只有一台咖啡機，一次只能洗一個杯子，時間耗費a，洗完才能洗下一杯。每個咖啡杯也可以自己揮發干凈，時間耗費b，咖啡杯可以並行揮發。返回讓所有咖啡杯變干凈的最早完成時間。三個參數：int[]arr , int a , int b（京東）
package class12;
import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
// 題目
// 數組arr代表每一個咖啡機沖一杯咖啡的時間，每個咖啡機只能串行的制造咖啡。
// 現在有n個人需要喝咖啡，只能用咖啡機來制造咖啡。
// 認為每個人喝咖啡的時間非常短，沖好的時間即是喝完的時間。
// 每個人喝完之后咖啡杯可以選擇洗或者自然揮發干凈，只有一台洗咖啡杯的機器，只能串行的洗咖啡杯。
// 洗杯子的機器洗完一個杯子時間為a，任何一個杯子自然揮發干凈的時間為b。
// 四個參數：arr, n, a, b
// 假設時間點從0開始，返回所有人喝完咖啡並洗完咖啡杯的全部過程結束后，至少來到什么時間點。
public class Code06_Coffee {
// 方法一：暴力嘗試方法
public static int minTime1(int[] arr, int n, int a, int b) {
int[] times = new int[arr.length];
int[] drink = new int[n];
return forceMake(arr, times, 0, drink, n, a, b);
}
// 方法一，每個人暴力嘗試用每一個咖啡機給自己做咖啡
public static int forceMake(int[] arr, int[] times, int kth, int[] drink, int n, int a, int b) {
if (kth == n) {
int[] drinkSorted = Arrays.copyOf(drink, kth);
Arrays.sort(drinkSorted);
return forceWash(drinkSorted, a, b, 0, 0, 0);
}
int time = Integer.MAX_VALUE;
for (int i = 0; i < arr.length; i++) {
int work = arr[i];
int pre = times[i];
drink[kth] = pre + work;
times[i] = pre + work;
time = Math.min(time, forceMake(arr, times, kth + 1, drink, n, a, b));
drink[kth] = 0;
times[i] = pre;
}
return time;
}
// 方法一，暴力嘗試洗咖啡杯的方式
public static int forceWash(int[] drinks, int a, int b, int index, int washLine, int time) {
if (index == drinks.length) {
return time;
}
// 選擇一：當前index號咖啡杯，選擇用洗咖啡機刷干凈
int wash = Math.max(drinks[index], washLine) + a;
int ans1 = forceWash(drinks, a, b, index + 1, wash, Math.max(wash, time));
// 選擇二：當前index號咖啡杯，選擇自然揮發
int dry = drinks[index] + b;
int ans2 = forceWash(drinks, a, b, index + 1, washLine, Math.max(dry, time));
return Math.min(ans1, ans2);
}
// 方法二：稍微好一點的解法
public static class Machine {
public int timePoint;
public int workTime;
public Machine(int t, int w) {
timePoint = t;
workTime = w;
}
}
public static class MachineComparator implements Comparator<Machine> {
@Override
public int compare(Machine o1, Machine o2) {
return (o1.timePoint + o1.workTime) - (o2.timePoint + o2.workTime);
}
}
// 方法二，每個人暴力嘗試用每一個咖啡機給自己做咖啡，優化成貪心
public static int minTime2(int[] arr, int n, int a, int b) {
PriorityQueue<Machine> heap = new PriorityQueue<Machine>(new MachineComparator());
for (int i = 0; i < arr.length; i++) {
heap.add(new Machine(0, arr[i]));
}
int[] drinks = new int[n];
for (int i = 0; i < n; i++) {
Machine cur = heap.poll();
cur.timePoint += cur.workTime;
drinks[i] = cur.timePoint;
heap.add(cur);
}
return process(drinks, a, b, 0, 0);
}
// 方法二，洗咖啡杯的方式和原來一樣，只是這個暴力版本減少了一個可變參數
// process(drinks, 3, 10, 0,0)
// a 洗一杯的時間 固定變量
// b 自己揮發干凈的時間 固定變量
// drinks 每一個員工喝完的時間 固定變量
// drinks[0..index-1]都已經干凈了，不用你操心了
// drinks[index...]都想變干凈，這是我操心的，washLine表示洗的機器何時可用
// drinks[index...]變干凈，最少的時間點返回
public static int process(int[] drinks, int a, int b, int index, int washLine) {
if (index == drinks.length - 1) {
return Math.min(Math.max(washLine, drinks[index]) + a, drinks[index] + b);
}
// 剩不止一杯咖啡
// wash是我當前的咖啡杯，洗完的時間
int wash = Math.max(washLine, drinks[index]) + a;// 洗，index一杯，結束的時間點
// index+1...變干凈的最早時間
int next1 = process(drinks, a, b, index + 1, wash);
// index....
int p1 = Math.max(wash, next1);
int dry = drinks[index] + b; // 揮發，index一杯，結束的時間點
int next2 = process(drinks, a, b, index + 1, washLine);
int p2 = Math.max(dry, next2);
return Math.min(p1, p2);
}
public static int dp(int[] drinks, int a, int b) {
if (a >= b) {
return drinks[drinks.length - 1] + b;
}
// a < b
int N = drinks.length;
int limit = 0; // 咖啡機什么時候可用
for (int i = 0; i < N; i++) {
limit = Math.max(limit, drinks[i]) + a;
}
int[][] dp = new int[N][limit + 1];
// N-1行，所有的值
for (int washLine = 0; washLine <= limit; washLine++) {
dp[N - 1][washLine] = Math.min(Math.max(washLine, drinks[N - 1]) + a, drinks[N - 1] + b);
}
for (int index = N - 2; index >= 0; index--) {
for (int washLine = 0; washLine <= limit; washLine++) {
int p1 = Integer.MAX_VALUE;
int wash = Math.max(washLine, drinks[index]) + a;
if (wash <= limit) {
p1 = Math.max(wash, dp[index + 1][wash]);
}
int p2 = Math.max(drinks[index] + b, dp[index + 1][washLine]);
dp[index][washLine] = Math.min(p1, p2);
}
}
return dp[0][0];
}
// 方法三：最終版本，把方法二洗咖啡杯的暴力嘗試進一步優化成動態規划
public static int minTime3(int[] arr, int n, int a, int b) {
PriorityQueue<Machine> heap = new PriorityQueue<Machine>(new MachineComparator());
for (int i = 0; i < arr.length; i++) {
heap.add(new Machine(0, arr[i]));
}
int[] drinks = new int[n];
for (int i = 0; i < n; i++) {
Machine cur = heap.poll();
cur.timePoint += cur.workTime;
drinks[i] = cur.timePoint;
heap.add(cur);
}
if (a >= b) {
return drinks[n - 1] + b;
}
int[][] dp = new int[n][drinks[n - 1] + n * a];
for (int i = 0; i < dp[0].length; i++) {
dp[n - 1][i] = Math.min(Math.max(i, drinks[n - 1]) + a, drinks[n - 1] + b);
}
for (int row = n - 2; row >= 0; row--) { // row 咖啡杯的編號
int washLine = drinks[row] + (row + 1) * a;
for (int col = 0; col < washLine; col++) {
int wash = Math.max(col, drinks[row]) + a;
dp[row][col] = Math.min(Math.max(wash, dp[row + 1][wash]), Math.max(drinks[row] + b, dp[row + 1][col]));
}
}
return dp[0][0];
}
// for test
public static int[] randomArray(int len, int max) {
int[] arr = new int[len];
for (int i = 0; i < len; i++) {
arr[i] = (int) (Math.random() * max) + 1;
}
return arr;
}
// for test
public static void printArray(int[] arr) {
System.out.print("arr : ");
for (int j = 0; j < arr.length; j++) {
System.out.print(arr[j] + ", ");
}
System.out.println();
}
public static void main(String[] args) {
int[] test = { 1, 1, 5, 5, 7, 10, 12, 12, 12, 12, 12, 12, 15 };
int a1 = 3;
int b1 = 10;
System.out.println(process(test, a1, b1, 0, 0));
System.out.println(dp(test, a1, b1));
int len = 5;
int max = 9;
int testTime = 50000;
for (int i = 0; i < testTime; i++) {
int[] arr = randomArray(len, max);
int n = (int) (Math.random() * 5) + 1;
int a = (int) (Math.random() * 5) + 1;
int b = (int) (Math.random() * 10) + 1;
int ans1 = minTime1(arr, n, a, b);
int ans2 = minTime2(arr, n, a, b);
int ans3 = minTime3(arr, n, a, b);
if (ans1 != ans2 || ans2 != ans3) {
printArray(arr);
System.out.println("n : " + n);
System.out.println("a : " + a);
System.out.println("b : " + b);
System.out.println(ans1 + " , " + ans2 + " , " + ans3);
System.out.println("===============");
break;
}
}
}
}
1.11 如何分析有沒有重復解
1、列出調用過程，可以只列出前幾層
2、有沒有重復解，一看便知
1.12 暴力遞歸到動態規划的套路
1、你已經有了一個不違反原則的暴力遞歸，而且的確存在重復調用
2、找到哪些參數的變化會影響返回值，對每一個列出變化范圍
3、參數間的所有組合數量，意味着緩存表(DP)大小
4、記憶化搜索的方法就是傻緩存，非常容易得到
5、規定好嚴格的表大小，分析位置的依賴順序，然后從基礎填寫到最終解
6、對於有枚舉行為的決策過程，進一步優化
1.13 動態規划的進一步優化
主要就是用來優化動態規划的單個位置的枚舉行為
1、空間壓縮
2、狀態化簡
3、四邊形不等式
4、其他優化技巧