hdu 6376 度度熊剪纸条 (百度之星2018-初赛A)(贪心/背包)

最新推荐文章于 2020-07-21 09:58:10 发布

Z_sea

最新推荐文章于 2020-07-21 09:58:10 发布

阅读量366

点赞数 1

CC 4.0 BY-SA版权

分类专栏：贪心文章标签：百度之星

本文链接：https://blog.youkuaiyun.com/Z_sea/article/details/81939578

贪心专栏收录该内容

11 篇文章

订阅专栏

本文介绍了一个关于寻找纸条上1的最大前缀数量的算法问题，并提供了两种解决方案：一种是通过直接分析和比较不同剪切策略来解决问题的方法，另一种则是采用背包问题的动态规划方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

度度熊剪纸条

Problem Description

度度熊有一张纸条和一把剪刀。

纸条上依次写着 N 个数字，数字只可能是 0 或者 1。

度度熊想在纸条上剪 K 刀（每一刀只能剪在数字和数字之间），这样就形成了 K+1 段。

他再把这 K+1 段按一定的顺序重新拼起来。

不同的剪和接的方案，可能会得到不同的结果。

度度熊好奇的是，前缀 1 的数量最多能是多少。

Input

有多组数据，读到EOF结束。

对于每一组数据，第一行读入两个数 N 和 K 。

第二行有一个长度为 N 的字符串，依次表示初始时纸条上的 N 个数。

0≤K<N≤10000

所有数据 N 的总和不超过100000

Output

对于每一组数据，输出一个数，表示可能的最大前缀 1 的数量。

Sample Input

5 1

11010

5 2

11010

Sample Output

Source

2018 “百度之星”程序设计大赛 - 初赛（A）

题解：

贪心可以做主要是参考别人的博客：https://blog.youkuaiyun.com/w326159487/article/details/81635023

分析一下花费：

1、

首位若为1：那么首位的花费为0

2、

末尾若为1：那么末尾的连通块花费为1.

3、

其余在中间的自行打理。每个花费肯定是2。

考虑一下：K比较小的情况。

k==1：

1、首尾拼接。

2、中间部分最大的。

k==2：

大家想象一下，给你两刀，可以看首尾分别各一刀。

然而另外一种容易忽略。

那就是，就是中间砍一刀，首或者尾砍一刀。

然后分析他们三部分的大小。两两组合得到（1 、2），（1 、3），（2 、3）.

k>2:

如果遇到这种情况，首先就是让它把中间最大的挑出来。

然后每一次都k-=2

最后到k==1，或者k==2再进行上面的比较。

就好比以前高中所学的分段函数，x是动态改变，最后到某个区域给定一个定值这样思考。

#include<bits/stdc++.h>
using namespace std;
const int N=100500;
int n,k,a[N],b[N];
int main()
{
    while(~scanf("%d%d",&n,&k)){
        memset(b,0,sizeof(b));
        for(int i=1;i<=n;i++){      //输入用了点小技巧
            scanf("%1d",&a[i]);
        }
        int st=1,ed=n,top=0,last=0,cnt=0,tot=0,ans=0;
        while(a[st]&&st<=n) st++;   top=st-1;   //首先是找开头非零,1的连通块
        while(a[ed]&&st<=ed) ed--;   last=n-ed; //其次是找末尾非零,1的连通块
        while(a[st]==0&&st<=n) st++;            //然后找 中间部分 1的连通块
        while(a[ed]==0&&st<=ed) ed--;           //为了方便查找更新一下，下标
        for(int i=st;i<=ed;i++){                
            if(a[i]) cnt++;
            else    b[tot++]=cnt,cnt=0;
        }
        if(a[ed]==1){                           //小细节要注意！！！
            b[tot++]=cnt;
        }
        sort(b,b+tot,[](int x,int y){return x>y;});
        /*
            printf("ST: %d , ED : %d\n",st,ed);
            printf("top: %d  last :%d\n",top,last);
            printf("tot: %d\n",tot);
            printf("B[i]:\n");
            for(int i=0;i<tot;i++){
                printf("%d : %d\n",i+1,b[i]);
            }
        */
        //下面真的是抄袭别人思路的。。自愧不如，只要能想出来。核心代码才三行
        if(k==0){
            printf("%d\n",top);
            continue;
        }

        int cur=0;
        while(k>2) ans+=b[cur++],k-=2;
        if(k==1) ans+=max(top+last,b[cur]);//只能砍一刀，当然只能看看中间最大的，和首尾两端的。
        if(k==2) ans+=max(top+b[cur],max(last+b[cur],top+last));
        //如果能给你砍两刀，你就要认真想一下，我给出来的示例
        //第一种是把中间取出来最大的，和不用花费的首位拼接。
        //第二种是把中间取出来最大的，花费+1，末尾取出来，花费+1.拼接一下。
        //第三种是把首尾拼接一下，但是这个花费虽然是1，但也可能是答案。
        printf("%d\n",ans);
    }
    return 0;
}
/*
22 2
1111101111111011111111
7 2
0101101
7 1
110111011
4 1
0010
1 0
1
*/

背包做法：

注意细节：

第一个细节：

首位为1 连通块价值为：1

末位为1 连通块价值为：1

中间为1 连通块价值为：2

第二个细节：

k++；

为什么呢？？？？？

1、大家认真想一想，其实如果首位为1，其实它是不用花费的。。。

2、然而如果首位为0,我只要中间在我们挑选的连通块中最靠近左边的。花费就会减少1.

综上所述：

K++是非常明智的。

#include<bits/stdc++.h>
using namespace std;
const int N=100500;
int n,k,a[N],b[N];
typedef struct node{
    int cost,val;
}node;
node c[N];
int main()
{
    while(~scanf("%d%d",&n,&k)){
        memset(b,0,sizeof(b));
        memset(c,0,sizeof(c));
        for(int i=1;i<=n;i++){      //输入用了点小技巧
            scanf("%1d",&a[i]);
        }
        int st=1,ed=n,top=0,last=0,cnt=0,tot=0,ans=0;
        while(a[st]&&st<=n) st++;   top=st-1;   //首先是找开头非零,1的连通块
        while(a[ed]&&st<=ed) ed--;   last=n-ed; //其次是找末尾非零,1的连通块
        while(a[st]==0&&st<=n) st++;            //然后找 中间部分 1的连通块
        while(a[ed]==0&&st<=ed) ed--;           //为了方便查找更新一下，下标
        for(int i=st;i<=ed;i++){
            if(a[i]) cnt++;
            else    b[tot++]=cnt,cnt=0;
        }
        if(a[ed]==1){                           //小细节要注意！！！
            b[tot++]=cnt;
        }
        sort(b,b+tot,[](int x,int y){return x>y;});
        /*
            printf("ST: %d , ED : %d\n",st,ed);
            printf("top: %d  last :%d\n",top,last);
            printf("tot: %d\n",tot);
            printf("B[i]:\n");
            for(int i=0;i<tot;i++){
                printf("%d : %d\n",i+1,b[i]);
            }
        */
        if(k==0){
            printf("%d\n",top);
            continue;
        }
        int cur=0;
        if(k==1) ans+=max(top+last,b[cur]);
        else if(k==2) ans+=max(top+b[cur],max(last+b[cur],top+last));
        else{
            k++;//值得思考其实大家认真想一想可能就得出答案了。
            int dp[N]={0};
            int cnt=0;
            c[cnt++]={1,top};
            c[cnt++]={1,last};
            for(int i=0;i<tot;i++){
                c[cnt++]={2,b[i]};
            }
            for(int i=0;i<cnt;i++){
                for(int j=k;j>=c[i].cost;j--){
                    dp[j]=max(dp[j],dp[j-c[i].cost]+c[i].val);
                }
            }
            //printf("%d\n",dp[k]);
            //printf("%d %d\n",c[1].cost,c[1].val);
            ans=dp[k];
        }
        printf("%d\n",ans);
    }
    return 0;
}
/*
15 5
101111001110011
// ：10
22 5
1111101111111011111111
// : 20
7 4
0101101
// :  4
7 1
110111011
// :  3
4 1
0010
// :  1
1 0
1
// :  1
13 3
1100110001101
// :  5
*/