动态规划实战-优快云博客

本文链接：https://blog.youkuaiyun.com/oldoldb/article/details/8946218

前天晚上以及昨天下午和晚上报了三场hdu的西山居比赛。。。三场比赛一共A了三题。。。我果然是签到题小王子么。。。

今天上午搞了动态规划...

3. 动态规划（15题以上），要学会使用循环的方法写动态规划，同时也要学会使用记忆化搜索的方法。
a) 最大子串和
b) 最长公共子序列
c) 最长单调递增子序列(O(n)与O(n log n)算法都需要掌握)

数塔什么的最基本的就不说了

最长公共子序列和最大子串问题是例题，还算比较简单

至于那个最长递增子序列感觉好难啊...

找到大牛的模版好好研究一下...然后以后就用这种模版了

以下是题解：

hdu 2084:http://acm.hdu.edu.cn/showproblem.php?pid=2084

/*
简单dp
从下向上，
dp[i][j]表示第i行第j列的最大和 
dp[i][j]=max{dp[i+1][j],dp[i+1][j+1]}+w[i][j],
同时将w[][]扩大一层设为0方便计算
*/
#include<iostream>
#include<algorithm>
int w[105][105];
int dp[105][105];
using namespace std;
int main()
{
	int T;
	cin>>T; 
	while(T--)
	{
		int n;
		cin>>n;
		memset(w,0,sizeof(w));
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<=i;j++)
			{
				cin>>w[i][j];
			}
		}
		for(int j=0;j<=n;j++)
		{
			w[n][j]=0;
		}
		memset(dp,0,sizeof(dp));
		for(int i=n-1;i>=0;i--)
		{
			for(int j=i;j>=0;j--)
			{
				dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+w[i][j];
			}
		}
		cout<<dp[0][0]<<endl;
	}
	system("pause");
	return 0;
}

hdu 1069: http://acm.hdu.edu.cn/showproblem.php?pid=1069

/*
dp
每输入一组数据转换为3组数据
dp：dp[i]表示是以第i块积木为顶的塔的最大高度
因此可得状态转移方程：dp[i] = max(dp[i]，dp[j] + r[i].z)
（满足积木j的底面长和宽都大于积木i的长和宽）
*/
#include <iostream>
#include <algorithm>
using namespace std;
struct R
{
       int x,y,z;
}r[100];
int n,dp[100];
bool cmp(const R a,const R b)
{
     if(a.x == b.x)
          return a.y > b.y;
     return a.x > b.x;
}
int DP()
{
    sort(r,r+n,cmp);
    int maxh = 0;
    for(int i = 0;i < n;i++)
    {
            dp[i] = r[i].z;
            for(int j = i-1;j >= 0;j--)
                    if(r[j].x > r[i].x && r[j].y > r[i].y)
                          if(dp[j] + r[i].z > dp[i])
                                   dp[i] = r[i].z+dp[j];
            if(dp[i] > maxh)
                     maxh = dp[i];
    }
    return maxh;
}
int main()
{
    int i,j,ca = 1,a,b,c;
    while(cin >> n, n)
    {
        for(j = 0,i = 0;i < n;i++)
        {
              cin >> a >> b >> c;
              r[j].x = min(a,b);
              r[j].y = max(a,b);
              r[j].z = c;
              r[j+1].x = min(a,c);
              r[j+1].y = max(a,c);
              r[j+1].z = b;
              r[j+2].x = min(c,b);
              r[j+2].y = max(c,b);
              r[j+2].z = a;
              j += 3;
        }
        n = j;
        printf("Case %d: maximum height = %d\n",ca++,DP());
    }
    return 0;
}

hdu 1159: http://acm.hdu.edu.cn/showproblem.php?pid=1159

/*
LCS最长公共子序列裸题~
1A
要注意的是避免数组出现负下标
所以我将dp[i][j]对应于s1[i-1]与s2[j-1]的判定~
*/
#include<iostream>
#include<algorithm>
#define N 500
int dp[N][N];
using namespace std;
void lcs(char s1[],char s2[])
{
	int len1=strlen(s1);
	int len2=strlen(s2);
	memset(dp,0,sizeof(dp));
	for(int i=0;i<=len1;i++)
	{
		dp[i][0]=0;
	}
	for(int j=0;j<=len2;j++)
	{
		dp[0][j]=0;
	}
	for(int i=1;i<=len1;i++)
	{
		for(int j=1;j<=len2;j++)
		{
			if(s1[i-1]==s2[j-1])
			{
				dp[i][j]=dp[i-1][j-1]+1;
			}
			else
			{
				dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
			}
		}
	}
	cout<<dp[len1][len2]<<endl;
}
int main()
{
	char s1[N],s2[N];
	while(scanf("%s%s",s1,s2)!=EOF)
	{
		lcs(s1,s2);
	}
	system("pause");
	return 0;
}

hdu 1003: http://acm.hdu.edu.cn/showproblem.php?pid=1003

/*
最大子串和
dp[i]=max{dp[i-1],0}+a[i]
*/
#include<iostream>
using namespace std;
int dp[100005];
int a[100005];
int begin,end,maxsum;
int n;
void MaxSum(int a[],int n)
{
	int tempbegin=0;
	begin=0;
	end=0;
	memset(dp,0,sizeof(dp));
	dp[0]=maxsum=a[0];
	for(int i=1;i<n;i++)
	{
		if(dp[i-1]<0)
		{
			dp[i]=a[i];
			tempbegin=i;
		}
		else
		{
			dp[i]=dp[i-1]+a[i];
		}
		if(dp[i]>maxsum)
		{
			maxsum=dp[i];
			end=i;
			begin=tempbegin;
		}
	}
}
			
int main()
{
	int T;
	cin>>T;
	for(int tt=1;tt<=T;tt++)
	{
		cin>>n;
		for(int i=0;i<n;i++)
		{
			cin>>a[i];
		}
		MaxSum(a,n);
		cout<<"Case "<<tt<<":"<<endl<<maxsum<<" "<<begin+1<<" "<<end+1<<endl;
		if(tt!=T)
		{
			cout<<endl;
		}
	}
	system("pause");
	return 0;
}

hdu 1257: http://acm.hdu.edu.cn/showproblem.php?pid=1257

/*
LIS
本题采用朴素算法,O(n^2)复杂度
当作模版啦~
*/
#include<iostream>
#include<cstdlib>
#include<cstdio>
using namespace std;
int dp[10000];
int main()
{
	int N,i,j,a[10000],maxtemp;
	while(scanf("%d",&N)!=EOF)
	{
		for(i=0;i<N;i++)
			scanf("%d",&a[i]);
		dp[0]=1;
		for(i=1;i<N;i++)
		{
			maxtemp=0;
			for(j=0;j<i;j++)
			{
				if(a[i]>=a[j]&&dp[j]>maxtemp)
					maxtemp=dp[j];
			}
			dp[i]=maxtemp+1;
//			printf("dp[%d]=%d/n",i,dp[i]);
		}
		maxtemp=0;
		for(i=0;i<N;i++)
			maxtemp=max(maxtemp,dp[i]);
		printf("%d\n",maxtemp);
	}
	return 0;
}

hdu 1025: http://acm.hdu.edu.cn/showproblem.php?pid=1025

/*
LIS(Longest Increasing Sequence)
看了网上的讲解，采用覆盖法+二分法可以达到O(nlogn)的复杂度
学习一下~用作模版~！
*/
 
#include<iostream>
#include<cstdio>
using namespace std;
int dp[50005],a[50005];
 
 int Lis(int n)
 {
     int len=1,i,low,high,mid;
     dp[1]=a[1];
     for(i=2;i<=n;i++)
     {
        low=1;
        high=len;
        while(low<=high)
        {
            mid=(low+high)/2;
            if(a[i]>dp[mid])
                low=mid+1;
            else
                high=mid-1;
        }
        dp[low]=a[i];
        if(low>len)
            len=low;
     }
     return len;
 }
 int main()
 {
     int n,x,y,i,ans,k=1;
     while(scanf("%d",&n)!=EOF)
     {
         for(i=0;i<n;i++)
         {
             scanf("%d%d",&x,&y);
             a[x]=y;
         }
         ans=Lis(n);
         printf("Case %d:\n",k++);
         if(ans==1)
             printf("My king, at most 1 road can be built.\n");
         else
             printf("My king, at most %d roads can be built.\n",ans);
         printf("\n");
     }
     return 0;
 }

先停下来再研究一下LIS问题...朴素算法和二分算法都要掌握

下午如果还看的下去的话就把LIS掌握然后做背包问题，学不下去的话粗去吃点东西...

吼吼..

加了好多大神为好友，不过不能和他们比，按部就班吧~！