Codeforces 1132G（关系转化树+dfn+线段树）

要点

• 显然要滑动修改维护。
• 像通常的数列next关系一样建边（单调栈预处理），因为贪心所以是树，然后发现增删只会影响区间内的子（or父，看你连边方向行事）节点，于是使用dfs序建线段树。
• 为了正确地修改，会发现必须得用大数向小数连边。一是根据题意，一个大数会有好几个小数儿子但小数只会贪心选一个父亲；二是每当增加一个大数时，对每个子孙都会有一个贡献，正好我们用size数组搞定左右边界。
• 某些子孙已经被滑动窗口移除了，加进一个大数又给它加了1，不会影响吗？不影响答案，因为移除以后它是0，只会有一个父亲出现才会增加它为1，并不影响最终答案。

const int maxn = 1e6 + 5;
int n, k, a[maxn], dfn[maxn], Time, size[maxn];
vector<int> adj[maxn];

class SegmentTree {
public:
	#define ls(p)	p << 1
	#define rs(p)	p << 1 | 1
	struct Node {
		int l, r, maxx, tag;
	}t[maxn << 2];

	void Push_up(int p) {
		t[p].maxx = max(t[ls(p)].maxx, t[rs(p)].maxx);
	}

	void Push_down(int p) {
		if (t[p].tag) {
			t[ls(p)].maxx += t[p].tag, t[rs(p)].maxx += t[p].tag;
			t[ls(p)].tag += t[p].tag, t[rs(p)].tag += t[p].tag;
			t[p].tag = 0;
		}
	}

	void Build(int l, int r, int p) {
		t[p].l = l, t[p].r = r;
		if (l == r)	return;
		int mid = (l + r) >> 1;
		Build(l, mid, ls(p));
		Build(mid + 1, r, rs(p));
	}

	void Modify(int l, int r, int p, int k) {
		if (l <= t[p].l && t[p].r <= r) {
			t[p].maxx += k, t[p].tag += k;
			return;
		}
		Push_down(p);
		int mid = (t[p].l + t[p].r) >> 1;
		if (l <= mid)	Modify(l, r, ls(p), k);
		if (mid < r)	Modify(l, r, rs(p), k);
		Push_up(p);
	}
}T;

void dfs(int fa) {
	dfn[fa] = ++Time;
	size[fa] = 1;
	for (auto i : adj[fa]) {
		dfs(i);
		size[fa] += size[i];
	}
}

void Pre() {
	stack<int> st;
	irep(i, n, 1) {
		while (!st.empty() && a[st.top()] <= a[i])	st.pop();
		int fa = st.empty() ? n + 1 : st.top();
		adj[fa].push_back(i);
		st.push(i);
	}
	dfs(n + 1);
}

void Solve() {
	T.Build(1, n + 1, 1);
	rep(i, 1, k - 1)	T.Modify(dfn[i], dfn[i] + size[i] - 1, 1, 1);
	for (int i = 1; i + k - 1 <= n; i++) {
		T.Modify(dfn[i + k - 1], dfn[i + k - 1] + size[i + k - 1] - 1, 1, 1);
		printf("%d ", T.t[1].maxx);
		T.Modify(dfn[i], dfn[i] + size[i] - 1, 1, -1);
	}
}

int main() {
	read(n), read(k);
	rep(i, 1, n)	read(a[i]);
	Pre();
	Solve();
	return 0;
}