Ezzat and Grid（珂朵莉树优化DP，颜色段均摊）

Codeforces Round 737 (Div. 2)

D. Ezzat and Grid

---

题意：

穆阿门正在画一个由 $n$ 行和 $10^9$ 列组成的网格，网格中只有数字 $0$ 和 $1$ 。艾扎特注意到了莫阿门所画的网格，并对最少需要删除多少行才能使网格美观产生了兴趣。

当且仅当每连续两行中至少有一列包含 $1$ 时，网格才是美丽的。

Ezzat 将给出网格中包含数字 $1$ 的 $n$ 行和 $m$ 段的数目。每个线段用三个整数 $i$ 、 $l$ 和 $r$ 表示，其中 $i$ 代表行号， $l$ 和 $r$ 代表该行线段的第一列和最后一列。

例如，如果 $n=3$ 、 $m=6$ 和线段是 $(1,1,1)$ 、 $(1,7,8)$ 、 $(2,7,7)$ 、 $(2,15,15)$ 、 $(3,1,1)$ 、 $(3,15,15)$ ，那么网格就是：

你的任务是告诉 Ezzat 为使网格美观而应删除的最少行数。

思路：

如果两行在某一位上同时有1，那么我们就可以删掉中间的行，使得这两行贴在一起，变得美观。

如果前 $i-1$ 行删掉某些行后变得美观，现在要加入第 $i$ 行，并考虑把它们变得美观。设 $dp[i]$ 表示加入第 $i$ 行（一定加入第 $i$ 行，不删去）后，前 $i$ 行变得美观的最小删除行数。

考虑如何得到状态转移方程。可以枚举第 $i$ 行上所有列上的 $1$，去寻找前面所有这一列上是 $1$ 的行，然后从这些行转移过来（也就是删掉中间的行）。实际上，并不需要枚举这一列是 $1$ 的所有行，只需要枚举其中的最后一行就行了，这样就是最优的。如果不优，一定存在一个不是最后一行的行，转移到当前行需要删除的行数最少，这样需要删掉中间的所有行，这时把最后一行加入，删除的行一定更少，因此直接选取最后一行一定最优。

朴素做法已经出来了，使用 $dp[i]$ 表示加入第 $i$ 行，前 $i$ 行变美观的最少删除次数，使用数组 $t[j]$ 表示前 $i$ 行里最后一次出现第 $j$ 列上是 $1$ 的行的编号。按顺序枚举 $1\sim n$ 行，对第 $i$ 行，枚举这一行上是 $1$ 的列 $j$ ，尝试用 $t[j]$ 行来更新 $dp[i]$。更新结束后，把 $t[j]$ 的值覆盖为 $i$。

但是列的个数是 $10^9$，不能暴力枚举 。考虑到 $1$ 的区间个数 $m=3\ast 10^5$ 比较小，因此可以离散化，然后这里需要区间赋值，使用线段树维护数组 $t[j]$ 实现。

不过由于只用到了区间赋值操作，所以可以使用珂朵莉树来维护。更直观好写。

由于需要打印删掉的行，而知道被删掉的行只需要知道我们 $dp$ 转移的路径，不在路径中的行就是被删掉的行。所以使用 $last[i]$ 数组记录一下 $dp[i]$ 是由哪一行转移过来的就行了。

颜色段均摊，广义的颜色段其实就是具有某一性质的一段区间，将一个元素具有相同性质的区间看成一个东西，也就是压成一个点来维护，就可以降低数量规模。珂朵莉树的核心思想就是这个，assign函数相当于把一种颜色摊到一个区间上，使得它们具有同一种颜色。

code：

时限2.5s，跑了1800ms，翻了一下其他的线段树做法，大概是800ms到2000ms不等，大部分是1000ms和1700ms。线段树可以额外维护 一个范围里最大的 $t[j]$ （范围区间里某一列有1的最近的行）。有没有维护到，这应该就是800ms和1800ms做法的差别所在。如果要维护这个东西，珂朵莉树就用不了了

不过这题不好卡这个，所以珂朵莉树暴力就过了。

#include <iostream> 
#include <cstdio>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;
const int maxn=3e5+5;

struct bar{
	int line;
	int l,r;
	bool operator<(const bar x)const{
		if(line!=x.line)return line<x.line;
		return l<x.l;
	}
};

int n,m;
bar a[maxn];

struct ODT{
	#define SIT set<Node>::iterator
	#define pii pair<int,int>
	#define type int
	
	struct Node{
		int l,r;
		mutable type val;//有1的最近行编号
		Node(int l,int r=0,type v=0):l(l),r(r),val(v){};
		bool operator<(const Node x)const{return l<x.l;};
	};
	set<Node> s;
	int dp[maxn],last[maxn];
	
	void build(int n){
		int r=1e9;
		for(int i=1;i<=n;i++)dp[i]=r;
		s.insert(Node(1,r,0));
		s.insert(Node(r+1,r+1,0));
	}
	void print(){
		for(auto x:s)printf("[%d,%d] %d\n",x.l,x.r,x.val);
		for(int i=1;i<=n;i++)printf("%d ",dp[i]);
		printf("\n\n");
	}
	SIT split(int pos){
		SIT it=s.lower_bound(Node(pos));
		if(it!=s.end() && it->l==pos)return it;
		it--;
		int l=it->l,r=it->r;
		type val=it->val;
		s.erase(it);
		s.insert(Node(l,pos-1,val));
		return s.insert(Node(pos,r,val)).first;
	}
	void assign(int l,int r,int ln){
		SIT it2=split(r+1),it1=split(l);
		s.erase(it1,it2);
		s.insert(Node(l,r,ln));
	}
	void updata(int l,int r,int ln){
		SIT it2=split(r+1),it1=split(l);
		for(int step;it1!=it2;it1++){
			step=ln-it1->val-1;
			if(dp[it1->val]+step<dp[ln]){
				dp[ln]=dp[it1->val]+step;
				last[ln]=it1->val;
			}
		}
		assign(l,r,ln);
	}
	void pans(){
		int ans=n,lst;
		for(int i=1;i<=n;i++)
			if(dp[i]+(n-i)<ans){
				ans=dp[i]+(n-i);
				lst=i;
			}
		printf("%d\n",ans);
		vector<int> a;
		for(int j=lst,i=n;~i;j=last[j]){
			for(int k=j+1;k<=i;k++)
				a.push_back(k);
			i=j-1;
		}
		sort(a.begin(),a.end());
		for(auto x:a)
			printf("%d ",x);
	}
	
	#undef SIT
	#undef pii
	#undef type
}tr;

int main(){
	cin>>n>>m;
	tr.build(n);
//	tr.print();
	
	for(int i=1;i<=m;i++)
		cin>>a[i].line>>a[i].l>>a[i].r;
	
	sort(a+1,a+m+1);
	for(int ln=1,p=1,lst;ln<=n;ln++){
		lst=1;
		while(a[p].line==ln){
			int l=a[p].l,r=a[p].r;
			if(lst<l)lst=l;
			if(lst<=r){
				tr.updata(lst,r,ln);
				lst=r+1;
			}
			p++;
		}
//		tr.print();
	}
	tr.pans();
	
	return 0;
}