从一道题目看蓝桥杯与ACM的区别

我不讨论蓝桥杯的好坏,也不吹捧acm,就从一道题目来看两者的区别。当然我并不是用前者的一道简单题和World final的真题来进行比较,不然就没有意义了,这篇博客的意义就在于前者和后者思考问题思路的不同之处。

废话说完,看题。蓝桥杯某题:一副扑克牌,去掉大小王,剩52张牌,均分给4人,每人13张牌,若不计花色,则这13张牌的可能序列有多少种?-->这原本是一道经典的多重集组合问题,用dp求解(秋叶拓哉--挑战程序竞赛),但还是从头开始看吧。

拿到题目,其一:固定的输入数据,其二:没有指明运行效率。于是诞生了第一种想法,暴力+for循环。

#include <iostream>  
#include <algorithm>  
#include <cstdio>  
#include <cstdlib>  
#include <cmath>  
#include <cstring>  
using namespace std;  
int main()  
{  
    int i,t,ans=0,a[20];  
    for (a[0]=0;a[0]<5;a[0]++)  
    for (a[1]=0;a[1]<5;a[1]++)  
    for (a[2]=0;a[2]<5;a[2]++)  
    for (a[3]=0;a[3]<5;a[3]++)  
    for (a[4]=0;a[4]<5;a[4]++)  
    for (a[5]=0;a[5]<5;a[5]++)  
    for (a[6]=0;a[6]<5;a[6]++)  
    for (a[7]=0;a[7]<5;a[7]++)  
    for (a[8]=0;a[8]<5;a[8]++)  
    for (a[9]=0;a[9]<5;a[9]++)  
    for (a[10]=0;a[10]<5;a[10]++)  
    for (a[11]=0;a[11]<5;a[11]++)  
    for (a[12]=0;a[12]<5;a[12]++)  
    {  
        t=0;  
        for (i=0;i<13;i++) t+=a[i];  
        if (t==13) ans++;  
    }  
    printf("%d",ans);  
    return 0;  
}  
引用了某钊的代码。

的确通俗易懂(QAQ)。

第一是如果是不固定的数据组数呢?for循环就没法解决了,但是谁让题目是死的呢。于是有了第二个思路,暴力+dfs

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;
int res;
void dfs(int number,int ans)
{
    if(number==14)
        return ;
    if(ans==13)
    {
        res++;
        return;
    }
    for(int i=0;i<=4;i++)
        dfs(number+1,ans+i);
}
int main()
{
    res=0;
    dfs(0,0);
    printf("%d\n",res);
    return 0;
}
然后就是等待数秒后,会出现正确答案,注意,是等待数秒。用dfs的好处是,如果题目改变输入,也可灵活得到答案,其二,不用机械性的敲13个for循环。但是作为一个acmer,应该考虑的不是这些问题,而是如何设计出1s的程序。

于是诞生了DP求解此题:

一共13种牌,dp[i][j]表示在前i种中选取j张的可能情况。

状态转移方程:dp[i][j]=dp[i][j-k]+..d[i][j](k从0到min(j,a[i]))  a[i]表示每种牌的个数

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
using namespace std;
#define rd(x) scanf("%d",&x)
#define rd2(x,y)  scanf("%d%d",&x,&y)
#define rd3(x,y,z) scanf("%d%d%d",&x,&y,&z)
int dp[100][100];
int w[100];
void solve(int n,int m)
{
    memset(dp,0,sizeof(dp));
    for(int i=0;i<=n;i++)
        dp[i][0]=1;
    for(int i=0;i<n;i++)
        for(int j=1;j<=m;j++)
    {
        for(int k=0;k<=min(j,w[i]);k++)
            dp[i+1][j]+=dp[i][j-k];
    }
    printf("%d\n",dp[n][m]);
}
//3598180
int main()
{
    int n,m;
    while(~rd2(n,m))
    {
        for(int i=0;i<n;i++)
            rd(w[i]);
        solve(n,m);
    }
    return 0;
}
此时,已经能高效的运行了,这才是真正的程序,当然还有改进之处,原来时间复杂度为O(nm^2),状态转移方程还是可以优化的。

dp[i+1][j]=dp[i+1][j-1]+dp[i][j]-dp[i][j-1-ai]

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
using namespace std;
#define rd(x) scanf("%d",&x)
#define rd2(x,y)  scanf("%d%d",&x,&y)
#define rd3(x,y,z) scanf("%d%d%d",&x,&y,&z)
const int M=10000007;
int dp[100][100];
int w[100];
void solve(int n,int m)
{
    memset(dp,0,sizeof(dp));
    for(int i=0;i<=n;i++)
        dp[i][0]=1;
    for(int i=0;i<n;i++)
        for(int j=1;j<=m;j++)
    {
        if(j-1-w[i]>=0)
        dp[i+1][j]=(dp[i+1][j-1]+dp[i][j]-dp[i][j-1-w[i]]+M)%M;
        else
        dp[i+1][j]=dp[i+1][j-1]+dp[i][j];
    }
    printf("%d\n",dp[n][m]);
}
//3598180
int main()
{
    int n,m;
    while(~rd2(n,m))
    {
        for(int i=0;i<n;i++)
            rd(w[i]);
        solve(n,m);
    }
    return 0;
}
这样复杂度讲到了O(nm),参考(秋叶拓哉)的多重集组合数章节。

怎么说呢,蓝桥杯也并不是水,考的比较差的我也没这个资格说,但是对于一直在刷acm题的我来说,也让我发现了很多漏洞,好比说,经典的dfs还没有掌握,dp的知识也暂时没有涉及太多,树形dp,状压dp.etc 都还没做。总之我感觉acm更多的是锻炼人的思维,而蓝桥杯则更偏向于对经典算法的涉猎程度,当然我并不是说acm涉猎不广,两者的难度我相信不用我比较也是不言而喻的,那么就借此题给之前自以为是的我画个句号吧。




你可能感兴趣的:(从一道题目看蓝桥杯与ACM的区别)