习题日常第七练

1数字游戏（题目链接）

这个题是典型的动态规划。首先，对于取模操作，直接取模会得到负数，所以取模后加十再取模保证了数字必定为正。再者，这是一个环，我们采用将环化为链的操作。然后，乘号一个一个往里面放，用一个三位数组表示，前两维表示序列起点和终点，最后一维表示乘号数。先将没有乘号的情况进行预处理。对于每一个序列有m个乘号，枚举它的间断点，将这个序列分为一个数和剩下有m-1个乘号的序列，注意这个操作是一个对称的，再根据动态规划得出最大，最小值。对于求最大的时候将数组初始化为0，可以用memset操作，但是求最小值时，数组初始化为最大时候最好手动赋值（因为memset操作是对于字节操作的，我写出来出来些奇怪的值）。具体见代码。

#include<cmath>
#include <iostream>
#include<stdio.h>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<cstring>
#include<math.h>
#include<stack>
#include<algorithm>
#include<queue>
#include<bitset>
#define ll long long int
const int mod=1e9+7;
using namespace std;
ll a[200],b[110][110][60],n,m,su[200],c[110][110][60];
int main()
{
    ios::sync_with_stdio(false);
    ll i,j,q,sum=0,k,p;
    cin>>n>>m;
    for(i=1;i<=n;i++)
    {
       cin>>a[i];
       a[i]=(a[i]%10+10)%10;
    }
    for(i=n+1;i<=2*n;i++)
        a[i]=a[i-n];
        memset(b,0,sizeof(b));
        memset(su,0,sizeof(su));
        for(i=0;i<m;i++)
            for(j=0;j<60;j++)
             for(k=0;k<60;k++)
             c[j][k][i]=1000000000;
        su[1]=a[1];
        for(i=2;i<=2*n;i++)
        {
            su[i]=su[i-1]+a[i];
        }
    for(i=1;i<=n;i++)
    {
        for(j=0;j<n;j++)
        {
            if(j==0)
            {
                c[i][i+j][0]=(a[i]%10+10)%10;
                b[i][i+j][0]=(a[i]%10+10)%10;
            }
            else
            {

                    b[i][i+j][0]=((su[i+j]-su[i-1])%10+10)%10;
                    c[i][i+j][0]=((su[i+j]-su[i-1])%10+10)%10;
            }
        }
    }
    for(i=1;i<=m-1;i++)
    {
        for(j=1;j<=n;j++)
        {
            for(k=i;k<n;k++)
            {
                for(p=0;p<k;p++)
                {
                    b[j][j+k][i]=max(b[j][j+k][i],b[j][j+p][0]*b[j+p+1][j+k][i-1]);
                    b[j][j+k][i]=max(b[j][j+k][i],b[j][j+p][i-1]*b[j+p+1][j+k][0]);
                    c[j][j+k][i]=min(c[j][j+k][i],c[j][j+p][0]*c[j+p+1][j+k][i-1]);
                    c[j][j+k][i]=min(c[j][j+k][i],c[j][j+p][i-1]*c[j+p+1][j+k][0]);
                }
            }
        }
    }
    ll ans=0,ano=1000000000;
    for(i=1;i<=n;i++)
    {
        ans=max(ans,b[i][i+n-1][m-1]);
        ano=min(ano,c[i][i+n-1][m-1]);
    }
    cout<<ano<<endl<<ans;
  return 0;
}

2能量项链（题目链接）

这个题是个明显的动态规划，数据表明是个O（N^3）的动态规划，从长度为2开始规划。注意这个题根据环状转为链状后，动态规划枚举起点要枚举到2*n（坑）。而且最后长度要更新到n+1.代码如下。

#include<cmath>
#include <iostream>
#include<stdio.h>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<cstring>
#include<math.h>
#include<stack>
#include<algorithm>
#include<queue>
#include<bitset>
#define ll long long int
const int mod=1e9+7;
using namespace std;
ll a[500],b[500][510],n;
int main()
{
    ios::sync_with_stdio(false);
    ll i,j,q,sum=0,k,p;
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>a[i];
        a[i+n]=a[i];
    }
    memset(b,0,sizeof(b));
    for(i=2;i<=n;i++)
    {
        for(j=1;j<=2*n;j++)
        {
            for(k=1;k<i;k++)
            {
                b[j][i+j]=max(b[j][i+j],b[j][j+k]+b[j+k][j+i]+a[j]*a[j+k]*a[i+j]);
            }
        }
    }
    ll ans=0;
    for(i=1;i<=n;i++)
    {
        ans=max(ans,b[i][i+n]);
    }
    cout<<ans;
  return 0;
}

3教主的花园（题目链接）

这个题也是一个动态规划。只是需要把状态表示的更具体一些。用一个三维数组，一维表示当前位置，一维表示选择种的树，一维表示当前选树比周围高还是低。由于是个环状，所以要从第二个开始，到n的时候向1往回推。具体代码如下。

#include<cmath>
#include <iostream>
#include<stdio.h>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<cstring>
#include<math.h>
#include<stack>
#include<algorithm>
#include<queue>
#include<bitset>
#define ll long long int
const int mod=1e9+7;
using namespace std;
ll a[500],b[500][510],n;
struct node
{
    int x[3];
}d[100100];
int dp[100100][3][3];
int main()
{
    ios::sync_with_stdio(false);
    int i,j,q,sum=0,k,p;
    cin>>n;
    for(i=1;i<=n;i++)
        cin>>d[i].x[0]>>d[i].x[1]>>d[i].x[2];
    for(i=2;i<=n;i++)
    {
        for(j=0;j<=2;j++)
        {
            if(j==0)
                dp[i][j][0]=max(dp[i-1][j+1][1],dp[i-1][j+2][1])+d[i].x[0];
            if(j==1)
            {
                dp[i][j][0]=dp[i-1][j+1][1]+d[i].x[1];
                dp[i][j][1]=dp[i-1][j-1][0]+d[i].x[1];
            }
            if(j==2)
            {
                dp[i][j][1]=max(dp[i-1][j-1][0],dp[i-1][j-2][0])+d[i].x[2];
            }
        }
    }

     for(j=0;j<=2;j++)
        {
            if(j==0)
            {
                dp[1][j][0]=max(dp[n][j+1][1],dp[n][j+2][1])+d[1].x[0];
                sum=max(dp[1][j][0],sum);
            }
            if(j==1)
            {
                dp[1][j][0]=dp[n][j+1][1]+d[1].x[1];
                dp[1][j][1]=dp[n][j-1][0]+d[1].x[1];
                sum=max(dp[1][j][0],sum);
                sum=max(dp[1][j][1],sum);
            }
            if(j==2)
            {
                dp[1][j][1]=max(dp[n][j-1][0],dp[n][j-2][0])+d[1].x[2];
                sum=max(sum,dp[1][j][1]);
            }
        }
        cout<<sum;
  return 0;
}