初学动态规划

（1）动态规划定义

           动态规划：动态规则可用于解最优解的问题，其基本思想为把一个大的问题分析小的子问题，并记录每个子问题的结果，再通过这些子问题的解能解出最终的结果。应用于重叠子问题的问题。

         步骤：1 把一个问题分解成好的子问题。 2 对每个子问题求解并记录下每个子问题的结果。

 

          例一：POJ 2533

          思路：动态规划思想，把每一个数看做一个“动态”，把这个“动态”看作是序列的结尾算出此时的递增子序列的长度并记录下来。则所有这些递增子序列中最长的就是所求的。

         代码：

//思路：把每一个数当做一个状态，并记录每个数的最长的上升子序列，当读取到一个新数时，如果这个新的数比前面的某个数小
//并且+1之后比所有的子序列的长度都长，那么这个子序列就是目前的最长子序列，直到序列的结束。
#include<iostream>
#include<fstream>
using namespace std;

int main()
{
// 	ifstream infile("test.txt");
// 	if(!infile)
// 	{
// 		cout<<"Error"<<endl;
// 		return 0;
// 	}
	int n,sequence[1001],recordMaxLength[1001],maxTemp,maxLength;
	int i,k;
	while(cin>>n)
	{
		for(i=0;i<n;i++)
			cin >> sequence[i];

		maxLength=1;
		recordMaxLength[0]=1;
		for(i=1;i<n;i++)
		{
			maxTemp=1;
			for(k=0;k<i;k++)
				if(sequence[k]<sequence[i])
					if(recordMaxLength[k]+1>maxTemp)
						maxTemp=recordMaxLength[k]+1;
			
			recordMaxLength[i]=maxTemp;

			if(maxTemp>maxLength)
				maxLength=maxTemp;
		}

		cout<<maxLength<<endl;
		
	}
	return 0;
}

 例二： 杭电ACM 4502题

把每天看成一个动态，计算每天最多能赚多少。

代码：

//DP，子问题划分以每天的截止时间为子问题
#include<iostream>
#include<algorithm>
#include<fstream>
#include<cmath>
using namespace std;

struct node
{
	int beg;
	int end;
	int money;
};

int cmp(const node &a,const node &b)
{
	return a.end<b.end;
}

int main()
{
// 	ifstream infile("test.txt");
// 	if(!infile)
// 	{
// 		cout<<"Error"<<endl;
// 	}
	int t;
	node job[1001];
	int sum[101];
	cin>>t;
	while(t>0)
	{
		int m,n,i,j,max=0;
		cin>>m>>n;
		for(i=0;i<n;i++)
		{
			cin>>job[i].beg>>job[i].end>>job[i].money;
		}
		memset(sum,0,sizeof(sum));
		sort(job,job+n,cmp);

		for(i=1;i<=m;i++)
		{
			sum[i]=sum[i-1];
			for(j=0;j<n;j++)
			{
				if(job[j].end==i)
				{
					if(sum[i]!=0)
					{
						int temp1,temp2;
						temp1=sum[i];
						temp2=sum[i]>sum[job[j].beg-1]+job[j].money?sum[i]:sum[job[j].beg-1]+job[j].money;
						sum[i]=temp1>temp2?temp1:temp2;
					}
					else
 			    	sum[i]=sum[i]>sum[job[j].beg-1]+job[j].money?sum[i-1]:sum[job[j].beg-1]+job[j].money;
				}
			}
		}
		cout<<sum[m]<<endl;
		t--;
	}
	return 0;
}

例三：杭电ACM 4508

         思想：把每个热量当成“状态”，则把子状态划分了。

         代码：

//动态规则
#include<iostream>
#include<fstream>
using namespace std;

struct node
{
	int happy;
	int hot;
};

int main()
{
// 	ifstream infile("test.txt");
// 	if(!infile)
// 	{
// 		cout<<"Error"<<endl;
// 	}

	int n;
	node food[110];
	int sum[2][100010];
	while(cin>>n)
	{

		int i,j,now=1;
		for(i=1;i<=n;i++)
		{
			cin>>food[i].happy>>food[i].hot;
		}
		
		
		int need;
		cin>>need;

		for(i=0;i<=need;i++)
			sum[now][i]=0;
		int tag;
		int temp;
		for(i=1;i<=n;i++)
		{
			now=now^1;
			for(tag=0;tag<=need;tag++)
			{
				sum[now][tag]=sum[now^1][tag];
				if(food[i].hot<=tag)
				{
					temp=sum[now][tag-food[i].hot]+food[i].happy;
					sum[now][tag]=sum[now^1][tag]>temp?sum[now^1][tag]:temp;
				}
			}
		}

		int max=0;
		for(i=1;i<=need;i++)
			if(sum[now][i]>max)
				max=sum[now][i];
		cout<<max<<endl;
	}		
	return 0;
}

例四：杭电4501

          思路：这个题目当数据量小的时候才能用DP，否则运行量太大

代码：

//动态规划——买年货
#include<iostream>
#include<fstream>
#include<algorithm>
#include<cmath>
#include<stdlib.h>
using namespace std;

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

struct node
{
	int money;
	int record;
	int valu;
};



int main()
{
// 	ifstream infile("test.txt");
// 	if(!infile)
// 	{
// 		cout<<"Error"<<endl;
// 	}
	
	int n,v1Money,v2Record,kFree;
	node object[110];
	int sum[2][110][110][6];
	while(cin>>n>>v1Money>>v2Record>>kFree)
	{
		int i;
		for(i=0;i<n;i++)
			cin>>object[i].money>>object[i].record>>object[i].valu;

		int now=1;
		int j,k,h;
		for(i=0;i<=v1Money;i++)
			for(j=0;j<=v2Record;j++)
				for(k=0;k<=kFree;k++)
					sum[now][i][j][k]=0;

		for(i=0;i<n;i++)
		{
			
			now=now^1;
			for(j=0;j<=v1Money;j++)
				for(k=0;k<=v2Record;k++)
				 	for(h=0;h<=kFree;h++)
					{
						
						sum[now][j][k][h]=sum[now^1][j][k][h];
						if(object[i].money<=j)
							sum[now][j][k][h]=max(sum[now][j][k][h],sum[now^1][j-object[i].money][k][h]+object[i].valu);
						if(object[i].record<=k)
							sum[now][j][k][h]=max(sum[now][j][k][h],sum[now^1][j][k-object[i].record][h]+object[i].valu);
					 	if(h>0)
					 	{
					 		sum[now][j][k][h]=max(sum[now][j][k][h],sum[now^1][j][k][h-1]+object[i].valu);
					 	}
					}
		}

		int big=0;
		for(j=0;j<=v1Money;j++)
			for(k=0;k<=v2Record;k++)
					for(h=0;h<=kFree;h++)
						if(sum[now][j][k][h]>big)
							big=sum[now][j][k][h];

		cout<<big<<endl;
	}
	return 0;
}