AcWing算法基础课贪心模板题

一、区间问题

区间选点、最大不相交区间数量

题解：

1）如何选点？

（1）将每个区间按右端点递增排序、

（2）从前往后遍历每个区间，如果当前区间中已经包含点，跳过，否则选取当前区间的右端点

PS:此方法选择的点必然是序列中无交集的区间的数量，所以此方法适用于两题

2）证明？

最优解$ans$：所有合法方案中的最小值，贪心解$cnt$：上述选法

（1）上述选法必然会使每个区间里至少包含一个点，是一种合法方案，所以$ans<=cnt$

（2）通过贪心方案我们知道序列中包含了$cnt$个相互之间没有交集的区间，所以对于一个合法方案，必然至少包含$cnt$个点，所以$cnt<=ans$

#include<bits/stdc++.h>
#define r first
#define l second
using namespace std;
typedef pair<int,int>PII;
const int N=1e5+10;
PII g[N];
int n;
int main(){
    cin>>n;
    for(int i=0;i<n;i++){
        int a,b; cin>>a>>b;
        g[i]={b,a};
    }
    sort(g,g+n);
    int ans=1,pos=g[0].r;
    for(int i=0;i<n;i++){
        if(g[i].l>pos){
            pos=g[i].r;
            ans++;
        }
    }
    cout<<ans;
}

按照左端点递增排序，选左端点做法：

#include<bits/stdc++.h>
#define l first
#define r second
using namespace std;
typedef pair<int,int>PII;
const int N=1e5+10;
PII g[N];
int n;
int main(){
    cin>>n;
    for(int i=0;i<n;i++){
        int a,b; cin>>a>>b;
        g[i]={a,b};
    }
    sort(g,g+n);
    int ans=1,pos=g[n-1].l;
    for(int i=n-1;i>=0;i--){
        if(g[i].r<pos){
            pos=g[i].l;
            ans++;
        }
    }
    cout<<ans;
}

区间分组

题解：

1）方案？

（1）将所有区间按左端点递增排序

（2）从左往右枚举每个区间，判断能否放进现有的组中，能则更新选择组的$maxr$，否则新开一个组

2）证明？

最优解$ans$，贪心解$cnt$

（1）对于贪心解$cnt$来说，一定可以使每个区间被包含到某个组中，所以$ans<=cnt$

（2）对于贪心解$cnt$，每一组所包含的区间一定有交集，否则不会新开一个组，所以对于一个合法方案至少包含$cnt$个组，所以$cnt<=ans$

左端点递增排序

#include<bits/stdc++.h>
#define l first
#define r second
using namespace std;
typedef pair<int,int>PII;
const int N=1e5+10;
int n;
PII g[N];
int main(){
    cin>>n;
    for(int i=0;i<n;i++){
        int a,b; cin>>a>>b;
        g[i]={a,b};
    }
    sort(g,g+n);
    priority_queue<int,vector<int>,greater<int>>q;
    q.push(g[0].r);
    for(int i=1;i<n;i++){
        auto [l,r]=g[i];
        int t=q.top();
        if(t<l){
            q.pop(),q.push(r);
        }
        else q.push(r);
    }
    cout<<q.size();
}

右端点递增排序

#include<bits/stdc++.h>
#define r first
#define l second
using namespace std;
typedef pair<int,int>PII;
const int N=1e5+10;
int n;
PII g[N];
int main(){
    cin>>n;
    for(int i=0;i<n;i++){
        int a,b; cin>>a>>b;
        g[i]={b,a};
    }
    sort(g,g+n);
    priority_queue<int>q;
    q.push(g[n-1].l);
    for(int i=n-2;i>=0;i--){
        auto [r,l]=g[i];
        int t=q.top();
        if(t>r){
            q.pop(),q.push(l);
        }
        else q.push(l);
    }
    cout<<q.size();
}

巨巨的做法：（扫描线）

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int n;
int g[N*2];
int main(){
    cin>>n;
    int cnt=0;
    for(int i=0;i<n;i++){
        int l,r; cin>>l>>r;
        g[cnt++]=l*2,g[cnt++]=r*2+1;
    }
    sort(g,g+cnt);
    int ans=0,now=0;
    for(int i=0;i<cnt;i++){
        if(g[i]%2) now--;
        else now++;
        ans=max(ans,now);
    }
    cout<<ans;
}

区间覆盖

题解：

1）方案？

（1）将所有区间按左端点递增排序

（2）从左往右遍历每个区间，在所有能覆盖$st$的区间中，选择右端点最大的区间，然后将st更新右端点的最大值

2）证明？（反证法）

最优解$ans$，贪心解$cnt$

不考虑无解情况

假设$ans$与$cnt$在第$i$个区间不同，由于贪心解找的是能覆盖st的情况下右端点最大的区间，所以当前$an{s}_r<cn{t}_r$，对于最优解的第$i+1$区间$x$有$an{s}_r>=x_l$，所以必然有$cn{t}_r>x_l$，所以最优解在第$i$个位置即使替换为与贪心解相同的区间也不会影响选取的区间个数，即使之后仍有与贪心解中不同的区间，也可将最优解中的区间替换为对应的贪心解中的区间，所以$ans=cnt$

#include<bits/stdc++.h>
#define l first
#define r second
using namespace std;
typedef pair<int,int>PII;
const int N=1e5+10;
int n,st,ed;
PII g[N];
int main(){
    cin>>st>>ed>>n;
    for(int i=0;i<n;i++){
        int a,b; cin>>a>>b;
        g[i]={a,b};
    }
    sort(g,g+n);
    int ans=0;
    bool f=0;
    for(int i=0;i<n;i++){
        int j=i,pos=-2e9;
        while(j<n&&g[j].l<=st) pos=max(g[j].r,pos),j++;//找最靠右的端点
        if(pos<st){
            ans=-1;
            break;
        }
        ans++;
        if(pos>=ed){
            f=1;
            break;
        }
        st=pos;
        i=j-1;
    }
    if(!f) ans=-1;
    cout<<ans;
}

二、排序不等式

排队打水

题解：

如何算每个人的等待时间？

对于第$i$个人而言，它后面的人必然要等它打完水，所以对于第$i$个人，所有人花费在它身上的等待时间为$s[i]\ast (n-i)$，所以应该按照每个人打水时间递增的顺序打水才能让总的打水时间最短

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
int n;
int s[N];
int main(){
    cin>>n;
    for(int i=1;i<=n;i++) cin>>s[i];
    sort(s+1,s+n+1);
    ll ans=0;
    for(int i=1;i<n;i++) ans+=s[i]*(n-i);
    cout<<ans;
    return 0;
}

三、中位数定理

货仓选址

题解：

找中位数

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int n;
int a[N];
int main(){
    cin>>n;
    for(int i=0;i<n;i++) cin>>a[i];
    sort(a,a+n);
    int sum=0;
    for(int i=0;i<n;i++) sum+=abs(a[i]-a[n/2]);//当n为偶数时取左中右中均可
    cout<<sum;
}

四、推公式

耍杂技的牛

题解：

如何构造最小的最大风险值？

局部调整法

第$i$头牛，第$i+1$头牛的风险值为：
$$\begin{gathered} 第i头牛：an{s}_i=w_1+w_2+...+w_{i-1}-s_i \\ 第i+1头牛：an{s}_{i+1}=w_1+w_2+...+w_{i-1}+w_i-s_{i+1} \end{gathered}$$
交换这两头牛在序列中的顺序：
$$\begin{gathered} 第i头牛：an{s}_i=w_1+w_2+...+w_{i-1}+w_{i+1}-s_i \\ 第i+1头牛：an{s}_{i+1}=w_1+w_2+...+w_{i-1}-s_{i+1} \end{gathered}$$
设$C={\sum }_{j=1}^{i-1}{w}_j$

得：

变化	第i个位置上的牛	第i+1个位置上的牛
交换前	$C-s_i$	$C+w_i-s_{i+1}$
交换后	$C+w_{i+1}-s_i$	$C-s_{i+1}$

化简得

变化	第i个位置上的牛	第i+1个位置上的牛
交换前	$-s_i$	$w_i-s_{i+1}$
交换后	$w_{i+1}-s_i$	$-s_{i+1}$

什么情况下交换前的$max>$ 交换后的$max$?

1）显然$w_i-s_{i+1}>-s_{i+1}$

2）当$w_i+s_i>w_{i+1}+s_{i+1}$时，有$w_i-s_{i+1}>w_{i+1}-s_i$

所以当$w_i+s_i>w_{i+1}+s_{i+1}$时，一定有交换前的风险最大值=$max(-s_i,w_i-s_{i+1})>$ 交换后的风险最大值

所以当按照$w+s$递增顺序排列时，会取得最小的风险最大值

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int>PII;
const int N=1e5+10;
PII g[N];
int n;
int main(){
    cin>>n;
    for(int i=0;i<n;i++){
        int a,b;
        cin>>a>>b;
        g[i]={a+b,b};
    }
    sort(g,g+n);
    int ans=-2e9-10,res=0;
    for(int i=0;i<n;i++){
        auto [w,s]=g[i];
        ans=max(ans,res-s);
        res+=w-s;
    }
    cout<<ans;
}