算法（六）贪心

最新推荐文章于 2022-11-16 07:52:09 发布
最新推荐文章于 2022-11-16 07:52:09 发布
阅读量817 收藏 3
点赞数
分类专栏： 算法 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44788545/article/details/107577016
版权

一、概述

1、概念

在每个决策点作出在当时看来最佳的选择，即总是遵循某种规则，做出局部最优的选择，以推导出全局最优解（局部最优解->全局最优解）

2、适用条件

  • 贪心选择性质：所求问题的整体最优解，可以通过一系列局部最优的选择（贪心选择）来达到。
    • 贪心选择可以依赖以往所做过的选择，但绝不依赖于将来所作的选择，也不依赖于子问题的解（所以叫贪心**，只看眼前，不管未来），是贪心法和动态规划法的主要区别**
    • 贪心算法通常以自顶向下的方式进行，不断迭代多出贪心选择，每做一次贪心选择就将问题简化为规模更小的问题。从全局来看，贪心法解决问题的过程中没有回溯过程。（动态规划算法通常是以底向上的方式）
  • 最优子结构性质：原问题包含了其子问题的最优解

3、解题思路

  1. 建立数学模型来描述最优化问题；
  2. 把求解的最优化问题转化为这样的形式：对其做出一次选择后，只剩下一个子问题需要求解；
  3. 证明做出贪心选择后：
    • 原问题总是存在全局最优解，即贪心选择始终安全；
    • 剩余子问题的局部最优解与贪心选择组合，即可得到原问题的全局最优解。

4、技巧

贪心算法解决的正确性虽然很多时候看起来是显而易见的，但是要严谨地证明算法能够得到最优解，并不是件容易的事。所以，很多时候，我们只需要多举几个例子，看一下贪心算法的解决方案是否真的能得到最优解就可以了。

简单的题多用排序

二、综合实例

1、简单排序

几道例题

https://www.luogu.com.cn/problem/P2945

https://www.luogu.com.cn/problem/P5602

1、排队打水问题

每个人的花费时间=每个人装满水桶的时间+等待时间。

显然越小的排在越前面（先接水）得出的结果越小

https://blog.csdn.net/ds19980228/article/details/82714478?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
int main() {

	int a[1000],b[0100],n,r;
	scanf("%d%d",&n,&r);
	int i,sum=0;
	int temp;
	for(i=0; i<n; i++)
		scanf("%d",&a[i]);
		sort(a,a+n);
    //r个水龙头，分队
    for(i=0; i<r; i++)
    {
        temp = 0;
        //计算每队时间，越小的越先接水
		for(int j=i;j<n;j = j + r)
        {
            temp += a[j];
            sum += temp;
        }
    }
    printf("%d\n",sum);
}

2、排队接水！

https://www.luogu.com.cn/problem/P1223

涉及到了多属性排序：重写Arrays.sort()方法

import java.io.*;
import java.util.*;

//外部类
class Person {
    int index;
    int time;
}

public class Main {
	
	public static void main(String[] args) throws IOException {	
	    StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	    in.nextToken();
	    int n = (int)in.nval;
	    Person[] people = new Person[n];
        for (int i = 0; i < n; i++) {
            //记得创建对象！
            people[i] = new Person();
            people[i].index = i + 1;
            in.nextToken();
            people[i].time = (int)in.nval;
        }
        //重写，这里是重小到大
	    Arrays.sort(people, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                if(o1.time == o2.time) return o1.index - o2.index;
                else return o1.time - o2.time;
            }
        });
        
	    long sum = 0;
	    long t = 0;
	    for(int i = 0;i < n;i++) {
	    	out.print(people[i].index);
	    	if(i != n - 1) {
	    		out.print(" ");
	    	}
	    	sum += t;
	    	t += people[i].time;
	    }
	    out.println();
	    out.printf("%.2f",(sum * 1.0)/n);
	    out.close();
	}
	
}

2、均分纸牌（NOIP2002）

https://blog.csdn.net/ds19980228/article/details/82714478?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

1.如果你想到把每堆牌的张数减去平均张数，题目就变成移动正数，加到负数中，使大家都变成0

2.正数可移，故负数也可移

#include <stdio.h>
int n;
int a[105];
int main()
{
    int i,j;
    int aver = 0,step=0;  //aver记录每堆纸牌的平均值 step记录移动次数
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
        aver+=a[i];
    }
    aver/=n;
    for(i=0;i<n;i++)
        a[i]-=aver;
    i=0,j=n-1;
    while(i<j)
    {
        if(a[i] != 0){
		a[i+1]+=a[i];   //将第i堆纸牌移到第i+1堆上
		a[i]=0;         //第i堆牌移走后变为0
		step++;
        }
        i++;
    }
    printf("%d\n",step);
    return 0;
}

3、Saruman’s Army（标记点问题）

#include <iostream>  
#include <cstdio>  
#include <algorithm>  
using namespace std;  
int N,R;  
int ans=0;       //标记数   
int point[1010];   
int main()  
{  
    int i,s,p;  
    scanf("%d",&N);  
    scanf("%d",&R);  
    for(i=0;i<N;i++)  
        scanf("%d",&point[i]);  
    sort(point,point+N);//预先对点按位置排序   
    i=0;  
    while(i<N)  
    {  
        s=point[i];   //s是没有被覆盖的最左的点的位置  
        while(i<N && point[i]<=s+R)  //一直向右前进直到第一个距s的距离大于R的点   
            i++;   
        p=point[i-1];   //p是新加上标记的点的位置  
        while(i<N && point[i]<=p+R)  //一直向右前进直到第一个距p的距离大于R的点，方便继续循环   
            i++;  
        ans++;   
    }   
    printf("%d\n",ans);  
    return 0;  
}

4、Sleepy Cow Herding S？？

https://www.luogu.com.cn/problem/P5541

三、背包问题

1、最优装载问题

有n个物体，第i个物体的重量为wi（wi为正整数）。选择尽量多的物体，使得总重量不超过C。

**优先取重量小的物体。**对n个物体按重量递增排序，依次选择每个物体直到装不下为止。

有时考虑条件可能需要转换后得出https://www.luogu.com.cn/problem/P2616

2、部分背包（分数背包）问题

有n个物体，第i个物体的重量为wi，价值为vi（wi, vi均为正整数）。在总重量不超过C的情况下让总价值尽量高。每一个物体都可以只取走一部分，价值和重量按比例计算。

优先取性价比高的物体。

四、区间问题

（一）不相交区间选择问题

1、概念

又称【区间调度问题】

2、解题思路

（1）构造区间

（2）右递增

（3）遍历取左侧大于等于当前最右侧的区间

3、例题
（1）工作选择

参与尽可能多的工作，如果选择了参与，那么自始至终都必须全程参与。此外，参与工作的时间段不能重叠

方法：在可选的工作中，每次都选取结束时间最早的工作（b递增）

https://blog.csdn.net/ds19980228/article/details/82714478?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

#include <iostream>  
#include <cstdio>  
#include <algorithm>  
using namespace std;  
const int maxn=100005;  
int N;  
int ans=0;  
struct Work   //定义工作   
{  
    int s;    //开始时间   
    int t;    //结束时间   
} w[maxn];  
bool cmp(struct Work w1,struct Work w2)  //按工作结束时间递增排序   
{  
    return (w1.t<w2.t);  
}  
int main()  
{  
    int i,j;  
    int end;  //end记录最后所选活动的结束时间  
    scanf("%d",&N);  
    for(i=0;i<N;i++)  
        scanf("%d %d",&w[i].s,&w[i].t);  
    sort(w,w+N,cmp);  
    j=ans=0;  
    end=0;  
    for(j=0;j<N;j++)  
    {  
        if(w[j].s>end)  //若发现某项工作的开始时间比end晚   
        {  
            ans++;      //则选择当前工作   
            end=w[j].t; //将这项工作的结束时间作为end   
        }  
    }  
    printf("%d\n",ans);  
    return 0;  
}
（2）会场安排

https://www.cnblogs.com/acgoto/p/9824723.html

（二）区间选点问题

1、概念
2、解题思路

（1）构造区间

（1）先右递增，再左递减

（2）取未覆盖的第一个区间的最右点。

如下图，如果选灰色点，移动到黑色点更优。

img

https://blog.csdn.net/ds19980228/article/details/82714478?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

3、例题
（1）找点
#include <iostream>  
#include <cstdio>  
#include <algorithm>  
#define maxn 10010  
using namespace std;  
int n;  
int ans;      //最少区间数量   
struct Seg    //定义区间   
{  
    int a;  
    int b;  
} s[maxn];  
bool cmp(struct Seg s1,struct Seg s2)  //自定义排序规则   
{  
    if(s1.b!=s2.b)  
        return (s1.b<s2.b);  
    else  
        return (s1.a>s2.a);  
}  
int main()  
{  
    int i,loc;   //loc记录当前选择的区间终点   
    scanf("%d",&n);  
    for(i=0;i<n;i++)  
        scanf("%d %d",&s[i].a,&s[i].b);  
    sort(s,s+n,cmp);  
    ans=1;       //排序完成后，选一个点，位置在第一个区间的终点   
    loc=s[0].b;  
    for(i=1;i<n;i++)    //遍历后续区间   
    {  
        if(s[i].a>loc)  //若发现后面有区间的起点比loc大   
        {  
            ans++;      //则应再选一个点   
            loc=s[i].b; //并修改loc为新区间的终点   
        }  
    }  
    printf("%d\n",ans);  
    return 0;  
}
（2）Radar Installation

（三）区间覆盖问题

1、概念

给定一个长度为m的区间**（连续的）**，再给出n条线段的起点和终点（注意这里是闭区间），求最少使用多少条线段可以将整个区间完全覆盖。（给定一条指定的线段[s,t]，数轴上有n个闭区间[ai,bi]，求最少使用多少区间可以覆盖整条线段。）

2、解题思路

（1）构造区间

（2）先左递增，再右递增

（2）设置一个变量表示已覆盖到的区间右端点，在剩下的线段中找出所有左端点小于等于当前已覆盖到的区间右端点的线段（使区间连续），选择右端点最大并且大于当前已覆盖到的区间右端点（否则题目无解），重复以上操作直至覆盖整个区间；

3、例题
（1）NYOJ #12 喷水装置（二）

https://www.cnblogs.com/acgoto/p/9824723.html

#include<bits/stdc++.h>
using namespace std;
const int maxn=10005;
int t,n,k,cnt,pos,beg;double w,h,lb,xi,ri,maxv;pair<double,double> itv[maxn];bool flag;
int main(){
    while(cin>>t){
        while(t--){
            cin>>n>>w>>h;h/=2.0;pos=cnt=0;//h取一半
            //构造得到“n条线段的起点和终点”！！！
            for(int i=0;i<n;++i){
                cin>>xi>>ri;
                //ri<h的圆不可能做到全覆盖，舍去！
                if(ri<h)continue;
                //计算该圆能完全覆盖的部分！
                itv[pos].first=xi-sqrt(ri*ri-h*h);
                itv[pos++].second=xi+sqrt(ri*ri-h*h);
            }
            //（1）排序
            sort(itv,itv+pos);lb=0;beg=0;flag=false;
            //最左端点不能从起始开始，无方案
            if(itv[0].first>0){cout<<0<<endl;continue;}
            //有方案
            while(lb<w){
                maxv=0;
                //itv[k].first<=lb这样保证整个区间是连续的，即草坪都会被润湿
                for(k=beg;k<pos&&itv[k].first<=lb;++k)
                    //（2）找线段左端点在lb以内右端点能覆盖到的最远距离
                    maxv=max(maxv,itv[k].second);
                //能到达的最右端大于当前已覆盖到的区间右端点
                if(maxv>lb)cnt++,lb=maxv；//beg=k;不用吧
                //否则说明不能覆盖整个区间，直接退出，输出0
                else {flag=true;break;}
            }
            if(flag)cout<<0<<endl;
            else cout<<cnt<<endl;
        }
    }
    return 0;
}

（四）其他

（1）铺设道路

每次可选一段区间进行操作

https://www.luogu.com.cn/problem/P5019

类似的还有https://www.luogu.com.cn/problem/P1969 https://www.luogu.com.cn/problem/P3078

import java.io.*;
import java.util.*;

public class Main {
	
	public static void main(String[] args) throws IOException {	
	    StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	    int result = 0;
	    in.nextToken();
	    int n = (int)in.nval;
	    int[] s = new int[n];
	    for(int i = 0;i < n;i++) {
	    	in.nextToken();
	    	s[i] = (int)in.nval;
	    }
	    for(int i = 1;i < n;i++) {
	    	if(s[i] > s[i - 1]) {
	    		result += s[i] - s[i - 1];
	    	}
	    }
	    out.print(result + s[0]);
	    out.close();
	}
	
}
（2）泥泞路

区间覆盖（所要覆盖的大区间是分散的……）

import java.io.*;
import java.util.*;

class Node{
	int a;
	int b;
}

public class Main {
	
	public static void main(String[] args) throws IOException {	
	    StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	    in.nextToken();
	    int n = (int)in.nval;
	    in.nextToken();
	    int l = (int)in.nval;
	    Node[] s = new Node[n];
	    for(int i = 0;i < n;i++) {
	    	s[i] = new Node();
	    	in.nextToken();
	    	s[i].a = (int)in.nval;
	    	in.nextToken();
	    	s[i].b = (int)in.nval;
	    }
	    Arrays.sort(s,new Comparator<Node>() {
			@Override
			public int compare(Node n1, Node n2) {
				// TODO Auto-generated method stub
				return n1.a - n2.a;
			}
	    });
	    int start = s[0].a,result = 0;
	    for(int i = 0;i < n;i++) {
	    	start = Math.max(start,s[i].a);
	    	while(start < s[i].b) {
	    		start += l;
	    		result++;
	    	}
	    }
	    out.print(result);
	    out.close();
	}
	
}
（3）鸿山洞的灯

每段距离小于dist的中间点去掉

import java.io.*;
import java.util.*;


public class Main {
	
	public static void main(String[] args) throws IOException {	
	    StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	    in.nextToken();
	    int n = (int)in.nval;
	    in.nextToken();
	    int dist = (int)in.nval;
	    int[] s = new int[n];
	    for(int i = 0;i < n;i++) {
	    	in.nextToken();
	    	s[i] = (int)in.nval;
	    }
	    Arrays.sort(s);
	    int result = 0;
        //对中间的点进行判断，看是否用除去
	    for(int i = 1;i < n - 1;i++) {
	    	if(s[i + 1] - s[i - 1] <= dist) {
                //除去该点，并使前面的点后移以便后续计算
	    		s[i] = s[i - 1];
	    		result++;
	    	}
	    }
	    out.print(result);
	    out.close();
	}
	
}
（4）公路维修问题

切分段数，使距离最小：去掉相距最远的几个点距离

import java.io.*;
import java.util.*;


public class Main {
	
	public static void main(String[] args) throws IOException {	
	    StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	    in.nextToken();
	    int n = (int)in.nval;
	    in.nextToken();
	    int m = (int)in.nval;
	    int[] s = new int[n];
	    int[] j = new int[n - 1];
	    for(int i = 0;i < n;i++) {
	    	in.nextToken();
	    	s[i] = (int)in.nval;
	    }
	    for(int i = 1;i < n;i++) {
	    	j[i - 1] = s[i] - s[i - 1]; 
	    }
	    Arrays.sort(j);
        //每段距离均要加一，m段则要加上m个1
	    int result = m;
	    for(int i = 0;i < n - m ;i++) {
	    	result += j[i];
	    }
	    out.print(result);
	    out.close();
	}
	
}

五、字典序问题

1、最大整数（拼数问题）

问题：设有n个正整数（n≤20），将它们联接成一排，组成一个最大的多位整数。

方法：按字典序从大到小输出即可

（字符串排序的规则：首先按字典序，然后看串长度。如7>414321>4143>32）

<https://blog.csdn.net/ds19980228/article/details/82714478?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

#include <iostream>  
#include <algorithm>  
using namespace std;  
string num[25];       //最多25个数（字符串）   
bool cmp(string a,string b)  //字典序从大到小排序
{  
    return (a+b > b+a);   
}   
int main()  
{  
    int i,n;  
    cin>>n;  
    for(i=0;i<n;i++)  
        cin>>num[i];  
    sort(num,num+n,cmp);  
    for(i=0;i<n;i++)  
        cout<<num[i];  //直接输出即可
    cout<<endl;  
    return 0;  
}

2、删数问题

问题：一个高精度的正整数n(≤240位)，去掉其中任意s个数字后剩下的数字按原左右次序将组成一个新的正整数

方法：

  • 以字符串形式处理，按高位到低位的顺序搜索，比较相邻两位数字大小。
  • 删除第一个递减区间的首字符，若数字全部递增，则删除最后一个数字；
  • 第二步重复s次，即得到解。（这样删数问题就与如何寻找递减区间首字符这个问题对应起来了）

https://blog.csdn.net/ds19980228/article/details/82714478?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

#include <stdio.h>  
#include <string.h>  
#define maxlen 245  
char n[maxlen];  
int s;  
int main()  
{  
    int i,j,k;  
    int flag,len;    //flag记录删除的数是否是最后一位 0-是 1-不是   
    scanf("%s",n);  
    scanf("%d",&s);  
    len=strlen(n);  
    for(i=0;i<s;i++)  
    {  
        //标示是否找到递减区间
        flag=0;  
        for(j=0;j<len-1;j++)  
        {  
            if(n[j]>n[j+1])  //找到递减区间的第一个元素   
            {  
                for(k=j;k<len-1;k++) //"删除"   
                    n[k]=n[k+1];  
                len--;   //同时修改数的长度   
                flag=1;  
                break;  
            }  
        }  
        if(flag==0)  //没有找到递减区间，则去掉最后一个数
            len--;  
    }  
    for(i=0;i<len;i++)  
        printf("%c",n[i]);  
    printf("\n");  
    return 0;  
}

3、字典序最小问题

问题：构造**字典序尽可能小（小的在前）**的字符串T

方法：

  • 双指针，不断去D开头和尾部中较小的一个字符放到T的尾部
  • **针对开头和尾部字符相同的情况，我们希望能够尽早使用更小的字符，**所以就要比较下一个字符的大小。下一个字符也有可能相同。

https://blog.csdn.net/weixin_41676901/article/details/80615415

#include<iostream>
using namespace std;
#define MAX 2000
char S[MAX+1];
 int main ()
{
    int n;
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> S[i];
    int a = 0, b = n - 1;
    while (a <= b)
    {
        bool vis = false;
        
        //针对开头和尾部字符相同的情况，我们希望能够尽早使用更小的字符！！
        for (int i = 0; i + a <= b; i++)
        {
            //从字符串的头和尾作比较
            if (S[a + i] < S[b - i])
            {
                vis = true;
                break;
            }
            if (S[a + i] > S[b - i])
            {
                vis = false;
                break;
            }
        }
        
        if (vis)
            cout << S[a++];
        else
            cout << S[b--];
    }
    cout << endl;
    return 0;
    
}

六、哈夫曼编码思想

https://blog.csdn.net/every__day/article/details/87252852

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wyLziFXk-1595651515299)(C:\Users\ddjj6\AppData\Roaming\Typora\typora-user-images\1582469479796.png)]

我们每个字符看作一个节点，并且附带把频率放到**优先级队列（频率从小到大，左边出队，取两最小的）**中。我们从队列中取出频率最小的两个节点A、B，然后新那一个节点C，把频率设置为两个节点的频率之和，并把这个新节点C作为节点A、B的父节点。最后两把C节点放到优先级队列中。重复这个过程，直到队列中只剩一个数据（这个结果往往是要求的最小解）。

逻辑上：哈夫曼树 实际操作：优先队列

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0gwPkE6j-1595651515307)(C:\Users\ddjj6\AppData\Roaming\Typora\typora-user-images\1582469551030.png)]

现在，给每一条边画一个权值，指向左子节点的边我们统统标记为0，指向右子节点的过，我们统统标记为1，那从根节点到叶子节点的路径就是叶子节点对应字符的霍夫曼编码。

1、贪心 哈夫曼思想

这里每次取两最大的处理后再放回去，最后队列剩下的最后元素就是最小的

https://blog.csdn.net/jianglw1/article/details/83037103

#include <stdio.h>
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <string>
#include <cstring>
#include <algorithm>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <ctime>
#include <vector>
#include <fstream>
#include <list>
#include <iomanip>
#include <numeric>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
priority_queue<double,vector<double>,less<double> >w; //优先队列
int main() 
{
	int n;
	double tmp;
	cin>>n;
    //输入并入队
	while(n--){
		scanf("%lf",&tmp);
		w.push(tmp);
	}
	double a,b;
    //结点合并并入队，最后队中剩下的为结果
	while(w.size()>1){
		a=w.top();
		w.pop();
		b=w.top();
		w.pop();
        //新结点入队
		w.push(2.0*sqrt(a*b));
	}
	//cout.precision(3);//
	//cout<<w.top()<<endl;//
	printf("%.3f\n",w.top());//输出方式
    return 0;
}

2、FZU 2219 StarCraft？？？

森林？

https://blog.csdn.net/Mr_Treeeee/article/details/80255022?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <queue>
using namespace std;
const int maxn = 100000+23;
 
priority_queue<int,vector<int>,greater<int> > q;
 
int main()
{
	int T;
	scanf("%d",&T);
	while(T--){
		int n,m,k;
		scanf("%d%d%d",&n,&m,&k);
        //输入并入队
		for(int i=1;i<=n;i++){
			int x;scanf("%d",&x);
			q.push(x);
		}	
        //结点合并并入队
		while(n>m){
			q.pop();
			int a=q.top();
			q.pop();
			q.push(a+k);
			n--;
		}
		while(q.size()!=1) q.pop();
		printf("%d\n",q.top());
	}
}
block2333
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法设计与分析——贪心算法——单个出水口打水问题
qq_50675813的博客
05-25 388
1.打水问题：有n个人去水房排队打水，只有一个出水口，且出水口流速恒定。每个人因为盛水的工具不一，打水所需的时间也不一致，设第i个人所需要的打水时间为ti；问如何安排打水顺序使得所有人的平均等待时间最短。 #include<iostream> #include<bits/stdc++.h> using namespace std; typedef struct Node { int i; int time; }node; bool cmp(node x,node y) {
打水问题（贪心算法）
善良的小乔的博客
10-03 1009
贪心算法
排队打水问题（贪心）
eRunn
03-07 6743
算法提高 排队打水问题 时间限制：1.0s 内存限制：256.0MB 问题描述 　　有n个人排队到r个水龙头去打水，他们装满水桶的时间t1、t2………..tn为整数且各不相等，应如何安排他们的打水顺序才能使他们总共花费的时间最少？ 输入格式 　　第一行n，r (n<=500,r<=75) 　　第二行为n个人打水所用的时间Ti (Ti<=100)； ...
信息学奥赛第九节 —— 贪心算法(需要安排几位师傅加工零件 + 排队打水问题)
smallrain6的博客
04-20 2180
贪心算法的特点 对于问题求解时，总是做出在当前来看是最好的选择的策略，即贪心算法不从整体来考虑问题。贪心算法与排序、高精度、背包等算法不同，没有一个特定的模板来表达贪心算法的过程。 贪心的步骤 抽象出题目的数学模型 把需要解决的问题分解为许多个小问题 选择一个策略，这个策略对于解决所有的小问题一定是通用的 证明所选择的策略一定适用于所有的情况 把子问题的解合并，就得到了全局的最优解 贪心的证明 反证法 数学归纳法 决策的包容性 范围的缩放 邻项交换法 贪心的入门模型 如图所示，在上图中，最外面的方
信息学奥赛一本通 1319：【例6.1】排队接水 | 洛谷 P1223 排队接水
君义NOIP的博客
03-23 4925
【题目链接】 ybt 1319：【例6.1】排队接水 洛谷 P1223 排队接水 【题目考点】 1. 贪心 2. 贪心选择性质的证明 要想证明贪心选择可以得到最优解，只需要证明最优解包含每一次的贪心选择。 使用数学归纳法： 证明最优解包含第一次的贪心选择 假设存在最优解包含前k次的贪心选择，证明该最优解包含第k+1次的贪心选择 【解题思路】 1. 证明贪心选择性质 贪心选择：每次选择接水时间最短的人去接水 贪心选择性质的证明： 设n个人的编号为1,2,3,…,n 证明：存在最优解，第一个接水的人是通过
贪心算法 code
11-14
贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。
贪心算法1
08-03
第16章 贪心算法第16章 贪心算法理解贪心算法的概念理解贪心算法的概念掌握贪心算法的基本要素理解贪心算法与动态规划算法的差异通过范例学习贪心算法设计策略算法导
Python贪心算法写法
03-13
贪心算法
算法_贪心算法_
09-29
贪心算法知识的一些有关内容.........
贪心算法c语言.rar
最新发布
04-25
贪心算法是一种在每一步选择中都采取当前状态下最好或最优（即最有利）的选择，从而希望导致结果是全局最好或最优的算法。在许多情况下，贪心算法能够得到全局最优解，或者在多项式时间内给出最优解。尽管贪心算法不...
蓝桥杯 ADV-104算法提高 打水问题
柳婼 の blog
07-21 1202
问题描述 　　N个人要打水，有M个水龙头，第i个人打水所需时间为Ti，请安排一个合理的方案使得所有人的等待时间之和尽量小。 输入格式 　　第一行两个正整数N M 接下来一行N个正整数Ti。 　　N,M 输出格式 　　最小的等待时间之和。（不需要输出具体的安排方案） 样例输入 7 3 3 6 1 4 2 5 7 样例输出 11 提示 　　一种最佳打水方案是，将N个人按照Ti
贪心算法之证明要点----算法导论16.2---5
a11123939的专栏
11-22 1万+
贪心算法之证明要点----算法导论16.2---5 目标：只需证明存在一个最优解是以贪心选择得到的，就ok了。一般先假设一个最优解，用剪切黏贴技术(参考算法导论) 两个性质： 贪心选择性质：一个全局最优解可以通过局部最优得到。即存在一个最优解是以贪心选择开始的。 最优子结构：一个最优解包括期子问题的最优解。即一个n的最优解分解成第一步的贪心选择，和n-1的子问题，这个n-1的子问题也是最优
贪心选择性质的证明
热门推荐
nicolelili1的专栏
04-12 1万+
1、贪心选择性质：在求解一个最优化的过程中，使用贪心的方式选择了一组内容之后，不会影响下面的子问题的求解。 2、 如果无法使用贪心性质，只需要举出一个反例就可以了 3、比如0-1背包问题 但是这个问题将1号物品和2号物品放进背包，最终得到的价值是10+12=22，这样一个反例就告诉我们贪心算法不成立 4、 直觉解法就是把比这个数小的最大的完全平方数加进这个数中...
贪心算法练习题：部分背包问题
weixin_30955341的博客
07-28 208
/*----------------------------------------------------- 有n个物体，第i个物体的重量是wi，价值为vi， 选若干个物体，使得在总重量不超过c的情况下让总价值尽量高。 这里每个物体都可以只取走一部分，价值和重量按比例计算。 输入： 第一行输入两个整数表示n和c。 第2到第n+1行每行两个整数分别表示wi和vi。 输出...
部分背包问题
wmoxie的博客
05-02 537
部分背包问题 **有n个物体，第i个物体的重量为wi，价值为vi，在总重量不超过C的情况下总价值尽量高，每个物体可以只去一部分，价值和重量按比例计算。 贪心策略：先选性价比高的** 题目 有n个物体，第i个物体的重量为wi，价值为vi（wi, vi均为正整数）。在总重量不超过C的情况下让总价值尽量高。每一个物体都可以只取走一部分，价值和重量按比例计算。 分析 这里在选择物品i装入背包时，可以选择物品的一部分，而不一定要全部装入背包。 一种直观的贪心策略是：引入“价重比”（价值/重量）这一概念，优先拿价重比
（贪心）背包问题
花有重开日，人无再少年
08-01 1857
1.最优装载问题。 给出n个物体，第i个物体重量为wi。选择尽量多的物体，使得总重量不 超过C。 由于只关心物体的数量，所以装重的没有装轻的划算。只需把所有物体按重量从小到大 排序，依次选择每个物体，直到装不下为止。 2.部分背包问题。 有n个物体，第i个物体的重量为wi，价值为vi。在总重量不超过C的情 况下让总价值尽量高。每一个物体都可以只取走一部分，价值和重量按比例计算。 本题在上...
1141. 【贪心算法】排队打水
Decide_k的博客
05-02 1196
题目描述 有n（n<=1000）个人在一个水龙头前排队接水，假如每个人接水的时间为Ti，请编程找出这n个人排队的一种顺序，使得n个人的平均等待时间最小。 输入 输入文件共两行，第一行为n；第二行分别表示第1个人到第n个人每人的接水时间T1，T2，…，Tn，每个数据之间有1个空格。 输出 输出文件有两行，第一行为一种排队顺序，即1到n的一种排列（如果有多种方案，请输出字典序最小的方案）；第二行为这种排列方案下的平均等待时间(输出结果精确到小数点后两位)。 样例输入 10 56 12 1
贪心算法问题
lengyue815的博客
11-16 525
算法笔记：贪心法一、概念1. 贪心法（Greedy Algorithm）定义 求解最优化问题的算法通常需要经过一系列的步骤，在每个步骤都面临多种选择； 贪心法就是这样的算法：它在每个决策点作出在当时看来最佳的选择，即总是遵循某种规则，做出局部最优的选择，以推导出全局最优解（局部最优解->全局最优解）2. 对贪心法的深入理解 （1）原理：一种启发式策略，在每个决策点作出在当时看来最佳的选择 （2）求解最优化问题的两个关键要素：贪心选择性质+最优子结构
蓝桥杯 练习题 01背包 python
qq_57844679的博客
04-05 1002
题目 1924: 蓝桥杯算法提高VIP-01背包 时间限制: 1Sec 内存限制: 128MB 提交: 5203 解决: 1506 题目描述 给定N个物品,每个物品有一个重量W和一个价值V.你有一个能装M重量的背包.问怎么装使得所装价值最大.每个物品只有一个. 输入 输入的第一行包含两个整数n, m，分别表示物品的个数和背包能装重量。 以后N行每行两个数Wi和Vi,表示物品的重量和价值 输出 输出1行，包含一个整数，表示最大价值。 样例输入 3 5 2 3 3 5 4 7 样例输
贪心算法排队接水问题
10-31
贪心算法排队接水问题是指在有限的水龙头数量下，如何安排接水顺序，使得所有人的平均等待时间最小。这个问题可以使用贪心算法来解决。具体来说，我们可以按照每个人接水所需的时间从小到大排序，然后依次让每个人接水，让等待时间最短的人先接水。这样可以保证每个人的等待时间都尽可能地短，从而达到最小化平均等待时间的目的。 具体实现时，我们可以使用一个优先队列来维护当前正在接水的人员，每次让等待时间最短的人接水，并将下一个等待接水的人加入队列中。当队列为空时，表示所有人都已经接完水，此时可以计算出平均等待时间。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值