2021 牛客第三场 G

行不行不行不行……
比赛的时候队友给我说了一说题意，想了一下没有想出来，主要是前边的简单题目都不会…
做法：
把给定的区间都当成限制，我们考虑区间的限制肯定越少越好。
给定两个结论，我们来证一下
结论一：对于两个区间$a,b$, 假如$b$完全包括$a$， 对于$b$区间，对于最优解我们有两种选择：
第一种：和$a$区间放到一个组。
第二种：单独放到一个组中。
第一种选择很好理解，我们怎样理解第二种选择呢，我们前边说过一句话，把区间都当成限制，假如$b$区间没有单独放到一个组中，我们可以将$b$区间所在的组中拿出$b$区间，然后放到$a$所在的组中，这样操作后，$a$所在的组对答案的贡献是不变的，对于$b$所在组，由于少了$b$区间的限制，所以答案只能更加优秀。
结论二：除去类似于这样的区间，我们对剩下的区间按照左端点进行排序，每个区间都用其排序后的下标来表示，剩下的区间形成的最优解的每个组别中的区间下标一定是连续的，类似于这样 { 1 ， 2 ， 3 } , { 4 ， 5 } , { 6 , 7 } \{1， 2， 3\},\{4， 5\}, \{6, 7\} {1，2，3},{4，5},{6,7}.
Q:为什么？
因为我们将所有的$b$类区都已经去除了，那么我们剩下的区间，对于每两个区间$i>j,a[i].l<a[j].l并且a[i].r<a[j].r$，知道这个结论后，我们可以知道，对于一个组别来说，决定其对答案贡献的左边界是该组中区间最大的$l$，决定其对答案贡献的右边界是该组中区间最小的$r$，我们可以想到，对于结论二的最优解来说，我们交换任何一对区间使得其不再满足结论二，他的答案只能变得更差，不可能更优。
dp需要进行单调队列优化，其他的就没有可说的了。

#pragma GCC optimize(2)
#include <iostream>
#include <cstring>
#include <algorithm>
#include <ctime>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <cmath>
#include <list>
#include <bitset>
#include <stack>


using namespace std;
#define x first 
#define y second 

typedef long long LL;
typedef pair <int, int> PII;

const int N = 5000 + 10, M = 1e7 + 10,  INF = 0x3f3f3f3f, mod = 998244353;

int q[N], dp[N][N], pre[N];
struct E
{
	int l, r;
	bool operator < (const E t) const 
	{
		if (l == t.l) return r > t.r;
		return l < t.l;
	}
}a[N];

int main()
{
	clock_t c1 = clock();
	ios::sync_with_stdio(false);
	cin.tie(0); //
    cout.tie(0);
#ifdef LOCAL
	freopen("in.in", "r", stdin);
	freopen("out.out", "w", stdout);
#endif
	// ------------------------------------------------------------------------------------------------>
		int n, k; cin >> n >> k; // 多加限制
		for (int i = 1; i <= n; i ++) cin >> a[i].l >> a[i].r; 
		vector <E> t;
		vector <int> t1;
		sort (a + 1, a + n + 1);
		int Min = 1e9;
		for (int i = n; i >= 1; i --) 
		{
			if (a[i].r >= Min) t1.push_back (a[i].r - a[i].l);
			else Min = a[i].r, t.push_back (a[i]);
		}
		sort (t.begin(), t.end());
		t.insert(t.begin(), {0, 0});
		int len = t.size();
		// dp[i][j] = max (dp[k][j - 1] + U (k + 1 ~ i)) ---- > U (k + 1 ~ i) > 0
		memset (dp, -0x3f, sizeof dp);
		dp[0][0] = 0;
		for (int j = 1; j <= k; j ++) 
		{
			int hh = 0, tt = -1;
			for (int i = 1; i < len; i ++) // 溢出
			{
				while (hh <= tt && t[q[hh] + 1].r <= t[i].l) hh ++;
				while (hh <= tt && dp[q[tt]][j - 1] + t[q[tt] + 1].r <= dp[i - 1][j - 1] + t[i].r) tt --;
				q[ ++ tt] = i - 1;
				if (hh <= tt) dp[i][j] = dp[q[hh]][j - 1] + t[q[hh] + 1].r - t[i].l;
			}
		}
		sort (t1.begin(), t1.end(), greater <int> ());
		for (int i = 1; i <= t1.size(); i ++) pre[i] = pre[i - 1] + t1[i - 1];
		int ans = 0;
		for (int j = 1; j <= k; j ++ ) 	
			ans = max (ans, dp[len - 1][j] + pre[k - j]);
		cout << ans << endl;
	// ------------------------------------------------------------------------------------------------>
end:
	cerr << "Time Use  -----> " << clock() - c1 << "ms" << endl;
	return 0;// 
}