计数dp小结

最新推荐文章于 2024-04-07 21:57:21 发布
置顶 最新推荐文章于 2024-04-07 21:57:21 发布
阅读量1k 收藏 2
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NOI_yzk/article/details/78416954
版权

序：除了刚开始的看了几道题的题解，后来也自己肛出了几道 剩下不可做的题不也没做吗
这些题目最大的特点是在于需要自己构造状态，这往往会成为一道题的最大卡点 穷举表示水不到几分

题目选讲：
E：
如果直接模拟，复杂度为 k∗n2
既然每一步只能往上下或往左右走，
那么我们可以把题目分解为在x轴上行走k步与在y轴上行走k步的方案数都处理出来 k∗n
然后枚举往左右走i步，往上下走k-i步，然后再用组合处理（常规套路）

#include<cstdio>
#include<cstring>
#define P 9999991
int dp[2][1005][1005];
long long Sum[2][1005];
int C[1005][1005];
int main(){
    int T;
    scanf("%d",&T);
    for(int i=1;i<=1000;i++){
        C[i][0]=C[i][i]=1;
        for(int j=1;j<i;j++){
            C[i][j]=(C[i-1][j]+C[i-1][j-1])%P;
        }
    }
    for(int cas=1;cas<=T;cas++){
        int n,m,k,x0,y0;
        memset(dp,0,sizeof(dp));
        memset(Sum,0,sizeof(Sum));
        scanf("%d%d%d%d%d",&n,&m,&k,&x0,&y0);
        dp[0][0][x0]=1;
        dp[1][0][y0]=1;
        Sum[1][0]=1;
        Sum[0][0]=1;
        for(int j=1;j<=k;j++){
            for(int i=1;i<=n;i++){
                if(i>1)dp[0][j][i]+=dp[0][j-1][i-1];
                if(i>2)dp[0][j][i]+=dp[0][j-1][i-2];
                if(i<n)dp[0][j][i]+=dp[0][j-1][i+1];
                if(i+1<n)dp[0][j][i]+=dp[0][j-1][i+2];
                dp[0][j][i]%=P;
                Sum[0][j]+=dp[0][j][i];
                Sum[0][j]%=P;
            }
        }
        for(int j=1;j<=k;j++){
            for(int i=1;i<=m;i++){
                if(i>1)dp[1][j][i]+=dp[1][j-1][i-1];
                if(i>2)dp[1][j][i]+=dp[1][j-1][i-2];
                if(i<m)dp[1][j][i]+=dp[1][j-1][i+1];
                if(i+1<m)dp[1][j][i]+=dp[1][j-1][i+2];
                dp[1][j][i]%=P;
                Sum[1][j]+=dp[1][j][i];
                Sum[1][j]%=P;
            }
        }
        long long ans=0;
        for(int i=0;i<=k;i++){
            ans+=Sum[0][i]*Sum[1][k-i]%P*C[k][i]%P;
            ans%=P;
        }
        printf("Case #%d:\n%lld\n",cas,ans);
    }
    return 0;
}

F:
又是一道 关于位运算的题目，一看到数据范围，就可以揣测出大概复杂度
求两个序列，正着扫一遍，倒着扫一遍。然后枚举两点（左序列的右端点，右序列的左端点），进行运算，这样复杂度为 O(n3) 加一个前缀和优化就是 O(n2) 了

#include<cstdio>
#include<cstring>
#define P 1000000007 
const int M=1023;
int A[1005];
long long dp[2][1005][M+5],dp1[2][1005][M+5];
long long Sum[1005][M+5];
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        memset(dp,0,sizeof(dp));
        memset(dp1,0,sizeof(dp1));
        memset(Sum,0,sizeof(Sum));
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)scanf("%d",&A[i]);
        dp[0][0][0]=1;
        for(int i=1;i<=n;i++){
            for(int j=0;j<=M;j++){
                dp[0][i][j]+=dp[1][i-1][j]+dp[0][i-1][j];
                dp[0][i][j]%=P;
            }
            for(int j=0;j<=M;j++){
                int t=A[i]^j;
                dp[1][i][t]+=dp[0][i-1][j]+dp[1][i-1][j];
                dp[1][i][t]%=P;
            }
        }
        dp1[0][n+1][M]=1;
        for(int i=n;i>=1;i--){
            for(int j=0;j<=M;j++){
                dp1[0][i][j]+=dp1[1][i+1][j]+dp1[0][i+1][j];
                dp1[0][i][j]%=P;
            }
            for(int j=0;j<=M;j++){
                int t=j&A[i];
                dp1[1][i][t]+=dp1[0][i+1][j]+dp1[1][i+1][j];
                dp1[1][i][t]%=P;
            }
        }
        for(int i=1;i<=n;i++){
            for(int j=0;j<=M;j++){
                Sum[i][j]=Sum[i-1][j]+dp[1][i][j];
                Sum[i][j]%=P;
            }
        }
        long long ans=0;
        for(int j=0;j<=M;j++){
            for(int i=1;i<n;i++){
                ans+=Sum[i][j]*dp1[1][i+1][j]%P;
                ans%=P;
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}

G：
像这种两维的题目可以存一维，枚举一维
定义dp两维，一维是枚举到哪一列，另一维是有几行是空着的
对于不同的情况，进行填充空行，或者是填充填过的行

#include<bits/stdc++.h>
using namespace std;
const int M=55,P=1000000007;
long long dp[55][55],C[M][M],Pow[M];
void init(){
    for(int i=1;i<=50;i++){
        C[i][0]=C[i][i]=1;
        for(int j=1;j<i;j++){
            C[i][j]=(C[i-1][j]+C[i-1][j-1])%P;
        }
    }
    Pow[0]=1;
    for(int i=1;i<=50;i++)Pow[i]=Pow[i-1]*2%P;
}
int main(){
    init();
    int n,m;
    while(~scanf("%d %d",&n,&m)){
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=m;i++)dp[1][i]=1;
        for(int i=1;i<=n;i++)dp[i][1]=1;
        for(int i=2;i<=n;i++){
            for(int j=2;j<=m;j++){
                dp[i][j]+=1ll*dp[i][j-1]*(Pow[i]-1)%P;
                dp[i][j]%=P;
                for(int k=1;k<i;k++){
                    dp[i][j]+=dp[i-k][j-1]*C[i][k]%P*Pow[i-k]%P;
                    dp[i][j]%=P;
                }
            }
        }
        printf("%lld\n",dp[n][m]);
    }
    return 0;
}

H：
这道题的难度相比于上面的题目略大
在树形dp的套路上还要加上组合数
虽然说是1-n的序列，但我们只用处理他们之间的大小关系就好了
可以证明：任意大小关系都可被不同的序列表示
在合并两个子树的时候，我们已知子树自身节点的大小关系，但并不知道两棵树之间的大小关系，且这个关系是确定的，那么就可以乘上 C(size(A)size(A)+size(B))
合并完子树之后，再加入根节点，根节点作为最大值时 dp[i]+=dp[i−1]
不然就是 dp[i]+=dp[i]∗size(A) 。 size(A) 为以某节点根的树的的节点个数

#include<cstdio>
#include<vector>
#include<cstring> 
using namespace std;
#define P 1000000007
vector<int>edge[1005];
long long dp[1005][1005];//i节点，j个最大值 
long long dp1[1005][1005];
int C[1005][1005];
int degree[1005],n;
void dfs(int x,int f){
    bool flag=0;
    int cnt=0;
    for(int k=0;k<(int)edge[x].size();k++){
        int y=edge[x][k];
        if(y==f)continue;
        dfs(y,x);
        if(!flag)for(int i=1;i<=n;i++)dp[x][i]=dp[y][i];
        else {
            for(int i=1;i<=n;i++){
                if(!dp[x][i])continue;
                for(int j=1;j<=n;j++){
                    if(!dp[y][j])continue;
                    dp1[x][i+j]+=dp[x][i]*dp[y][j]%P*C[cnt+degree[y]][degree[y]]%P;
                    dp1[x][i+j]%=P;
                }
            }
            for(int i=1;i<=n;i++){
                dp[x][i]=dp1[x][i];
                dp1[x][i]=0;
            }
        }
        cnt+=degree[y];
        flag=1;
    }
    degree[x]=cnt+1;
    if(!flag)dp[x][1]=1;
    else {
        for(int i=1;i<=n;i++)dp1[x][i]=dp[x][i];
        for(int i=1;i<=n;i++)dp[x][i]=dp[x][i]*(degree[x]-1)%P;
        for(int i=1;i<=n;i++){dp[x][i+1]+=dp1[x][i];dp1[x][i]=0;dp[x][i+1]%=P;}
    }
}
void Init(){
    for(int i=0;i<=1000;i++){
        C[i][0]=C[i][i]=1;
        for(int j=1;j<i;j++){
            if(i)C[i][j]=(C[i-1][j-1]+C[i-1][j])%P;     
        }
    }
}
int main(){
    int T,t=0;
    scanf("%d",&T);
    Init(); 
    while(T--){
        int k;
        scanf("%d%d",&n,&k);

        for(int i=1;i<=n;i++)edge[i].clear();
        memset(dp,0,sizeof(dp));
        memset(dp1,0,sizeof(dp1));

        for(int i=1;i<n;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            edge[x].push_back(y);
            edge[y].push_back(x);
        }
        dfs(1,0);
        printf("Case #%d: %lld\n",++t,dp[1][k]);
    }
    return 0;
}

K: 若直接根据题意模拟取了几个数，然后用组合数来计算，复杂度为 n3
然后思考优化，对于满足条件的一组数，保证至少取两个数，且不去两个数就好了，那么dp只用存 选到哪个数 累和为多少 不选几个数 选几个数
由于不选2个数和不选3.4….n个数的效果都是一样的，所以只用存0-2就好了
同理与选几个数

#include<cstdio>
#include<cstring>
#define P 1000000007
int dp[1005][1005][3][3];//选到那个数  得到的值  可以不选   必须选 
int A[1005];
void Add(int &x,int y){
    x+=y;
    if(x>=P)x-=P;
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        memset(dp,0,sizeof(dp));
        int n,s;
        scanf("%d%d",&n,&s);
        for(int i=1;i<=n;i++)scanf("%d",&A[i]);
        dp[0][0][0][0]=1;
        for(int i=1;i<=n;i++){
            for(int j=0;j<=s;j++){
                for(int k=0;k<=2;k++){
                    Add(dp[i][j][0][k],dp[i-1][j][0][k]);
                    Add(dp[i][j][1][k],dp[i-1][j][0][k]);
                    Add(dp[i][j][1][k],dp[i-1][j][1][k]);
                    Add(dp[i][j][2][k],dp[i-1][j][1][k]);
                    Add(dp[i][j][2][k],dp[i-1][j][2][k]);
                }
                if(j+A[i]<=s){
                    for(int k=0;k<=2;k++){
                        Add(dp[i][j+A[i]][k][0],dp[i-1][j][k][0]);
                        Add(dp[i][j+A[i]][k][1],dp[i-1][j][k][1]);
                        Add(dp[i][j+A[i]][k][1],dp[i-1][j][k][0]);
                        Add(dp[i][j+A[i]][k][2],dp[i-1][j][k][1]);
                        Add(dp[i][j+A[i]][k][2],dp[i-1][j][k][2]);
                    }
                }
            }
        }
        int ans=0;
        for(int i=1;i<=s;i++)Add(ans,dp[n][i][2][2]);
        printf("%lld\n",1ll*ans*4%P);
    }
    return 0;
}

M：
是一道裸的递推题
可以预处理出用j种颜色染i个格子的方案数（第二类斯特林数）
然后枚举第一行用几种颜色，第二行用几种颜色
同时对于染色的方案再乘上颜色数量的全排
然后就可以在 O(n2) 的时间内算出答案

#include<cstdio>
#define M 2005
#define P 1000000007
long long dp[M][M],C[M][M],A[M];
void Init(){
    dp[0][0]=1;
    for(int i=1;i<=2000;i++){
        for(int j=1;j<=2000;j++){
            dp[i][j]=dp[i-1][j]*j+dp[i-1][j-1];
            dp[i][j]%=P;
        }
    }
    for(int i=1;i<=2000;i++){
        C[i][0]=C[i][i]=1;
        for(int j=1;j<i;j++){
            C[i][j]=C[i-1][j]+C[i-1][j-1];
            C[i][j]%=P;
        }
    }
    A[0]=1;
    for(int i=1;i<=2000;i++){
        A[i]=A[i-1]*i%P;
    }
}
int main(){
    Init();
    int T;
    scanf("%d",&T);
    while(T--){
        int n,m;
        long long ans=0;
        scanf("%d%d",&n,&m);
        for(int i=1;i<=m;i++){
            for(int j=1;i+j<=m;j++){
                ans+=dp[n][i]*A[i]%P*C[m][i]%P*dp[n][j]%P*A[j]%P*C[m-i][j]%P;
                ans%=P;
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}
NOI_yzk
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计数类DP
qq_37957064的博客
03-12 758
计数类DP   所谓计数类DP就是常说的统计可行解数目的问题，区别于求解最优解，此类问题需要统计所有满足条件的可行解，而求解最优值的DP问题往往只需要统计子问题时满足不漏的条件即可，但是计数类DP需要满足不重不漏的条件，是约束更高的。   最常见的计数类DP问题就是上楼梯的问题，我们要求解此类问题一个重要的点就是如何划分子问题，然后做到不重不漏，大部分情况下我们想到的方法，同一个解可能会被多次统计，这是不合理的。此类问题也常常与组合数结合到一起，我们可能需要用到数学中组合数的概念，所以如何快速实现组合数，也
数位dp
nowting的博客
11-06 201
先看一道题目： 不要62 Time Limit: 1000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 59667Accepted Submission(s): 23557 Problem Description 杭州人称那些傻乎乎粘嗒嗒的人为62...
数位dp总结
weixin_52621204的博客
11-25 784
补题的时候有个题需要数位dp，有去重学了一波上一年就学过的数位dp，又学一遍感觉上一年学了个寂寞，，，这种问题大多数都是和数的每一位的数字有关，一般是一个数的数位之间存在着某种关系，让求具有这种关系的数字在[a,b]的范围内有多少个。一般代码有两种，一种是偏递推的dp，另一种是记忆化搜索，前者太难了就放弃了，，，先按一道例题来说P2602 [ZJOI2010] 数字计数 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)一般的记忆化搜索的框架 pos代表的是枚举到了数字的第几位，一般是先从
算法：计数类dp
m0_63997099的博客
04-07 848
根据问题的特性，合理定义状态，表示达到当前状态的可能情况数量。状态通常涉及考虑的元素个数、已选择元素的性质（如总和、最大值等）以及其他约束条件。
算法6：计数DP、数统DP、状压DP
weixin_73538099的博客
04-12 600
假设此时对应的状态是k（第i-2列到第i-1列伸出来的二进制数，比如00100），k也是一个二进制数，1表示哪几行小方块是横着伸出来的，0表示哪几行不是横着伸出来的。既然从第i-1列到第i列横着摆的，和第i-2列到第i-1列横着摆的都确定了，那么第i-1列 空着的格子就确定了，这些空着的格子将来用作竖着放。首先==k不能和 j在同一行==（如下图）：因为从i-1列到第i列是横着摆放的12的方块，那么i-2列到i-1列就不能是横着摆放的，否则就是1 3的方块了。例如当 N=2，M=4 时，共有 5 种方案。
计数DP
ChenKunn的博客
10-24 1845
Dp不仅对于求解最优解问题有效，还可以用来求解各种排列组合的个数、概率或者期望之类的计算。 一、划分数：           有n个毫无区别的物品，将它们划分成不超过m组，求划分方法数模M的余数。    例如有4个物品，将它们分成3组，则有4种情况:1+1+2,1+3,2+2,4。这样的划分叫做n的m划分。 定义如下：d[i][j]=j的i划分总数 我们可以思考根据这一定义可以得到那些递...
数位dp专题
hipamp的博客
01-13 490
前言 本篇博客目的是给自己总结复习用，而不是给萌新学习用滴。萌新能不能看得懂需要看造化=.=，毕竟数位 dpdpdp 还是有点难理解的。 概括 数位 dpdpdp，是用来解决一些带有数位上的限制的计数问题的。常见的有问区间 [L,R][L, R][L,R] 中满足某种数位限制的数的个数，或者求数对的对数等等，也可以用来求和。一般是用 [0,R][0,R][0,R] 的 值减去 [0,L−1][0, L- 1][0,L−1] 的值。 常常设 dp[pos][sta]dp[pos][sta]dp[pos][st
php实现计数器方法小结
12-19
这里收藏了三款php计数器代码,他们三个都有一个同共点就是全部无需数据库,而是利用了文本文件来实现网页浏览计数. 第一款PHP计数器代码如下: 复制代码 代码如下:<?php  //计数器  function countx($file=”...
计数小插件
03-28
可以统CAD长度，CAD元件个数，还可以用，无广告什么的，安装很方便
最小生成树计数结题报告与代码
12-12
最小生成树计数的详细解题报告与C++代码~ 利用矩阵~
计数的小实验
12-05
没事自己玩的，公司里要求写的，根据车间要求来的不知道行不行
C++计数排序详解
01-20
计数排序不同于比较排序，是基于计数的方式，对于计数排序，假设每一个输入都是介于0~k之间的整数。对于每一个输入元素x，确定出小于x的元素的个数。假如有17个元素小于x，则x就属于第18个输出位置。 计数排序涉及到...
DP 计数
qq_41755258的博客
08-04 324
DP不仅广泛用于各种最优化问题，也常常用于排列组合的个数、概率期望计算等等，因为这些问题往往具有很好的“ 重叠子问题”特性，这些问题往往都起源于排列组合中的组合公式A(n, k) = A(n-1, k) + A(n-1, k-1) 例一：求解划分数 有n个无差别的物品，将他们划分成不超过m组，求划分方法数除以M的余数。 分析：dp[i][j]j的i划分的总数 dp[i][j] = dp[i][...
计数类dp：
_Griefs
08-24 514
写在前面： 这一类dp特别要求不重不漏。统计对象的可能情况一般比较多，通常需要精确的划分和整体性计算。因此，使用动态规划抽象出问题中的子结构和推导的阶段，将有助于我们准确而高效的进行求解。 在求解计数类动态规划的问题时，通常要找到一个基准点，围绕这个基准点构造一个不可划分的整体，以避免子问题之间的重复。 一、Gerald and Giant Chess CodeForces - 559C： Gia...
计数dp
ACMer_ZP的博客
04-24 661
1265: Hmz 的女装 思路:当起始点颜色固定后，我们可以依次求出其往后的每个点的涂色方式，包含和起始点颜色相同还有和起始点颜色不同，而当前点的状态可以由上一个点的状态推出来，最后选择和起始点不同的方式数就好了（起点终点颜色相同），又分成了两段，两段相成就好；#include<cstdio> #include<queue> #include<cstring> #include<iostream
数位DP学习整理（数位DP看完这篇你就会了）
热门推荐
pursuit的博客
05-12 3万+
文章目录数位DP数位DP介绍数位DP解法数位DP经典例题例题1：度的数量例题2：计数问题例题3：数字游戏例题4：windy数数位DP总结 数位DP 数位DP介绍 数位DP往往都是这样的题型，给定一个闭区间[l,r][l,r][l,r]，让你求这个区间中满足某种条件的数的总数。而这个区间可能很大，简单的暴力代码如下： int ans=0; for(int i=l;i<=r;i++){ if(check(i))ans++; } 我们发现，若区间长度超过1e81e81e8，我们暴力枚举就会超时了，
数位dp总结（模板+例题）（从入门到放弃）
weixin_45434743的博客
02-02 587
转载自：https://blog.csdn.net/wust_zzwh/article/details/52100392 数位dp模板： typedef long long ll; int a[20]; ll dp[20][state];//不同题目状态不同 ll dfs(int pos,/*state变量*/,bool lead/*前导零*/,bool limit/*数位上界变量*/)//不是每个题都要判断前导零 { //递归边界，既然是按位枚举，最低位是0，那么pos==-1说明这个数我枚举完了
led计数电路实验小结logisim
最新发布
05-14
LED计数电路实验是一种基础的数字电路实验，通过这个实验可以学习到数字电路的设计和实现。在这个实验中，我们需要使用Logisim这个数字电路模拟软件来模拟实验过程。 在LED计数电路实验中，我们需要设计一个计数器...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值