学习笔记反悔贪心

Dawn-_-cx

已于 2024-03-09 14:58:22 修改

阅读量1.2k

点赞数 28

分类专栏：基础算法文章标签： c++ 算法

于 2024-03-09 11:46:41 首次发布

本文链接：https://blog.csdn.net/dhdhdhx/article/details/136570335

版权

基础算法专栏收录该内容

10 篇文章 1 订阅

订阅专栏

0.写在前面

好久没更了，这周是开学第一周 $A CM$ 队临时安排讲课任务，没人讲，我就揽下来这活了。前两天有一道 $c f$ 的 $d i v 2 C$ 用到了反悔贪心这个技巧，也不需要什么前置算法就可以学，所以我第一时间想到的就是讲反悔贪心了，顺便更一下好久没更过的博客当备课了。

这个技巧的思维含量不是很高，大家可能或多或少在之前无意间用出来过。我第一次了解这个技巧是在去年暑假的时候，我的队友跟我说要给我讲一个他新学的小 $t r i c k$ ，给我看了一道题洛谷P1484 种树，我之前从来没了解过这个小技巧但是做过这个题。

1.随便讲讲

字面意思，反悔贪心就是可以反悔的贪心。贪心本身是没有反悔操作的，通过对一个问题应用特定的问题选出最优解。然而有时候我们发现贪心只能得到局部最优解，这时候可以进行反悔操作。为了实现反悔操作，我们要记录下前面操作的最大/最小值等信息，因此反悔贪心大多会使用一些数据结构进行实现。

毕竟这只是一个小技巧不是一个算法，只靠说大家可能不好理解，我们直接进入例题，就题分析。

2.例题

CF865D Buy Low Sell High

一个我觉得比较好解释反悔贪心思想的例题

题意：对于一支股票，你可以知道后面 $N$ 天这个股票的价格，每天可以在两种操作中选一种：买入一股该股票、卖出一股之前买入的股票。要求在最后一天手里不能有任何股票。求最后最多能赚多少钱。其中 $N\le 3\times 10^5$ 。

对于买股票的操作，我们观察到题目要求最后一天手里不能有任何股票，所以我们只要没有卖出的操作，就直接进行买入操作，如果最后这支股票卖不出去，我们进行反悔，这股票我不买了退了，就当我那一天没买过。

对于卖股票的操作，我们什么时机卖呢，肯定是价格高于当前买入，但是如果卖亏了怎么办，我们选择反悔上次卖的，相当于上次不卖了退回来，这次再卖。

这就是反悔贪心的思想，具体怎么实现呢？

我们使用小根堆 $q$ 来存储买入的价格。

对于第 $i$ 天价格 $a_i$ ，如果该价格不超过当前小根堆堆顶的价格，那么我们无法进行卖出操作，只能进行买入操作，因此将 $a_i$ 入堆即可。此时入堆的 $a_i$ 的意义为：记录下当前的买入价格，为后续卖出操作准备。

如果该价格超过了当前小根堆堆顶的价格，即 $a_i>q.top$ ，意味着我们可以进行卖出操作，此时我们就将堆顶元素弹出，并将 $a_i$ 入堆，该操作堆答案的贡献为 $a_i-q.top$ 。此时入堆的 $a_i$ 的意义为：记录当前卖出的价格，为后续反悔操作准备。此时我们会发现，如果后续进行了反悔操作，那么就相当于这一天没有卖出，因此还要将这一天的价格再次入堆，此时入堆的 $a_i$ 的意义为：填补进行了反悔操作后这一天的空挡。

这样我们就通过用一个小根堆来维护了我们反悔贪心的思想。

代码很短↓

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll ans;
int n;
priority_queue<int,vector<int>,greater<int>> q;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    cin>>n;
    for(int i=1,x;i<=n;i++){
        cin>>x;
        if(!q.empty()&&q.top()<x)
            ans+=x-q.top(),
            q.pop(),
            q.push(x);
        q.push(x);
    }
    cout<<ans<<'\n';
}

洛谷P1484 种树

一道非常经典的反悔贪心题

题意：给定一个长度为 $n(n\le3\times 10^5)$ 的序列 $a$ ，第 $i$ 个数为 $a_i(-10^6\le a_i\le 10^6)$ ，求在该数列中选出不超过 $k(0\le k\le\lfloor\frac{n}{2}\rfloor)$ 个数的和最大。限制条件为选了第 $i$ 个位置的 $a_i$ 就不能选该位置两侧的 $a_{i-1}$ 和 $a_{i+1}$ 。

对问题进行简化：取消限制条件，即在 $n$ 个数中选出不超过 $k$ 个数的和最大。

利用贪心的思想，从最大的数开始选，直到选满 $k$ 个数或选到负数为止。

现在回到这个问题，如果继续利用之前的贪心的思想，很容易举出反例。例如 $a[]=\{2,3,2\}$ ，从最大的开始选会选到 $a_2=3$ ，但是最有策略明显是选择 $a_1$ 和 $a_3$ ，贡献为 $a_1+a_3=4>3=a_2$ 。通过上述例子，我们发现选当前位置的两侧和选当前位置 $i$ 的差值 $d=a_{i+1}+a_{i-1}-a_i$ 。如果只考虑这三个位置，当 $d > 0$ 时，我们选择两侧的更优；当 $d < 0$ 时，我们选择第 $i$ 个位置更优。

因此考虑反悔贪心，我们每次选到 $a_i$ 的时候，将 $a_i$ 记录进答案，同时将当前位置和两侧的差值 $d$ 放回 $a_i$ ，并将 $a_{i-1}$ 和 $a_{i+1}$ 拿出序列。这样如果我们再次选到了 $a_i$ ，这时第 $i$ 个位置对答案的贡献为第一次的 $a_i$ 和第二次的 $d=a_{i+1}+a_{i-1}-a_i$ ，总贡献为 $a_{i+1}+a{i-1}$ ，其意义是不选择 $a_i$ 选择 $a_{i+1}$ 和 $a_{i-1}$ 。

因此只需要开一个大根堆，代表待选的数的集合，维护一个 $l, r$ 数组代表当前位置的左侧和右侧，同时记录已经被选过的位置防止选重即可。时间复杂度为 $O(k\log n)$ 。

代码↓

#include<bits/stdc++.h>
using namespace std;
const int N = 3e5 + 100;
struct node{
    int id,w;
    node(){
        id=w=0;
    }
    node(int x, int y){
        id=x,w=y;
    }
    bool operator<(const node &x) const{
        return w<x.w;
    }
};
int n,k,a[N],l[N],r[N];
bool vis[N];
priority_queue<node> q;
typedef long long ll;
ll ans;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    cin>>n>>k;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        l[i]=i-1,r[i]=i+1;
        q.push(node(i,a[i]));
    }
    for(int i=1;i<=k;i++){
        while(vis[q.top().id])q.pop();
        node now=q.top();
        if(now.w<0)break;
        q.pop();
        ans+=now.w;
        a[now.id]=now.w=a[l[now.id]]+a[r[now.id]]-a[now.id];
        q.push(now);
        vis[l[now.id]]=vis[r[now.id]]=1;
        l[now.id]=l[l[now.id]],r[now.id]=r[r[now.id]];
        l[r[now.id]]=r[l[now.id]]=now.id;
    }
    cout<<ans<<'\n';
    
}

cf1935C Messenger in MAC

最新的用到反悔贪心的cf比赛题

题意：有 $n(1\le n\le 2000)$ 条短信，第 $i$ 条短信包含两个信息 $a_i$ 和 $b_i(1\le a_i,b_i\le 10^9)$ ，读取下标为 $p_1,p_2,\dots,p_k$ 的短信所需要的时间为 $\sum_{i=1}^{k}a_{p_k}+\sum_{i=1}^{k-1}\mid b_{p_k}-b_{p_{k+1}} \mid$ 。求在给定时间 $l(1\le l\le 10^9)$ 内最多能读取多少条短信。 $T(1\le T\le 5\times10^4)$ 组数据， $\sum n^2\le 4\times10^6$ 。

对问题进行拆分，分成两个问题：选出第 $p_1,p_2,\dots,p_k$ 位置的短信，如何安排能使得总时间最短；以及如何选出 $p_1,p_2,\dots,p_k$ 。

首先第一个问题：选出第 $p_1,p_2,\dots,p_k$ 位置的短信，如何安排顺序能使得总时间最短？

观察式子，可以发现对于信息 $a$ ，如何安排对时间的贡献是相同的，因此只需要考虑信息 $b$ ，不难发现将 $b$ 按顺序排列是最优的，此时所需时间为 $\sum_{i=1}^k a_{p_k}+b_{max}-b_{min}$ 。即对于选出的第 $p_1,p_2,\dots,p_k$ 位置的短信，我们读取这些短信所需时间为所有短信 $a$ 的总和加上这些短信的 $b$ 中最大与最小的差。

对于第二个问题，我们考虑到上面化简的式子中，如果确定了 $b$ 的值，那么就是选出最小的 $a_i$ ，因此我们考虑按 $b$ 从小到大排序， $b$ 相同的按 $a$ 从小到大排序，并枚举最小的 $b$ 。我们的贪心策略是使得 $b_{max}-b_{min}$ 尽可能的小，因此先将 $b$ 相同的选出，再去考虑 $b$ 不同的。对于一个 $b$ 大于当前 $b$ 的短信，读取它的时间为 $a_i+b-b_{now}$ 。此时在考虑反悔操作，如果前面选了 $a_p>a_i+b-b_{now}$ ，就将 $a_p$ 反悔，不进行选择，并将当前的 $b$ 进行更新。通过建一个堆即可维护反悔操作。

赛时代码↓

#include<bits/stdc++.h>
#define endl '\n'
using namespace std;
typedef long long ll;
const int N = 3e5 + 100;
const int mod = 998244353;
inline void read(int &x){
    int s=0,w=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
    x=s*w;
}
struct node{
    int a,b;
    node(){
        a=b=0;
    }
    node(int x, int y){
        a=x,b=y;
    }
}ms[N];
bool cmp(node x, node y){
    if(x.b!=y.b)return x.b<y.b;
    else return x.a<y.a;
}
int n,T,nxt[N];
ll l;
void solve(){
    cin>>n>>l;
    for(int i=1;i<=n;i++)cin>>ms[i].a>>ms[i].b;
    sort(ms+1,ms+1+n,cmp);
    ms[n+1]=node(0,0);
    nxt[n]=n+1;
    for(int i=n-1;i;i--){
        nxt[i]=nxt[i+1];
        if(ms[i].b!=ms[i+1].b)nxt[i]=i+1;
    }
    int ans=0;
    for(int i=1;i<=n;i++){
        ll now=ms[i].a;
        int nb=ms[i].b,cnt=1;
        if(now>l)continue;
        priority_queue<int> q;
        for(int j=i+1;j<nxt[i];j++){
            if(now+ms[j].a<=l)now+=ms[j].a,q.push(ms[j].a),cnt++;
            else break;
        }
        ans=max(ans,cnt);
        for(int j=nxt[i];j<=n;j++){
            if(ms[j].b!=nb){
                now+=ms[j].b-nb;
                nb=ms[j].b;
                while(now>l&&!q.empty()){
                    now-=q.top();
                    q.pop();
                    cnt--;
                }
                if(now>l)break;
            }
            if(now+ms[j].a<=l)now+=ms[j].a,q.push(ms[j].a),cnt++;
            else {
                if(!q.empty()){
                    if(ms[j].a<q.top()){
                        now+=ms[j].a;
                        now-=q.top();
                        q.pop();
                        q.push(ms[j].a);
                    }
                }
            }
            ans=max(ans,cnt);
        }

    }
    cout<<ans<<'\n';
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    cin>>T;
    while(T--)solve();
    return 0;
}