贪心小结 [贪心专题16题]

最新推荐文章于 2022-10-27 10:10:44 发布
最新推荐文章于 2022-10-27 10:10:44 发布
阅读量5.4k 收藏 13
点赞数 5
分类专栏： ACM_贪心 文章标签： ini n2 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acm_cxlove/article/details/7724021
版权

转载请注明出处，谢谢 http://blog.csdn.net/ACM_cxlove?viewmode=contents           by---cxlove

自己开的专题，用于集训队暑期集训。题目来源已经给出。

1001

部分背包问题。优先选取性价比高的，将单位价格进行排序，依次选取，直至满足条件。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct Node{
    int j,f;
    double p;
}a[1000];
int n,m;
bool cmp(Node n1,Node n2){
    return n1.p>n2.p;
}
int main(){
    while(scanf("%d%d",&n,&m)!=EOF&&(n!=-1&&m!=-1)){
        for(int i=0;i<m;i++){
            scanf("%d%d",&a[i].j,&a[i].f);
            a[i].p=a[i].j*1.0/a[i].f;
        }
        sort(a,a+m,cmp);
        double ans=0;
        int tmp=0;
        for(int i=0;i<m;i++){
            if(a[i].f+tmp>=n){
                if(a[i].f+tmp==n)
                    ans+=a[i].j;
                else
                    ans+=a[i].p*(n-tmp);
                break;
            }
            else{
                ans+=a[i].j;
                tmp+=a[i].f;
            }
        }
        printf("%.3f\n",ans);
    }
    return 0;
}


1002

没有交叉的区间是可以同时进行的。那么需要的次数便是某个点所经过的最大次数。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int t,n,x,y,a[205];
int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        memset(a,0,sizeof(a));
        while(n--){
            scanf("%d%d",&x,&y);
            if(x>y)
                swap(x,y);
            for(int i=(x+1)/2;i<=(y+1)/2;i++)
                a[i]++;
        }
        int ans=0;
        for(int i=1;i<=200;i++)
            ans=max(ans,a[i]);
        printf("%d\n",ans*10);
    }
    return 0;
}


1003

贪心思想，先放6*6，格子已经全部放满，然后放5*5,剩下的空间可以用来放1*1,然后放4*4，剩余的空间可以放2*2,然后放1*1,之后放3*3,同理处理完剩余空间，最后考虑2*2，1*1。

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
int a,b,c,d,e,f;
int main(){
	int u[4]={0,5,3,1};
	while(scanf("%d%d%d%d%d%d",&a,&b,&c,&d,&e,&f)&&a+b+c+d+e+f){
		int ans=d+e+f+(c+3)/4;
		int x=d*5+u[c%4];
		if(b>=x)
			ans+=(b-x+8)/9;
		int y=36*ans-36*f-25*e-16*d-9*c-4*b;
		if(a>y)
			ans+=(a-y+35)/36;
		printf("%d\n",ans);
	}
	return 0;
}


1004

不错的题目，暴力可解，但是没有意思。可以发现规律
排序之后，对于每一组相邻的差a[pos]-a[pos-1]，当i取0-（pos-1）以及j取pos-n时，i和j之间的差值必然包括a[pos]-a[pos-1]。

那么a[pos]-a[pos-1]出现的次数是i*（n-i）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int a[10000],n;
int main(){
	while(scanf("%d",&n)!=EOF){
		for(int i=0;i<n;i++)
			scanf("%d",&a[i]);
		sort(a,a+n);
		LL ans=0;
		for(int i=1;i<n;i++)
			ans+=(LL)(a[i]-a[i-1])*i*(n-i);
		printf("%I64d\n",ans*2);
	}
	return 0;

}


1005

按两个关键字从小到大排序，之后遍历。

#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct Node{
	int l,r;
}a[5000];
int n;
bool cmp(Node n1,Node n2){
	return n1.l!=n2.l?n1.l<n2.l:n1.r<n2.r;
}
int main(){
	int t;
	scanf("%d",&t);
	while(t--){
		scanf("%d",&n);
		for(int i=0;i<n;i++)
			scanf("%d%d",&a[i].l,&a[i].r);
		sort(a,a+n,cmp);
		bool flag[5000];
		memset(flag,false,sizeof(flag));
		int ans=0;
		for(int i=0;i<n;i++){
			if(flag[i])
				continue;
			int L=a[i].l,R=a[i].r;
			ans++;
			for(int j=i;j<n;j++)
				if(a[j].l>=L&&a[j].r>=R&&flag[j]==false){
					L=a[j].l;
					R=a[j].r;
					flag[j]=true;
				}
		}
		printf("%d\n",ans);
	}
	return 0;
}


1006

每个人手中有m张牌，有n个人，牌上的数字分别为1-n*m,互不相等。

赢的最少情况肯定是自己出大的，别人有大的，肯定压，否则别人出最小的。

每次选取最大的牌出，如果别人有大牌，则输，否则别人出最小的。不需要模拟，从大到小遍历一次。如果某张牌我有，说明我可以赢，+1，如果没有，说明别人可以比我大一次，-1。

#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int a[1005],n,m,k,cas=0;
bool flag[1005];
int main(){
	while(scanf("%d%d",&n,&m)!=EOF&&n+m){
		memset(flag,false,sizeof(flag));
		for(int i=0;i<m;i++){
			scanf("%d",&k);
			flag[k]=true;
		}
		int ans=0,tmp=0;
		for(int i=n*m;i>0;i--)
			if(flag[i]){
				tmp++;
				ans=max(ans,tmp);
			}
			else
				tmp--;
		printf("Case %d: %d\n",++cas,ans);
	}
	return 0;
}


1007

离散化所有带宽。

枚举带宽，作为最小的带宽。然后在每一组选取满足最小带宽，而且价格最低的。

所以对于每一组按价格递增排序。优先考虑价格低的。

#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct Node{
    int b,p;
}a[400][400];
int t,m[400],B[160000],cnt,n;
bool cmp(Node n1,Node n2){
    return n1.p<n2.p;
}
int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        cnt=0;
        for(int i=0;i<n;i++){
            scanf("%d",&m[i]);
            for(int j=0;j<m[i];j++){
                scanf("%d%d",&a[i][j].b,&a[i][j].p);
                B[cnt++]=a[i][j].b;
            }
            sort(a[i],a[i]+m[i],cmp);
        }
        sort(B,B+cnt);
        int CNT=1;
        for(int i=1;i<cnt;i++)
            if(B[i]!=B[CNT-1])
                B[CNT++]=B[i];
        double ans=0;
        for(int k=0;k<CNT;k++){
            int ptmp=0,flag=1;
            for(int i=0;i<n;i++){
                int j;
                for(j=0;j<m[i];j++)
                    if(a[i][j].b>=B[k])
                        break;
                if(j==m[i]){
                    flag=0;
                    break;
                }
                ptmp+=a[i][j].p;
            }
            if(flag)
                ans=max(ans,B[k]*1.0/ptmp);
        }
        printf("%.3f\n",ans);
    }
    return 0;
}


1008

骑车去上学。时间为负的车子不用考虑，因为要不是追不上，要么追上也不是最快的。然后求出每辆车的所需时间，求出最小值。

#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct Node {
    int v,t,need;
}a[10000];
int n;
int main(){
    while(scanf("%d",&n)!=EOF&&n){
        for(int i=0;i<n;i++)
            scanf("%d%d",&a[i].v,&a[i].t);
        for(int i=0;i<n;i++){
            if(a[i].t<0)
                a[i].need=inf;
            else{
                a[i].need=(int)((4500*3.6)/a[i].v+a[i].t);
                if((int)(4500*3.6)%a[i].v)
                    a[i].need++;
            }
        }
        int ans=a[0].need;
        for(int i=1;i<n;i++)
            ans=min(ans,a[i].need);
        printf("%d\n",ans);
    }
    return 0;
}


1009

同样的根据价值递减排序，先满足价值高的先做，日期尽可能靠后。

#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct Node{
	int d,p;
}a[1000];
bool cmp(Node n1,Node n2){
	return n1.p>n2.p;
}
int n,t;
int main(){
	scanf("%d",&t);
	while(t--){
		scanf("%d",&n);
		for(int i=0;i<n;i++)
			scanf("%d",&a[i].d);
		for(int i=0;i<n;i++)
			scanf("%d",&a[i].p);
		sort(a,a+n,cmp);
		int ans=0;
		bool flag[10000];
		memset(flag,false,sizeof(flag));
		for(int i=0;i<n;i++){
			int j;
			for(j=a[i].d;j>=1;j--)
				if(flag[j]==false){
					flag[j]=true;
					break;
				}
			if(j==0)
				ans+=a[i].p;
		}
		printf("%d\n",ans);
	}
	return 0;
}


1010

按结束时间排序，然后依次遍历。

#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct Node{
    int l,r;
}a[100];
int n;
bool cmp(Node n1,Node n2){
    return n1.r!=n2.r?n1.r<n2.r:n1.l>n2.l;
}
int main(){
    while(scanf("%d",&n)!=EOF&&n){
        for(int i=0;i<n;i++)
            scanf("%d%d",&a[i].l,&a[i].r);
        sort(a,a+n,cmp);
        int ans=1,k=0;
        for(int i=1;i<n;i++)
            if(a[i].l>=a[k].r){
                ans++;
                k=i;
            }
        printf("%d\n",ans);
    }
    return 0;
}


1011

贪心，每次优先选取价值高的，而且尽量时间靠后的。用flag数组标记，某天是否已经被利用，如果已经被利用，则往前遍历。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct Node{
	int p,d;
}a[10000];
bool cmp(Node n1,Node n2){
	return n1.p>n2.p;
}
int n;
int main(){
	while(scanf("%d",&n)!=EOF){
		for(int i=0;i<n;i++)
			scanf("%d%d",&a[i].p,&a[i].d);
		sort(a,a+n,cmp);
		int ans=0;
		bool flag[10005];
		memset(flag,false,sizeof(flag));
		for(int i=0;i<n;i++)
			for(int t=a[i].d;t>0;t--)
				if(flag[t]==false){
					ans+=a[i].p;
					flag[t]=true;
					break;
				}		
		printf("%d\n",ans);
	}
	return 0;
}


1012

对于每一个岛，存在一个区间，区间内任意位置建的雷达都能覆盖岛屿。这样就形成若干个区间。对于每一个区间从左到右遍历，尽可能选取最右端点，这样就能满足最多的区间。可以处理掉子区间。或者在遍历的时候遇到子区间，就尽可能取子区间的右端点。

#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct Node{
    double l,r;
}a[1000];
int n,d;
bool cmp(Node n1,Node n2){
    return n1.l<n2.l;
}
int main(){
    int cas=0;
    while(scanf("%d%d",&n,&d)!=EOF&&n+d){
        bool flag=true;
        for(int i=0;i<n;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            if(abs(y)>d)
                flag=false;
            if(!flag)
                continue;
            a[i].l=x-sqrt((double)d*d-y*y);
            a[i].r=x+sqrt((double)d*d-y*y);
        }
        if(!flag){
            printf("Case %d: -1\n",++cas);
            continue;
        }
        sort(a,a+n,cmp);
        int ans=1;
        double pos=a[0].r;
        for(int i=1;i<n;i++)
            if(a[i].l>pos){
                pos=a[i].r;
                ans++;
            }
            else if(a[i].r<pos)
                pos=a[i].r;
        printf("Case %d: %d\n",++cas,ans);
    }
    return 0;
}

 

1013

对于每一个池塘，从左到右依次放木板。

#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,d;
struct Node{
    int l,r;
}a[10000];
bool cmp(Node n1,Node n2){
    return n1.l<n2.l;
}
int main(){
    while(scanf("%d%d",&n,&d)!=EOF){
        for(int i=0;i<n;i++)
            scanf("%d%d",&a[i].l,&a[i].r);
        sort(a,a+n,cmp);
        int ans=0,pos=-inf;
        for(int i=0;i<n;i++){
            if(a[i].l>pos){
                ans+=(a[i].r-a[i].l+d-1)/d;
                pos=(a[i].r-a[i].l+d-1)/d*d+a[i].l;
            }
            else if(a[i].r>pos){
                ans+=(a[i].r-pos+d-1)/d;
                pos=(a[i].r-pos+d-1)/d*d+pos;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}


1014

黑书上的例题。首先枚举走过的湖泊数X，则从1走到X，路上花的时间可以算出。每一次选一个鱼最多的湖泊钓鱼，对于每个湖泊来说，由于 在任何时候鱼的数目只和在这个湖泊里钓鱼的次数有关，和总次数无关。所以这样是最优的。

#include<iostream> 
#include<cstdio> 
#include<cstring> 
using namespace std; 
int main() 
{ 
    int n,h,f[30],d[30],t[30],Case=0; 
    while(scanf("%d",&n),n>0) 
    { 
        if(Case!=0)  printf("\n"); 
        Case++; 
        scanf("%d",&h); 
        h=h*60; 
        for(int i=1;i<=n;i++) 
            scanf("%d",&f[i]); 
        for(int i=1;i<=n;i++) 
            scanf("%d",&d[i]); 
        t[1]=0; 
        for(int i=1;i<=n-1;i++) 
        { 
            int a; 
            scanf("%d",&a); 
            t[i+1]=t[i]+a*5; 
        } 
        int fish=0; 
        int f_temp[30]; 
        int spe[30]; 
        int spe_temp[30]; 
        int tt; 
        for(int i=1;i<=n;i++) 
            spe[i]=-1; 
      
        for(int i=1;i<=n;i++) 
        { 
            int sum=0; 
            tt=h-t[i]; 
            for(int j=1;j<=n;j++) 
                f_temp[j]=f[j]; 
            memset(spe_temp,0,sizeof(spe_temp)); 
            while(tt>=5) 
            { 
                int mmax=0,maxj=-1; 
                for(int j=1;j<=i;j++) 
                { 
                    if(f_temp[j]>mmax) 
                    { 
                        mmax=f_temp[j]; 
                        maxj=j; 
                    } 
                } 
                if(maxj==-1) 
                    break; 
                    tt=tt-5; 
                spe_temp[maxj]++; 
                sum+=f_temp[maxj]; 
                f_temp[maxj]=f_temp[maxj]-d[maxj]; 
            } 
            if(sum>fish) 
            { 
                fish=sum; 
                for(int j=1;j<=n;j++) 
                    spe[j]=spe_temp[j]; 
                spe[1]+=tt/5; 
            } 
            else if(sum==fish) 
            { 
                bool flag=false; 
                for(int j=1;j<=n;j++) 
                    if(spe[j]<spe_temp[j]) 
                    { 
                        flag=true; 
                        break; 
                    } 
                    else if(spe[j]>spe_temp[j]) 
                        break; 
                if(flag) 
                { 
                    fish=sum; 
                    for(int j=1;j<=n;j++) 
                        spe[j]=spe_temp[j]; 
                    spe[1]+=tt/5; 
                } 
            } 
        } 
        for(int i=1;i<n;i++) 
            printf("%d, ",spe[i]*5); 
        printf("%d\nNumber of fish expected: %d\n",spe[n]*5,fish); 
    } 
    return 0; 
}


1015

经典贪心，详见http://blog.csdn.net/acm_cxlove/article/details/7720218

 

1016

肯定所有的物品都要买，依次选取价值高的物品，这样打折的物品价格也高

#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int t,n,a[20000];
int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        for(int i=0;i<n;i++)
            scanf("%d",&a[i]);
        sort(a,a+n);
        int ans=0;
        for(int i=n-3;i>=0;i-=3)
            ans+=a[i];
        printf("%d\n",ans);
    }
    return 0;
}


 

ACM_cxlove
关注
  • 5
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Python贪心算法实例小结
01-20
本文实例讲述了Python贪心算法。分享给大家供大家参考，具体如下： 1. 找零钱问题：假设只有 1 分、 2 分、五分、 1 角、二角、 五角、 1元的硬币。在超市结账 时，如果 需要找零钱， 收银员希望将最少的硬币数找给...
贪心经典例题
m0_61409183的博客
05-31 527
目录148. 合并果子（Huffman树）913. 排队打水 （排序不等式）104. 货仓选址 （绝对值不等式）125. 耍杂技的牛 （推公式）在一个果园里，达达已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。达达决定把所有的果子合成一堆。每一次合并，达达可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过 n−1 次合并之后，就只剩下 1 堆了。达达在合并果子时总共消耗的体力等于每次合并所耗体力之和。因为还要花大力气把这些果子搬回家，所以达达在合并果子时要尽可
算法提高：贪心策略的11个经典题目
阿呆的隐秘角落
10-27 5754
算法成神之路：11个经典贪心算法
【刷题日记】贪心算法经典题目
白晨的博客
02-17 4578
????大家好，我是白晨，一个不是很能熬夜????，但是也想日更的人✈。如果喜欢这篇文章，点个赞????，关注一下????白晨吧！你的支持就是我最大的动力！???????????? 文章目录????前言????贪心算法经典题目????1.分割平衡字符串????2.买卖股票的最佳时机????3.跳跃游戏????4.多机调度问题????5.活动选择????6.最多可以参加的会议数目????7.无重叠区间????总结 ????前言 观前提示：此文章需要一定贪心算法的基础。 大家好呀，我是白晨????。 贪心算
贪心问题求解思路（总结）
刘小雨的博客
10-01 1047
贪心问题： 局部最优解， 需证明该解就是该题的最优解无其他情况，则能直接用贪心法。典型例题： 部分背包问题， 直接用贪心法求的解即最优解，；而0-1背包问题额不能用贪心法去求最优解。 下面给出几道贪心的典型例题，在知道思路的情况，可遇到题目则以不变应万变去求解。 例题1 ： 区间选点 给定N个闭区间[ai,bi]，请你在数轴上选择尽量少的点，使得每个区间内至少包含一个选出的点。 输出选择的点的最小数量。 位于区间端点上的点也算作区间内。 输入格式 第一行包含整数N，表示区间数。 接下来N行，每行包含两.
贪心算法典型例题
bajin7353的博客
06-17 3万+
贪心是算法中一种特别基础和重要的思想，下面从几个例题中开始讲解贪心的思想。 1. 分糖果(leetcode455) 题目：已知一些孩子和一些糖果，每个孩子有需求因子g，每个糖果有大小s，当某个糖果的大小s&amp;amp;amp;gt;=某个孩子的需求因子g时，代表该糖果可以满足该孩子，求使用这些糖果，最多能满足多少孩子（注意，某个孩子最多只能用1个糖果满足） 思考： 当某个孩子可以被多个糖果满足时，是否需要...
matlab代码：使用贪心算法求解最小支配集
07-03
matlab代码：使用贪心算法求解最小支配集 详情参见文章https://blog.csdn.net/C_1024/article/details/125582995
贪心算法_小北1
08-03
1. 贪心 2. 二分 3. 前缀和和差分 4. 单调队列/单调栈 5. 分治 6. 倍增
信息学奥赛基础算法之贪心算法测试题
最新发布
01-18
信息学奥赛基础算法之贪心算法测试题
贪心算法例题
xiaobaidad的博客
12-28 2974
贪心算法经典例题解析 贪心法：遵循某种规律，不断贪心的选取当前最优策略的算法设计方法。 例一：分糖果 已知一些孩子和一些糖果，每个孩子有需求因子g，每个糖果有大小s，当某个糖果的大小s >= 某个孩子的需求因子g时，代表该糖果可以满足该孩子；求使用这些糖果，最多能满足多少孩子？(注意，某个孩子最多只能用1个糖果满足)例如，需求因子数组g = [5, 10, 2, 9, 15, 9]；糖果大小数组s = [6, 1, 20, 3, 8]；最多可以满足3个孩子 思考：　　 1、当某个孩子可以被多个糖果
贪心算法经典例题.doc
12-25
贪心算法经典例题.doc贪心算法经典例题.doc贪心算法经典例题.doc贪心算法经典例题.doc贪心算法经典例题.doc贪心算法经典例题.doc贪心算法经典例题.doc
贪心算法总结
Summer_night_star的博客
04-12 4532
一 基本思想     贪心算法总是作出在当前看来最好的选择。即贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择，不一定达到全局最优。     当一个问题动具有最优子结构性质时,可用动态规划算法求解，但有时贪心算法会更简单有效。如下图所示例题，贪心所得的局部最优就是全局最优。     贪心算法解题简单、有效，利用了问题本身的特性。但它有时并不能从局部的最优得到整体的最优。如下图所示例题，贪心所得的局部最优并非全局最优。     虽然贪心算法不是对所有问题都能从局部得到整体的最优解，但它
贪心算法的几种经典例题
热门推荐
马一凡的博客
12-18 5万+
什么是贪心算法 贪心算法是一种在解决问题的过程中追求局部最优的算法，对于一个有多种属性的事物来说，贪心算法会优先满足某种条件，追求局部最优的同时希望达到整体最优的效果。以背包问题为例，可以放在背包中的物体有它的重量和价值两种属性，背包的容量也是有限的，我们希望得到一种价值最大的物品摆放方式，如果我们倾向于重量贪心，那么在摆放物品的时候会优先放重量小的，但这和我们追求的价值最优没有关系，自然不能采用...
贪心类题目专题训练 -- LeetCode上10道与贪心相关的题
今天你学习了吗？
02-21 868
这个专题中的题目是我跟随代码随想录的刷题计划，在LeetCode上做的与贪心相关的题目，用于加深对贪心的理解！ 下面的内容将会有每一道题目的题意、在代码随想录中对应的参考文章、我的思路以及我所写的Java代码，希望对你有帮助！ 目录1 - LeetCode 455 分发饼干 1 - LeetCode 455 分发饼干 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/assign-cookies 题意： 假设你是一位很棒的家长，想要给你的孩子们一些小饼
贪心算法及其经典例题
追梦少年ML的博客
04-04 2443
有一类问题，它有n个输入，而它的解就是这n个解的某个子集，这些子集必须满足某些先给定的条件。 贪心方法是指在对问题求解时，总是做出在当前看来是最好的选择。 ...
贪心专题
Black__wing的博客
08-17 390
贪心，由局部最优，最终推导出，全部最优。 例题： loj 10003： 每个工作i有两部分组成，第一部分在a中完成，ai，第二部分在b中完成，bi。所有工作需要先完成a再完成b因此，我们要让a时间小的先完成a，然后去完成b，让b时间大的先完成b（也就是说它也要先完成a），这样工作等待时间最少。 那我们怎么选择，a，b的大的跟小的问题呢？ 我们开辟一个空间m放，ai与bi的最小值，如果mi...
贪心思想及例题
weixin_46438976的博客
01-14 1877
贪心（greedy)思想：一个问题拆解成多个步骤，每个步骤采用最优的解法（叫局部最优），不考虑对别的步骤的影响。 最少硬币问题： 题目描述：某人带着3种面值的硬币去购物，有1元、2元、5元的，硬币数量不限；他需要支付M元，问怎么支付，才能使硬币数量最少？ 思路：根据生活常识，第一步应该先拿出面值最大的5​ 元硬币，第二步拿出面值第二大的2​ 元硬币，最后才拿出面值最小的1​ 元硬币。在这个解决方案中，硬币数量总数是最少的。 #include<bits/stdc++.h> usi...
贪心专题（例题）
月殇
12-05 772
目录 线段（最大不相交区间数问题） 活动安排3（最大不相交区间数问题） 种树 喷水装置3（区间完全覆盖问题）                                                               线段 时间限制: 1 Sec  内存限制: 128 MB 提交: 27  解决: 10 [提交] [状态] [讨论版] [命题人:admin] 题目描...
LeetCode贪心经典题目（一）
CodePanda@GPF的博客
05-29 206
LeetCode贪心算法题（一）
贪心动态规划算法实验小结
05-29
好的，我会为您总结一下贪心动态规划算法实验的小结。 在贪心算法方面，实验中我们学习了贪心算法的基本思想和应用场景，如找零钱问题、区间覆盖问题等。通过实际编程实现，我们加深了对贪心算法的理解和掌握。 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值