挑战程序设计：1 D - Ezzat and Grid(离散化线段树线性）

题目

传送门

题目大意

给定n个长度为1e9的01串，由于数据过大，所以采用区间的方式给定
m, l ,r表示第m个串的[l,r]为1。
定义一个美丽的序列，对于相邻的两个01串，存在同一位置两者都为1。
问最少删去多少个串使得序列美丽，输出方案。

解题思路

先忽视数据范围，求最长的方案，可以采用dp的思想，dp[i]表示以i串为结尾的最长的长度，通过暴力的方法来解决问题：

• 枚举当前串每一个为1的位置，该串可以继承在该位置为1的子串的最长长度$（n\ast n\ast len）$。
• 时间复杂度爆炸，空间复杂度爆炸。
  因为给定的是区间，我们可以利用区间查询，区间修改的数据结构来加速该过程。
  于是便想到了线段树，但是1e9的区间询问，于是便有了离散化。
  为什么可以离散化？
  尽管区间很大，但是区间的个数是恒定的，很大一部分的信息都是存在冗余的。
  我们只需要关注端点值的影响。
  于是他开始尝试写离散化，耗时巨大。
  如何输出方案，这是一个线性dp，何谓线性dp?其状态转移是线性的类似于最短路，我们可以通过记录当前状态是由哪个状态转移过来的，我们便可以通过回溯去找出整个转移的路径，那么不在路径中的自然是要删去的点。

code

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int,int>
#define il i<<1
#define ir (i<<1)+1
const int maxn = 3e5 + 5;
int n, m, vis[maxn];
vector<int>lsh; vector<pii>a[maxn];
pii t[maxn << 4], lz[maxn << 4], path[maxn];//八倍空间，path数组用于记录dp路径
int getid(int i)
{
	return lower_bound(lsh.begin(), lsh.end(), i) - lsh.begin()+1;//离散化之后的id查询
}
void build(int i, int l, int r)
{
	t[i] = { 0,0 }; lz[i] = { 0,0 };
	if (l == r)return;
	int mid = (l + r) >> 1;
	build(il, l, mid);
	build(ir, mid + 1, r);
	t[i] = max(t[ir], t[il]);
}
void pushdown(int i)
{
	if (lz[i] != make_pair(0, 0))
	{
		lz[ir] = lz[i]; lz[il] = lz[i];
		t[ir] = max(lz[i], t[ir]); t[il] = max(lz[i], t[il]);
		lz[i] = { 0,0 };
	}
}
void updata(int i, int l, int r, int L, int R, pii v)
{
	if (l >= L && r <= R) { t[i] = v; lz[i] =  v; return; }//必定更新
	pushdown(i);
	int mid = (l + r) >> 1;
	if (L <= mid)updata(il, l, mid, L, R, v);
	if (R > mid)updata(ir, mid + 1, r, L, R, v);
	t[i] = max(t[ir], t[il]);
}
pii querry(int i, int l, int r, int L, int R)
{
	if (l >= L && r <= R)return t[i];
	pushdown(i);
	int mid = (l + r) >> 1;
	pii ans = make_pair(0, 0);
	if (L<=mid)ans = max(ans, querry(il, l, mid, L, R));
	if (R > mid)ans = max(ans, querry(ir, mid + 1, r, L, R));
	return ans;
}
int main()
{
	ios::sync_with_stdio(false);
	cin >> n >> m;
	for (int i = 1; i <= m; i++)
	{
		int id, l, r;
		cin >> id >> l >> r;
		a[id].push_back(make_pair(l, r));
		lsh.push_back(l); lsh.push_back(r);
	}
	sort(lsh.begin(), lsh.end());
	lsh.resize(unique(lsh.begin(), lsh.end()) - lsh.begin());//unique函数返回的是不重复的最后一位的指针
	//for (int i = 0; i < lsh.size(); i++)cout << lsh[i] << " "; cout << endl;
	//cout << getid(6) << endl;
	build(1, 1, lsh.size());
	pii res = make_pair(0, 0);
	for (int i = 1; i <= n; i++)
	{
		//cout << "find::" << i << endl;
		pii ans = make_pair(0, 0);
		for (auto x : a[i])//查询
		{
			ans = max(ans, querry(1, 1, lsh.size(), getid(x.first), getid(x.second)));
		}
		path[i] = ans;
		//cout << ans.first << " " << ans.second << endl;
		ans = make_pair(ans.first+1,i);//ans记录要转移的状态，res记录最长序列的结尾
		res = max(res, ans);
		for (auto x : a[i])//修改
		{
			updata(1, 1, lsh.size(), getid(x.first), getid(x.second), ans);
		}
	}
	printf("%d\n", n - res.first);
	int p = res.second;
	while (path[p] != make_pair(0, 0))vis[p] = 1, p = path[p].second;
	//代码同思想，回溯找到路径经过的点，那么没经过的便是要删去的部分
	vis[p] = 1;
	for (int i = 1; i <= n; i++)if (vis[i] == 0)printf("%d ",i); printf("\n");
	return 0;
}