贪心+二分+快速排序

贪心思想：比如你要做个贪婪的人，但是你要拿的东西有数量限制，你是不是就是从最好的东西开始拿。
贪心满足局部最优解，不一定满足全局最优解

二分查找的常见应用
①：假定一个解，并判断是否可行。

和下面的分蛋糕的题一样。就是一个一个试。
②：最大化最小值。

我们假设每头牛之间的最短距离为k，那么此时我们判断在满足最短距离为k的情况下是否能用牛舍将牛都放完，如果可以则增大查找范围，否则减小查找范围。
③：最大化平均值。
有n个物品的重量和价值分别是 W[i]和 V[i], 从中选出k个物品使得单位重量的价值最大。
限制条件： 1 ≤ k ≤ n ≤ 10000
1 ≤ w[i], v[i], ≤ 1000000
二分确定解，我们假设C(x)为可以选择使得单位重量的价值不小于x。由此，问题就变为了可以满足C(x)的最大x。

那么我们如何去判断一个x是否可行呢？我们假设我们选定了某个物品集合S
,那么他们的单位重量的价值为，
因此就变成了判断是否存在S满足下面的条件，
，将这个不等式变形之后就得到。

因此就可以对(v[i]-x.w[i]) ≥ 0的值进行排序贪心的进行选取。

问题 A: 这些卡片非常OK

题目描述
现在有一些写着数字的卡片，我们定义一个规则：
两张数字相同的卡片是 OK 的，
三张连续数字的卡片是 OK 的，
给你一堆卡片，请你找出尽可能多的 OK 数，卡片不可以重复利用。
输入
多组输入，每组输入第一行为一个整数 n 表示卡片数量，1 ≤ n ≤ 1000000， n = 0 时输入结束。
接下来一行为 n 张卡片上的数字 x ，可能乱序。1 ≤ x ≤ 100 。
输出
输出卡片能凑出最多 OK 的数量。
样例输入
4
2 2 3 3
5
1 2 3 4 4
0
样例输出
2
2
提示
如样例一，(2 2) 为一个 OK ，(3 3) 为一个 OK，所以输出为 2

贪心思想：肯定是让两个牌的ok数最多，然后再在剩下的牌里找三个
#include<bits/stdc++.h>
using namespace std;
const int maxn=1000000+5;
int kapian[maxn];
vector<int> v;
int solve(int a[maxn],int n){sort(a,a+n);  //先排序int flag=0;  //flag为ok数for(int i=0;i<n;i++){if(a[i]==a[i+1]&&(i+1<n)){  //找两两的flag++;a[i]=a[i+1]=0;  //将他赋值为0，因为你将两两的赋值为0，再一排序两两的0不就跑到前面了，然后再在最后一个0以后找三张连续牌}}sort(a,a+n);//再排序int i;for( i=0;a[i]==0;i++){  //找到0for(;i<n;i++){if((a[i+1]==a[i]+1)&&(a[i+2]==a[i]+2)&&(i+3<n)){flag++;i+=2; //每次位置跳2，但是后面又有个i++,所以这里只需+2}}}return flag;//返回总数
}int main(){int n;while(scanf("%d",&n)&&n){for(int i=0;i<n;i++){scanf("%d",&kapian[i]);}cout<<solve(kapian,n)<<endl;}}

问题 B: 佳星的苹果派

题目描述
佳星最近开了一家专营苹果派的店，开店以来生意火爆，所以他打算扩大规模。为了做好扩大规模的准备工作，他进了一大批的苹果。
但是扩大规模后发现他进的苹果太多了，一时间卖不完，但是果农现在已经没有苹果了，也就是说，接下来他只能靠剩下的苹果过活，但是周期问题导致苹果对苹果派的味道加成不一样。
苹果派的味道即苹果味道加成总和，即如果三个苹果加成的味道分别为 1， -1， 3 那苹果派最后的味道为3
但是今天客户下单的苹果派他不小心把苹果拿出来拿多了，所以他需要拿掉一部分苹果，但是他希望尽可能的保持苹果派的味道变化小，所以现在需要你编写一个程序来计算苹果派的味道问题。如果变化程度相同，比如去掉一个苹果有，苹果派的味道原来是 12，有一个苹果是1，另一个苹果是 -1，则选择去掉-1那个，苹果派味道变成13，即使得苹果派的味道在变化最小的情况下尽可能变得味道更好，当然，优先变化最小。

输入
有多组输入样例
第一行包括一个n ，m ( 0< m < n <=100000) n 是苹果总数，m是需要拿掉的苹果数量
第二行有n 个数字，表示每个苹果对苹果派的味道加成( -100<= a[i] <= 100)
输出
输出拿掉m个苹果后味道变化最小的味道总和
样例输入
3 1
-1 0 10
5 2
2 2 1 -1 0
样例输出
9
5
提示
绝对值相等的时候选择拿掉加成为负的那个

贪心思想:我只需在排序时对这个排序操作进行一下改变，把我想去掉的苹果排到前面
#include<bits/stdc++.h>
using namespace std;
const int maxn = 100000+7;
int n,m;
int a[maxn];int cmp(int x,int y){   //重载判断条件if(abs(x)==abs(y)){  //绝对值相等，把小的放到前面，比如-1,1，因为我要尽可能的让他的口味变化最小，在这前提下再让口味最优，return x<y;}elsereturn abs(x)<abs(y);  //否则将绝对值小的放前面，比如-3,2，因为我要尽可能的让他的口味变化最小。
}int main(){while(cin>>n>>m){int sum = 0;for(int i = 0;i<n;i++){cin>>a[i];sum += a[i];}sort(a,a+n,cmp);  //在之前的条件下排序for(int i = 0;i<m;i++){sum -= a[i];}cout<<sum<<endl;}return 0;
}

问题 D: 数字游戏

时间限制: 1 Sec 内存限制: 128 MB

题目描述
给你一个长度为N的数组A，数组元素为N的一个排列。你的任务是使用数组中的数字凑出M，每个数字只能使用一次。
输入
输入多组数据
输入第一行，两个数字，N， M， 1 <= N <= 1000000， 1< =M <= 100000000。
接下来是长度为N的数组， 1 <= A[i] < =1000000。保证所有数字的个数和不超过1000000。
输出
输出一行，如果能用长度为N的数组凑出M输出“YES”，否则输出"NO" ，输出不包括引号。
样例输入
3 6
1 3 2
4 3
1 4 3 2
样例输出
YES
YES

#include<bits/stdc++.h>
using namespace std;
const int maxn=1000000+5;
int a[maxn];
int main(){int n,m;while(cin>>n>>m){for(int i=0;i<n;i++)cin>>a[i];sort(a,a+n);for(int i=n-1;i>=0;i--){if(m>=a[i]){m-=a[i];}if(m<=0){break;}}if(m==0)cout<<"YES"<<endl;elsecout<<"NO"<<endl; }
}

问题 E: 分批萨

时间限制: 1 Sec 内存限制: 128 MB
题目描述
红红马上过生日了，他打算买n块蛋糕用来庆祝生日，假设n块蛋糕都为圆柱形，他们的底面圆的半径不一定相等但是他们的高都相等且为1，他邀请了F个人参加他的生日Party，保证每个人都能来，现在他想把这n块蛋糕等体积的分给包括他的参加聚会的所有人，为了保证蛋糕的颜值，他想每块蛋糕只能被切开但是不能重新组合，现在问你每个人最大能分到多大的蛋糕，结果保留至小数点后四位。
输入
输入第一行为一个整数t，表示样例数。
对于每个样例，输入第一行包括两个正整数n，F分别表示红红打算买蛋糕的数目以及红红邀请的客人数。
数据保证(1 ≤ n，F ≤ 10000）。每组测试样例的第二行包括n个正整数，分别表示n块蛋糕的半径r，每两个整数之间有一个空格。(1 ≤ r ≤ 10000)。
输出
对于每组测试样例，请输出每个人能分到的蛋糕的最大体积，回答为一个浮点数，精确到小数点后四位。
样例输入
3
3 3
4 3 3
1 24
5
10 5
1 4 2 3 4 5 6 5 4 2
样例输出
25.1327
3.1416
50.2655

二分思想：用二分去试我分后的体积，在最小的区间和最大的区间进行二分，然后进行判断。
#include<bits/stdc++.h>
using namespace std;
const int maxn=10000+5;
const double pi=acos(-1.0);
double s[maxn];
int n,f;
bool check(double x ){  //x为分后半径double ss=pi*x*x;   //ss为分后体积，也是面积，因为高为1int sum=0; //sum为能分到的块for(int i=0;i<n;i++){sum+=(int)(s[i]/ss);   //对每一块进行试，看他在分后体积为ss的情况下，能分多少块}return sum>=(f+1);   //如果我在分后体积ss的情况下，分到的块数大于我要给的人了，说明我分后体积给小了，如果小于，说明我分后体积给小了。
}
void slove(){double min=0,max=10000,mid;  //题目给出最大半径为10000，所以我分后的体积的半径最大肯定也是10000，所以我在0到10000的区间二分for(int i=0;i<100;i++){  mid=(min+max)/2;if(check(mid)) {min=mid;}else{max=mid;}}printf("%.4lf\n",max*max*pi);
}int main(){int t;cin>>t;while(t--){while(cin>>n>>f){double r;memset(s,0,sizeof(s));for(int i=0;i<n;i++){cin>>r;s[i]=pi*r*r;}slove();}}
}

问题 F: 寻找第k大的数

时间限制: 1 Sec 内存限制: 128 MB
题目描述
给出n个无序的整数，请输出其中按升序排列后的第k个数。(请应用分治(快排)思想)
输入
有多组测试样例，每组测试样例的第一行包含两个正整数n，k(1 ≤ k ≤ n ≤ 10000000)。
第二行包含n个整数，每两个数之间由一个空格分开。保证每个数的绝对值都小于1000000。
输出
对于每组测试样例，输出一个整数，表示按升序排列后的第k个数。
样例输入
5 3
1 4 2 5 6
5 5
1 10 2 3 4
样例输出
4
10

这题要求快速排序，用的二分思想
#include<stdio.h>
#include<stdlib.h>
int a[10000000];int partition(int low, int high) {int pivotkey = a[low];while (low < high) {while (low < high&&a[high] >= pivotkey)--high;a[low] = a[high];while (low < high&&a[low] <= pivotkey)++low;a[high] = a[low];}a[low] = pivotkey;return low;
}void soft(int low, int high) {int pivotloc;if (low < high) {pivotloc = partition(low, high);soft(low, pivotloc - 1);soft(pivotloc + 1, high);}
}
int main() {int n,k;while(scanf("%d %d", &n,&k)!=EOF){for (int i = 0; i <n; i++)scanf("%d", &a[i]);soft(0, n-1);printf("%d\n", a[k-1]);}return 0;
}

问题 G: 码农红红

时间限制: 1 Sec 内存限制: 128 MB
题目描述
红红准备了m斤肉肉准备和肉店兑换金钱以供自己上网码代码，现在有n家肉店，第i家肉店最多需要J[i]斤肉肉，如果全部交换红红可以获得F[i]美金，当然红红可以选择在某家肉店只交换一部分，红红问你他最多能获得多少美金。
输入
输入第一行包含两个正整数m，n分别表示红红初始拥有的肉肉的斤数和肉店数。
接下来n行，每行包括两个正整数分别表示第 i 家肉店的F[i] 和 J[i]，意思如题目所述，保证所有整数都小于1000.
输出
输出一个浮点数，表示红红能获得的最大美金数，保留小数点后三位。
样例输入
5 3
7 2
4 3
5 2
样例输出
13.333

这题是个贪心题：我肯定先去单位肉价格最大的店，然后再去次之的店,直到我把手上的肉全交换完，所以我就根据这一条件排序
#include<bits/stdc++.h>
using namespace std;
const int maxn=1000;
struct node{double money,jin;double xjb;
}y[maxn];
bool operator < (node a,node b){  //重载运算符，也可以在sort函数参数里定义函数，去改变运算符条件if(a.xjb>b.xjb) return true;else return false;
}
int m,n;  //m初始斤数  n家店
void solve(){sort(y,y+n);double sum=0; //能换到的总钱数for(int i=0;i<n;i++){if(y[i].jin<=m){  //我手上的肉大于这家店的总需求肉sum+=y[i].money;m-=y[i].jin;}else{   //我手上的肉小于这家店的总需求肉，那就把我能给的都给了sum+=y[i].xjb*m;  break;}}printf("%.3lf\n",sum);
}int main(){while(cin>>m>>n){for(int i=0;i<n;i++){cin>>y[i].money>>y[i].jin;y[i].xjb=(y[i].money)/(y[i].jin);  //int除Int还是个int，所以用double除double}solve();}return 0;
}