年輕即出發...
簡書：http://www.lxweimin.com/u/7110a2ba6f9e
知乎：https://www.zhihu.com/people/zqtao23/posts
GitHub源碼：https://github.com/zqtao2332
個人網站：http://www.zqtaotao.cn/ （停止維護更新內容）
QQ交流群：606939954
? 咆哮怪獸一枚...嗷嗷嗷...趁你現在還有時間，盡你自己最大的努力。努力做成你最想做的那件事，成為你最想成為的那種人，過著你最想過的那種生活。也許我們始終都只是一個小人物，但這并不妨礙我們選擇用什么樣的方式活下去，這個世界永遠比你想的要更精彩。
最后：喜歡編程，對生活充滿激情
本節內容預告
實例1：玩家選數問題
實例2：有效括號配對問題
實例3：數組累加和問題1
實例4：數組累加和問題2
實例5：數組累加和問題3
實例1：玩家選數問題
有一排正數，玩家A和玩家B都可以看到。
每位玩家在拿走數字的時候，都只能從最左和最右的數中選擇一個。
玩家A先拿，玩家B再拿，兩人交替拿走所有的數字，
兩人都力爭自己拿到的數的總和比對方多。請返回最后獲勝者的分數。
例如：
5,2,3,4
玩家A先拿，當前他只能拿走5或者4。
如果玩家A拿走5，那么剩下2，3，4。輪到玩家B，此時玩家B可以選擇2或4中的一個，…
如果玩家A拿走4，那么剩下5，2，3。輪到玩家B，此時玩家B可以選擇5或3中的一個，…
思路1、遞歸: 暴力嘗試
自己分別作為先選人，后選人，查看收益最大
無論是作為先選人，還是作為后選人，都是絕對理智的，每一次做出的選擇都是最優的
具體過程見代碼詳解
1_1_遞歸過程依賴圖.png
/**
* @description: 兩人選數游戲
* 思路1、遞歸: 暴力嘗試
* @version: 1.0
*/
public class Code_01_CardsInLine_1 {
// 方式1、遞歸: 暴力嘗試
public static int win1(int[] arr) {
if (arr == null || arr.length == 0) return 0;
// 自己分別作為先選人，后選人，查看收益最大
// 無論是作為先選人，還是作為后選人，都是絕對理智的，每一次做出的選擇都是最優的
return Math.max(first(arr, 0, arr.length - 1), second(arr, 0, arr.length - 1));
}
/*
作為先選人，從 i 到 j 位置上獲得的最大分數
核心：我作為先選人每一次決策都是選擇的最優的
如：
5 2 3 4
那么我作為先選者一定最終做出的選擇的是 （5 + 作為后選人最大分數）（4 + 作為后選人最大分數）中最大分數的
*/
public static int first(int[] arr, int i, int j) {
if (i == j) { // 只有一個數，同時作為先選人，當然返回這個唯一的數
return arr[i];
}
// 選擇左邊數，然后自己變成了后選人
// 從 i 到 j 位置上獲得的最大分數 = 左邊數 + 自己變為后選人從 i+1 到 j 位置上獲得的最大分數
int L = arr[i] + second(arr, i + 1, j);
// 選擇右邊數，然后自己變成了后選人
// 從 i 到 j 位置上獲得的最大分數 = 右邊數 + 自己變為后選人從 i 到 j-1 位置上獲得的最大分數
int R = arr[j] + second(arr, i, j - 1);
// 返回自己選擇左邊數和選擇右邊數兩種情況下，最大的分數
return Math.max(L, R);
}
/*
作為后選人，從i 到 j 位置上獲得的最大分數
核心：每一次都認為先選人做出的選擇是最優的，留給自己的一定是最小的
5 2 3 4
先選人，選了 5 給自己留下 2 3 4 = 9
先選人，選了 4 給自己留下 5 2 3 = 10
先選人怎么可能那么好心讓自己贏，我們都是絕對理智的人
所以
我作為后選人，悲催的只能在先選人選擇后的區域選擇我的數
但是我現在也不知道那邊的數大，需要計算才能知道先選人選擇的到底是哪邊的數？
5 2 3 4
先選人，選了 5 給自己留下 2 3 4 = 9
先選人，選了 4 給自己留下 5 2 3 = 10
通過計算發現，9 < 10 ，先選人既然是絕對理智的，那么他給我留下的就是最小的
而我，只能從最小的那幾個數中找最大的分數。
由于先選人已經選擇了，現在他退位到后選人，我上了先選人位置，即，我現在是先選人。
總結: 我作為后選人做出什么樣的決定，完全取決于先選人做出了什么決定，先選人扔給我的一定是最小的
*/
public static int second(int[] arr, int i, int j) {
if (i == j) { //只有一個數，自己作為后選人，自己前面有一個先選人，先選人選擇后，剩下0個數可選
return 0;
}
// 現在我是先選人，選擇左邊數
int L = first(arr, i + 1, j);
// 現在我是先選人，選擇右邊數
int R = second(arr, i, j - 1);
// 我只能從最小的區域中進行選擇
return Math.min(L, R);
}
}
思路2：從暴力遞歸到動態規劃
暴力遞歸其實就是一個暴力嘗試過程，嘗試每一種選擇
缺點：重復的大量計算，而且這種重復計算隨著樣本量的增加而指數式增加，做了很多無用功
暴力遞歸到動態規劃的一般步驟
動態規劃：
1、寫出暴力嘗試
2、確定最終解，是什么點
3、查看暴力嘗試過程中的計算解，是否是完全無后效性的
4、找到可以代替解的變量
5、base case 給表賦值
6、一般情況的依賴關系
根據題具體分析
1、暴力嘗試：win1()
2、確定最終解：(0, N-1) 點
3、win1() 中 f(arr, i, j) arr 是固定值，f(i , j) 是無效性的
4、可以用 i , j 表示解
5、根據遞歸中的base case 來給表賦值（不變值，基本情況下的值，如本題 i==j 時）
6、一般情況下的依賴關系
first() (i,j) 依賴于second() 中的 (i+1, j) 和 (i, j-1)
second() (i,j) 依賴于 first() 中的 (i+1,j) 和 (i, j-1)
1_2_fs依賴關系.png
import static cn.zqtao.learn.nowcode_other.day1.Code_01_CardsInLine_1.win1;
/**
* @description: 兩人選數游戲
* 思路2：從暴力遞歸到動態規劃
* <p>
* 暴力遞歸其實就是一個暴力嘗試過程，嘗試每一種選擇
* 缺點：重復的大量計算，而且這種重復計算隨著樣本量的增加而指數式增加，做了很多無用功
* <p>
* 動態規劃：
* 1、寫出暴力嘗試
* 2、確定最終解，是什么點
* 3、查看暴力嘗試過程中的計算解，是否是完全無后效性的
* 4、找到可以代替解的變量
* 5、base case 給表賦值
* 6、一般情況的依賴關系
* <p>
* 1、暴力嘗試：win1()
* 2、確定最終解：(0, N-1) 點
* 3、win1() 中 f(arr, i, j) arr 是固定值，f(i , j) 是無效性的
* 4、可以用 i , j 表示解
* 5、根據遞歸中的base case 來給表賦值（不變值，基本情況下的值，如本題 i==j 時）
* 6、一般情況下的依賴關系
* first() (i,j) 依賴于second() 中的 (i+1, j) 和 (i, j-1)
* second() (i,j) 依賴于 first() 中的 (i+1,j) 和 (i, j-1)
* <p>
* <p>
* 暴力嘗試可以使用表進行表示
* dpf 可以保存所有 first() 的所有情況
* dps 可以保存所有 second() 的所有情況
* <p>
* first() 中
* @version: 1.0
*/
public class Code_02_CardsInLine_2 {
public static int win2(int[] arr) {
if (arr == null || arr.length == 0) return 0;
// 保存各種狀態
int[][] dpf = new int[arr.length][arr.length];
int[][] dps = new int[arr.length][arr.length];
for (int j = 0; j < arr.length; j++) {
dpf[j][j] = arr[j]; // first() 中 base case 中 i==j 情況賦值
// dps[j][j] = 0; // second() 中 base case 中 i==j 情況，由于Java是自動給數組初始化為0 的所以可以忽略
for (int i = j - 1; i >= 0; i--) {
// 一般情況依賴關系
// first() (i,j) 依賴于second() 中的 (i+1, j) 和 (i, j-1)
dpf[i][j] = Math.max(arr[i] + dps[i + 1][j], arr[j] + dps[i][j - 1]);
// second() (i,j) 依賴于 first() 中的 (i+1,j) 和 (i, j-1)
dps[i][j] = Math.min(dpf[i + 1][j], dpf[i][j - 1]);
}
}
return Math.max(dpf[0][arr.length - 1], dps[0][arr.length - 1]);
}
public static int[] generateRandomArr(int maxSize, int maxValue) {
int[] arr = new int[(int) (Math.random() * (maxSize + 1))];
return arr;
}
public static void main(String[] args) {
int maxSize = 5;
int testTime = 50000;
for (int i = 0; i < testTime; i++) {
int[] arr = generateRandomArr(maxSize, 20);
int r1 = win1(arr);
int r2 = win2(arr);
if (r1 != r2) {
System.out.println("error");
}
}
}
}
實例2：有效括號配對問題
1、已知一個字符串都是由左括號(和右括號)組成，判斷該字符串是否是有效的括號組合。
例子：
有效的括號組合:()(),(()),(()())
無效的括號組合:(,()),((),()(()
2、題目進階：
已知一個字符串都是由左括號(和右括號)組成，返回最長有效括號子串的長度。
1思路：
1、臨時變量count
2、"(" count+1
")" count-1 每次判斷count < 0 返回false
3、最終遍歷完成，count != 0 false
// 是否是有效括號
public static boolean isValidParentheses(String str) {
if (str == null || "".equals(str)){
return false;
}
char[] chars = str.toCharArray();
int count = 0;
for (int i = 0; i < chars.length; i++) {
if (")".equals(chars[i]) && --count < 0){
return false;
}
if ("(".equals(chars[i])) {
count++;
}
}
return count == 0;
}
進階思路
動態規劃
）（）（）（（）（））
2_1_最長有效括號子串.png
// 有效最大長度
public static int maxLength(String str) {
if (str == null || "".equals(str)) {
return 0;
}
char[] chars = str.toCharArray();
int res = 0;
int[] dp = new int[chars.length];
int pre = 0; // 和當前 ')' 對應的 '('的位置下標
for (int i = 1; i < chars.length; i++) { // 無論是什么括號，dp[0] 一定是0
if (')' == chars[i]) {
pre = i - dp[i - 1] - 1; // 根據第 i-1 位，進行前推 dp[i-1] - 1 個
if (pre >= 0 && chars[pre] == '(') {
int preLenth = pre > 0 ? dp[pre - 1] : 0; // 之前有效的長度, 注意：pre <= 0 的存在
dp[i] = (dp[i - 1] + 2) + preLenth;
}
}
res = Math.max(dp[i], res);
}
return res;
}
實例3：數組累加和問題1
1、給定一個數組，值全是正數，請返回累加和為給定值k的最長子數組長度。
思路：滑動窗口
雙指針 L R 分別控制窗口進元素和出元素
public static int maxSubArrLen(int[] arr, int k) {
if (arr == null || arr.length == 0) return 0;
int L = 0;
int R = 0;
int sum = arr[R];
int len = 0;
while (R < arr.length) {
if (sum == k) {
len = Math.max(len, R - L + 1);
sum -= arr[L++];
} else if (sum < k) {
R++;
if (R == arr.length) break; // 防止越界
sum += arr[R];
} else {
sum -= arr[L++];
}
}
return len;
}
實例4：數組累加和問題2
2、給定一個數組，值可以為正、負和0，請返回累加和為給定值k的最長子數組長度。
注意：子數組，子串等問題，常規套路：
選擇以某個位置開始怎么怎么樣, 或者選擇以某個位置結束怎么怎么樣！！
即選擇子串開始位置考慮，或者選擇子串結束位置考慮。
通過其他位置來推此位置時的狀態
此題，以某個位置為結尾的子數組，累加和為定值 k
public static int maxSubArrLen(int[] arr, int k) {
if (arr == null || arr.length == 0) return 0;
int len = 0;
int sum = 0;
HashMap<Integer, Integer> map = new HashMap<>();
map.put(0, -1); // 處理第一位等于 k 的情況
/*
6 1 2 3 k = 6
上來 sum = 6
sum - k = 0;
len = i - map.get(0) 但是現在不存在map.get(0) 這樣len返回的結果是0，而不是 1
*/
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
if (map.containsKey(sum - k)) {
len = Math.max(len, i - map.get(sum - k));
}
if (!map.containsKey(sum)) {
map.put(sum, i);
}
}
return len;
}
實例5：數組累加和問題3
3、給定一個數組，值可以為正、負和0，請返回累加和小于等于k的最長子數組長度。
import java.util.Arrays;
import java.util.HashMap;
/**
* @description: 數組累加和問題3
*
* 3、給定一個數組，值可以為正、負和0，請返回累加和小于等于k的最長子數組長度。
* @version: 1.0
*/
public class Code_04_3_LongestSumSubArrayLengthInPositiveArray {
/**
* 第一步：求得 以arr[i] 開頭的情況下，往后累加，能得到的最小和是多少？存進 sums
* 以arr[i] 開頭累加出最小和，邊界時多少？存進ends
*
* 第二步：遍歷數組，求以a[i] 為開頭，累加和 <=k 的子數組
*
* 無注釋版
*/
public static int maxLengthAwesome(int[] arr, int k) {
if (arr == null || arr.length == 0) {
return 0;
}
int[] sums = new int[arr.length];
HashMap<Integer, Integer> ends = new HashMap<>();
// 第一步
sums[arr.length - 1] = arr[arr.length - 1];
ends.put(arr.length - 1, arr.length - 1);
for (int i = arr.length - 2; i >= 0; i--) {
if (sums[i + 1] < 0) {
sums[i] = arr[i] + sums[i + 1];
ends.put(i, ends.get(i+1));
} else {
sums[i] = arr[i];
ends.put(i, i);
}
}
// 第二步: 采用滑動窗口
int end = 0;
int sum = 0;
int resLen = 0;
for (int i = 0; i < arr.length; i++) {
while (end < arr.length && sum + sums[end] <= k) {
sum += sums[end];
end = ends.get(end) + 1;
}
sum -= end > i ? arr[i] : 0;
resLen = Math.max(resLen, end - i);
end = Math.max(end, i + 1);
}
return resLen;
}
// 注釋版
public static int maxLengthAwesome2(int[] arr, int k) {
if (arr == null || arr.length == 0) {
return 0;
}
int[] sums = new int[arr.length];
// key: 第i位數下標 value: 第i位數開頭的情況下累加最小和的右邊界
HashMap<Integer, Integer> ends = new HashMap<>();
// 以arr[i] 開頭的情況下，往后累加，能得到的最小和是多少？存進 sums
// 以arr[i] 開頭累加出最小和，邊界時多少？存進ends
// 最后一個數的最小累加和，就是本身
sums[arr.length - 1] = arr[arr.length - 1];
// 右邊界時最后一個數的下標
ends.put(arr.length - 1, arr.length - 1);
// 遍歷數組，求以arr[i] 開頭情況下，往后累加，能得到的最小和是多少？存進sums
// 右邊界存進 ends
for (int i = arr.length - 2; i >= 0; i--) {
if (sums[i + 1] < 0) { // 對于arr[i] 如果以 arr[i+1] 開頭求得的最小和 < 0
sums[i] = arr[i] + sums[i + 1]; // arr[i] 開頭的最小和=當前數+以arr[i+1]開頭累加的最小和
ends.put(i, ends.get(i + 1));// 右邊界就等于 i+1 的右邊界
} else { // >= 0 情況下
sums[i] = arr[i]; // 最小和就是本身
ends.put(i, i); // 右邊界也是本身
}
}
// 以a[i] 為開頭，累加和<=k 的子數組
int end = 0; // 記錄右邊界
int sum = 0; // 記錄滑動窗口內累加和
int res = 0; // 記錄最長子數組長度
for (int i = 0; i < arr.length; i++) {
// 以arr[i]開頭的最小累加和是小于 k 的才能繼續累加。
// 如果連最小的累加和都大于k,那么無論怎么樣累加都不可能累加出小于等于k的累加和
while (end < arr.length && sum + sums[end] <= k) { // 持續累加直到找到累加和大于 K的
sum += sums[end];
end = ends.get(end) + 1; // end指向下一個最小累加和的起始位置
// 如以arr[0]開始的最小累加和到 i=7結束，即ends[0]=7。
// 那么下一個最小累加和就是i=8位置開始的，end=8
}
sum -= end > i ? arr[i] : 0;
res = Math.max(res, end - i);
end = Math.max(end, i + 1); // 如果沒有走while循環end 需要更新為下一個數
}
return res;
}
// ---------------------- test -----------------------------
// 下面提供一種 O(N*logN) 的方法進行對比測試
public static int maxLength(int[] arr, int k) {
int[] h = new int[arr.length + 1];
int sum = 0;
h[0] = sum;
for (int i = 0; i != arr.length; i++) {
sum += arr[i];
h[i + 1] = Math.max(sum, h[i]);
}
sum = 0;
int res = 0;
int pre = 0;
int len = 0;
for (int i = 0; i != arr.length; i++) {
sum += arr[i];
pre = getLessIndex(h, sum - k);
len = pre == -1 ? 0 : i - pre + 1;
res = Math.max(res, len);
}
return res;
}
public static int getLessIndex(int[] arr, int num) {
int low = 0;
int high = arr.length - 1;
int mid = 0;
int res = -1;
while (low <= high) {
mid = (low + high) / 2;
if (arr[mid] >= num) {
res = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
return res;
}
// for test
public static int[] generateRandomArray(int len, int maxValue) {
int[] res = new int[len];
for (int i = 0; i != res.length; i++) {
res[i] = (int) (Math.random() * maxValue) - (maxValue / 3);
}
return res;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
int[] arr = generateRandomArray(10, 20);
int k = (int) (Math.random() * 20) - 5;
System.out.println("arr: " + Arrays.toString(arr) + " k=" + k);
System.out.println("maxLengthAwesome(arr, k): " + maxLengthAwesome(arr, k));
System.out.println("maxLength(arr, k): " + maxLength(arr, k));
if (maxLengthAwesome(arr, k) != maxLength(arr, k)) {
System.out.println("oops!");
}
}
}
}
