假期集训--线性dp

最新推荐文章于 2022-08-10 21:30:26 发布

zjy2015302395

最新推荐文章于 2022-08-10 21:30:26 发布

阅读量1k

点赞数 1

分类专栏： acm 基本算法

本文链接：https://blog.csdn.net/zjy2015302395/article/details/51920140

版权

acm 同时被 2 个专栏收录

178 篇文章 0 订阅

订阅专栏

基本算法

166 篇文章 0 订阅

订阅专栏

例题A

http://acm.hust.edu.cn/vjudge/contest/view.action?cid=121767#problem/A

这里写图片描述

Figure 1 shows a number triangle. Write a program that calculates the highest sum of numbers passed on a route that starts at the top and ends somewhere on the base. Each step can go either diagonally down to the left or diagonally down to the right.

题意：

每个数字加上左上角或者正上方位置上的数字，每行只能选一个，到最后一行为止，最多能求得数字和为多少。

思考过程：

线性dp的经典例题之一，因为每个数字只有两种选择方式，一种是加上左上角的，另一种是加上上边的，所以想到dp【i】【j】表示选择第i行第j个数字时和的最大值

转移方程：

dp[i][j] = max ( dp[i-1][j] , dp[i-1][j-1] ) + a[i][j];

#include <cstdio>
#include <iostream>
#include <cstring>
int dp[110][110];
using namespace std;

int main()
{
    int n;
    while(cin >> n)
    {
        for (int i = 1 ; i <= n ;i++)
        {
            for(int j = 1; j <=i;j++)
            {
                if(j == 1 && i ==1)
                    cin >> dp[i][j];
                else if(j > 1)
                {
                    int k;
                    cin >> k;
                    dp[i][j] = k+max(dp[i-1][j],dp[i-1][j-1]);
                }
                else if(j == 1)
                {
                    int k;
                    cin >>k;
                    dp[i][j] = k+dp[i-1][j];  //左边界只有一种可能，没有选择的余地，所以单独判断。
                }
            }
        }

        int ans = dp[n][1];
        for (int i = 2 ; i < n ;i++)
        {
            ans = max(ans,dp[n][i]);     // 最大值是最后一行中的最大值
        }
        cout <<ans << endl;
    }
}

例题B

http://acm.hust.edu.cn/vjudge/contest/view.action?cid=121767#problem/B

Michael喜欢滑雪百这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长底滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子
这里写图片描述

思考过程：

一道经典的dp，有人也说是dfs的例题，个人认为与其说是dfs不如说是dp，深搜和广搜在后面的专题也是有的2333，已经记不清楚是第几次敲这道题了，入坑一个学期，算起来4个多月，竟然做了应该有5次了，每次的理解都不太一样，说说这次的理解吧，首先他说的是每次都只能从高的地方滑下来，那么很容易就想到，除了边界以外，其他的点都只可能是从上下左右而来，而且是其中比他高的=。=，那状态是dp[i][j]就很容易想到了，问题的关键在于，你并不能通过一个for（i : 0 ~ n ) for ( j : 0 ~ m ) 求出来，因为你在求第i行第j列的时候，并不能知道他的下面和右面的地方dp值，但是，每个位置的值显然是固定的，换句话说，想到一个办法求出来这个点的dp值之后，就完全没必要在算第二次，老司机一定已经想到用递归了，因为每个路径一定有一个起点，无论是正想思维的最高点，还是逆向思维的最低点，总之肯定递归有边界，而且每次都保证最远的原则，算过得点就不用算第二次了，也就是传说中的记忆画搜索。

转移方程：

dp[i][j] = max (dp[i-1][j],dp[i+1][j],dp[i][j+1],dp[i][j-1] ) + a[i][j];

#include <cstdio>
#include <iostream>
#include <cstring>
int a[110][110],dp[110][110];
using namespace std;
int n,m;
int  makeup(int i,int j)
{
    if(dp[i][j])
        return dp[i][j];
    dp[i][j] = 1;
    if(i-1 >= 1 && a[i-1][j] >a[i][j]) dp[i][j] = max(dp[i][j],makeup(i-1,j)+1);
    if(i+1 <= n && a[i+1][j] > a[i][j]) dp[i][j] = max(dp[i][j],makeup(i+1,j)+1);
    if(j-1 >= 1 && a[i][j-1] > a[i][j]) dp[i][j] = max(dp[i][j],makeup(i,j-1)+1);
    if(j+1 <= m && a[i][j+1] > a[i][j]) dp[i][j] = max(dp[i][j],makeup(i,j+1)+1);
    return dp[i][j];
}

int main()
{
   while(cin >> n >> m)
  {
        memset(dp,0,sizeof(dp));
    for (int i = 1 ; i <= n ;i++)
        for (int j =1 ; j <= m ;j++)
        cin >> a[i][j];

    int ans = 0;
    for (int i = 1 ; i <= n ;i++)
        for (int j = 1 ; j <= m;j++)
           {
               makeup (i,j);   //可以理解程分别以各个点为起点的时候求得当前最大值=。=
                ans = max(ans,dp[i][j]);
           }
    cout << ans <<endl;
  }
}

例题C

http://acm.hust.edu.cn/vjudge/contest/view.action?cid=121767#problem/C
A numeric sequence of ai is ordered if a1 < a2 < … < aN. Let the subsequence of the given numeric sequence ( a1, a2, …, aN) be any sequence ( ai1, ai2, …, aiK), where 1 <= i1 < i2 < … < iK <= N. For example, sequence (1, 7, 3, 5, 9, 4, 8) has ordered subsequences, e. g., (1, 7), (3, 4, 8) and many others. All longest ordered subsequences are of length 4, e. g., (1, 3, 5, 8).

Your program, when given the numeric sequence, must find the length of its longest ordered subsequence.

题意：

最长上升子序列，几乎是每个初学dp的acmer都要做的一道题，相当经典，给一串数字，求其中最长的上升子序列，注意子序列和子串的区别，子序列是不用连续的，而子串是要求连续的，那就是另一个算法了，尺取法，之前做cf的题解时写过=。=

思考过程：

很基础的思想，简单的一维状态转移，dp[ i ] 表示到了第i个数字的时候最长的上升子序列多长了，他肯定是由在他之前的所有的比他小的数字当前长度+1而来，

转移方程：

dp【i】 = max ( dp [ k ] k : 0~i ) + 1;

#include <cstdio>
#include <iostream>
#include <cstring>
int a[1010],dp[1010];
using namespace std;
int main()
{
    int n;
    while(cin >> n)
    {
        if(!n)
            break;
        memset(dp,0,sizeof(dp));
        for (int i = 0 ; i < n ;i++)
            cin >> a[i];
        for (int i = 0 ; i < n ;i++)
            dp[i] = 1;
        int ans = 1;
        for(int i = 1 ; i <n ; i++)
        {
            for (int j = 0 ; j < i ;j++)
            {
                if(a[i] > a[j])
                    dp[i] = max(dp[i],dp[j]+1);
            }
            ans = max(dp[i],ans);
        }
        cout << ans <<endl;
    }
}

话说，dp的初始化其实是很多wa点所在，如果处理不好很可能蜜汁wa哒

例题D

http://acm.hust.edu.cn/vjudge/contest/view.action?cid=121767#problem/D

A subsequence of a given sequence is the given sequence with some elements (possible none) left out. Given a sequence 。。。

这里写图片描述

题意：

找到最长公共子序列

思考过程：

也是一道比较经典也比较好想的dp题，让我们假设dp[ i ] [ j ] 表示第一个串的从0开始到第i个第二个串到第j个为止一共有多少个公共子序列了，那么显然分两种可能,当s1 [ i ] == s2[ j] 的时候，dp[ i-1] [j-1] +1就是当前的值了，而如果两者不等，那么这个值为max ( dp[ i-1] [j] , dp[ i ] [ j-1 ] ), 整个过程是外层循环i，走一圈j，当发现s1 [ i ] == s2[ j ] 时，dp【i-1】【j】就可以加了，
这里写图片描述

转移方程：

dp[ i ] [ j ] = dp [ i - 1 ] [ j - 1 ] ( s1[ i ] == s2 [ j ] )
dp [ i ] [ j ] = max ( dp [ i - 1 ] [ j ] , dp [ i ] [ j -1 ] )

#include <cstdio>
#include <iostream>
#include <cstring>
int dp[1010][1010];
char s1[1010],s2[1010];

using namespace std;
int main()
{
    while(~scanf("%s%s",s1,s2) )
    {
        memset(dp,0,sizeof(dp));
        for (int i = 1 ; i <= strlen(s1); i++)
            for (int j = 1 ; j<= strlen(s2); 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[strlen(s1)][strlen(s2)] << endl;
        }
}

练习题E

http://acm.hust.edu.cn/vjudge/contest/view.action?cid=121767#problem/E

Nowadays, a kind of chess game called “Super Jumping! Jumping! Jumping!” is very popular in HDU. Maybe you are a good boy, and know little about this game, so I introduce it to you now.
这里写图片描述

题意:

在棋盘上随便跳转，但是必须从较小的数字跳跃到较大的数字的地方，于是
自然而然的想到之前的题，dp【i】表示前面所有比他小的数字加a【i】后的数字大小、

#include <cstdio>
#include <iostream>
#include <cstring>
int a[1010],dp[1010];
using namespace std;
int main()
{
    int n;
    while(cin >> n)
    {
        if(!n)
            break;
        memset(dp,0,sizeof(dp));
        for (int i = 0 ; i < n ;i++)
            cin >> a[i];
        for (int i = 0 ; i < n ;i++)
            dp[i] = a[i];
        int ans = 1;
        for(int i = 1 ; i <n ; i++)
        {
            for (int j = 0 ; j < i ;j++)
            {
                if(a[i] > a[j])
                    dp[i] = max(dp[i],dp[j]+a[i]);
            }
            ans = max(dp[i],ans);
        }
        cout << ans <<endl;
    }
}

练习题F

http://acm.hust.edu.cn/vjudge/contest/view.action?cid=121767#problem/F

搬寝室是很累的,xhd深有体会.时间追述2006年7月9号,那天xhd迫于无奈要从27号楼搬到3号楼,因为10号要封楼了.看着寝室里的n件物品,xhd开始发呆,因为n是一个小于2000的整数,实在是太多了,于是xhd决定随便搬2*k件过去就行了.但还是会很累,因为2*k也不小是一个不大于n的整数.幸运的是xhd根据多年的搬东西的经验发现每搬一次的疲劳度是和左右手的物品的重量差的平方成正比(这里补充一句,xhd每次搬两件东西,左手一件右手一件).例如xhd左手拿重量为3的物品,右手拿重量为6的物品,则他搬完这次的疲劳度为(6-3)^2 = 9.现在可怜的xhd希望知道搬完这2*k件物品后的最佳状态是怎样的(也就是最低的疲劳度),请告诉他吧.
这里写图片描述

思考过程：

既然要左右手上的差的平方和最小，那么自然而然的想到了排序，那么排序后，每个物品都只可能和左边的或者右边的相邻的组成一组，而实现的时候，只需要让每件物品都和自己左边的一组，如果选择了这一组，那么自然他的左边的物品就不能和自己左边的一组了，去掉即可，如此一来，自然的想到转移方程

转移方程：

dp[ i ] [ j ] = min ( dp [ i - 2 ][ j - 1 ] + a[ i - 1 ] , dp[ i - 1][ j ] ) //a[ i ]是计算过以后的差的平方，逗号前是选这一组，后面是不选这一组。

#include<iostream>

#include<algorithm>

using namespace std;

int dp[2010][1005];

int main()
{

    int n,k;

    while(cin >>n>>k)
    {

        int a[2010];
        for(int i=1; i<n+1; i++)
            cin >> a[i];

        sort(a+1,a+n+1);

        for(int i=0; i<n+1; i++)
            for(int j=1; j<k+1; j++)
                dp[i][j]=999999999;

        for(int i=0; i<n+1; i++)
            dp[i][0]=0;

        for(int i=1; i<n; i++)

            a[i]=(a[i]-a[i+1])*(a[i]-a[i+1]);

        for(int i=2; i<n+1; i++)
            for(int j=1;j <= k; j++)
                dp[i][j]=min(dp[i-2][j-1]+a[i-1],dp[i-1][j]);

        cout<<dp[n][k]<<endl;
    }
    return 0;
}

练习题G：

http://acm.hust.edu.cn/vjudge/contest/view.action?cid=121767#problem/G

Given a sequence a[1],a[2],a[3]……a[n], your job is to calculate the max sum of a sub-sequence. For example, given (6,-1,5,4,-7), the max sum in this sequence is 6 + (-1) + 5 + 4 = 14.
这里写图片描述

思考过程:

如果一个数字加上之前的数之后变得比自己小了，换句话说，前面数字的和是负数，那么这个数字之前的东西就是不要的，如果这个数字本身就是负数，那么加他还是不加他就要取决于他后面的数字是不是绝对值比他大。所以其实如果不用dp，用找规律的方法也是可以求出来的，但是转移方程更方便理解，也更容易想，不会乱而出错，dp【i】表示目前的最大值，这道题wa好很多次，主要原因不是转移方程，而是ans，left，right初始化为什么比较好，因为是由-2，-1，-3这种数据出现的，显然答案是-1，还有0,0,0这种数据，也要考虑。

转移方程：

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

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
int dp[100010],a[100010];
using namespace std;

int main()
{
    int T;
    cin >> T;
    for(int ca = 1 ; ca <= T ;ca++)
    {
        printf("Case %d:\n",ca);
        memset(dp,0,sizeof(dp));
        int n;
        cin >> n;
        for (int i = 0 ; i < n ;i++)
            cin >> a[i];
       dp[0] = a[0] ;
       int l = 0 ,r = 0,ans = a[0],right = 0,left = 0;
       for (int  i = 1; i < n ;i++)
       {
           if(dp[i-1] + a[i] >= a[i])
                    r = i;
           else
                l = i;
           dp[i] = max(dp[i-1]+a[i],a[i]);
           //cout << r <<" dd  " <<endl;
           if(ans <= dp[i])
           {
               ans = dp[i];
               left = l;
               right = r;
           }
       }
        cout << ans << " "<< left+1 << " "<<((right >= left)?right:left)+1 <<endl;
        if(ca != T)
            cout << endl;
    }
}