20级课程作业-动态规划线性DP 做题总结（六）

O Long Path
题意：一个人要从房间1走到房间n+1，每走到一个房间要在此进行一次标记，若标记次数为奇数则走到房间p[i]；若标记次数为偶数则走到房间i+1，问此人需要走多少步才能到达房间n+1（p[i],1<=i<=n）

求需要走多少步到达n+1，我们可以把需要走多少步到达房间i做为子问题(状态)，即需要构建一个一维数组dp[i]，表示刚到达这个房间时的步数。由题意知，只有偶数次到达i房间才可以到达i+1房间，奇数次就去别的房间，所以dp[i]应由dp[i-1]决定。
以1，1，2，3为例，如图所示

第i个房间是由第i-1房间到达的，dp[i]等于奇数次到达i-1房间dp[i-1]的步数加1，到达p[i-1]房间然后回到i-1房间变成偶数次再加1。从p[i-1]房间回到i-1房间需要的步数为dp[i-1]-dp[p[i-1]]，所以状态转移方程为
dp[i]=dp[i-1]+1+dp[i-1]-d[p[i-1]]+1
验证发现
dp[1]=0
dp[2]=2
dp[3]=6
dp[4]=12
dp[5]=20
计算发现dp[4]=dp[3]+1+dp[3]-dp[p[3]]+1=6+1+6-2+1=12符合，同理dp[5]=12+1+12-6+1=20符合

#include<iostream>
using namespace std;
long long int p[1005],d[1005];
const int maxx=1e9+7;
int main()
{
    int n,i,j;
    cin>>n;
    for(i=1; i<=n; i++)
        cin>>p[i];
    d[1]=0;
    for(i=2; i<=n+1; i++)
    {
        d[i]=(d[i-1]+1+d[i-1]-d[p[i-1]]+1+maxx)%maxx;
    }
    cout<<d[n+1]<<endl;
    return 0;
}

H Worm
题意：每过1分钟，毛毛虫会随机从一棵树爬到相邻的一棵树上。告诉你苹果树的数目N，毛毛虫刚开始所在的位置P，问在M分钟后，毛毛虫到达第T棵树，有多少种行走方案。

这个题比较好想，由M分钟后到达第T棵树，不难想到子状态为i分钟后到达第j棵树，所以子状态的值就是i分钟后到达第j棵树需要的方案数，我们构建一个二维数组dp[i][j]表示上述状态。要想求i分钟到达第j棵树的方案数，先考虑到达第j棵树的条件，第j棵树是由前一分钟第j-1棵树或者第j+1棵树到达的，所以状态转移方程为d[i][j]=d[i-1][j-1]+d[i-1][j+1]

#include<iostream>
using namespace std;

int main()
{
    int n,p,m,t,i,j;
    while(cin>>n>>p>>m>>t)
    {   int d[101][101]= {0,0};
        d[0][p]=1;
        for(i=1; i<=m; i++)
        {
            for(j=1; j<=n; j++)
            {   d[i][j]=d[i-1][j-1]+d[i-1][j+1];
            }
        }
        cout<<d[m][t]<<endl;
    }
    return 0;
}

L Sonya and Problem Wihtout a Legend（dp+离散化）
题意：给一个包含n个正整数的数组。可以选择任何元素增加或减少1。通过尽可能少的操作数使数组严格递增。可以以任何方式更改元素，它们可以变为负的或等于0。求最小操作数。
如：2 3 5 6 7 9 11
|2 - 2| + |1 - 3| + |5 - 5| + |11 - 6| + |5 - 7| + |9 - 9| + |11 - 11| = 9

这个题有一个限定条件是严格递增，我们可以用一个小技巧将其变成不严格单调递增我们知道严格递增是
a[i]<a[i+1]
a[i]<=a[i+1]-1
a[i]-i<=a[i+1]-(i+1)
所以我们就将严格递增变成了不严格递增，将给定的数组每个元素都减i，再用不严格递增的方法求解。
不严格递增的方法：构建的新数组的元素一定是原数组出现过的元素，所以我们对原数组先排序再去重，去重的目的是优化次数和时间。
然后构建一个二维数组dp[i][j]，i表示构造新数组的第几个数，j表示构造成的数，dp[i][j]的确定需要在当前j列构造的值与前一列j-1中取小值，动态转移方程为d[i][j]=min(d[i][j-1],d[i-1][j]+abs(a[i]-b[j]))
图片理解

#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#define inf 1e18
using namespace std;
const long long int maxx=1e9;
long long int a[3005],b[3005],d[3005][3005];
int main()
{
    long long int n,i,c=0,j,ans;
    cin>>n;
    for(i=1; i<=n; i++)
    {
        cin>>a[i];
        a[i]-=i;
        b[i]=a[i];
    }
    sort(b+1,b+1+n);
    c=unique(b+1,b+1+n)-b-1;
    memset(d,0,sizeof(d));
    for(i=1; i<=n; i++)
    {
        d[i][0]=inf;
        for(j=1; j<=c; j++)
        {
            d[i][j]=min(d[i][j-1],d[i-1][j]+abs(a[i]-b[j]));
        }
    }
    cout<<d[n][c]<<endl;
    return 0;
}

R How to Type
题意：敲最少的按键把题目所给的单词打出来。默认为小写，如果cap关，要打一个大写字母，可以通过shift+小写字母，或者用cap把默认变成大写。如果cap开，这个时候要打小写字母，可以按shift+这个小写字母，或再按一下cap把默认变成小写。要求打完所有单词后，cap关。

首先，题干给出的每一个位置的字符有两种情况，大写或小写，大写可以由前一个状态达成，cap关，打开cap变成大写或者用shift+字母;cap开，直接打字符，或者shift+字母，小写同理，这样状态间的关系就好找了，列动态转移方程为
if(s[i]>='A'&&s[i]<='Z') {
d[i][1]=min(d[i-1][1]+1,d[i-1][0]+2);//表示结束状态为开灯
d[i][0]=min(d[i-1][1]+2,d[i-1][0]+2) }//表示结束状态为关灯
if(s[i]>='a'&&s[i]<='z') {
d[i][1]=min(d[i-1][1]+2,d[i-1][0]+2);
d[i][0]=min(d[i-1][1]+2,d[i-1][0]+1); }

#include<iostream>
#include<minmax.h>
using namespace std;
char s[105];
int d[105][2];
int main()
{
    int n,i,j,z;
    cin>>n;
    while(n--)
    {
        cin>>(s+1);
        z=strlen(s+1);
        d[0][0]=0;d[0][1]=1;
        for(i=1; i<=z; i++)
        {
            if(s[i]>='A'&&s[i]<='Z')
            {
              d[i][1]=min(d[i-1][1]+1,d[i-1][0]+2);
              d[i][0]=min(d[i-1][1]+2,d[i-1][0]+2);
            }
            if(s[i]>='a'&&s[i]<='z')
            {
              d[i][1]=min(d[i-1][1]+2,d[i-1][0]+2);
              d[i][0]=min(d[i-1][1]+2,d[i-1][0]+1);
            }
        }
        cout<<min(d[z][1]+1,d[z][0])<<endl;
    }
    return 0;
}

S 搬寝室
题意：给出 n 件物品的重量，在其中取 k对物品，求疲劳度最小为多少

首先，要想求最小疲劳度，不需让去的每一对重量都要小，所以我们先对重量从小到大排序，由题目n件物品取k对，我们可以把前i件物品已经取了j对作为子状态，子状态的值为前i件物品取j对时的最小疲劳度，构建二维数组dp[i][j]，我们要求dp[i][j]，发现到达dp[i][j]有两种途径，一种是不取第i件物品，j对不变，所以其值等于dp[i-1][j]，另一种是取第i件物品，一定是取i和i-1的物品作为第j对所以其值为dp[i-2][j-1]加上第j对新的疲劳值。状态转移方程为：
d[i][j]=min(d[i-1][j],d[i-2][j-1]+(a[i]-a[i-1])*(a[i]-a[i-1]))
注意初始化

#include<iostream>
#include<minmax.h>
#include<algorithm>
using namespace std;
int a[2005],d[2005][2005];
const long long int maxx=0x3f3f3f3f;
int main()
{
    int n,k,i,j;
    while(cin>>n>>k)
    {   for(i=1; i<=n; i++)
            cin>>a[i];
        sort(a+1,a+1+n);
        for(i=0; i<=n; i++)
        {   for(j=0; j<=k; j++)
                d[i][j]=maxx;
        }
        for(i=0; i<=n; i++)
            d[i][0]=0;
        for(i=2; i<=n; i++)
        {
            for(j=1; j<=k; j++)
            {
                d[i][j]=min(d[i-1][j],d[i-2][j-1]+(a[i]-a[i-1])*(a[i]-a[i-1]));
            }
        }
        cout<<d[n][k]<<endl;
    }
    return 0;
}