DP专题

最新推荐文章于 2022-02-23 20:34:53 发布

Pluto_cc

最新推荐文章于 2022-02-23 20:34:53 发布

阅读量289

点赞数

分类专栏：题目文章标签： dp

本文链接：https://blog.csdn.net/qq_43412506/article/details/88540179

版权

题目专栏收录该内容

27 篇文章 0 订阅

订阅专栏

P1004 方格取数（多进程dp）

一开始我的思路是用两次dp(但是普及+/提高的题目显然没这么容易A掉) 想了好久最后还是看了题解发现一个新操作：多进程dp，我们假设两个人一起走，第一个人是(i,j)，第二个人是(k,l)，那么这两个人一起走向B的路线是：

（i-1，j，k-1，l）

（i，j-1，k-1，l）

（i-1，j，k，l-1）

（i，j-1，k，l-1）

然后看数据范围，n<=9，暴力四维dp就可以A了

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 20;
int dp[maxn][maxn][maxn][maxn];
int a[maxn][maxn];
int main()
{
    int n;
    scanf("%d",&n);
    int x,y,v;
    while(scanf("%d %d %d",&x,&y,&v)&&x&&y&&v)
    {
        a[x][y]=v;
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            for(int k=1;k<=n;k++)
            {
                for(int l=1;l<=n;l++)
                {
                    dp[i][j][k][l]=max(max(dp[i-1][j][k-1][l],dp[i-1][j][k][l-1]),max(dp[i][j-1][k-1][l],dp[i][j-1][k][l-1]))+a[i][j]+a[k][l];
                    if(i==k&&l==j) dp[i][j][k][l]-=a[i][j]; //由于取走后数字变为0，去重
                }
            }
        }
    }
    printf("%d\n",dp[n][n][n][n]);
}

P1005 矩阵取数游戏（区间dp+高精度）

搞了两天才A了这道题....

很明显这道题的行与行之间是相互独立的，而且满足无后效性，所以只要求出每一行的最优子结构就可以，并且取走一部分数字后，剩下的数字总是形成一个区间，所以这道题是一道区间dp问题

用f（j，k）表示[j，k]区间的最优解，如果设i为行，那么我们就可以得出状态转移方程 dp[j][k] = Max(dp[j - 1][k]+(map[i][j]-1]*(a[cnt]))，dp[j][k + 1]+(map[i][k + 1]*(a[cnt]))); (a[i]为预处理过后的2的i次方) 此时dp的终点是j==k的位置（只有一个元素），所以对长度为1的区间进行枚举求每一行的最大值，最大值就是该行的最大贡献，加入到答案中

然后就是高精度问题了，高精度的实现用了c++和java实现(java大法好！)

我们可以先尝试没有高精度的，假如只是单纯在每一行取出最优解

代码：

#include<cstdio>
#include<cmath>
#include<algorithm>
#define ll long long
using namespace std;
const int maxn = 82;
ll map[maxn][maxn],dp[maxn][maxn];
ll a[maxn];

ll pow(ll a,ll b)
{
    ll ans=1,base=a;
    while(!b)
    {
        if(!(b&1))
        {
            ans*=base;
            base*=base;
            b>>=1;
        }
    }
    return ans;
}

int main()
{
    int n,m;
    ll tmp=-1,ans=0;
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            scanf("%lld",&map[i][j]);
        }
    }
    //预处理出所有的2^i
    for(int i=1;i<=80;i++)
    {
        a[i]=pow(2,i);
    }
    for(int i=1;i<=n;i++)
    {
        memset(f,0,sizeof(f));
        for(int j=1;j<=m;j++)
        {
            for(int k=m;k>=j;k--)
            {
                int cnt=j-1+m-k;
                dp[j][k]=max(dp[j-1][k]+map[i][j-1]*a[cnt],dp[j][k+1]+map[i][k+1]*a[cnt]);
            }
        }
        //枚举最大值
        for(int j=1;j<=m;j++) tmp=max(tmp,dp[j][j]+map[i][j]*a[m]);
        ans+=tmp;
    }
    printf("%lld\n",ans);
}

需要用到的高精度：

高精度+单精度高精度*高精度高精度>高精度

高精度板子：

const int power = 4;
const int base = 10000;
const int maxn = 82;
struct num
{
    int a[505];
    num()
    {
        memset(a,0,sizeof(a));
    }
    num(char *s)
    {
        memset(a,0,sizeof(a));
        int len = strlen(s);
        a[0]=(len+power-1)/power;
        for(int i=0,t=0,w; i<len; w*=10,i++)
        {
            if(i%power==0)
            {
                w=1,t++;
            }
            a[t]+=w*(s[i]-'0');
        }
    }
    void add(int k)
    {
        if(k||a[0])
            a[++a[0]]=k;
    }
    void re()
    {
        reverse(a+1,a+a[0]+1);
    }
    void print()
    {
        printf("%d",a[a[0]]);
        for(int i=a[0]-1; i>0; i--)
            printf("%0*d",power,a[i]);
        printf("\n");
    }
} bit[maxn],dp[maxn][maxn],q;
//高精与高精的大小比较
bool operator < (const num &a,const num &b)
{
    if(a.a[0]<b.a[0])
        return true;
    if(a.a[0]>b.a[0])
        return false;
    for(int i=a.a[0]; i>0; i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]<b.a[i];
    return false;
}
//高精+高精
num operator + (const num &a,const num &b)
{
    num c;
    c.a[0]=max(a.a[0],b.a[0]);
    for(int i=1; i<=c.a[0]; i++)
    {
        c.a[i]+=a.a[i]+b.a[i];
        c.a[i+1]+=c.a[i]/base;
        c.a[i]%=base;
    }
    if(c.a[c.a[0]+1])
        ++c.a[0];
    return c;
}
//高精-高精
num operator - (const num &a,const num &b)
{
    num c=a;
    for(int i=1; i<=c.a[0]; i++)
    {
        c.a[i]-=b.a[i];
        if(c.a[i]<0)
        {
            c.a[i]+=base;
            --c.a[i+1];
        }
    }
    while(c.a[0]>0&&!c.a[c.a[0]])
        --c.a[0];
    return c;
}
//高精乘高精
num operator * (const num &a,const num &b)
{
    num c;
    c.a[0]=a.a[0]+b.a[0]-1;
    for(int i=1; i<=a.a[0]; i++)
    {
        for(int j=1; j<=b.a[0]; j++)
        {
            c.a[i+j-1]+=a.a[i]*b.a[j];
            c.a[i+j]+=c.a[i+j-1]/base;
            c.a[i+j-1]%=base;
        }
    }
    if(c.a[c.a[0]+1])
        ++c.a[0];
    return c;
}
//高精乘单精
num operator * (const int &b,const num &a)
{
    num c;
    c.a[0]=a.a[0];
    int x=0;
    for(int i=1;i<=a.a[0];i++)
    {
        c.a[i]=a.a[i]*b+x;
        x=c.a[i]/base;
        c.a[i]%=base;
    }
    while(x>0) c.a[++c.a[0]]=x%base,x/=base;
    return c;
}
//高精除高精
num operator / (const num &a,const num &b)
{
    num x,y;
    for(int i=a.a[0]; i>=1; i--)
    {
        y.add(a.a[i]);
        y.re();
        while(!(y<b))
            y=y-b,++x.a[i];
        y.re();
    }
    x.a[0]=a.a[0];
    while(x.a[0]>0&&!x.a[x.a[0]])
        --x.a[0];
    return x;
}
//高精与高精大小比较
num max(const num &a,const num &b)
{
    if(a.a[0]>b.a[0]) return a;
    else if(a.a[0]<b.a[0]) return b;
    for(int i=a.a[0];i>=1;i--)
    {
        if(a.a[i]>b.a[i]) return a;
        else if(a.a[i]<b.a[i]) return b;
    }
    return a;
}

C++代码：

#include<algorithm>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define ll long long
using namespace std;
const int power = 4;
const int base = 10000;
const int maxn = 82;
int map[maxn][maxn];
struct num
{
    int a[505];
    num()
    {
        memset(a,0,sizeof(a));
    }
    num(char *s)
    {
        memset(a,0,sizeof(a));
        int len = strlen(s);
        a[0]=(len+power-1)/power;
        for(int i=0,t=0,w; i<len; w*=10,i++)
        {
            if(i%power==0)
            {
                w=1,t++;
            }
            a[t]+=w*(s[i]-'0');
        }
    }
    void add(int k)
    {
        if(k||a[0])
            a[++a[0]]=k;
    }
    void re()
    {
        reverse(a+1,a+a[0]+1);
    }
    void print()
    {
        printf("%d",a[a[0]]);
        for(int i=a[0]-1; i>0; i--)
            printf("%0*d",power,a[i]);
        printf("\n");
    }
} bit[maxn],dp[maxn][maxn],q;
//高精与高精的大小比较
bool operator < (const num &a,const num &b)
{
    if(a.a[0]<b.a[0])
        return true;
    if(a.a[0]>b.a[0])
        return false;
    for(int i=a.a[0]; i>0; i--)
        if(a.a[i]!=b.a[i])
            return a.a[i]<b.a[i];
    return false;
}
//高精+高精
num operator + (const num &a,const num &b)
{
    num c;
    c.a[0]=max(a.a[0],b.a[0]);
    for(int i=1; i<=c.a[0]; i++)
    {
        c.a[i]+=a.a[i]+b.a[i];
        c.a[i+1]+=c.a[i]/base;
        c.a[i]%=base;
    }
    if(c.a[c.a[0]+1])
        ++c.a[0];
    return c;
}
//高精-高精
num operator - (const num &a,const num &b)
{
    num c=a;
    for(int i=1; i<=c.a[0]; i++)
    {
        c.a[i]-=b.a[i];
        if(c.a[i]<0)
        {
            c.a[i]+=base;
            --c.a[i+1];
        }
    }
    while(c.a[0]>0&&!c.a[c.a[0]])
        --c.a[0];
    return c;
}
//高精乘高精
num operator * (const num &a,const num &b)
{
    num c;
    c.a[0]=a.a[0]+b.a[0]-1;
    for(int i=1; i<=a.a[0]; i++)
    {
        for(int j=1; j<=b.a[0]; j++)
        {
            c.a[i+j-1]+=a.a[i]*b.a[j];
            c.a[i+j]+=c.a[i+j-1]/base;
            c.a[i+j-1]%=base;
        }
    }
    if(c.a[c.a[0]+1])
        ++c.a[0];
    return c;
}
//高精乘单精
num operator * (const int &b,const num &a)
{
    num c;
    c.a[0]=a.a[0];
    int x=0;
    for(int i=1;i<=a.a[0];i++)
    {
        c.a[i]=a.a[i]*b+x;
        x=c.a[i]/base;
        c.a[i]%=base;
    }
    while(x>0) c.a[++c.a[0]]=x%base,x/=base;
    return c;
}
//高精除高精
num operator / (const num &a,const num &b)
{
    num x,y;
    for(int i=a.a[0]; i>=1; i--)
    {
        y.add(a.a[i]);
        y.re();
        while(!(y<b))
            y=y-b,++x.a[i];
        y.re();
    }
    x.a[0]=a.a[0];
    while(x.a[0]>0&&!x.a[x.a[0]])
        --x.a[0];
    return x;
}
//高精与高精大小比较
num max(const num &a,const num &b)
{
    if(a.a[0]>b.a[0]) return a;
    else if(a.a[0]<b.a[0]) return b;
    for(int i=a.a[0];i>=1;i--)
    {
        if(a.a[i]>b.a[i]) return a;
        else if(a.a[i]<b.a[i]) return b;
    }
    return a;
}
void Bit()
{
    bit[0].a[1]=1,bit[0].a[0]=1;
    for(int i=1;i<=82;i++)
        bit[i]=2*bit[i-1];
}
int main()
{
    int n,m;
    char tmp[505],ans[505];
    scanf("%d %d",&n,&m);
    Bit();
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=m; j++)
        {
            scanf("%d",&map[i][j]);
        }
    }
    for(int i=1; i<=n; i++)
    {
        memset(dp,0,sizeof(dp));
        for(int j=1; j<=m; j++)
        {
            for(int k=m; k>=j; k--)
            {
                int cnt=m-k+j-1;
                dp[j][k]=max(dp[j-1][k]+map[i][j-1]*bit[cnt],dp[j][k+1]+map[i][k+1]*bit[cnt]);
            }
        }
        num p;
        for(int j=1; j<=m; j++)
            p=max(p,dp[j][j]+map[i][j]*bit[m]);
        q=q+p;

    }
    q.print();
}

JAVA代码：

import java.math.BigInteger;
import java.util.Scanner;

public class Main
{
    // 大数比较
    public static BigInteger Max(BigInteger a, BigInteger b)
    {
        if (a.compareTo(b) >= 0)
            return a;
        return b;
    }

    public static void main(String[] args)
    {
        BigInteger[] a = new BigInteger[81];
        BigInteger tmp = new BigInteger("1");
        // 预处理出2的i次方
        for (int i = 1; i <= 80; i++)
        {
            tmp = tmp.multiply(new BigInteger("2"));
            a[i] = tmp;
        }
        tmp = new BigInteger("0");
        BigInteger[][] dp = new BigInteger[82][82];
        BigInteger[][] map = new BigInteger[82][82];
        Scanner cin = new Scanner(System.in);
        int n, m;
        n = cin.nextInt();
        m = cin.nextInt();
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++)
            {
                map[i][j] = cin.nextBigInteger();
            }
        }
        //初始化map数组
        for (int i = 1; i <= n; i++)
            map[i][0] = map[i][m + 1] = tmp;

        int cnt = 0;
        BigInteger ans = new BigInteger("0");
        BigInteger tmp1 = new BigInteger("0");
        //初始化dp数组 进行动态规划
        for (int i =1; i <= n; i++) //枚举行
        {
            for (int j = 0; j <= m; j++)
            {
                for (int k = 0; k <= m + 1; k++)
                {
                    dp[j][k] = tmp;
                }
            }
            for (int j = 1; j <= m; j++) //枚举区间起点
            {
                for (int k = m; k >= j; k--) //枚举区间终点
                {
                    cnt = j - 1 + m - k; //第cnt次取数
                    if (cnt == 0)continue;
                    dp[j][k] = Max(dp[j - 1][k].add(map[i][j - 1].multiply(a[cnt])),
                                   dp[j][k + 1].add(map[i][k + 1].multiply(a[cnt])));
                }
            }
            tmp1 = new BigInteger("0");
            //模拟每个长度为1的区间
            for (int j = 1; j <= m; j++)
            {
                tmp1 = Max(tmp1, dp[j][j].add(map[i][j].multiply(a[m])));
            }
            ans = ans.add(tmp1);
        }
        System.out.println(ans);
    }
}

P1006 传纸条（多进程dp）

类似于方格取数，也是一个多进程dp问题，设f[i][j][k][l]为从小渊传到小轩的纸条到达(i,j)，从小轩传给小渊的纸条到达(k,l)的路径上取得的最大的好心程度和，可以看出是从同一个起点出发，求两条通向终点权值最大且不相交的路径，状态转移方程跟P1004相同，dp[i][j][k][l]=max( dp[i][j-1][k-1][l] , dp[i-1][j][k][l-1] , dp[i][j-1][k][l-1] , dp[i-1][j][k-1][l] )+a[i][j]+a[k][l]

但是P1004跟这道题有一个明显的差别，方格取数是取数后变成0，但是还可以取这里的数，但是传纸条只要这个人传过一次就不能再传了，也就是不能再走这条路了，所以方格取数的代码稍微改下可以在这道题A ，但是这道题的代码不能在方格取数的题目A（也是错了好多次才发现的）

这里一共两种处理判重的方法

代码1：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 55;
int dp[maxn][maxn][maxn][maxn];
int a[maxn][maxn];
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);
    int x,y,v;
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=m; j++)
            scanf("%d",&a[i][j]);
    }
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=m; j++)
        {
            for(int k=1; k<=n; k++)
            {
                for(int l=1; l<=m; l++)
                {
                    dp[i][j][k][l]=max(max(dp[i-1][j][k-1][l],dp[i-1][j][k][l-1]),max(dp[i][j-1][k-1][l],dp[i][j-1][k][l-1]))+a[i][j]+a[k][l];
                    if(i==k&&l==j) dp[i][j][k][l]-=a[i][j]; //由于取走后数字变为0，去重
                }
            }
        }
    }
    printf("%d",dp[n][m][n][m]);
}

代码2：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 55;
int dp[maxn][maxn][maxn][maxn];
int a[maxn][maxn];
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);
    int x,y,v;
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=m; j++)
            scanf("%d",&a[i][j]);
    }
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=m; j++)
        {
            for(int k=1; k<=n; k++)
            {
                for(int l=j+1; l<=m; l++)
                {
                    dp[i][j][k][l]=max(max(dp[i-1][j][k-1][l],dp[i-1][j][k][l-1]),max(dp[i][j-1][k-1][l],dp[i][j-1][k][l-1]))+a[i][j]+a[k][l];
                }
            }
        }
    }
    printf("%d\n",dp[n][m-1][n-1][m]);
}

对于代码2可以思考一下，为什么l=j+1？为什么终值是dp[n][m-1][n-1][m]？一开始一直没想明白，后来在状态转移的时候加了一个打印出i,j,k,l的语句才发现，如果l=j+1的话，它在枚举第二条路的时候就没有重复的可能，所以它的dp在j=m的时候根本就没有进行（可以自己打印出i,j,k,l），所以dp[n][m][n][m]为零，那dp[n][m-1][n-1][m]就相当于第一条路走到了（n,m-1），第二条路走到了（n-1，m），还有一个问题也想了很久（还是不是特别明白），为什么终值不能是dp[n][m-1][n][m]？后面发现如果第二条路是到（n，m），走的路就出现了相交的地方（别问我为啥，我也不清楚，等一个大佬）

T35377 大教室中传纸条（传纸条数据加强版）

数据加强版的传纸条问题（T了无数次）还没搞出来，先放着吧...

P1018 乘积最大（预处理+高精度）

高精度真的好烦思路有了先搁着..

P1020 导弹拦截（线性dp）

维护一个最长不上升子序列和最长上升子序列，二分优化到nlogn （这个输入真的好恶心啊，wa了我一页）

n²代码：

#include<bits/stdc++.h>
using namespace std;
int a[100005],dp[100005],res;
int LDS(int n)
{
    for(int i=0; i<n;i++)
    {
        dp[i]=1;
        for(int j=0; j<i; j++)
        {
            if(a[j]>=a[i])
                dp[i]=max(dp[i],dp[j]+1);
        }
        res=max(res,dp[i]);
    }
    return res;
}
int LIS(int n)
{
    for(int i=0; i<n; ++i)
    {
        dp[i]=1;
        for(int j=0; j<i; ++j)
            if(a[j]<a[i])
                dp[i]=max(dp[i],dp[j]+1);
        res=max(res,dp[i]);
    }
    return res;
}
int main()
{
    int n=0;
    while(cin>>a[n]&&a[n]!=-1)
    {
        n++;
    }
    memset(dp,0,sizeof(dp));
    res=0;
    cout<<LDS(n)<<endl;
    memset(dp,0,sizeof(dp));
    res=0;
    cout<<LIS(n)<<endl;
}

nlogn代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int dp1[maxn],a[maxn],dp2[maxn];
struct cmp
{
    bool operator()(int x,int y)
    {
        return x>y;
    }
};
int main()
{
    int n=1;
    while(cin>>a[n]) n++;
    n--;
    dp1[1]=dp2[1]=a[1];
    int up=1,down=1;
    for(int i=2;i<=n;i++)
    {
        //维护一个最长不上升子序列
        if(dp2[down]>=a[i]) dp2[++down]=a[i];
        else dp2[upper_bound(dp2+1,dp2+down+1,a[i],cmp())-dp2]=a[i];
        //维护一个最长上升子序列
        if(dp1[up]<a[i]) dp1[++up]=a[i];
        else dp1[lower_bound(dp1+1,dp1+up+1,a[i])-dp1]=a[i];
    }
    cout<<down<<endl;
    cout<<up<<endl;
}

P1040 加分二叉树（树形dp）

#include<bits/stdc++.h>
using namespace std;
int dp[35][35],root[35][35];

void print(int l,int r)
{
    if(l>r) return;
    printf("%d ",root[l][r]);
    print(l,root[l][r]-1);
    print(root[l][r]+1,r);
}

int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&dp[i][i]),root[i][i]=i;
    for(int len=1;len<=n;len++) //枚举区间长度
    {
        for(int i=1;i+len<=n;i++) //枚举起点
        {
            int j=len+i; //终点
            dp[i][j]=dp[i][i]+dp[j][j];
            root[i][j]=i; //由于是中序遍历 i~j的len为1的情况就是以i为根节点 左子树为空的情况
            for(int k=i;k<=j;k++)
            {
                if(dp[i][j]<dp[i][k-1]*dp[k+1][j]+dp[k][k])
                {
                    dp[i][j]=dp[i][k-1]*dp[k+1][j]+dp[k][k];
                    root[i][j]=k;
                }
            }
        }
    }
    printf("%d\n",dp[1][n]);
    print(1,n);
}

删除子串

这一题关键就在对上个串的尾部元素状态的记录，我们知道假设已经取了i个串，那么我们的决策有三种，第一种取了，然后变化加1长度加1，第二种不取，保持原来的状态。但是这两种都是要建立在我们要加入的字符和我们已经构造的字符的尾部元素不同时，所以我认为这题的难点就是记录尾部元素的状态。第三种尾部元素和加入字符相同，直接插入长度加1即可。

接下来就是维护一个数组，这个数组记录了所有的dp[i][j]尾部元素的状态，当我们删除了加入的字符，状态不变，当我们加入了字符，那么状态转移成加入的字符。

/*Today you do things people will not do,
tomorrow you will do things people can not do.*/

#include<bits/stdc++.h>
#define ll long long
#define lson l,m,cnt<<1
#define rson m+1,r,cnt<<1|1
//priority_queue <int,vector<int>,greater<int> > Q;//优先队列递增
//priority_queue<int>Q;//递减
using namespace std;
const int maxn = 1e5+10;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-6;
char s1[maxn];
int dp[maxn][15];
int n,m;
int cnt[maxn],pre[maxn][15];
int main()
{
    int flag=0,c1=0,c2=0;
    scanf("%d %d",&n,&m);
    getchar();
    for(int i=1; i<=n; i++)
        scanf("%c",&s1[i]);
    int cut=0;
    while(s1[cut+1]=='b')
        cut++;
    cut=cut+1;
    for(int i=cut; i<=n; i++)
    {
        if(s1[i]=='a')
            flag=1,c1++;
         dp[i][0]=c1;
    }
    if(m==0)
    {
        printf("%d\n",cnt[n]);
        return 0;
    }
    if(flag==0)
        puts("0");
    else
    {
        for(int i=1; i<=m; i++)
            dp[cut][i]=1;
        pre[cut][0]='a';
        for(int i=cut+1; i<=n; i++)
        {
            for(int j=1; j<=m; j++)
            {
                if(s1[i]!=pre[i-1][j])
                {
                    dp[i][j]=max(dp[i-1][j],dp[i-1][j-1]+1);
                    if(dp[i][j]==dp[i-1][j]) pre[i][j]=pre[i-1][j];
                    if(dp[i][j]==dp[i-1][j-1]+1)
                        pre[i][j]=s1[i];
                }
                else
                    dp[i][j]=dp[i-1][j]+1,pre[i][j]=s1[i];
            }
        }
        printf("%d\n",dp[n][m]);
    }
}

被3整除的子序列

状态定义错，转移两行泪qwq

正解的状态：dp[i][j]表示前i个数和为j的总方案数处理总方案数然后j%3取和就是答案了

然后方程就出来了

但是这里我一开始对于j>=temp的情况没搞太清楚，我一开始推出的方程是dp[i][j]=(dp[i-1][j-temp]+dp[i-1][temp]+dp[i-1][j]+dp[i][j])%mod; 但是其实我们可以发现dp[i-1][temp]已经包括在dp[i-1][j]中了

/*Today you do things people will not do,
tomorrow you will do things people can not do.*/

#include<bits/stdc++.h>
#define ll long long
#define lson l,m,cnt<<1
#define rson m+1,r,cnt<<1|1
//priority_queue <int,vector<int>,greater<int> > Q;//优先队列递增
//priority_queue<int>Q;//递减
using namespace std;
const int maxn = 55;
const int INF = 0x3f3f3f3f;
const int mod = 1e9+7;
const double PI = acos(-1.0);
const double eps = 1e-6;
ll dp[maxn][455];
char s[maxn];
int n[maxn];
ll ans=0;
int sum[maxn];
int main()
{
    scanf("%s",s);
    int len=strlen(s);
    for(int i=1;i<=len;i++)
    {
        n[i]=s[i-1]-'0';
        dp[i][n[i]]=1;
        sum[i]=n[i]+sum[i-1];
    }
    for(int i=1;i<=len;i++)
    {
        int temp=n[i];
        for(int j=0;j<=sum[i];j++)
        {
            if(j<temp) dp[i][j]=(dp[i-1][j]+dp[i][j])%mod;
            else dp[i][j]=(dp[i-1][j-temp]+dp[i-1][j]+dp[i][j])%mod;
        }
    }
    for(int i=0;i<=sum[len];i++)
    {
        if(i%3==0)
            ans=(ans+dp[len][i])%mod;
    }
    printf("%lld\n",ans);
}

花匠

一开始没看清题瞎推了一个多小时..

题目要求的是两种第一种是先升后降第二种是先降后升所以我们可以定义dp[i][j]：当j==0时表示当前递增 j==1时表示当前递减然后就可以得出状态转移方程：

if(a[i]>a[i-1]) dp[i][0]=dp[i-1][1]+1;
else dp[i][0]=dp[i-1][0];
if(a[i]<a[i-1]) dp[i][1]=dp[i-1][0]+1;
else dp[i][1]=dp[i-1][1];

/**Today you do things people will not do,
tomorrow you will do things people can not do.**/

#include<bits/stdc++.h>
#define ll long long
#define lson l,m,cnt<<1
#define rson m+1,r,cnt<<1|1
//priority_queue <int,vector<int>,greater<int> > Q;//优先队列递增
//priority_queue<int>Q;//递减
using namespace std;
const int maxn = 1e5+10;
const int maxm = 105;
const int mod = 1e9+7;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-6;
int a[maxn],dp[maxn][2];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    dp[1][0]=dp[1][1]=1;
    for(int i=2;i<=n;i++)
    {
        if(a[i]>a[i-1]) dp[i][0]=dp[i-1][1]+1;
        else dp[i][0]=dp[i-1][0];
        if(a[i]<a[i-1]) dp[i][1]=dp[i-1][0]+1;
        else dp[i][1]=dp[i-1][1];
    }
    printf("%d\n",max(dp[n][0],dp[n][1]));
}

摆花

首先我们可以确定dp[i][j]：前i种花摆j个位置的方案数但是每一种花有a[i]个可以放所以我们可以用一个循环枚举每次放i的个数从0~a[i] 然后i-1就是从j-0~j-a[i] 最后注意初始化

/**Today you do things people will not do,
tomorrow you will do things people can not do.**/
 
#include<bits/stdc++.h>
#define ll long long
#define lson l,m,cnt<<1
#define rson m+1,r,cnt<<1|1
//priority_queue <int,vector<int>,greater<int> > Q;//优先队列递增
//priority_queue<int>Q;//递减
using namespace std;
const int maxn = 105;
const int maxm = 105;
const int mod = 1000007;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-6;
int a[maxn],dp[maxn][maxn];
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);
    for(int i=1; i<=n; i++)
        scanf("%d",&a[i]);
    for(int i=0; i<=a[1]; i++)
        dp[1][i]=1;
    for(int i=2; i<=n; i++)
    {
        for(int j=0; j<=m; j++)
        {
            for(int k=0; k<=a[i]; k++)
            {
                if(k<=j)
                    dp[i][j]=(dp[i][j]+dp[i-1][j-k])%mod;
            }
        }
    }
    printf("%d\n",dp[n][m]%mod);
}

乌龟棋

根据题意卡片最多只有4种分别是走1 走2 走3 走4 那么可以定义dp[i][j][k][l]为走1 走2 走3 走4的卡片数然后暴力把所有情况枚举出来

/**Today you do things people will not do,
tomorrow you will do things people can not do.**/

#include<bits/stdc++.h>
#define ll long long
#define lson l,m,cnt<<1
#define rson m+1,r,cnt<<1|1
//priority_queue <int,vector<int>,greater<int> > Q;//优先队列递增
//priority_queue<int>Q;//递减
using namespace std;
const int maxn = 360;
const int maxm = 105;
const int mod = 1000007;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-6;

int a[maxn],dp[45][45][45][45],b[5];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1; i<=n; i++)
        scanf("%d",&a[i]);
    for(int i=1; i<=m; i++)
    {
        int p;
        scanf("%d",&p);
        b[p]++;
    }
    dp[0][0][0][0]=a[1];
    for(int i=0; i<=b[1]; i++)
        for(int j=0; j<=b[2]; j++)
            for(int k=0; k<=b[3]; k++)
                for(int l=0; l<=b[4]; l++)
                {
                    int num=a[1+i+2*j+3*k+4*l];
                    if(i)
                        dp[i][j][k][l]=max(dp[i][j][k][l],dp[i-1][j][k][l]+num);
                    if(j)
                        dp[i][j][k][l]=max(dp[i][j][k][l],dp[i][j-1][k][l]+num);
                    if(k)
                        dp[i][j][k][l]=max(dp[i][j][k][l],dp[i][j][k-1][l]+num);
                    if(l)
                        dp[i][j][k][l]=max(dp[i][j][k][l],dp[i][j][k][l-1]+num);
                }
    printf("%d\n",dp[b[1]][b[2]][b[3]][b[4]]);
}

P1879 Corn Fields

一道最基础的状压dp 但是我是最近才搞懂的

通过十进制转二进制将每一行的地图压缩成一个十进制位数其中1代表土地肥沃 0代表土地贫瘠

枚举状态其中状态中的1代表种草 0代表不种草

/**Today you do things people will not do,
tomorrow you will do things people can not do.**/

#include<bits/stdc++.h>
#define ll long long
#define lson l,m,cnt<<1
#define rson m+1,r,cnt<<1|1
#define mem(a,b) memset(a,b,sizeof(a))
//priority_queue <int,vector<int>,greater<int> > Q;//优先队列递增
//priority_queue<int>Q;//递减
using namespace std;
const int maxn = 15;
const int mod = 1e8;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-6;
int mp[maxn][maxn],dp[maxn][1<<maxn];
int f[maxn];
int cnt[1<<maxn];
int tot;
bool check(int x)
{
    if(x&(x<<1))
        return 0;
    if(x&(x>>1))
        return 0;
    return 1;
}
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=m; j++)
            scanf("%d",&mp[i][j]);
    }
    for(int i=0; i<(1<<m); i++)
    {
        if(check(i))
            cnt[++tot]=i;
    }
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=m; j++)
            f[i]=(f[i]<<1)+mp[i][j];
    }
    for(int i=1; i<=tot; i++)
    {
        if((f[1]&cnt[i])==cnt[i])
            dp[1][i]=1;
    }
    for(int i=2; i<=n; i++)
    {
        for(int j=1; j<=tot; j++) //枚举这一行的状态
        {
            if((cnt[j]&f[i])==cnt[j])
            {
                for(int k=1; k<=tot; k++) //枚举上一行的状态
                {
                    if(!(cnt[j]&cnt[k]))
                    {
                        dp[i][j]=(dp[i][j]+dp[i-1][k])%mod;
                    }
                }
            }
        }
    }
    int ans=0;
    for(int i=1;i<=tot;i++)
        ans+=dp[n][i],ans%=mod;
    printf("%d\n",ans);
}

P1896 互不侵犯

这个比上一题只是多枚举了一个需要放的国王数要多开一组记录放的国王数

/**Today you do things people will not do,
tomorrow you will do things people can not do.**/

#include<bits/stdc++.h>
#define ll long long
#define lson l,m,cnt<<1
#define rson m+1,r,cnt<<1|1
#define mem(a,b) memset(a,b,sizeof(a))
//priority_queue <int,vector<int>,greater<int> > Q;//优先队列递增
//priority_queue<int>Q;//递减
using namespace std;
const int maxn = 10;
const int mod = 1e8;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-6;
ll dp[maxn][1<<maxn][81];
int num[1<<maxn];
int cnt[1<<maxn];
bool check(int x)
{
    if(x&(x<<1))
        return 0;
    if(x&(x>>1))
        return 0;
    return 1;
}
bool check(int x,int y)
{
    if(x&y)
        return 0;
    if(x&(y>>1))
        return 0;
    if(x&(y<<1))
        return 0;
    return 1;
}
int main()
{
    int n,k,tot=0;
    scanf("%d %d",&n,&k);
    for(int i=0; i<(1<<n); i++)
    {
        if(check(i))
            cnt[++tot]=i;
    }
    //处理每一个状态有多少个国王
    for(int i=1; i<=tot; i++)
    {
        for(int j=0; j<n; j++)
        {
            if((cnt[i]>>j)&1)
                num[i]++;
        }
    }
    //对于第一行
    for(int i=1; i<=tot; i++)
    {
        if(num[i]<=k)
            dp[1][i][num[i]]=1;
    }
    for(int i=2; i<=n; i++)
    {
        for(int j=1; j<=tot; j++) //枚举当前行状态
        {
            for(int z=1; z<=tot; z++) //枚举上一行状态
            {
                if(check(cnt[j],cnt[z]))
                {
                    for(int nn=num[j]; nn<=k; nn++) //枚举king的个数
                    {
                        dp[i][j][nn]+=dp[i-1][z][nn-num[j]];
                    }
                }
            }
        }
    }
    ll sum=0;
    for(int i=1; i<=tot; i++)
    {
        sum+=dp[n][i][k];
        //printf("%d\n",sum);
    }
    printf("%lld\n",sum);
}

Pluto_cc

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
DP专题

P1004方格取数（多进程dp）一开始我的思路是用两次dp(但是普及+/提高的题目显然没这么容易A掉) 想了好久最后还是看了题解发现一个新操作：多进程dp，我们假设两个人一起走，第一个人是(i,j)，第二个人是(k,l)，那么这两个人一起走向B的路线是：（i-1，j，k-1，l）（i，j-1，k-1，l）（i-1，j，k，l-1）（i，j-1，k，l-1）然后看数据范...
复制链接

扫一扫