后悔贪心定义

后悔贪心： 这个主要是因为我们正常的贪心是得不到最优解的，所以我们需要对我们的贪心的决策进行修改。

可以数形结合进行理解：

这里看上去我们通过普通的贪心达到了局部最优解，但是我们可以发现这个时候并不是全局最优解，所以我们可以通过对其进行修改来达到全局最优解。也就是先爬下去再爬到另外一座真正的最高峰。这个一个后悔贪心的一个大题思路。

用时一定模型

题目描述
我们考虑这样一个问题，我们有n个任务(n≤1e5)，每个任务都恰好需要一个单位时间完成，并且每个任务都有两个属性——截止日期和价值。在截止日期前完成任务就可以得到这个任务产生的价值。每个单位时间我们都可以选择这n个任务当中还没有做过的并且还没有截止的任务中的一个去完成，问我们最后最多能得到多少价值呢？

A

题目链接
核心思路：这里我们一个大致的思路肯定是贪心，但是该怎么去贪心呢，这是一个很大的问题。因为我们发现我们的一个结果其实是和deadline和value都相关的。我们如果贪心的话肯定只可以对其中一个进行贪心。所以这个是肯定达不到全局最优解的。
所以这就需要我们使用后悔贪心了，也就是边贪心边修改。我们首先一个想法肯定是需要先把截至日期进行排序，也就是先对日期进行贪心。需要注意的是完成每个操作的耗时都是1。
再然后我们可以使用小根堆对于value排序，因为我们堆顶储存的是我们的最小价值，所以如果时间允许的话那我们就可以将当前元素替换到我们的堆顶。也就是完成了后悔贪心的修改操作。

// Problem: P2949 [USACO09OPEN]Work Scheduling G
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P2949
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
#define IOS std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define NO {puts("NO") ; return ;}
#define YES {puts("YES") ; return ;}
#define endl "\n"
const int N=3e5+10;


struct Node{
	int deadline,value;
	bool operator < (const Node &v)const
	{
		return value>v.value;
	}
}a[N];
int cmp(Node x,Node y)
{
	return x.deadline<y.deadline;
}
priority_queue<Node> q;

int main()
{
int n;
cin>>n;
for(int i=1;i<=n;i++)
{
	cin>>a[i].deadline>>a[i].value;
}
sort(a+1,a+1+n,cmp);//按照截至日期排序
LL ans=0;
for(int i=1;i<=n;i++)
{
	if(a[i].deadline>q.size())//如果时间允许的话
	{
		q.push(a[i]);
		ans+=a[i].value;
	}
	else
	{
		if(a[i].value>q.top().value)//替换堆顶元素
		{
			ans-=q.top().value;
			q.pop();
			ans+=a[i].value;
			q.push(a[i]);
		}
	}
	
}
cout<<ans<<endl;

}

价值一定模型

题目描述
我们再来考虑这样一个问题，我们有n个任务(\(n\leq10000\))，并且每个任务都有两个属性——截止日期和完成耗时。在截止日期前完成任务就可以得到这个任务产生的价值。在同一时间我们只能去做一个任务。所有任务的价值都是一样的，问我们最后最多能完成多少个任务。
题目链接
核心思路
这里和我们上一个题目的不同之处是这里的耗时不相同了，也就是这里的完成了每个任务的时间不是1了。所以这个题目我们可以把这里的耗时看成上一个题目的价值，不过和上面的不同之处是我们首先选价值比较大的，但是这里我们是首先选耗时比较小的。所以也只有重载运算符的不同。
还有一个需要注意的是我们需要记录我们当前队列的总耗时，看有没有超过我们当前元素的deadline.

// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P4053
// Memory Limit: 128 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
#define IOS std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define NO {puts("NO") ; return ;}
#define YES {puts("YES") ; return ;}
#define endl "\n"
const int N=1e6+10;

struct node{
	int time,deadline;
	bool operator <(const node& v)const {
		return time<v.time;
	}
}a[N];//因为是大根堆所以是<
bool cmp(node x,node y)
{
	return x.deadline<y.deadline;
}
priority_queue<node> q;

LL last=0;


int main()
{
int n;
cin>>n;
for(int i=1;i<=n;i++)
{
	cin>>a[i].time>>a[i].deadline;
}
sort(a+1,a+1+n,cmp);
for(int i=1;i<=n;i++)
{
	if(a[i].deadline>=last+a[i].time)
	{
		last+=a[i].time;
		q.push(a[i]);
	}
	else
	{
		if(a[i].time<q.top().time)
		{
			last-=q.top().time;
			q.pop();
			last+=a[i].time;//一定要注意加
			q.push(a[i]);
		}
	}
}
printf("%lld",q.size());
return 0;
}

后悔自动机

题目描述
我们考虑这样一个问题，假如我们要种树，我们在一条直线上挖了 n (n ≤ 5e5)个坑。这 n 个坑都可以种树，但为了保证每一棵树都有充足的养料，我们不会在相邻的两个坑中种树。而且由于树种不够，我们至多会种 m (m ≤ n / 2)棵树。假设我们能预知自己在某个坑种树的获利会是多少（可能为负），求我们的最大获利。
核心思路
我们一个基本的想法就是将某一个股票使用较低的价格买入，然后再收益比较高的时候再卖出。所以我们可以使用小根堆来进行维护。也就是如果遇到了大于堆顶元素的股票就可以考虑卖出了。然后再将这只新的股票买进去。

// Problem: D. Buy Low Sell High
// Contest: Codeforces - MemSQL Start[c]UP 3.0 - Round 2 (onsite finalists)
// URL: https://codeforces.com/contest/865/problem/D
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
#define IOS std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define NO {puts("NO") ; return ;}
#define YES {puts("YES") ; return ;}
#define endl "\n"
const int N=1e6+10;
struct node{
	int value;
	bool operator < (const node& v) const
	{
		return value>v.value;//小根堆
	}
}a[N];
priority_queue<node> q;
int n;
LL ans=0;



int main()
{
cin>>n;
for(int i=1;i<=n;i++)
{
	cin>>a[i].value;
}
for(int i=1;i<=n;i++)
{
	q.push(a[i]);//先买入
	if(!q.empty()&&q.top().value<a[i].value)
	{
		ans+=a[i].value-q.top().value;
		q.pop();//卖出
		q.push(a[i]);//再买入。这就是我们的后悔操作。
		
	}
}
cout<<ans<<endl;
return 0;
}

参考下这位大佬的博客