动态规划知识总结

DP-方法

动态规划和分治的联系和区别

1.动态规划和分治相似，都是通过组合子问题的解来求解原问题。

2.分治法：将问题划分为互不相交的子问题，递归求解子问题，再将子问题的解组合起来，求解原问题的解。
动态规划：应用于子问题重叠的情况，即不同的子问题拥有公共的子子问题。（如果用分治法来求解，会反复求解公共的子子问题；用动态规划就求一次。）该方法通常用来解决多阶段决策过程（前后关联，链状结构，多阶段过程）的最优化问题。

适合用动态规划解决的问题

最优性原理：无论过程的初始决策、状态是什么，其余决策都必须相对于初始决策产生的状态构成一个最优决策序列。

如果最优性原理成立的问题，说明动态规划有可能解决该问题。

疑问

最优性原理对于多阶段决策问题，总是成立吗？
答：不。多段图问题：路径和改为路径乘积，并允许出现负数。

例子

1.多段图

#include<iostream>
using namespace std;

#define N 12//点个数
#define K 4//层数
int c[N][N];//存各边长度
int cost[N];//存直达某点的最小边
int d[N];//存最短路径

void init() {
	//为了测试方便，直接码出来了
	c[1][2] = 9; c[1][3] = 7; c[1][4] = 3; c[1][5] = 2;
	c[2][6] = 4; c[2][7] = 2; c[2][8] = 1; c[3][6] = 2;
	c[3][7] = 7; c[4][8] = 11; c[5][7] = 11; c[5][8] = 8;
	c[6][9] = 6; c[6][10] = 5; c[7][9] = 4; c[7][10] = 3;
	c[8][10] = 5; c[8][11] = 6; c[9][12] = 4; c[10][12] = 2;
	c[11][12] = 5;
}

//void fGraph() {//向前处理法
//	
//	for (int i = N-1; i >=1; i--) {
//		cost[i] = 9999;
//		for (int j = i; j <= N; j++) {
//			if (c[i][j] != 0 ) {//有边
//				if(cost[j] + c[i][j] < cost[i])//更新最小值
//				{
//					cost[i] = cost[j] + c[i][j];
//					d[i] = j;
//				}
//			}
//		}
//	}
//}
void fGraph() {//向后处理法
	for (int i =2; i<=N; i++) {
		cost[i] = 0x3f3f3f;
		for (int j = i-1; j >= 1; j--) {
			if (c[j][i] != 0) {//有边
				if (cost[j] + c[j][i] < cost[i])//更新最小值
				{
					cost[i] = cost[j] + c[j][i];
					d[i] = j;
				}
			}
		}
		
	}
}

int main() {
	init();//多段图的初始化
	fGraph();//处理多段图	
	cout << cost[12] << endl;
	//int n = 12;
	//int m = 5;
	//cout << 12 << endl;
	//while (n!=1)
	//{
	//	cout << d[n] << endl;
	//	n = d[n];
	//}//输出路径
}

2.最优二分检索树

3.流水线调度问题

直观上，一个最优调度应使机器M1没有空闲时间，且机器M2的空闲时间最少。在一般情况下，机器M2上会有机器空闲和作业积压2种情况。

1. 使M1上的加工是无间断的。即M1上的加工时间是所有ai之和，但M2上不一定是bi之和。
2. 使作业在两台机器上的加工次序是完全相同的。
   则得结论：仅需考虑在两台机上加工次序完全相同的调度。

#include<iostream>
#include<algorithm>
using namespace std;

int n,m;

class JOB {
public:
	int key, index;//时间和原下标索引
	bool job;//是在前还是后
};

bool cmp(JOB a, JOB b) {
	return a.key < b.key;
}

int func(int n, int a[], int b[], int c[]) {
	JOB* j = new JOB[100];
	/*
	Johson法则分出的第一组都是M2加工时间大于M1的，且按M1时间
	递增；分出的第二组都是M1加工时间大于M2的，且按M2时间递减。
	由于M1加工是无间断的，决定时间长短的只是M2。
	按照Johson法则会发现，中间部分都是一些M2耗时大的
	作业，两头都是一些耗时小的作业，
	个人觉得这样安排会很好填充M2中的时间空隙。
	*/
	for (int i = 0; i < n; i++) {
		if (a[i] <= b[i]) {
			j[i].job = true;
			j[i].key = a[i];
		}
		else {
			j[i].job = false;
			j[i].key = b[i];
		}
		j[i].index = i;
	}
	sort(j, j + n, cmp);
	int s = 0, e = n - 1;
	for (int i = 0; i < n; i++) {
		if (j[i].job) {
			c[s++] = j[i].index;
		}
		else {
			c[e--] = j[i].index;
		}
	}
	
	int t1 = a[c[0]], t2 = t1+b[c[0]];
	for (int i = 1; i < n; i++) {
		t1 += a[c[i]];
		t2 = t2 < t1 ? t1 + b[c[i]] : t2 + b[c[i]];//第二条流水线是谁大就接在谁的后面
	}
	return t2;//第二个的时间肯定比第一个大或者相等
}

int main() {
	int a[100], b[100],c[100];
	cin >> n;
	while (n--)
	{
		cin >> m;
		for (int i = 0; i < m; i++) {
			cin >> a[i] >> b[i];
		}
		cout << func(m, a, b, c) << endl;
	}
}
/*
1
7
5 2
3 4
6 7
4 2
8 9
9 7
6 3
*/
//答案是43

4.01背包问题

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1010;
int n, m;
int v[N], w[N];
int f[N];
int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		scanf("%d%d", &v[i], &w[i]);
	}
	for (int i = 1; i <= n; i++) {
		for (int j = m; j >=v[i]; j--) {//从大到小才能防止下面f[j-v[i]]的数据因被更新成第i层，你用的是第i-1层的数据。因为j-v[i]小于j所以防止提前更新因从大到小遍历
			f[j] = max(f[j], f[j - v[i]] + w[i]);
		}
	}
	cout << f[m];
}

5.旅行商问题(TSP、货郎担问题)

总结