动态规划算法(DP)学习＜1＞

是一种用来最优化问题的方法，将一个复杂问题分解成若干个子问题，再通过将每个子问题的最优解记录下来，这样在再次碰到子问题的时候，就有一个直接的答案。重点就是其取消了重复计算环节。

通常使用递归和递推两种方法实现动态规划，递归又叫做：记忆化搜索。

可以从一个Fibonacci数列的计算为例：
计算斐波那契数列的经典方法就是递归，也就是如下：

int F(int n)
{
	if(n==0||n==1) return 1;
	else return F(n-1)+F(n-2);
}

这里就涉及了重复计算的问题，例如我要计算F(5)。那么要计算F(4)和F(3)而F4=F3+F2，F3=F2+F1；可以看到F2被计算了两遍。如果可以把重复计算的值在计算一遍后保存起来，则可以实现程序的优化。

分析其迭代过程：可以用一个一位数组dp[maxn]记录被计算过的F(n)的值。

			   dp[i]=F(i-1)+F(i-2)；

那么可以将原函数改写：

int F(int n)
{	
	int maxn=1000;
	int dp[maxn];
	for(int i=0;i<maxn;i++)
		dp[i]=-1;
	//设置成-1，如果不等于-1则说明其已经被赋值，直接输出。
	if(n==1||n==0)	return 1;
	if(dp[n]!=-1) return dp[n];
	else
		dp[n]=F(n-1)+F(n-2);
	return dp[n];
}

这里就可以看出记忆化搜索的意思来，就是用一个数组记录需要被重复计算的部分，等到再次调用到的时候直接输出。

记忆化搜索能够把复杂度降级。

这里可以引出动态规划的一个要素，就是重叠子问题和最优子结构，它被分解为几个子结构后，每个子结构每次决策过程中要有最优解。

下面以一个问题为例，再分步思考动态规划问题。

最大连续子序列和

 给定一个数字序列A1，A2，A3...,An，求i,j（1<=i<=j<=n），使得Ai+...+Aj最大，输出最大和

这里使用动态规划解法，假设一个dp[i]一维数组。
他的子问题是什么？假设现在有

                     A1=-2, A2=11, A3=-4, A4=-3

暴力方法就是遍历，其过程可以写下为：

A[1->1]=-2  A[1->2]=-2+11  A[1->3]=-2+11-4  A[1->4]=-2+11-4-3
		    A[2->2]=11     A[2->3]=11-4     A[2->4]=11-4-3
		                   A[3->3]=-4       A[3->4]=-4-3
		                                    A[4->4]=-3

总结可以得到其子问题：
在这里需要考虑：需要得到的结果是最大值。可以将最大值设为dp[i]，表示以A[I]为结尾的一系列最大值。
而每次计算得到的最大值是什么？

	dp[i]=dp[i-1]+A[i]

这里再考虑如果A[i]+dp[i-1]<A[i]，那么如果加上则最大值变小，这不是我们想要的，所以这种情况可以加上

   dp[i]=max(dp[i-1]+A[i],A[i])

而边界条件根据i-1>=0，则i>=1，所以需要单独考虑i=0的情况：

   dp[0]=A[0]

这样就不会发生在迭代的时候卡壳的问题。
整个逻辑完成了之后就可以开始代码编写了。

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn=10010;
int A[maxn],dp[maxn];
int main()
{
	//输入数列
	int n;
	scanf(%d,&n);
	for(int i=0;i<n;i++)
	{sacnf(%d,&A[i]);}
	//数列输入完毕
	dp[0]=A[0];
	for(int i=1;i<n;i++)
	{
		dp[i]=max(dp[i-1],A[i]);
	}
	//已经完成，接下来比较输出	
	int k=0;
	for(int i=1;i<n;i++)
	{
		if(dp[i]>dp[k])
			k=i;
	}
	printf(%d,&dp[k]);
	return dp[k];
}

再来看一个问题

最长回文子串

给出一个字符串S，求S的最长回文子串长度
eg：字符串"PATZJUJZTACCBCC"的最长回文子串为"ATZJUJZTA"，长度为9。

怎么判断是不是回文串？这是首要的问题。
传统判断回文的方法：

	两头夹：先判断s[0] 与s[len-1],再是s[1]与s[len-1-1]，。。。。以此循环

那么判断是不是回文的方法就确定了，这是一个可以分解成子问题的过程。

暴力方法就是遍历所有的子串组合，在这个过程中，有许多的重复计算。
在每次判定的组合里，都会重复之前的步骤，判定某个子串是不是回文。
那么是否需要一个数列，储存之前计算过的关于某子串是不是回文的信息？

这就是优化的地方。
那么判断一个子串是不是回文的DP写法呢？

//伪代码
bool dp[i][j];
if(s[i]==s[j])
	dp[i][j]==dp[i+1][j-1];  //j>=1
else if(s[i]!=s[j])
	dp[i][j]=0;

我判断我自身是不是回文，只需要先比较我的两头是不是相等，再判断我里面是不是回文，而里面是不是回文这个信息已经在之前计算过了。

这是一个递归的过程。

那么其边界条件需要考虑的：
1.自身与自身，长度为1的回文子串，不能让不能让i+1>j-1
2.根据i+1>j-1，则j>i+2；那么j=i+1的情况呢？要设置为边界条件。
//两条都是根据j>i+2的条件来写的

for(i=0;i<len;i++)
	dp[i][i]=1;
dp[i][i+1]=(s[i]==s[i+1])?1:0;

完成了设置后就可以开始写代码了。

#include <iostream>
#include <string>
#define MAXN 1010

using namespace std;
int main()
{
int dp[MAXN][MAXN];//dp只有0和1
string s;
cin>>s>>endl;
int ans=1;
memset(dp,0,sizeof(dp)); //初始化为0
//边界处理
for(int i=0;i<s.size();i++)
{
	dp[i][i]=1;
	if(i<len-1)
	{
		dp[i][i+1]=(s[i]==s[i+1])?1:0;
		ans=2;
	}	
}
//这里进行筛选的方式也需要考虑，是根据i,j双循环的方式进行？还是根据固定长度L，遍历完一个长度的序列后再遍历L++的值呢
//看哪种方式能够不卡壳，那么i,j双循环的方式明显不行，选用固定长度方式
for(int L=3;L<s.size();L++)
{	int j=i+L-1
	for(int i=1;i+L-1<s.size();i++)
	{
		if(s[i]==s[j])
			dp[i][j]=dp[i+1][j-1];
		else
			dp[i][j]=0;	
	}
	if(dp[i][j]==1)
		ans=j-i+1;
}
return ans;
}

《算法笔记》