动态规划章节总顾

        动态规划算法与分治法类似，其基本思想是将待求解问题分解成若干子问题,先求解子问题，再结合这些子问题的解得到原问题的解。与分治法不同的是,适合用动态规划法求解的问题经分解得到的子问题往往不是互相独立的。若用分治法来解这类问题,则分解得到的子问题数目太多，以致最后解决原问题需要耗费指数级时间。然而，不同子问题的数目常常只有多项式量级。在用分治法求解时，有些子问题被重复计算了许多次。如果能够保存已解决的子问题的答案，在需要时再找出已求得的答案，这样可以避免大量的重复计算，从而得到多项式时间算法。为了达到此目的，可以用一个表来记录所有已解决的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中。这就是动态规划法的基本思想。具体的动态规划算法多种多样，但它们具有相同的填表格式。

矩阵链乘

#include<iostream>
using namespace std;
int p[1001];
int m[1001][1001];
int s[1001][1001];
void fun(int n)
{
	for(int i=1;i<=n;i++)
		m[i][i]=0;
	for(int r=2;r<=n;r++)
	{
		for(int i=1;i<=n-r+1;i++)
		{
			int j=i+r-1;
			m[i][j]=m[i+1][j]+p[i-1]*p[i]*p[j];
			s[i][j]=i;
			for(int k=i+1;k<j;k++)
			{
				int t=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
				if(t<m[i][j]){
					m[i][j]=t;
					s[i][j]=k;
				}
			}
		}
	}
 } 
 void traceback(int i,int j)
 {
 	if(i==j)
 	cout<<"A"<<i;
 	else{
 		cout<<"(";
 		traceback(i,s[i][j]);
 		traceback(s[i][j]+1,j);
 		cout<<")"; 
	}
}
int main()
{
	int n=0;
	int x,t;
	cin>>x;
	for(int j=0;j<x;j++){
	while(1)
	{
		cin>>t;
		char c=cin.get();
		p[n++]=t;
		if(c=='\n')
		break;
		
	}
	n--;
//	for(int i=0;i<n;i++)
//		cout<<p[i]<<"**";
	fun(n);
	cout<<m[1][n]<<endl;
	traceback(1,n);
	n=0;
	} 
	return 0;
 } 

 

0-1背包动态规划

        0-1背包作为动态规划中较为经典的题目，可以作为初学者理解动态规划的高效问题。其问题的关键是如何在一定负载规模的情况下去获得更大的价值。如下为解题思路：（手写）

 实现源码：

//0-1背包问题 
#include<iostream>
#include<fstream> 
using namespace std;
int n,c;//n 为物品数，c为背包容量
int v[1001]={0};
int w[1001]={0};
int m[1001][1001]={0};//最优值 
int f[1001];
ifstream in;
ofstream out;
void fun();
void print();
int main()
{
	
	in.open("input.txt");
	out.open("output.txt");
	in>>n>>c;
	for(int i=1;i<=n;i++)
		in>>v[i];
	for(int i=1;i<=n;i++)
		in>>w[i];
	fun();
	out<<m[n][c]<<endl; 
	print();
	in.close();
	out.close();
	return 0; 
 } 
 void fun()
 {
 	for(int i=1;i<=c;i++)
 	m[0][i]=0;
 	for(int i=1;i<=n;i++)
 	m[i][0]=0;
 	for(int i=1;i<=n;i++)
 	{
 		for(int j=1;j<=c;j++)
 		{
 			if(j>=w[i])
 			{
 				if(m[i-1][j]>m[i-1][j-w[i]]+v[i])
 				m[i][j]=m[i-1][j];
 				else
 				m[i][j]=m[i-1][j-w[i]]+v[i];
			 }
			 else
			 m[i][j]=m[i-1][j]; 
		}
	 }
 	
 }
 void print()
 {
 	int j=c;
	for(int i=n;i>1;i--)
	{
		if(m[i][j]!=m[i-1][j])
		{
			f[i]=1;
			j-=w[i];
		}
	} 
	if(m[1][c]>0)
	f[1]=1;
	else 
	f[1]=0;
	for(int i=1;i<=n;i++)
	out<<f[i]<<" ";
 }

0-1背包备忘录

        备忘录方法为每个解过的子问题建立了备忘录以备需要时查看，避免相同子问题的重复求解；而动态规划算法则是建立一个表格，从最小的子问题开始向上求解较大的子问题，把每一个子问题的解全部填入表格中，直到表格中出现原问题的解为止。

最优值：

 最优解：

 最长递增子序列

        求一个字符串的最长递增子序列的长度。请分别给出最长递增子序列长度的O（n2）及O（nlogn）算法。如：dabdbf最长递增子序列就是abdf，长度为4。

输入：第一行一个整数0<n<20,表示有n个字符串要处理随后的n行，每行有一个字符串，该字符串的长度不会超过10000。

输出：输出字符串的最长递增子序列的长度。

O（n2）：

#include<iostream>
using namespace std;
string m;
int mf[1001];
int fun();
int main()
{
	int n;
	char x;
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>m;
		cout<<fun()<<endl;
	}
	return  0;
 } 
int fun()
{
	for(int i=0;i<m.size();i++)
		mf[i]=1;
	for(int i=1;i<m.size();i++)
	{
		for(int j=0;j<i;j++)
		{
			if(m[j]<m[i]&&mf[i]<mf[j]+1){
				mf[i]=mf[j]+1;
			}	 
		}
	}
	int max=mf[0];
	for(int i=1;i<m.size();i++){
		if(max<mf[i])
			max=mf[i];
	}
	return max;
}

O(logn)：

 

#include<iostream>
#include<string>
using namespace std;
int search(int n,int x);//二分查找 
int fun();
int len;
string m;
char f[1001];
int main()
{
	int n;
	char x;
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>m;
		cout<<fun()<<endl;
	}
//	for(int i=0;i<len;i++)
//	{
//		cout<<f[i]<<" ";
//	}
	return 0;
 } 
int fun()
{
	int p=0; 
	len=1;
	f[0]=m[0];
	for(int i=1;i<m.size();++i)
	{
		if(m[i]>f[len-1])
			f[len++]=m[i];
		else
		{
			p=search(len,m[i]);
//			cout<<p<<"^";
			f[p]=m[i];
		}
	}
	return len;
} 
int search(int n,int x)
{
	int l=0,r=n-1;
	int mid;
	while(l<=r)
	{
//		cout<<"*";
		mid=l+(r-l)/2;
		if(f[mid]>x)
			r=mid-1;
		else if(f[mid]<x)
			l=mid+1;
		else
			return mid;
	}
	return l;
}