Codeforces LATOKEN Round 1 (Div. 1 + Div. 2)

Posted 2021-06-20 C202044zxy

F1. Falling Sand

题目描述

点此看题

有 \\(n\\times m\\) 的方格，其中#代表沙子，.代表空格，你可以每次操作可以任意选择一个沙子使之自由落体，和这个沙子下落路径有边相邻的沙子也会下落，问让所有沙子下落的最小操作数。

\\(1\\leq n\\cdot m\\leq 400000\\)

解法

首先大概分析下这个问题，一个沙子的下落会引起连锁反应，这时候用图论表达这个过程是最好的。

点 \\(i\\) 向 \\(j\\) 连边表示 \\(i\\) 的下落会带动 \\(j\\) 的下落，要根据下落的路径把有关的点都连起来，但实际上只用连这四条边即可：

• 如果这个点上方一格有点，那么连边。
• 如果这个点下方有点，那么连边。
• 找到左侧第一个在它下面的点连边。
• 找到右侧第一个在它下面的点连边。

问题就转化到这张图上了，我们可以先 \\(\\tt tarjan\\) 缩点，然后直接选入度为 \\(0\\) 的点即可。

F2.Falling Sand

题目描述

点此看题

相对于简单版本，你需要让第 \\(i\\) 列有 \\(a_i\\) 个沙子下落。

解法

不妨考虑和简单版本有什么变化，我们不用让所有沙子下落。因为同一列高的下落矮的一定下落，可以把每一行的限制简化成让第 \\(a_i\\) 个沙子下落即可，还可以简化，如果在建出的图中某个关键点能到达另一个关键点，那么可以忽略被到达点的限制。

现在回到图上思考这个问题，选取一个点等价于覆盖它能到达的所有关键点，最后的目的是让所有关键点都被覆盖。直接是做不动的，但是这个覆盖体现在原来的矩阵中是倾向于覆盖更相邻的列的，我们不禁要想，覆盖是否有区间性质？

也就是某个点覆盖的关键点一定在矩阵中构成一段连续的区间，证明用反证法：考虑三列 \\(u<v<w\\)，如果能通过操作第 \\(u\\) 列解决第 \\(w\\) 列的限制，那么一定会经过 \\(v\\) 列中的一个点 \\(i\\)，因为不能解决 \\(v\\) 的限制，所以 \\(v\\) 的关键点高于 \\(i\\)，进而推出 \\(v\\) 的关键点可以到达 \\(w\\) 的关键点，这与我们简化后的问题矛盾，这里是不能存在到达关系的。

那么问题变成了选取若干个区间的并集是全集，可以考虑贪心，我们把所有区间按左端点排序，然后顺次扫描，如果当前必须选一个区间（也就是下一个区间的左端点大于现在右端点 \\(+1\\)，不选就会出现空档），那么就选一个最大的右端点，时间复杂度 \\(O(nm\\log nm)\\)

注意一定要按照列的顺序来给关键点编号，而且缩过点的关键点一定不能重复编号。

总结

只有你尽量的去简化问题，神秘的性质才会赐福于你。

#include <cstdio>
#include <vector>
#include <assert.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <stack>
using namespace std;
const int M = 400005;
const int inf = 0x3f3f3f3f;
int read()
{
	int x=0,f=1;char c;
	while((c=getchar())<\'0\' || c>\'9\') {if(c==\'-\') f=-1;}
	while(c>=\'0\' && c<=\'9\') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
	return x*f;
}
int n,m,k,tot,cnt,ans,Ind,zxy,f[M],a[M],val[M];
int low[M],dfn[M],in[M],col[M],d[M],key[M],p[M];
vector<int> v[M],g[M],o;char s[M];
pair<int,int> sq[M];stack<int> st;
struct edge
{
	int v,next;
}e[4*M];
int id(int x,int y)
{
	return (x-1)*m+y;
}
void add(int u,int v)
{
	e[++tot]=edge{v,f[u]},f[u]=tot;
}
void tarjan(int u)
{
	dfn[u]=low[u]=++Ind;in[u]=1;
	st.push(u);
	for(int i=f[u];i;i=e[i].next)
	{
		int v=e[i].v;
		if(!dfn[v])
		{
			tarjan(v);
			low[u]=min(low[u],low[v]);
		}
		else if(in[v])
			low[u]=min(low[u],dfn[v]);
	}
	if(low[u]==dfn[u])
	{
		int v;cnt++;
		do
		{
			v=st.top();st.pop();
			in[v]=0;col[v]=cnt;
		}while(u!=v);
	}
}
void tpsort()
{
	queue<int> q;
	for(int i=1;i<=cnt;i++)
		if(!d[i]) q.push(i);
	while(!q.empty())
	{
		int u=q.front();q.pop();
		if(key[u]) in[u]=1;
		o.push_back(u);
		for(int i=0;i<g[u].size();i++)
		{
			int v=g[u][i];d[v]--;
			if(in[u]) in[v]=1,key[v]=0;
			if(!d[v]) q.push(v);
		}
	}
	for(int i=1;i<=cnt;i++)
		sq[i]=make_pair(inf,-inf);
	for(int i=1;i<=m;i++)//in this order
		if(key[p[i]] && sq[p[i]].first==inf)
            // I WA for this for thousands of time
			zxy++,sq[p[i]]=make_pair(zxy,zxy);
	int len=o.size();
	for(int i=len-1;i>=0;i--)
	{
		int u=o[i];
		for(int j=0;j<g[u].size();j++)
		{
			int v=g[u][j];
			sq[u].first=min(sq[u].first,sq[v].first);
			sq[u].second=max(sq[u].second,sq[v].second);
		}
	}
	sort(sq+1,sq+1+cnt);
}
signed main()
{
	n=read();m=read();
	for(int i=1;i<=n;i++)
	{
		scanf("%s",s+1);
		for(int j=1;j<=m;j++)
			if(s[j]==\'#\')
			{
				a[id(i,j)]=++k;
				v[j].push_back(i);
			}
	}
	for(int i=1;i<=m;i++) val[i]=read();
	for(int i=1;i<=m;i++)
	{
		for(int j=0;j<v[i].size();j++)
		{
			int u=a[id(v[i][j],i)];
			if(j && v[i][j-1]+1==v[i][j])
				add(u,a[id(v[i][j-1],i)]);
			if(j+1<v[i].size())
				add(u,a[id(v[i][j+1],i)]);
			if(i>1)
			{
				auto t=lower_bound(v[i-1].begin(),v[i-1].end(),v[i][j]);
				if(t!=v[i-1].end()) add(u,a[id(*t,i-1)]);
			}
			if(i<m)
			{
				auto t=lower_bound(v[i+1].begin(),v[i+1].end(),v[i][j]);
				if(t!=v[i+1].end()) add(u,a[id(*t,i+1)]);
			}
		}
	}
	for(int i=1;i<=k;i++)
		if(!dfn[i]) tarjan(i);
	for(int i=1;i<=m;i++)
	{
		int t=v[i].size()-val[i];
		if(t<v[i].size() && t>=0)
		{
			p[i]=col[a[id(v[i][t],i)]];
			key[p[i]]=1;
			assert(p[i]<=cnt);
		}
	}
	for(int i=1;i<=k;i++)
		for(int j=f[i];j;j=e[j].next)
		{
			int v=e[j].v;
			if(col[i]!=col[v])
			{
				g[col[i]].push_back(col[v]);
				d[col[v]]++;
			}
		}
	tpsort();
	int now=0,r=0;
	for(int i=1;i<=cnt && now<zxy;i++)
	{
		r=max(r,sq[i].second);
		if(i==cnt || sq[i+1].first>now+1)
			ans++,now=r;
	}
	printf("%d\\n",ans);
}

G. A New Beginning

题目描述

点此看题

有一个二维平面和 \\(n\\) 个人，阿七一开始在 \\((0,0)\\)，每次可以向上或者向右走一格，如果当前在 \\((a,b)\\) 那么给 \\((x_i,y_i)\\) 的人剪头发的代价是 \\(\\max(|x_i-a|,|y_i-b|)\\)，最强发型师阿七想给每个人都剪一次头发，请你求出最小的代价。

\\(1\\leq n\\leq 8\\cdot 10^5,0\\leq x_i,y_i\\leq 10^9\\)

解法

首先把 slope trick 看了吧，我有时间的话我会写一篇翻译博客的。

假设我们已经知道了阿七的移动路径，那么怎么确定每个人什么时候让阿七给他剪头发呢？注意到这道题代价的计算方式不是曼哈顿距离，而是相邻两个横纵坐标差值的较大值，我们可以同时增大横纵坐标看和路径有没有交，这样可以得出结论：直线 \\(y=-x+(x_i+y_i)\\) 和路径的交点就是阿七剪头发的位置。

证明这个结论也不难，画画图就行了，这里就略去证明过程。

那么也就是说当阿七移动到 \\(a+b=x_i+y_i\\) 就会给第 \\(i\\) 个人剪头发，我们把这个平面旋转 \\(45\\) 度，那么每个人的坐标就变成了 \\((x+y,x-y)\\)，每次可以走到 \\((a+1,b-1)\\) 和 \\((a+1,b+1)\\)，然后我们考察 \\(y\\) 坐标的差值即可，最后答案要除以 \\(2\\)

然后可以设计一个 \\(dp\\)，设 \\(dp[a][b]\\) 表示走到 \\((a,b)\\) 并且给所有 \\(x\\leq a\\) 的人剪头发的最小花费，转移：

\\[dp[a][b]=\\min(dp[i][j]+|b-y_k|),b-(a-i)\\leq j\\leq b+(a-i) \\]

但是这样就稳 \\(T\\) 了，观察转移可以发现其实有两种操作：和某一个绝对值函数合并；范围取 \\(\\min\\) 更新单点；可以考虑用 \\(\\tt slope\\space trick\\) 的方法，把 \\(dp[a]\\) 当成一个折线函数来维护。

不难发现 \\(0\\) 斜率的折线是最优解存在的地方，那么可以把左右边分开，左边斜率 \\(<0\\)，右边斜率大于 \\(>0\\)，在范围取 \\(\\min\\) 更新单点的时候两边的函数值都会向中间收拢，转折点会根据 \\(0\\) 斜率线发散，这和 \\(a\\) 的差值是有关的，所以我们可以打标记，左边的转折点在插入的时候加 \\(a\\)，在取出转折点的时候减 \\(a\\)，右边加减对换即可，搞两个优先队列 \\(L,R\\) 维护转折点。

现在解决了第二个问题，第一个问题要考虑斜率的变化，这对优先队列里的元素有影响，分情况讨论：

• 如果 \\(0\\) 斜率线的左端点 \\(>y\\)，单个人 \\(y\\) 处斜率会由 \\(-1\\) 变 \\(1\\)，这个可以直接合并，所以把 \\(y\\) 插进 \\(l\\) 两次即可，但这会导致左端点（也就是 \\(L\\) 中最大的点）不再属于 \\(L\\)，这时候要把它弹掉并且插入到 \\(R\\) 中去。
• 如果 \\(0\\) 斜率线的右端点 \\(<y\\)，右端点是 \\(R\\) 中最小的点，类似情况一操作即可。
• 如果 \\(y\\) 在 \\(0\\) 斜率线上，那么在 \\(L,R\\) 中都插入 \\(y\\) 来更新 \\(0\\) 斜率线。

在上述操作中维护 \\(0\\) 斜率线的函数值，时间复杂度 \\(O(n\\log n)\\)

#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
#define pii pair<int,int>
#define int long long
int read()
{
	int x=0,f=1;char c;
	while((c=getchar())<\'0\' || c>\'9\') {if(c==\'-\') f=-1;}
	while(c>=\'0\' && c<=\'9\') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
	return x*f;
}
int n,shift,ans;vector<pii> v;
signed main()
{
	n=read();
	for(int i=1;i<=n;i++)
	{
		int x=read(),y=read();
		v.push_back(make_pair(x+y,x-y));
	}
	sort(v.begin(),v.end());
	priority_queue<int> L;
	priority_queue<int,vector<int>,greater<int>> R;
	L.push(0);R.push(0);
	for(int i=0;i<v.size();i++)
	{
		int x=v[i].first,y=v[i].second;shift=x;
		int l=L.top()-shift,r=R.top()+shift;
		if(l>y)
		{
			L.push(y+shift);L.push(y+shift);
			L.pop();R.push(l-shift);
			ans+=l-y;
		}
		else if(y>r)
		{
			R.push(y-shift);R.push(y-shift);
			R.pop();L.push(r+shift);
			ans+=y-r;
		}
		else L.push(y+shift),R.push(y-shift);
	}
	printf("%lld\\n",ans/2);
}