本博來自左神視頻，特此做下筆記。
文章目錄
1 換錢的方法數
【題目】
給定數組arr，arr中所有的值都爲正數且不重複。每個值代表一種面值的貨幣，每種面值的貨幣可以使用任意張，再給定一個整數aim代表要找的錢數，求換錢有多少種方法。
【舉例】
1：arr=[5，10，25，1]，aim=0。
組成0元的方法有1種，就是所有面值的貨幣都不用。所以返回1。
2：arr=[5，10，25，1]，aim=15。
組成15元的方法有6種，分別爲3張5元、1張10元+1張5元、1張10元+5張1元、10張1元+1張5元、2張5元+5張1元和15張1元。所以返回6。
3：arr=[3，5]，aim=2。
任何方法都無法組成2元。所以返回0。
1.1 暴力遞歸
【分析】
如上面的例子2，需要湊出15，以每種錢的張數作爲中間變量。
代碼中arr和aim含義同題意；index爲錢數，配合num這種錢的張數可得到這種錢總共佔有了多少。因此aim - arr[index] * num爲不算這種錢剩餘需要湊的。
如下：
當5元使用0張，則[10，25，1]需要湊夠15-5x0=15元，從10繼續看，以此遞歸；
當5元使用1張，則[10，25，1]需要湊夠15-5x1=10元，從10繼續看，以此遞歸；
當5元使用2張，則[10，25，1]需要湊夠15-5x2=5元，從10繼續看，以此遞歸；
跳出遞歸的條件：達到最後的位置時.
這就是暴力遞歸的方法。
【代碼】
void recur(vector<int> arr, int index, int aim, int &ret)
{
if (index == arr.size())
{
ret += (aim == 0 ? 1 : 0);
return;
}
else
{
for(int num = 0; arr[index] * num <= aim; num++)
recur(arr, index+1, aim - arr[index] * num, ret);
}
}
int Solution::orgRecur(vector<int> arr, int aim)
{
int ret = 0;
recur(arr, 0, aim, ret);
return ret;
}
1.2 動態規劃
1.2.1 第一次優化，製作備忘錄
【分析】
複雜度爆炸，多於計算過多。如要達到100元，即aim爲100時，遞歸過程中會有以下情況：
5元使用0張，10元使用5張，25元使用0張，則剩餘50元繼續在1處遞歸；
5元使用6張，10元使用2張，25元使用0張，則剩餘50元繼續在1處遞歸；
5元使用1張，10元使用2張，25元使用1張，則剩餘50元繼續在1處遞歸；
這些情況都是最後剩了50元，但是，每次到了50元還要繼續遞歸，進行同樣的重複計算。 因此過於複雜，動態規劃就是爲了省去這些多餘的計算，即，當到了50元時，我們把50元和到1這個位置，湊成的方法數記錄下來，用空間變時間。
以上，就是無後效性，即剩餘50元和該看1用多少張，和怎麼到的50和1沒有關係。
因此把aim和index作爲一個索引key，直接把計算到的值放入對應的value中，即可最大程度的減少重複運算，這就是“備忘錄”。
【代碼】
int dynamicProgramm(vector<int> arr, int index, int aim, vector<vector<int>>& dp )
{
int ret = 0;
if (index == arr.size())
{
ret = (aim == 0 ? 1 : 0);
}
else
{
for (int num = 0; arr[index] * num <= aim; num++)
{
int rest = aim - arr[index] * num;
if (dp[rest][index + 1] != -1)
{
ret += dp[rest][index + 1];
}
else
{
ret += dynamicProgramm(arr, index + 1, rest, dp);
}
}
}
dp[aim][index] = ret;
return ret;
}
int Solution::newDp(vector<int> arr, int aim)
{
vector<int> temp(arr.size() + 1, -1);
vector<vector<int>> dp(aim + 1, temp);
int ret = dynamicProgramm(arr, 0, aim, dp);
return ret;
}
1.2.2 將備忘錄中的遞歸變成備忘錄表
目的：將遞歸過程改成——帶有初始狀態的，並且只填表而無遞歸的形式。
依然以例子2爲例。
1、確定表的形狀，這裏無疑是個二維的數組，一維是aim，另一維是index
2、確定初始值，即不用遞歸就能知道的值，如：①我們已知aim爲0時，所有的index下都有1種可能；②當index爲0時表示只用5元，此時要看用幾張5元，即只有5的倍數的錢數有可能，即5，10，15，且這些情況只有這1種可能。根據以上兩個初始條件，填表如下：
3、確定待求值：根據題意我們要求得當index爲4-1=3時，aim爲15的的值，因此待求值爲右下角位置的值，在上圖中已經標出。
4、找到如何從初始值計算到待求值的計算方法：看遞歸代碼
ret += dp[aim - arr[index] * num][index + 1]
得出
dp[aim][index] += aim - arr[index] >= 0 ? dp[aim - arr[index]][index] : 0;
自下而上，得出每一個aim和index對應的可能性數目，並將可能性數目的關係對應起來。填表如下：
找轉移關係並不容易，需要多加思考。
【代碼】
int dynamicProgramm_v2(vector<int> arr, int index, int aim, vector<vector<int>>& dp)
{
/*確定初始值*/
for (int i = 0; i < arr.size(); i++)
{
dp[0][i] = 1;
}
for (int j = 1; j <= aim; j++)
{
dp[j][0] = 0;
}
for (int j = 1; arr[0] * j <= aim; j++)
{
dp[arr[0] * j][0] = 1;
}
/*填表過程*/
for (int aimTemp = 1; aimTemp <= aim; aimTemp++)
{
for (int indexLast = 1; indexLast < arr.size(); indexLast++)
{
dp[aimTemp][indexLast] = dp[aimTemp][indexLast - 1];
dp[aimTemp][indexLast] += (((aimTemp - arr[indexLast]) >= 0) ? dp[aimTemp - arr[indexLast]][indexLast] : 0);
}
}
/* TEST
for (int i = 0; i <= aim; i++)
{
for (int j = 0; j < arr.size(); j++)
{
cout << dp[i][j] << '\t';
}
cout << endl;
}
*/
/*確定待求值*/
return dp[aim][arr.size() - 1];
}
1.3 修改代碼的方式：從遞歸到dp
1.3.1 第一次優化，加個備忘錄
代碼量有所增加，但消耗時間顯著減少。
1.3.2 將備忘錄中的遞歸變成備忘錄表
這裏已經是無關題意了，只是尋找從表中已知值到未知值的關係問題。因此代碼將變得完全不同。
1.4 附錄：“換錢的方法數”整體手擼代碼
皮一波，順手試着寫個類~
/*main.cpp*/
#include "solution.h"
int main()
{
Solution result;
result.setAim(50);
result.setArr({ 5,10,25,1 });
int aim = result.getAim();
vector<int> arr = result.getArr();
cout << result.orgRecur(arr, aim) << endl;
cout << result.newDp(arr, aim) << endl;
system("pause");
return 0;
}
/*solution.h*/
#pragma once
#include<iostream>
#include<vector>
using namespace std;
class Solution
{
private:
vector<int> arr;
int aim;
public:
void setArr(vector<int> a);
void setAim(int a);
vector<int> getArr();
int getAim();
public:
int orgRecur(vector<int> arr, int aim);
int newDp(vector<int> arr, int aim);
};
/*solution.cpp*/
#include "solution.h"
void Solution::setArr(vector<int> a)
{
for (int i = 0; i < a.size(); i++)
{
arr.push_back(a[i]);
}
}
void Solution::setAim(int a)
{
aim = a;
}
vector<int> Solution::getArr()
{
return arr;
}
int Solution::getAim()
{
return aim;
}
/********** 遞歸解法 **********/
int recur(vector<int> arr, int index, int aim)
{
int ret = 0;
if (index == arr.size())
{
ret = (aim == 0 ? 1 : 0);
}
else
{
for (int num = 0; arr[index] * num <= aim; num++)
{
int rest = aim - arr[index] * num;
ret += recur(arr, index + 1, rest);
}
}
return ret;
}
int Solution::orgRecur(vector<int> arr, int aim)
{
int ret = recur(arr, 0, aim);
return ret;
}
/********** 動態規劃解法 **********/
int dynamicProgramm(vector<int> arr, int index, int aim, vector<vector<int>>& dp )
{
int ret = 0;
if (index == arr.size())
{
ret = (aim == 0 ? 1 : 0);
}
else
{
for (int num = 0; arr[index] * num <= aim; num++)
{
int rest = aim - arr[index] * num;
if (dp[rest][index + 1] != -1)
{
ret += dp[rest][index + 1];
}
else
{
ret += dynamicProgramm(arr, index + 1, rest, dp);
}
}
}
dp[aim][index] = ret;
return ret;
}
int dynamicProgramm_v2(vector<int> arr, int index, int aim, vector<vector<int>>& dp)
{
/*初始化過程*/
for (int i = 0; i < arr.size(); i++)
{
dp[0][i] = 1;
}
for (int j = 1; j <= aim; j++)
{
dp[j][0] = 0;
}
for (int j = 1; arr[0] * j <= aim; j++)
{
dp[arr[0] * j][0] = 1;
}
/*填表過程*/
for (int aimTemp = 1; aimTemp <= aim; aimTemp++)
{
for (int indexLast = 1; indexLast < arr.size(); indexLast++)
{
dp[aimTemp][indexLast] = dp[aimTemp][indexLast - 1];
dp[aimTemp][indexLast] += (((aimTemp - arr[indexLast]) >= 0) ? dp[aimTemp - arr[indexLast]][indexLast] : 0);
}
}
/* TEST
for (int i = 0; i <= aim; i++)
{
for (int j = 0; j < arr.size(); j++)
{
cout << dp[i][j] << '\t';
}
cout << endl;
}
*/
/*返回答案*/
return dp[aim][arr.size() - 1];
}
int Solution::newDp(vector<int> arr, int aim)
{
vector<int> temp(arr.size() + 1, -1);
vector<vector<int>> dp(aim + 1, temp);
int ret = dynamicProgramm_v2(arr, 0, aim, dp);
return ret;
}
2 排成一條線的紙牌博弈問題
【題目】
給定一個整型數組arr，代表數值不同的紙牌排成一條線。玩家A和玩家B依次拿每張紙牌，規定玩家A先拿，玩家B後拿，但是每個玩家每次只能拿走最左或最右的紙牌，玩家A和玩家B都絕頂聰明。請返回最後獲勝者的分數。
【舉例】
arr=[1，2，100，4]。
開始時玩家A只能拿走1或4。如果玩家A拿走1，則排列變爲[2，100，4]，接下來玩家B可以拿走2或4，然後繼續輪到玩家A。如果開始時玩家A拿走4，則排列變爲
[1，2，100]，接下來玩家B可以拿走1或100，然後繼續輪到玩家A。玩家A作爲絕頂聰明的人不會先拿4，因爲拿4之後，玩家B將拿走100。所以玩家A會先拿1，讓排列變爲[2，100，4]，接下來玩家B不管怎麼選，100都會被玩家A拿走。玩家A會得到分數爲101。所以返回101。
arr=[1，100，2]。
開始時玩家A不管拿1還是2，玩家B作爲絕頂聰明的人，都會把100拿走。玩家B會得到分數爲100。所以返回100。
3 行走的機器人
【題目】
給定一個整型數N，則組成arr[0…N-1]代表一條路，共有N步的長度。有一個機器人初始位置下標爲M，規定這個機器人一次只能走p步，每一步可以超任意方向，但是當機器人到達下標0位置時只能換向右走，機器人到達下標N-1位置時只能換向左走。請返回最後停在k位置的可能性有多少種。
【舉例】
輸入：N = 4，M = 2， k = 2， p=2。
由題意arr=[0,1,2,3]，在起始點2處，一次走2步，最終到達2的位置有兩種可能：
第一種方法：2→3→2；第二種方法：2→1→2；
因此返回值爲2。
輸入：N = 4，M = 2， k = 3， p=3。
由題意arr=[0,1,2,3]，在起始點2處，一次走3步，最終到達1的位置有0種可能，返回0。
#include<iostream>
#include<vector>
using namespace std;
int Recur(int N, int M, int p, int k)
{
int ret = 0;
if (p == 0)
{
return M == k ? 1 : 0;
}
else
{
if (M == 0)
ret = Recur(N, M + 1, p - 1, k);
else if (M == N - 1)
ret = Recur(N, M - 1, p - 1, k);
else
ret = Recur(N, M - 1, p - 1, k) + Recur(N, M + 1, p - 1, k);
}
return ret;
}
int Dp(int N, int M, int p, int k)
{
vector<int> temp(N, 0);
vector<vector<int>> dp(p + 1, temp);
for (int i = 0; i < N; i++)
{
if (i == k)
dp[0][i] = 1;
else
dp[0][i] = 0;
}
for (int restStep = 1; restStep <= p; restStep++)
{
for (int currPos = 0; currPos < N; currPos++)
{
if (currPos == 0)
dp[restStep][currPos] = dp[restStep - 1][currPos + 1];
else if (currPos == N - 1)
dp[restStep][currPos] = dp[restStep - 1][currPos - 1];
else
dp[restStep][currPos] = dp[restStep - 1][currPos - 1] + dp[restStep - 1][currPos + 1];
}
}
return dp[p][M];
}
int main()
{
int N = 16;
int M = 10;
int p = 20;
int k = 6;
cout << Recur(N, M, p, k) << endl;
cout << Dp(N, M, p, k) << endl;
system("pause");
}
代碼對比如下，對應關係可以說是很明顯了。
4 字符串的匹配問題
【題目】
給定字符串str，其中絕對不含有字符.和*。再給定字符串exp，其中可以含有.或*，*字符不能是exp的首字符，並且任意兩個*字符不相鄰。exp中的.代表任何一個字符，exp中的*表示*的前一個字符可以有0個或者多個。請寫一個函數，判斷str是否能被exp匹配。
【舉例】
1、str=“abc”，exp=“abc”，返回true。
2、str=“abc”，exp=“a.c”，exp中單個’.’可以代表任意字符，所以返回true。
3、str=“abcd”，exp=.*。exp中*的前一個字符是.，所以可表示任意數量的.字符，當exp是”…“時與“abcd“匹配，返回true。
4、str=”"，exp=..*。exp中*的前一個字符是.，可表示任意數量的.字符，但是.*之前還有一個.字符，該字符不受*的影響，所以str起碼有一個字符才能被exp匹配，所以返回false。
【分析】
1、遞歸方法：假設str從i位置開始，exp從j位置開始，兩者能否匹配構造一個函數f，並返回一個bool類型的值。
bool f(string str, string exp, int i, int j)
{
return false;
}
由於*比較特殊，因此先查看j+1位置和*的關係，共三種可能：是*，不是*，沒有。
1）若j+1不是*，則需要i和j必須相同或j爲.才能夠配上，纔有可能返回true，但是否返回true要看i+1和j+1及後面的部分，即進入了遞歸。
if (j < exp.size() - 1 && exp[j + 1] != '*')
{
if (exp[j] != '.' && str[i] != exp[j])
return false;
return f(str, exp, i+1, j+1);
}
2）若j+1是*，就比較麻煩，需要看這個*能對應上i位置的多少“前綴”，並遍歷每一種情況
while (str[i] < str.size() && (exp[j] == '.' || exp[j] == str[i]))
{
if (f(str, exp, i, j + 2))
return true;
i++;
}
3）如果不存在j+1位置，即j已經不再exp裏面了，此時需要i也不再str中
以此遞歸查看i-1或j-1位置
if (j == exp.size())
{
return i == str.size();
}
綜上，整體遞歸代碼：
bool f(string str, string exp, int i, int j)
{
if (j >= exp.size())
{
return i == str.size();
}
if (j < exp.size() - 1 && exp[j + 1] != '*')
{
if (exp[j] != '.' && str[i] != exp[j])
return false;
return i != str.size() && (exp[j] == '.' || exp[j] == str[i]) && f(str, exp, i+1, j+1);
}
while (i != str.size() && (exp[j] == '.' || exp[j] == str[i]))
{
if (f(str, exp, i, j + 2))
return true;
i++;
}
return f(str, exp, i, j + 2);
}
}
2、改爲動態規劃
我們可以看到，當i和j確定時，其實已經確定了
5 買賣股票的最佳時機
給定一個數組，它的第 i 個元素是一支給定的股票在第 i 天的價格。
設計一個算法來計算你所能獲取的最大利潤。你最多可以完成 兩筆 交易。
注意: 你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。
示例 1:
輸入: [3,3,5,0,0,3,1,4]
輸出: 6
解釋: 在第 4 天（股票價格 = 0）的時候買入，在第 6 天（股票價格 = 3）的時候賣出，這筆交易所能獲得利潤 = 3-0 = 3 。
隨後，在第 7 天（股票價格 = 1）的時候買入，在第 8 天 （股票價格 = 4）的時候賣出，這筆交易所能獲得利潤 = 4-1 = 3 。
示例 2:
輸入: [1,2,3,4,5]
輸出: 4
解釋: 在第 1 天（股票價格 = 1）的時候買入，在第 5 天 （股票價格 = 5）的時候賣出, 這筆交易所能獲得利潤 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接連購買股票，之後再將它們賣出。
因爲這樣屬於同時參與了多筆交易，你必須在再次購買前出售掉之前的股票。
示例 3:
輸入: [7,6,4,3,1]
輸出: 0
解釋: 在這個情況下, 沒有交易完成, 所以最大利潤爲 0。
思路：
#include<iostream>
#include<vector>
using namespace std;
int max(int a, int b)
{
return a > b ? a : b;
}
int Recur(vector<int> prices, int day, int has, int count)
{
int ret = 0;
if (day == prices.size() || (count >= 2 && !has))
return 0;
if (has == 0)
ret = max(Recur(prices, day + 1, 1, count + 1) - prices[day], Recur(prices, day + 1, 0, count));
else
ret = max(Recur(prices, day + 1, 0, count) + prices[day], Recur(prices, day + 1, 1, count) );
return ret;
}
int Dp(vector<int> prices)
{
int ret = 0;
int day = prices.size();
int has = 1;// 0, 1
int count = 2;//0, 1, 2
vector<int> c(count + 1, 0);
vector<vector<int>> h(has + 1, c);
vector<vector<vector<int>>> dp(day + 2, h);//dp[day][has][count]
for (int day_idx = day - 1; day_idx >= 0; day_idx--)
{
for (int has_idx = has; has_idx >= 0; has_idx--)
{
for (int count_idx = count; count_idx >= 0; count_idx--)
{
if (count_idx == 2 && has_idx == 0)
continue;
if (has_idx == 0)
dp[day_idx][has_idx][count_idx] = max(dp[day_idx + 1][1][count_idx + 1] - prices[day_idx], dp[day_idx + 1][0][count_idx]);
else
dp[day_idx][has_idx][count_idx] = max(dp[day_idx + 1][0][count_idx] + prices[day_idx], dp[day_idx + 1][1][count_idx]);
}
}
}
ret = dp[0][0][0];
return ret;
}
int main()
{
for (int i = 0; i < 1000; i++)//簡易對數器
{
int r = rand() % 20;
vector<int> prices;
for (int v = 0; v < r; v++)
{
int t = rand() % 100;
prices.push_back(t);
}
int rc = Recur(prices, 0, 0, 0);
int dp = Dp(prices);
prices.clear();
if (rc != dp)
{
cout << i << "次試驗出錯" << endl;
break;
}
}
cout << "試驗成功~" << endl;
system("pause");
return 0;
}
6 揹包問題
相關的博客已經很多了，這裏不多贅述，其精髓就是下面這兩個式子（選一即可）：
//dp[要拿的是第幾個][還剩多少揹包容量]
dp[i][j] = max( dp[i-1][j], dp[i-1][j-nums[i]] );
dp[j] = max(dp[j], dp[j - nums[i]])