贪心算法初步

一、简单贪心

1.定义：

求解最优化问题的方法，总是考虑局部最优（较优）的策略，使得全局结果达到最优（较优）
想要获得最优解往往需要对才用的策略进行证明，一般采用反证或者是数学归纳法
在考试过程中，如果没有时间想到严谨的证明，如果在想到某个可行的策略且短时间内没有想出反例推翻它，则勇敢实现即可。

2.例题

(1)PAT乙级1020

月饼是中国人在中秋佳节时吃的一种传统食品，不同地区有许多不同风味的月饼。现给定所有种类月饼的库存量、总售价、以及市场的最大需求量，请你计算可以获得的最大收益是多少。

注意：销售时允许取出一部分库存。样例给出的情形是这样的：假如我们有 3 种月饼，其库存量分别为 18、15、10 万吨，总售价分别为
75、72、45 亿元。如果市场的最大需求量只有 20 万吨，那么我们最大收益策略应该是卖出全部 15 万吨第 2 种月饼、以及 5 万吨第
3 种月饼，获得 72 + 45/2 = 94.5（亿元）

输入格式： 每个输入包含一个测试用例。每个测试用例先给出一个不超过 1000 的正整数 N 表示月饼的种类数、以及不超过
500（以万吨为单位）的正整数 D 表示市场最大需求量。随后一行给出 N 个正数表示每种月饼的库存量（以万吨为单位）；最后一行给出 N
个正数表示每种月饼的总售价（以亿元为单位）。数字间以空格分隔。

输出格式： 对每组测试用例，在一行中输出最大收益，以亿元为单位并精确到小数点后 2 位。

输入样例： 3 20 18 15 10 75 72 45
输出样例： 94.50

# include<cstdio>
# include<vector>
# include<algorithm>
using namespace std;

struct info{
    double price;
    double quantity;
    double unit_price;
    info(double _quantity):quantity(_quantity){};//定义构造函数
};

bool cmp(info a, info b){
	return a.unit_price>b.unit_price;
}

int main()
{
    int N;
	double D, max_profit;
    vector<info> stock;
    scanf("%d %lf",&N,&D);
    for(int i=0; i<N;i++){
        double q_temp;
        scanf("%lf",&q_temp);
		info temp = info(q_temp);
        stock.push_back(temp);
    }
    for(int i=0; i<N;i++){
        double p_temp;
        scanf("%lf",&p_temp);
        stock[i].price = p_temp;
        stock[i].unit_price = p_temp/stock[i].quantity;
    }
	sort(stock.begin(),stock.end(),cmp);
	for(int i=0; i<N; i++){
		if(D>stock[i].quantity)
		{
			max_profit+=stock[i].price;
			D -= stock[i].quantity;
		}
		else
		{
			max_profit+=stock[i].unit_price*D;
			break;
		}
	}
	printf("%.2lf",max_profit);
}

(2)PAT乙级1023

给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。现给定数字，请编写程序输出能够组成的最小的数。

输入格式： 输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……数字 9 的个数。整数间用一个空格分隔。10
个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。

输出格式： 在一行中输出能够组成的最小的数。

输入样例： 2 2 0 0 0 3 0 0 1 0
输出样例： 10015558

# include<stdio.h>


int main(){
    int num[10];
    for(int i=0;i<10;i++)
        scanf("%d",&num[i]);
    for(int i=1;i<10;i++){
        if(num[i]!=0){
            num[i]--;
            printf("%d",i);
            break;
        }
    }
    for(int i=0;i<10;i++){
        while(num[i]-->0)
            printf("%d",i);
    }
}

二、区间贪心

问题描述

区间不相交问题：给出N个开区间，从中选出尽可能多的开区间，使得这些区间两两之间没有交集。

以(1,3),(1,2),(2,3),(3,5),(4,6),(6,7),(3,8)作为输入为例

解决方案

1.先对区间进行排序，假设区间记为（begin,end），我们按照begin升序排序，当begin相同时，end降序排序(为什么end降序排序，后面就会知道了)：
此时排序结果为(1,3),(1,2),(2,3),(3,8),(3,5),(4,6),(6,7)

2.对于那些被包含的区间，例如(1,2)包含于(1,3)之中，那么我们会选择(1,2)，因为(1,3)占用范围大，会减少区间的个数；故在这一步我们需要将包含其他区间的区间丢弃
此时获得结果为(1,2),(2,3),(3,5),(4,6),(6,7)

3.接着我们只需要遍历剩余的结果，保证后序的begin值大于前者的end值，就能够输出出结果

# include<cstdio>
# include<algorithm>
# include<vector>
using namespace std;

struct section
{
	int begin,end;
	section(int _begin, int _end):begin(_begin),end(_end){}
};

bool cmp(section a, section b){
	if(a.begin!=b.begin)
		return a.begin<b.begin;
	else
		return a.end>b.end;
}
int main()
{
	int i=0,num,temp_b,temp_e,last_end;
	vector<section> aSet;
	vector<section> result;
	scanf("%d",&num);
	while(i++<num){
		scanf("%d %d",&temp_b,&temp_e);
		section temp_s = section(temp_b,temp_e);
		aSet.push_back(temp_s);
	}
	sort(aSet.begin(),aSet.end(),cmp); //从小到大排序
	for(int i=0;i<aSet.size()-1;i++){
		if(aSet[i].end>aSet[i+1].end)
			aSet.erase(aSet.begin()+i);
	}
	result.push_back(aSet[0]);
	last_end = aSet[0].end;
	for(int i=1;i<aSet.size();i++){
		if(aSet[i].begin>=last_end){
			result.push_back(aSet[i]);
			last_end = aSet[i].end;
		}
	}
	for(vector<section>::iterator it = result.begin();it!=result.end();it++)
		printf("(%d,%d) ",(*it).begin,(*it).end);
}