动态规划

思路总结

看了一篇大佬的总结：
告别动态规划，连刷40道动规算法题，我总结了动规的套路
自己的收获：
思路三步走：

1. 找数组元素定义：一般动态规划用一维或者二维数组解得，而且我们要的答案一般为dp[i]或者dp[i][j]，那么这里的数组元素代表什么意思呢？一般指的是当前最优解
2. 归纳法推导动态规划转移方程：动态规划指的就是从历史最优解推出当前最优解，这里我们就需要找出问题的最优子结构。一般从全局向小规模推导，即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的基础上找三个历史最优解最大或最小值

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

Leetcode第53题

#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. 不同路径

1. 思路：到达每格的方法总数为其左方和上方的方法数总和
   其动态规划转移方程为：dp[i][j] = dp[i-1][j]+dp[i][j-1]
2. 注意：起始位置方法数为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;
}