一、区间问题
1、区间选点
给定 N 个闭区间
[ai,bi]，请你在数轴上选择尽量少的点，使得每个区间内至少包含一个选出的点。输出选择的点的最小数量。
位于区间端点上的点也算作区间内。
输入格式
第一行包含整数 N，表示区间数。
接下来 N 行，每行包含两个整数 ai,bi，表示一个区间的两个端点。
输出格式
输出一个整数，表示所需的点的最小数量。
数据范围
1≤N≤10^5,
−109≤ai≤bi≤109输入样例：
3 -1 1 2 4 3 5输出样例：
2
-
将每个区间按右端点从小到大排序
-
从前往后依次枚举每个区间
如果当前区间中已经包含点，直接pass；否则选择当前区间的右端点
若要证明局部最优解为全局最优解，可结合数学知识，若要证明A=B，则可证明A>=B && A<=B
本题的最优解为，所有可行解中的最小值。令最终答案为ans，而求出的解为cnt，由定义已知：ans<=cnt
要证ans>=cnt，看没有被pass的点，如下图，即相互之前有空隙的区间
那么想要覆盖掉所有的区间，必须要>=cnt个数，因此ans>=cnt
故ans=cnt，该算法可以获得最优解
#include<iostream>
#include<algorithm>
using namespace std;
const int N=100010;
int n;
struct Range{
int l,r;//左右端点
bool operator< (const Range &W)const{
return r<W.r; //按照右端点排序
}
}range[N];
int main(){
scanf("%d",&n);
for(int i=0;i<n;i++){
int l,r;
cin>>l>>r;
range[i]={l,r};
}
sort(range,range+n);//对结构体进行排序
int res=0;//当前选择的点数
int ed=-2e9;//上一个点的下标
for(int i=0;i<n;i++){
if(range[i].l>ed){//当前区间的左端点>上一个选择的点（上一个点不在这个区间里）
res++;
ed=range[i].r;
}
}
printf("%d\n",res);
return 0;
}
2、最大不相交区间数量
给定 N 个闭区间
[ai,bi][ai,bi]，请你在数轴上选择若干区间，使得选中的区间之间互不相交（包括端点）。输出可选取区间的最大数量。
输入格式
第一行包含整数 N，表示区间数。
接下来 N 行，每行包含两个整数 ai,bi，表示一个区间的两个端点。
输出格式
输出一个整数，表示可选取区间的最大数量。
数据范围
1≤N≤10^5,
−109≤ai≤bi≤109输入样例：
3 -1 1 2 4 3 5输出样例：
2
与上一题思路相同，先按照右端点排序，再从小到大枚举，最终选择的端点数量，就是最大的不相交的区间数量
3、区间分组
给定 N 个闭区间
[ai,bi][ai,bi]，请你将这些区间分成若干组，使得每组内部的区间两两之间（包括端点）没有交集，并使得组数尽可能小。输出最小组数。
输入格式
第一行包含整数 N，表示区间数。
接下来 N 行，每行包含两个整数 ai,bi，表示一个区间的两个端点。
输出格式
输出一个整数，表示最小组数。
数据范围
1≤N≤10^5,
−109≤ai≤bi≤109输入样例：
3 -1 1 2 4 3 5输出样例：
2
-
将所有区间按照左端点从小到大排序
-
从前往后处理每个区间
判断能否将其放到某个现有的组中
L[i]>Max_r- 如果不存在这样的组，则开新组，然后再将其放进去
- 如果存在这样的组，随意取一个，将其放到这个组中，并更新当前组的Max_r
证明：
- 按照此做法，一定能够得到一个合法方案，而ans是所有合法方案里的最小值，所以
ans<=cnt - 寻找特殊的时刻：每个区间都和其他区间有交集，需要各自开新组，所以
ans>=cnt
贪心决策：
-
如果一个区间的左端点比最小组的右端点要大，则没有交集，放在该组，
heap.pop(), heap.push(range[i].r); -
如果一个区间的左端点比最小组的右端点要小，
ranges[i].l<=heap.top()， 就开一个新组heap.push(range[i].r);
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 100010;
int n;
struct Range{
int l, r;
bool operator< (const Range &W) const{
return l < W.l;//按照左端点进行排序
}
}range[N];
int main(){
cin>>n;
for(int i=0;i<n;i++){
int l,r;
cin>>l>>r;
range[i]={l,r};
}
sort(range,range+n);
//用堆来存储组的右端点
priority_queue<int,vector<int>,greater<int>> heap;//用小根堆来维护所有组中最小的右端点为根节点
for(int i=0;i<n;i++){
auto t=range[i];
if(heap.empty() || heap.top()>=t.l) //当前队列空或当前区间的端点小于小根堆的根（最小的右端点）
heap.push(t.r);//新开一组
else{
heap.pop();//如果大于组中的最小右端点，则至少跟这个组无交集，可以放到这个组里
heap.push(t.r);//把它该归到小根堆根所代表的这一组，根就失去了作用，并更新堆
}
}
cout<<heap.size()<<endl;
return 0;
}
另解：
可以把这个问题想象成活动安排问题
有若干个活动，第i个活动开始时间和结束时间是[Si,fi]，同一个教室安排的活动之间不能交叠，求要安排所有活动，少需要几个教室？
有时间冲突的活动不能安排在同一间教室，与该问题的限制条件相同，即最小需要的教室个数即为该题答案。
我们可以把所有开始时间和结束时间排序，遇到开始时间就把需要的教室加1，遇到结束时间就把需要的教室减1,在一系列需要的教室个数变化的过程中，峰值就是多同时进行的活动数，也是我们至少需要的教室数。
#include<iostream>
#include<algorithm>
using namespace std;
const int N=100010;
int n;
int b[2*N],idx;
int main(){
cin>>n;
for(int i=0;i<n;i++){
int l,r;
cin>>l>>r;
b[idx++]=l*2;//标记左端点为偶数
b[idx++]=r*2+1;//标记右端点为奇数
}
sort(b,b+idx);
int res=1,t=0;
for(int i=0;i<idx;i++){
if(b[i]%2==0) t++;//遇到开始就加1
else t--;
res=max(res,t);
}
printf("%d\n",res);
return 0;
}
4、区间覆盖
给定 N 个闭区间
[ai,bi]以及一个线段区间[s,t]，请你选择尽量少的区间，将指定线段区间完全覆盖。输出最少区间数，如果无法完全覆盖则输出 −1。
输入格式
第一行包含两个整数 s 和 t，表示给定线段区间的两个端点。
第二行包含整数 N，表示给定区间数。
接下来 N 行，每行包含两个整数 ai,bi，表示一个区间的两个端点。
输出格式
输出一个整数，表示所需最少区间数。
如果无解，则输出 −1。
数据范围
1≤N≤10^5,
−10^9 ≤ai≤bi≤ 10^9,
−10^9 ≤s≤t≤ 10^9输入样例：
1 5 3 -1 3 2 4 3 5输出样例：
2
- 将所有区间按左端点从小到大排序
- 从前往后依次枚举每个区间，在所有能覆盖start的区间中，选择右端点最大的区间，然后将start更新成右端点的最大值
#include<iostream>
#include<algorithm>
using namespace std;
const int N=100010;
int n;
struct Range{
int l,r;
bool operator< (const Range &W)const
{
return l<W.l;
}
}range[N];
int main(){
int st,ed;
cin>>st>>ed;
cin>>n;
for(int i=0;i<n;i++){
int l,r;
cin>>l>>r;
range[i]={l,r};
}
sort(range,range+n);
int res=0;//选择的区间个数
bool success=false;
for(int i=0;i<n;i++){
int j=i,r=-2e9;
while(j<n && range[j].l<=st){
//遍历所有能覆盖start的区域中，右端点的最大值
r=max(r,range[j].r);
j++;
}
if(r<st){
res=-1;
break;
}
res++;
if(r>=ed){//全部覆盖
success=true;
break;
}
st=r; //确定一个区间之后，更新一下st
i=j-1;//j++ 最后多执行了一步
}
if(!success) res=-1;
printf("%d\n",res);
return 0;
}
二、Huffman树
合并果子
在一个果园里，达达已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。
达达决定把所有的果子合成一堆。
每一次合并，达达可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。
可以看出，所有的果子经过 n−1 次合并之后，就只剩下一堆了。
达达在合并果子时总共消耗的体力等于每次合并所耗体力之和。
因为还要花大力气把这些果子搬回家，所以达达在合并果子时要尽可能地节省体力。
假定每个果子重量都为 1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使达达耗费的体力最少，并输出这个最小的体力耗费值。
例如有 3 种果子，数目依次为 1，2，9。
可以先将 1、2 堆合并，新堆数目为 3，耗费体力为 3。
接着，将新堆与原先的第三堆合并，又得到新的堆，数目为 12，耗费体力为 12。
所以达达总共耗费体力=3+12=15。
可以证明 15 为最小的体力耗费值。
输入格式
输入包括两行，第一行是一个整数 n，表示果子的种类数。
第二行包含 n 个整数，用空格分隔，第 i 个整数 ai 是第 i 种果子的数目。
输出格式
输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。
输入数据保证这个值小于 2^31。
数据范围
1≤n≤10000,
1≤ai≤20000输入样例：
3 1 2 9输出样例：
15
huffman树是一个二叉树，所有叶子节点都是要合并的点
贪心策略：
每次挑出权值最小的两堆合并，局部最优解即全局最优解。
最小的两个点，深度一定最深，且可以互为兄弟节点
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
int main(){
int n;
cin>>n;
priority_queue<int,vector<int>,greater<int>> heap;//小根堆
while(n--){
int x;
cin>>x;
heap.push(x);//小根堆，直接存入即会自动排序
}
int res=0;
while(heap.size()>1){
int a=heap.top();heap.pop();
int b=heap.top();heap.pop();//取出最小的两个节点
res+=a+b;//合并
heap.push(a+b);//合并后的节点插到堆里
}
cout<<res<<endl;
return 0;
}
三、排序不等式
排队打水
有 n 个人排队到 1 个水龙头处打水，第 i 个人装满水桶所需的时间是 ti，请问如何安排他们的打水顺序才能使所有人的等待时间之和最小？
输入格式
第一行包含整数 n。
第二行包含 n 个整数，其中第 i 个整数表示第 i 个人装满水桶所花费的时间 ti。
输出格式
输出一个整数，表示最小的等待时间之和。
数据范围
1≤n≤105,
1≤ti≤104输入样例：
7 3 6 1 4 2 5 7输出样例：
56
按照从小到大的顺序排队，总时间最小。
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
const int N=100010;
int n;
int t[N];
int main(){
cin>>n;
for(int i=0;i<n;i++) cin>>t[i];
sort(t,t+n);
LL res=0;
for(int i=0;i<n;i++) res+=t[i]*(n-i-1);
cout<<res<<endl;
return 0;
}
四、绝对值不等式
货仓选址
在一条数轴上有 N 家商店，它们的坐标分别为 A1∼AN。
现在需要在数轴上建立一家货仓，每天清晨，从货仓到每家商店都要运送一车商品。
为了提高效率，求把货仓建在何处，可以使得货仓到每家商店的距离之和最小。
输入格式
第一行输入整数 N。
第二行 N 个整数 A1∼AN。
输出格式
输出一个整数，表示距离之和的最小值。
数据范围
1≤N≤100000,
0≤Ai≤40000输入样例：
4 6 2 9 1输出样例：
12
即求函数f的最小值，这里运用分组的做法
转化成：
据图分析，最优解一定在a和b之间
因此：f(x)>=
等号同时成立的条件，是x在最中间的两个数之间，或取到中位数，此时取最小值
#include<iostream>
#include<algorithm>
using namespace std;
const int N=100010;
int n;
int a[N];
int main(){
cin>>n;
for(int i=0;i<n;i++) scanf("%d",&a[i]);
sort(a,a+n);
int res=0;
for(int i=0;i<n;i++) res+=abs(a[i]-a[n/2]);
//a[n/2]是中位数
cout<<res<<endl;
return 0;
}
五、推公式
耍杂技的牛
农民约翰的 N 头奶牛（编号为 1…N）计划逃跑并加入马戏团，为此它们决定练习表演杂技。
奶牛们不是非常有创意，只提出了一个杂技表演：
叠罗汉，表演时，奶牛们站在彼此的身上，形成一个高高的垂直堆叠。
奶牛们正在试图找到自己在这个堆叠中应该所处的位置顺序。
这 N 头奶牛中的每一头都有着自己的重量 Wi 以及自己的强壮程度 Si。
一头牛支撑不住的可能性取决于它头上所有牛的总重量（不包括它自己）减去它的身体强壮程度的值，现在称该数值为风险值，风险值越大，这只牛撑不住的可能性越高。
您的任务是确定奶牛的排序，使得所有奶牛的风险值中的最大值尽可能的小。
输入格式
第一行输入整数 N，表示奶牛数量。
接下来 N 行，每行输入两个整数，表示牛的重量和强壮程度，第 ii 行表示第 i 头牛的重量 Wi 以及它的强壮程度 Si。
输出格式
输出一个整数，表示最大风险值的最小可能值。
数据范围
1≤N≤50000,
1≤Wi≤10,000,
1≤Si≤1,000,000,000输入样例：
3 10 3 2 5 3 3输出样例：
2
每头牛的危险值 = 他前面牛的w(重量值)和 - 自身的s(强壮值)，要使每头牛的危险值最小，这显然是与w 和 s同时相关
所以，按照wi+si从小到大的顺序排，最大的危险系数一定是最小的。
贪心得到的答案>=最优解：最优解是所有方案的最小值
贪心得到的答案<=最优解：如果不是按照这样排序，则一定存在wi+si>w(i+1)+s(i+1)
对其他牛无影响，故只需看第i头和第i+1头的危险系数
对相同的部分进行化简处理：
四个数均+s(i)+s(i+1)
即：
所以得到做法: 按每头牛的 w + s 进行排序，当存在逆序时就进行交换(即升序排序)
然后根据题意算出每头牛的危险值记录其中的最大值即可
#include<iostream>
#include<algorithm>
using namespace std;
//需要按照w+s排序，故存到pair里
typedef pair<int,int>PII;
const int N=50010;
int n;
PII cow[N];
int main(){
cin>>n;
for(int i=0;i<n;i++){
int w,s;
cin>>w>>s;
cow[i]={w+s,w};
}
sort(cow,cow+n);
int res=-2e9;//危险系数
int sum=0;//上面所有牛的重量之和
for(int i=0;i<n;i++){
int w=cow[i].second,s=cow[i].first-w;
res=max(res,sum-s);//计算当前危险系数
sum+=w;
}
printf("%d\n",res);
return 0;
}
参考：
1、https://www.acwing.com/solution/content/17241/
2、https://www.acwing.com/solution/content/8902/
3、https://www.acwing.com/solution/content/845/
扫一扫
1740
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
