【DP动态规划】个人常用基础动态规划DP小总结【TODO】

【TODO】

个人小感悟：

关于动态规划，书上和网上有各种理论，

什么决策，状态转移方程，看起来好像思路还挺清晰的。

但是光光看完理论，直接去做题，基本啥也做不出来，这也说明看懂和自己能运用完全是两码事。

理论是严谨的，理论是抽象的，理解起来难免生涩。

一个方法，一个知识，除了其抽象性，人们经常还忽略了另一个重要的方面，直觉性。

形式化的抽象，保证了其严谨性，但是却少了很多直觉性。

我认为在数学上，想要很好的理解的运用，抽象性和直觉性都很重要，

有时候我个人认为，直觉性甚至比抽象性更重要。

如果，你对这种问题，没有办法形成一个直观的理解，那恐怕换个场景，基本就不懂得如果运用自己所学的知识了。

故，希望有花点时间，将自己的理解的一些动态规划问题，做一些直觉性的小总结。

希望日后，在真正能用得上的时候，不是想破了半天理论也套不上，而是能有自己的一点解决方法。

由数据规模可推测大概用什么解法：

1) n <= 20, 基本就是DP了, O(n^2)

2) n < 10^3 or 10^4, 也是DP, O(n^2)

3) n = 10^5, 10^6, 一般得集合分治法得到O(nlogn)

4) n >= 10^8, 那就得考虑怎么O(logn), 或者O(1)了

动态规划的核心思想： 重复， 最优， 子问题

DP分类：

1) 当数据，单行，线性可列的时候

2) 当数据双行，线性可列的时候

1# 最大上升子序列之和

题目编号：HDU1087

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1087

#include<stdio.h>
#define MIN 1 << 31
#define MAX ~(MAX);

int a[1001];
int dp[1001];

int main() {
	int i, j, n;
	while (scanf("%d", &n) && n != 0) {
		for (i = 0; i < n; i++) {
			scanf("%d", &a[i]);
			dp[i] = a[i];
		}
		
		int dpMAX = MIN;
		for (i = 0; i < n; i++) {
			dpMAX = MIN;
			for (j = i - 1; j >= 0; j--) {	
				if (a[i] > a[j]) {
					dpMAX = dpMAX > dp[j] + a[i] ? dpMAX : dp[j] + a[i];
				}				
			}
			dp[i] = dp[i] > dpMAX ?  dp[i] : dpMAX;
		}

		dpMAX = MIN;
		for (i = 0; i < n; i++) {
			dpMAX = dpMAX > dp[i] ?  dpMAX : dp[i];
		}
		printf("%d\n", dpMAX);
	}
	return 0;
}

2#  最大连续子序列（子串）之和，并输出首位元素

题目编号：HDU1231

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1231

#include<stdio.h>

int a[10001];

int main() {
	int i, n;
	while (scanf("%d", &n) && n != 0) {
		int flag = 1;
		for (i = 0; i < n; i++) {
			scanf("%d", &a[i]);
			if (a[i] >= 0) flag = 0;
		}
		if (flag == 1) {
			printf("0 %d %d\n", a[0], a[n - 1]);
			continue;
		}
		

		int pl = 0;
		int l = 0;
		int r = -1;

		int dpMAX = 0;	
		int sum = 0;
		for (i = 0; i < n; i++) {
			if (sum + a[i] >= 0) {
				sum = sum + a[i];
				if (sum > dpMAX) {
					dpMAX = sum;
					l = pl;
					r = i;
				}
			} else {
				sum = 0;
				pl = i + 1;
			}
		}
		if (dpMAX == 0) {
			printf("0 0 0\n");
		} else {
			printf("%d %d %d\n", dpMAX, a[l], a[r]);
		}
	}
	return 0;
}

3# 区间动态规划，注意区间的错位pre

题目编号：HDU4283

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4283

#include<stdio.h>
#include<string>

int a[101];
int dp[101][101][101];

int solve(int l , int r, int head) {
	if (l >  r) return 0;
	if (l == r) return a[l] * head;
	if (dp[l][r][head] != 0) return dp[l][r][head];
	
	int dpMin = INT_MAX;
	for (int k = l; k <= r; k++) {
		int dpL = solve(l + 1, k, head);
		int dpK = (head + k - l) * a[l];
		int dpR = solve(k + 1, r, head + k - l + 1);
		int sum = dpL + dpK + dpR;
		dpMin = dpMin < sum ? dpMin : sum;
	}
	return dp[l][r][head] = dpMin;
}

int main() {
	int ti, t;
	int i, n;
	scanf("%d", &t);
	for (ti = 0; ti < t; ti++) {
		memset(dp, 0, sizeof(dp));
		scanf("%d", &n);
		for (i = 0; i < n; i++) {
			scanf("%d", &a[i]);
		}
		int ans = solve(0, n - 1, 0);
		printf("Case #%d: %d\n", ti + 1, ans);
	}
	return 0;
}

3# 最长公公共子序列

原理：

结果：

回溯，找到最长公共子序列

只要从，dp最大的位置i1, i2，从pre退回来找到的都是最长公共子序列，（有可能结果不同）

#include<stdio.h>
#include<stdlib.h>

char s1[101];
char s2[101];
int dp[101][101];
int pre[101][101]; // 回溯，找到最长公共子序列
char stack[101];
int top = 0;

void LCS(char s1[], char s2[], int n1, int n2) {
	int i1, i2;

	for (i1 = 0; i1 <= n1; i1++) {
		for (i2 = 0; i2 <= n2; i2++) {
			if (i1 == 0 || i2 == 0) {
				dp[i1][i2] = 0;
			} else if (s1[i1 - 1] == s2[i2 - 1]) {
				dp[i1][i2] = dp[i1 - 1][i2 - 1] + 1;
				pre[i1][i2] = 0;
			} else {
				if (dp[i1 - 1][i2] >= dp[i1][i2 - 1]) {
					dp[i1][i2] = dp[i1 - 1][i2];
					pre[i1][i2] = 1;
				} else {
					dp[i1][i2] = dp[i1][i2 - 1];
					pre[i1][i2] = 2;
				}
			}
		}
	}

	// printf the length
	printf("%maxn len = %d\n", dp[n1 - 1][n2 - 1]);
	
	// print dp array
	printf("\ndp array:\n");
	for (i1 = 0; i1 <= n1; i1++) {
		for (i2 = 0; i2 <= n2; i2++) {
			printf("%d ", dp[i1][i2]);
		}
		printf("\n");
	}
	
	printf("\npre array:\n");
	// print pre arrary
	for (i2 = -1; i2 <= n2; i2++) {
		printf("%d\t", i2);
	} printf("\n");
	for (i1 = 0; i1 <= n1; i1++) {
		printf("%d\t", i1);
		for (i2 = 0; i2 <= n2; i2++) {
			printf("%d\t", pre[i1][i2]);
		}
		printf("\n");
	}

	// print the common sequence
	i1 = n1;
	i2 = n2;
	while(i1 > 0 && i2 > 0) {
		if (pre[i1][i2] == 0) {
			stack[top++] = s1[i1 - 1];
			i1--;
			i2--;
		} else if (pre[i1][i2] == 1) {
			i1--;
		} else {
			i2--;
		}

	}
	printf("longest conmmon sequnce:\n");
	for (int ti = top - 1; ti >= 0; ti--) {
		printf("%c ", stack[ti]);
	} printf("\n");
}

int main() {
	int i;
	int n1 = 14;
	int n2 = 15;

	//n1 = 1;
	//n2 = 2;
	//char s1[] = "1";
	//char s2[] = "12";
	for (i = 0; i < n1; i++) {
		s1[i] = '0' + (rand() % 10);
		printf("%c ", s1[i]);
	}
	printf(", len = %d\n", n1);

	for (i = 0; i < n2; i++) {
		s2[i] = '0' + (rand() % 10);
		printf("%c ", s2[i]);
	}
	printf(", len = %d\n", n2);

	LCS(s1, s2, n1, n2);
	return 0;

}