「学习笔记」反悔贪心

一.什么是反悔贪心#

顾名思义，反悔贪心就是两个操作：“反悔” + “贪心”。

一般来说，贪心仅能解出局部最优解。

那么在要求全局最优解时，我们就可以利用“反悔”这个操作解决。

反悔贪心的思想是：每次都进行操作，在以后有最优情况的时候再取消这次操作。

二.基本反悔贪心#

一般来说，我们采用一个堆来存选的元素，堆顶是最劣解。

分两种情况：

$1.$ 符合某种条件时，推入堆，计算答案。

$2.$ 不符合某种条件时，与堆顶比较，做出操作。

接下来用一些例题来帮助大家理解这个算法。

三.反悔贪心例题#

CF865D Buy Low Sell High#

可以算是反悔贪心的模板了。

对于当前操作，我们要让收益最大，那么就要在最低点买入，最高点卖出。

我们可以用一个堆来记录今天之前的最小值，然后操作，就等于今天卖出最小值那天买入。

显然，这不是最优解法，因为我们没有考虑到后面的更优解法。

那么我们采用“反悔”操作，在卖出时，将当前价格推入堆，当做买入，那么这样计算的答案就是最优解。

也就是说，当前卖出价格 $x$，更优卖出价格 $y$，买入价格 $z$，最优解 $y - z$ 等于 $(x-z)+(y-x)$。

代码就很好写了：

Copy
#include <bits/stdc++.h>

using namespace std;

#define int long long

struct Node {
	int x;
	
	Node (int x = 0) : x(x) {
		
	}
	
	bool operator < (const Node &xx) const {
		return xx.x < x;
	} 
};

priority_queue<Node> q;//小根堆。

int n, ans = 0ll; 

signed main () {
	cin >> n;
	
	for (int i = 1, x; i <= n; i ++) {
		cin >> x;
		
		q.push (x);//每一个都当做买入。 
		
		if (!q.empty() && q.top().x < x) {
			//当前卖出价格大于最低价格时。 
			
			ans += x - q.top().x;
			//当前价格和堆顶相减，累计答案。 
			
			q.pop ();
			//弹出最低价格。 
			
			q.push (x);
			//推入当前价格，反悔操作。 
		}
	}
	
	cout << ans;
	
	return 0;
}

---

P2209 [USACO13OPEN]Fuel Economy S#

正好打模拟赛碰到，一起写了。

显然，我们有一个反悔贪心的思路。

首先要判断无解情况：
$1.$ $B$ 个单位的油无法到达第一个加油站。

$2.$ 第 $i$ 个加油站与第 $i+1$ 个加油站的距离大于 $G$ $(1\le i<N)$。

$3.$ 在第 $N$ 个加油站即使满油也无法到达 $D$。

然后可以进行反悔贪心。

首先，为了从第 $i$ 个加油站到第 $i+1$ 个加油站（或终点），我们都需要加满油。（贪心操作）

第 $i$ 个加油站到第 $i+1$ 个加油站之间多余的油，可以退掉。（反悔操作）

而应该如何使用油呢？显然，我们优先使用单位价格低的油，这样就能使总花费最小。

Copy
#include <bits/stdc++.h>

using namespace std;

const int N = 55555;

#define int long long

int n, g, b, d;

struct Node {
	int x;
	int y;
	
	Node (int x = 0, int y = 0) : x (x), y (y){
		
	}
	
	bool operator < (const Node & xx) const {
		return x < xx.x;
	} 
}a[N];

int l = 0, r = -1;

struct Oil {
	int v;
	int t;
	
	Oil (int v = 0, int t = 0) : v (v), t (t) {
		
	}
	
	bool operator < (const Oil & xx) const {
		return v < xx.v;
	} 
	
	//单调性。	
}q[N];

int calc (int len) {//走距离为len的花费 
	int res = 0;
	
	while (len > 0) {
		if (q[l].t > len) {//不需要用完最便宜的油就可以走到。 
			res += len * q[l].v;
			
			q[l].t -= len;
			
			len = 0;
		}
		
		else {//需要用光最便宜的油。 
			res += q[l].t * q[l].v; 
			
			len -= q[l].t;
			
			l ++;
		}
	}
	
	return res;
}

signed main () {
	cin >> n >> g >> b >> d;
	
	for (int i = 1; i <= n; i ++) {
		cin >> a[i].x >> a[i].y;
	}
	
	a[++ n] = Node (d, 0);//把终点也当做加油站。 
	
	sort (a + 1, a + 1 + n);
	
	if (a[1].x >= b) {
		puts ("-1");
		
		return 0;
	}
	
	for (int i = 2; i <= n; i ++) {
		if (a[i].x - a[i - 1].x > g) {
			puts ("-1");
			
			return 0;
		}
	}
	
	//判无解。 
	
	q[++ r] = Oil (0, b);//加入初始油。 
	
	int ans = 0;
	
	a[0].x = 0;
	
	for (int i = 1; i <= n; i ++) {
		ans += calc (a[i].x - a[i - 1].x);//从第i-1个加油站到第i个加油站。 
		b -= a[i].x - a[i - 1].x;
		
		if (i == n) {
			cout << ans;
			
			return 0;
		}
		
		while (l <= r && q[r].v > a[i].y) {//反悔操作。
			//从r开始退油，保证退的油较贵。
			 
			b -= q[r].t;
			
			r --;
		}
		
		q[++ r] = Oil (a[i].y, g - b);//加满油。 
		
		b = g;
	}
	
	return 0;
} 

---

P2949 [USACO09OPEN]Work Scheduling G#

反悔的操作比较明显。

如果可以进行操作，那么就操作。

如果当前任务已经截止，就反悔操作，与最劣解比较。

Copy
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define int ll

const int N = 1e5 + 7;

struct Node {
	int d;
	int p;
}a[N];

inline bool cmp (Node x, Node y) {
    return x.d < y.d;
}

int n;

priority_queue<int, vector<int>, greater<int> > q;//小根堆。

signed main () {
    cin >> n;

    for (int i = 1; i <= n; i ++) {
    	cin >> a[i].d >> a[i].p;
	}
	
	sort (a + 1, a + 1 + n, cmp);//按截止时间排序。
	
	int ans = 0;
	
	for (int i = 1; i <= n; i ++) {
	    if (a[i].d <= q.size ()) {
		//每项任务花费时间都是1，那么队列长度就是当前时间。
		//于是这行就表示当前任务已经截止的情况。
	        if (q.top() < a[i].p) {
	            ans += a[i].p - q.top();//反悔操作。
	            
	            q.pop ();
	            
	            q.push (a[i].p);
	        }
	    }
	    
	    else {
	        ans += a[i].p;
	        
	        q.push (a[i].p);
			
			//贪心操作，每项都做。
	    }
	}
	
	cout << ans;

	return 0;
}

---

P4053 [JSOI2007]建筑抢修#

和上一题很像。

我们开一个大根堆，存入工程需要的时间。

堆顶放的是最劣解，也就是说工程需要的时间越久越不好，所以开大根堆。

分两种情况：

$1.$ 当前任务无法完成时：反悔操作，与堆顶比较，取用时短的较优解。

$2.$ 当前任务可以完成时：贪心操作，完成该操作，推入堆。

代码：

Copy
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

template <typename T>

inline T read() {
	T x = 0, f = 1;

	char ch = getchar();

	while (!isdigit(ch)) {
		if(ch=='-') {
	    	f = -1;

			ch = getchar();
  		}
	}

	while (isdigit (ch)) {
		  x = x * 10 + (ch ^ 48);

		  ch = getchar();
	}

	return x * f;
}

const int N = 155555;

struct Node {
	int t1;
	int t2;
	
	inline bool operator < (const Node &x) const {
		return t2 < x.t2;
	}
}a[N];

int n;

int main () {
    int n = read<int>(), mx = -1;

    for (int i = 1; i <= n; i ++) {
    	a[i].t1 = read<int>();
    	a[i].t2 = read<int>();
    }
    
    sort (a + 1, a + 1 + n);//按截止时间排序。
    
    priority_queue<int> q;
    
    int now = 0, ans = 0;
	
	//now表示当前时间。
    
    for (int i = 1; i <= n; i ++) {
    	if (now + a[i].t1 > a[i].t2) {//反悔操作。
    		if (a[i].t1 < q.top ()) {
    			now -= q.top () - a[i].t1;//时间减少。
    			
    			q.pop ();
    			
    			q.push (a[i].t1);
    		}
    	}
    	
    	else {//贪心操作。
    		q.push (a[i].t1);
    		
    		now += a[i].t1;
    		
    		ans ++;//任务可以完成。
    	}
    }
    
    cout << ans << endl;

	return 0;
}