动态规划的空间优化， 以最长公共子序列为例

最简单的直接按照递推式去写

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

char a[1001], b[1001]; 
int tag[1001][1001]; 

#define max(a, b) a > b ? a : b

int f(int i, int j) 
{ 
	if (i < 0 || j < 0) return 0; 
	
	if (tag[i][j] != -1) return tag[i][j]; 
	if (a[i] == b[j])    return tag[i][j] = f(i - 1, j - 1) + 1; 
	else return tag[i][j] = Max(f(i - 1, j), f(i, j - 1)); 
} 

int main() 
{ 
	int N; 

	scanf("%d", &N); 

	while (N--) 
	{ 
		memset(tag, -1, sizeof(tag)); 
		scanf("%s %s", a, b); 
		printf("%d\n", f(strlen(a) - 1, strlen(b) - 1)); 
	} 
	return 0; 
}

空间消耗tag[1005][1005] + 递归栈内存的消耗

所以第一步的优化就是用循环来替代递归，减少找内存的消耗

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

char a[1001], b[1001]; 
int dp[1005][1005] = {0};

#define max(a, b) a > b ? a : b 

int f(int len1, int len2) 
{ 
	
	memset(dp, 0, sizeof(dp));
	for (int i = 1; i <= len1; i++)
	{
		for (int j = 1; j <= len2; j++)
		{
			if (a[i - 1] != b[j - 1]) dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
			else dp[i][j] = dp[i - 1][j - 1] + 1;
		}
	}
	return dp[len1][len2];
} 

int main() 
{ 
	int N; 

	scanf("%d", &N); 

	while (N--) 
	{ 
		scanf("%s %s", a, b); 
		printf("%d\n", f(strlen(a), strlen(b))); 
	} 
	return 0; 
}

循环版本辅助空间就是一个dp[1005][1005]，但是可以到我们计算f(i, j)时，只需要dp[i][j]的第i-1、i行，而不需要一整个数组，所以我们可以用dp1[1005], dp2[1005]， 来存储之前的最优解，当计算完dp2后，交换指针，让之前的dp2数组做最优解，用dp1数组继续计算下去。

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

char s1[1005], s2[1005];

int f(int len1, int len2)
{
	int tag1[1005] = {0}, tag2[1005];
	int *q, *p, *t;
	
	p = tag1;
	q = tag2;
	
	for (int i = 1; i <= len1; i++)
	{
		for (int j = 1; j <= len2; j++)
		{
			if (s1[i - 1] == s2[j - 1]) q[j] = p[j - 1] + 1;
			else q[j] = max(p[j], q[j - 1]);
		}
		t = p; p = q; q = t;
	} 
	return p[len2];
}

int main()
{
	int casen;
	
	scanf("%d", &casen);
	while (casen--)
	{
		scanf("%s%s", s1, s2);
		printf("%d\n", f(strlen(s1), strlen(s2)));
	}
	
	return 0;
}    

这样动态规划的空间就是dp1[1005] + dp2[1005]， 空间优化到O(n)的时间复杂度，准确的说是2*n的辅助空间。

仔细分析递推式，我们计算f(i, j)其实最终只用到了f(i - 1, j) f(i - 1, j - 1) , f(i, j - 1)三个变量，所以当我们计算完一行最优价时， 我们就有了f(i - 1, j - 1)、f(i - 1, j)，但是缺一个f(i, j - 1)，但是当我们计算到f(i, j)时，其实f(i, j - 1）已经有结果了，只是f(i, j - 1)的结果把f(i - 1, j - 1)给覆盖了，所以实际上我们只需要一个dp[1005]， 然后用一个pre来保存f(i - 1, j - 1）的值即可

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

char s1[1005], s2[1005];

int f(int l1, int l2)
{
	int tag[1005] = {0};
	int pre, t;
	
	for (int i = 1; i <= l1; i++)
	{
		pre = 0;
		for (int j = 1; j <= l2; j++)
		{
			t = tag[j];
			if (s1[i - 1] == s2[j - 1]) tag[j] = pre + 1;
			else tag[j] = max(tag[j], tag[j - 1]);
			pre = t;
		}
	}
	return tag[l2];
}

int main()
{
	int casen;
	
	scanf("%d", &casen);
	while (casen--)
	{
		scanf("%s%s", s1, s2);
		printf("%d\n", f(strlen(s1), strlen(s2)));
	}
	
	return 0;
}        

此时空间复杂度到了到了真正的n