思路总结
看了一篇大佬的总结:
告别动态规划,连刷40道动规算法题,我总结了动规的套路
自己的收获:
思路三步走:
- 找数组元素定义:一般动态规划用一维或者二维数组解得,而且我们要的答案一般为
dp[i]
或者dp[i][j]
,那么这里的数组元素代表什么意思呢?一般指的是当前最优解 - 归纳法推导动态规划转移方程:动态规划指的就是从历史最优解推出当前最优解,这里我们就需要找出问题的最优子结构。一般从全局向小规模推导,即
dp[i]-->dp[0]
或者dp[i][j]-->dp[0][0]
,代码一般用循环实现。而且动态规划转移方程一般是
3. dp[n] = dp[n-1] + dp[n-2]
4. dp[i][j] = min(dp[i-1][j],dp[i][j-1]) + arr[i][j] // arr[i][j]指二维数组(不是动态规划数组)初始值
5. dp[i][j] = max(dp[i-1][j],dp[i][j-1]) + arr[i][j] // arr[i][j]指二维数组(不是动态规划数组)初始值
6. 或者在2、3的基础上找三个历史最优解最大或最小值
- 找动态数组初始值:这里的初始值一般指第二步求出的递推式递推的基础,这些值放在递推式里一般不合法(一般是第一步或者特殊情况,如
dp[n] = dp[n-1] + dp[n-2]
中n=0),但是可以通过简单模拟得出来。
练习
钢条切割
一公司购买长钢条,将其切为短钢条出售,假设切割没有成本,公司希望知道最佳的切割方案!假设我们知道一段长度为i的钢条的价格为pi(i = 1,2,3…),钢条长度均为整英寸,下面给出一个价格表:
长度i 1 2 3 4 5 6 7 8 9 10
价格pi 1 5 8 9 10 17 17 20 24 30
给定一长度为n的钢条和一张价格表(i =1, 2,3…n),求切割钢条的方案,使的利润最大,可以不进行切割
思路:把前面的长度的最大利润求出来后,后面的长度可以分隔成前面的长度,那么前面的长度的最优解(存入数组)就可以直接应用到后面的长度。
用Python实现:
# 动态规划和最优值有关,贪心算法是动态规划中的特殊情况
import time
# 计算时间的装饰器
def cal_time(func):
def wrapper(*args, **kwargs):
t1 = time.time()
result = func(*args, **kwargs)
t2 = time.time()
print("%s running time: %s secs." %(func.__name__,t2-t1))
return result
return wrapper
p = [0, 1, 5, 8, 9, 10, 17, 20, 21, 23, 24, 26, 27, 27, 28, 30, 33, 36, 39, 40, 43]
# p = [0, 1, 5, 8, 9, 10, 17, 20, 24, 30]
# r = [0, 1, 5, 8, 10, 13, 17, 20, 24, 30]
def cutRod_recursion_up2down(n,p): # 自顶向下实现
if n == 0:
return 0
else:
res = p[n]
for i in range(1,n+1):
res = max(res,cutRod_recursion_up2down(i,p)+cutRod_recursion_up2down(n-i,p))
return res
@cal_time
def c1(p,n):
return cutRod_recursion_up2down(n,p)
def cutRod_recursive_up2down2(n,p):
if n == 0:
return 0
else:
res = 0
for i in range(1,n+1):
res = max(res,cutRod_recursive_up2down2(n-i,p)+p[i])
return res
@cal_time
def c2(p,n):
return cutRod_recursive_up2down2(n,p)
def cutRod_down2up(n,p): # 不用递归
r = [0]
for i in range(1,n+1):
res = p[i]
for j in range(1,i+1):
res = max(res,p[j]+r[i-j]) # 与上一个排列的最大值比较
r.append(res)
return r[n]
# coding = utf-8
def cut_rod_extend(n,p):
r = [0]
s = [0]
for i in range(1,n+1):
res_r = 0
res_s = 0
for j in range(1,i+1):
if r[i-j]+p[j] > res_r:
res_r = r[i-j]+p[j]
res_s = j
r.append(res_r)
s.append(res_s)
return r[n],s
def cutRod_solution(n,p):
ans = []
r,s = cut_rod_extend(n,p)
while n > 0:
ans.append(s[n])
n -= s[n]
return ans
print(cutRod_down2up(7,p))
print(cutRod_solution(7,p))
# print(c1(p,9))
# print(c2(p,15))
# print(c3(p,20))
# print(curRod_down2up(9,p))
最大子序和
给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
示例 1:
输入:nums = [-2,1,-3,4,-1,2,1,-5,4]
输出:6
解释:连续子数组 [4,-1,2,1] 的和最大,为 6 。
示例 2:
输入:nums = [1]
输出:1
示例 3:
输入:nums = [0]
输出:0
示例 4:
输入:nums = [-1]
输出:-1
示例 5:
输入:nums = [-100000]
输出:-100000
#include<bits/stdc++.h>
using namespace std;
int maxSum(){
vector<int> a;
while(1){
int b;
cin >> b;
a.push_back(b);
char c = getchar();
if(c =='\n') break;
}
if(a.size()==1){
return a[0];
}
int rise = a[0];
int res=0;
for(int i=1;i<=a.size();i++){
rise = max(0,rise); //一旦序列和起始值小于0就丢弃,重新开始
rise += a[i];
res = max(res,rise); //rise 为当前最大子序和,res为上一次的最大子序和
}
return res;
}
int main(){
int res = maxSum();
cout << res << endl;
return 0;
}
不同路径1
先看看典型的不同路径v1.0:
在n*m的迷宫里,可以向下或者向右走:
Leetcode–62. 不同路径
- 思路:到达每格的方法总数为其左方和上方的方法数总和
其动态规划转移方程为:dp[i][j] = dp[i-1][j]+dp[i][j-1]
- 注意:起始位置方法数为1,即
dp[0][0] = 1
。边缘部分,最上方一排的每个格子的方法数为其左方方法数,即dp[i][j] = 0+dp[i][j-1]
,都为1。最左方一排的每个格子的方法数为其上方方法数,即dp[i][j] = dp[i-1][j]+0
,都为1。
#include<bits/stdc++.h>
using namespace std;
int diffRoute(){
int n,m;
cin >> n >> m;
int a[m][n];
for(int i=0;i<m;i++){
a[i][0] = 1;
}
for(int i=0;i<n;i++){
a[0][i] = 1;
}
for(int i=1;i<m;i++){
for(int j=1;j<n;j++){
a[i][j] = a[i-1][j]+a[i][j-1];
}
}
return a[m-1][n-1];
}
int main(){
int res = diffRoute();
cout << res << endl;
return 0;
}