educoder贪心算法
贪心算法:
在对问题求解时,总是做出在当前看来是最好的选择。也就是说,不从整体最优上加以考虑,算法得到的是在某种意义上的局部最优解
贪心算法不是对所有问题都能得到整体最优解,关键是贪心策略的选择
利用贪心法求解的问题应具备如下2个特征
1、贪心选择性质
一个问题的整体最优解可通过一系列局部的最优解的选择达到,并且每次的选择可以依赖以前作出的选择,但不依赖于后面要作出的选择。这就是贪心选择性质。对于一个具体问题,要确定它是否具有贪心选择性质,必须证明每一步所作的贪心选择最终导致问题的整体最优解
2、最优子结构性质
当一个问题的最优解包含其子问题的最优解时,称此问题具有最优子结构性质。问题的最优子结构性质是该问题可用贪心法求解的关键所在。在实际应用中,至于什么问题具有什么样的贪心选择性质是不确定的,需要具体问题具体分析
1.活动安排
任务描述
学校的小礼堂每天都会有许多活动,有时间这些活动的计划时间会发生冲突,需要选择出一些活动进行举办。小刘的工作就是安排学校小礼堂的活动,每个时间最多安排一个活动。现在小刘有一些活动计划的时间表,他想尽可能的安排更多的活动,请问他该如何安排。
输入格式
第一行是一个整数n(1<n<10000)表示该测试数据共有n个活动。 随后的n行,每行有两个正整数Bi,Ei(0<=Bi,Ei<10000),分别表示第i个活动的起始与结束时间(Bi<=Ei)
输出格式
输出安排的最多的活动数
输入样例
11 1 4 3 6 0 6 5 7 3 8 5 9 6 10 8 11 8 12 2 13 12 14
输出样例
4
贪心策略:以结束时间最早进行排序,计算相容时间活动的最多个数
#include <stdio.h>
#include <algorithm>
#define MAX 100
struct A{
int B,E;
};
A a[MAX];
bool b[MAX];
int n;
void swap(A &a,A &b)
{
A t=a;
a=b;
b=t;
}
void sort(int l,int r)//快速排序
{
if(l<r)
{
int i=l,j=r;
A t=a[l];
while(i<j)
{
while(t.E<=a[j].E&&j>l)
j--;
while(a[i].E<=t.E&&i<r)
i++;
if(i>=j)
break;
swap(a[i],a[j]);
}
swap(a[j],a[l]);
sort(l,j-1);
sort(j+1,r);
}
}
int main()
{
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%d %d",&a[i].B,&a[i].E);
}
sort(0,n-1);
int j=0;b[0]=true;//第一个活动肯定可以
int count=1;
for(int i=1;i<n;i++)
{
if(a[i].B>=a[j].E)//活动相容的条件
{
j=i;
b[i]=true;
count++;
}
}
printf("%d",count);
}
2.最优装载问题
任务描述
有一天,海盗截获了一艘装满各种各样古董的货船,每一件古董都价值连城,一但打碎就失去了价值,虽然海盗船足够大,但载重量为C,每件古董的重量为Wi,海盗们如何把尽量多的宝贝装上海盗船呢?
输入格式
第一行输入n,c,代表有n个古董和船的重量 第二行输入n个数,代表每个古董的重量。 1<n,c<100000 每个古董的重量不超过100
输出格式
输出一个数,代表最多装多少个古董
输入样例
8 30 4 10 7 11 3 5 14 2
输出样例
5
贪心策略:宝贝尽量多,那么就尽量先装重量小的
#include <stdio.h>
#define MAX 100
int n,c;
int w[MAX];
void swap(int &a,int &b)
{
int t=a;
a=b;
b=t;
}
void sort(int l,int r)//快速排序
{
if(l<r)
{
int i=l,j=r;
int t=w[l];
// i++;
while(i<j)
{
while(t<=w[j]&&j>l)
j--;
while(w[i]<=t&&i<r)
i++;
if(i>=j)
break;
swap(w[i],w[j]);
}
swap(w[j],w[l]);
sort(l,j-1);
sort(j+1,r);
}
}
int main()
{
scanf("%d %d",&n,&c);
for(int i=0;i<n;i++)
{
scanf("%d",&w[i]);
}
sort(0,n-1);
int count=0;
for(int i=0;i<n;i++)
{
if(w[i]<=c)
{
count++;
c-=w[i];
}
}
printf("%d",count);
}
3.背包问题
任务描述
现在有很多物品(它们是可以分割的),每个物品有多个,我们知道它们每个物品的单位重量的价值v和重量w(1<=v,w<=10);如果给你一个背包它能容纳的重量为m(10<=m<=20),你所要做的就是把物品装到背包里,使背包里的物品的价值总和最大。
输入格式
第一行有两个正整数s,m(1<=s<=10);s表示有s个物品。接下来的s行每行有两个正整数w,v。
输出格式
输出每组测试数据中背包内的物品的价值和,每次输出占一行。
输入样例
3 15 5 10 2 8 3 9
输出样例
65
思路:注意不要想成01背包问题 或者完全背包问题,这个题是单位重量,不仔细看题会做成完全背包问题
#include <stdio.h>
#define MAX 100
int s,m;
int w[MAX],v[MAX];
int dp[MAX][MAX];
void swap(int &a,int &b)
{
int t=a;
a=b;
b=t;
}
void sort(int l,int r)
{
if(l<r)
{
int i=l,j=r;
int t=w[l];
// i++;
while(i<j)
{
while(t<=w[j]&&j>l)
j--;
while(w[i]<=t&&i<r)
i++;
if(i>=j)
break;
swap(w[i],w[j]);
swap(v[i],v[j]);
}
swap(w[j],w[l]);
swap(v[i],v[l]);
sort(l,j-1);
sort(j+1,r);
}
}
int main()
{
scanf("%d %d",&s,&m);
for(int i=1;i<=s;i++)
{
scanf("%d %d",&w[i],&v[i]);
}
sort(1,s);
int sum=0;
for(int i=s;i>=1;i--)
{
if(v[i]<=m)
{
sum+=w[i]*v[i];
m-=v[i];
}
else if(m>0)
{
sum+=m*w[i];
m-=v[i];
}
else
break;
}
printf("%d",sum);
}
4.会场安排
任务描述
假设要在足够多的会场里安排一批活动,并希望使用尽可能少的会场。设计一个有效的贪心算法进行安排。(这个问题实际上是著名的图着色问题。若将每一个活动作为图的一个顶点,不相容活动间用边相连。使相邻顶点着有不同颜色的最小着色数,相应于要找的最小会场数。)
输入格式
第一行有1 个正整数k,表示有k 个待安排的活动。接下来的k 行中,每行有2 个正整数,分别表示k 个待安排的活动开始时间和结束时间。时间以0 点开始的分钟计。
输出格式
将编程计算出的最少会场数
输入样例
5 1 23 12 28 25 35 27 80 36 50
输出样例
3
解法1:
贪心策略:与活动安排一样,唯一不同的是会场多个,调用"活动安排"的策略直到数组全部被标记
解法2:
多个可能的重叠的区间,找出重叠区间的最大个数
解法1代码如下:
#include <stdio.h>
#include <algorithm>
#define MAX 100
struct A{
int B,E;
};
A a[MAX];
bool b[MAX];//标记数组 活动是否被安排
int n;
void swap(A &a,A &b)
{
A t=a;
a=b;
b=t;
}
void sort(int l,int r)
{
if(l<r)
{
int i=l,j=r;
A t=a[l];
while(i<j)
{
while(t.E<=a[j].E&&j>l)
j--;
while(a[i].E<=t.E&&i<r)
i++;
if(i>=j)
break;
swap(a[i],a[j]);
}
swap(a[j],a[l]);
sort(l,j-1);
sort(j+1,r);
}
}
int main()
{
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%d %d",&a[i].B,&a[i].E);
}
sort(0,n-1);
int count=1;
for(int k=1;k<n;k++)//遍历每个活动
{
if(!b[k])
{
int j=0;b[0]=true;
for(int i=1;i<n;i++)
{
if(a[i].B>=a[j].E)
{
j=i;
b[i]=true;
}
}
count++;
}
}
printf("%d",count);
}
解法2代码:(本来说给大家画个图,太丑了,大家还是意会吧)
#include <stdio.h>
#include <algorithm>
#define MAX 100
struct A{
int val,start;//val为实际值,start为是否是开始下标,是为1,反之为0
};
A a[MAX];
int n;
void swap(A &a,A &val)
{
A t=a;
a=val;
val=t;
}
void sort(int l,int r)
{
if(l<r)
{
int i=l,j=r;
A t=a[l];
while(i<j)
{
while(t.val<=a[j].val&&j>l)
j--;
while(a[i].val<=t.val&&i<r)
i++;
if(i>=j)
break;
swap(a[i],a[j]);
}
swap(a[j],a[l]);
sort(l,j-1);
sort(j+1,r);
}
}
int main()
{
scanf("%d",&n);
int t=0;
for(int i=0;i<n;i++)
{
scanf("%d %d",&a[t++].val,&a[t++].val);
a[i].start=1;
}
sort(0,t-1);
int max=0,count=0;
for(int i=0;i<t;i++)
{
// printf("%d %d\n",a[i].val,a[i].start);
if(a[i].start==1)
{
count++;
if(count>max)
max=count;
}
else
count--;
}
printf("%d",max);
}
5.删数问题
任务描述
有一个长度为n(n <= 240)的正整数,从中取出s(s < n)个数,使剩余的数保持原来的次序不变,求这个正整数经过删数之后最小是多少。
输入格式
第一行输入n和s
输出格式
输出一个整数
输入样例
178543 4
输出样例
13
贪心策略:
1.找到数组中递减序列的第一个数删掉(reason:因为如果只能删一个数并不能直接删数字最大的那个,你需要考虑去掉该数后整体最小)
2.如果不存在递减序列(即全是递增序列),删掉最后一个数字即可
3.考虑100100,s=4的情况会得到00,得到的结果不是正整数需要特殊处理(可以记录非0的需要去掉的最小数字)
#include<stdio.h>
#include<string.h>
#define MAX 300
using namespace std;
int t=0;
int b[MAX];
int x=0;
int main()
{
char n[MAX];//char数组存储长度240的一串数字
int m;
scanf("%s",n);
scanf("%d",&m);
t=strlen(n);
int cnti=t;
for(int i=0;i<t;i++)
{
b[i]=int(n[i])-48;//强转出是ASCII值 需要处理
}
int cntmax;
while(m)
{
bool flag=false;//标记是否存在递减序列
for(int i=0;i<t-1;i++)
{
if(b[i]>=b[i+1])//存在递减序列
{
flag=true;
if(b[i+1]==0&&b[i]!=0)
{
cntmax=b[i];
}
for(int j=i;j<t-1;j++)//顺次左移覆盖
{
b[j]=b[j+1];
}
m--;
t--;
break;
}
}
if(!flag)//不存在递减序列 长度t-- 相当于删掉最后一个数字
{
m--;
t--;
}
}
int count=0;
for(int i=0;i<t;i++)
{
if(b[i]==0)//处理后的数组中0的个数
count++;
}
if(count==t)//若0的个数与数组长度相同 即结果不是正整数 不合法
{
b[t-1]=cntmax;
}
for(int i=0;i<t;i++)
{
printf("%d",b[i]);
}
return 0;
}
贪心算法拓展
任务描述
本关任务:掌握贪心算法的算法思想,并能利用贪心算法的算法思想解决删除数字问题。
给定n个纯数字组成的数字串,删除其中k(k<n)个数字后,剩下的数字按原来的秩序组成一个新的正整数,确定删除方案,使得剩下的数字组成的新的正整数最大。
测试输入:
79502867154829179316
8
预期输出:
987829179316
贪心策略:与删数问题相同,唯一不同的是此次求最大且大数可用字符串进行存储,并将比较大小的符号换一下即可。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int main(int argc, const char * argv[]) {
char s[1001];
int a[1001];
int k;
int n,i,j;
cin>>s;
cin>>k;
n=strlen(s);
for(int i=0;i<n;i++)
a[i]=s[i]-48;
cout<<endl;
while(k)
{
bool flag=false;
for(i=0;i<n-1;i++)
{
if(a[i]<a[i+1])
{
for(j=i;j<n-1;j++)
{
a[j]=a[j+1];
}
k--;
n--;
flag=true;
break;
}
}
if(!flag)
{
n--;
k--;
}
}
for(int i=0;i<n;i++)
{
cout<<a[i];
}
return 0;
}