jzoj1656. 【2010集训队出题】数据读取问题

原创于 2019-08-02 19:05:43 发布 · 253 阅读

0 ·

CC 4.0 BY-SA版权

OJ题解专栏收录该内容

145 篇文章

订阅专栏

探讨了在平行宇宙理论背景下，如何优化数据读取策略以达到最小代价完成数据读取的问题。通过构建数据事件图，运用最短路径算法如BFS进行求解，旨在寻找所有可能宇宙中读取数据所需的最小代价。

题目描述

Description
平行宇宙，或者叫做多重宇宙论，这是一种在物理学里尚未被证实的理论。

我们假想，在某个事件点(以时间为轴)之后，宇宙的运行轨迹会出现许多可能，而这些可能的宇宙是平行的。举例来说，从我们现在存在的这个宇宙开始，每过一个时刻，宇宙就会分成很多个，在这些宇宙中，会有成为警察的你，会有成为总理的你，等等。而这些不同的宇宙是相互平行的，且在之后的发展中也是平行，不会相交。

现在我们进入正题。

我们正在使用计算机读数据，数据有K行，每行一个非负整数。我们需要按如下方式读取数据:

1、首先读入第一个数，需要支付1的代价。

2、我们假设读入的数是x，那么我们需要读入接下来x个数。

3、如果文件已经读完，则读入结束；否则我们接着再读一个数(需要支付 $1$ 的代价)，然后转2。

数据保证任何一个读入的x，在他后面至少还有x个数字。虽然按照上面的方法一定可以恰好读完数据，但是这么做支付的代价不一定是最小的，你可以修改读入的那个x，可以把x修改为x+y或者x-y，不过必须保证，值仍然是非负整数，且接下来有不少于x±y个数。

而我们需要支付的代价就是y。

相信你已经猜到我们的问题了，那就是恰好读完所有数据，需要支付的最少代价是多少。

等等，似乎还缺了什么。没错，我们并不知道这些数据是什么，但我们知道这些数据可能是什么，就像薛定谔的猫。在没有读入这个数字之前，它什么都是，

一旦读入了这个数，根据结果，我们就进入了不同的平行世界。

现在我将告诉你宇宙可能出现的轨迹，希望你计算出所有不同的结果(读完数据需要支付的最小代价)。

Input
为了方便起见，我们把读入一个数看成一个事件，我们用1 … N把所有可能的事件编号。

第一行，读入一个整数N，表示可能的事件的个数。

接下来N行，第i+1行描述第i个事件。第i个事件，将会告知这些参数x m a1 a2 a3 … ：

x 表示第 $i$ 个事件的数据值是多少。

m 表示这个事件之后有多少种可能出现的事件，编号是a1 a2 a3 …。

其中第1个事件，它的数据值一定是-1，因为这时第一个数还未读入。也就是说，第1个事件所相关的事件a1 a2 a3 …，就是读入的第一个数所有的可能值。且如果某个事件m=0，那么这个所读入的数x，就是数据中的最后一个数。

Output
输出M行，M是最终所有可能的不同宇宙的个数。

每行输出一个最小的代价值，按照代价值的大小，从小到大输出。

Sample Input
7

-1 1 2

1 2 3 7

3 1 4

0 1 5

0 1 6

0 0

Sample Output
1

Data Constraint
数据保证有20% 的数据N≤2000；

保证有60%的数据N≤200000；

另有20%的数据，输出的个数M ≤50。

所有数据N≤1000000。

链

~~难点在于读题~~
如果只有一条链，那么只有唯一的数列a
在a的最后加一个空点，表示终点

考虑最短路
设f[i]表示准备选i的最小代价
对于x±y，考虑先跳到x，再向前/后跳
所以i向i+ai+1连长度为1的边，i（i≠1和1的儿子，因为只有跳了第一次后才能调整y）向i±1连长度为1的边

因为所有的边长度都为1，所以直接bfs覆盖就行了

树

大致同链，如果能建出图来，跑bfs的时间还是O(n)
先在叶子节点后面建结束点，然后每个点i（i≠1和1的儿子）向相邻节点连长度为1的边
跑最短路就直接从1的儿子开始

现在问题是，如果点i要向子树中深度=deep[i]+a[i]+1的连边，可能会连出n²条边
因为树的形态不变，所以可以从dfs序D和bfs序B中下手
点i向下走a[i]+1步走到的点为D[i的编号+a[i]+1]，并且在bfs序中连续一段深度相同且在子树i中的第一个

所以可以在bfs时找第一个点，依次更新（前提是这个点未被遍历过）并与下一个点合并（并查集）
这样的时间复杂度为O(nα(n))（2n条边，每个点最多被合并一次）

code

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
using namespace std;

int A[2000001][2];
int Ls[2000001];
int a[4000001][2];
int ls[2000001];
int b[2000001];
int D[2000001]; //dfs xu
int B[2000001]; //bfs xu
int I[2000001];
int d[2000001];
int dfn[2000001][2];
int bfsx[2000001];
bool bz[2000001];
int fa[2000001];
int lf[2000001];
int f[2000001];
bool BZ[2000001];
int dp[2000001]; //deep
int ans[1000001];
int Fa[2000001];
int N,n,m,i,j,k,l,Len,len,h,t,tot;

void NEW(int x,int y)
{
	++Len;
	A[Len][0]=y;
	A[Len][1]=Ls[x];
	Ls[x]=Len;
}
void New(int x,int y)
{
	++len;
	a[len][0]=y;
	a[len][1]=ls[x];
	ls[x]=len;
}

int gf(int t)
{
	l=0;
	while (fa[t]!=t)
	{
		Fa[++l]=t;
		t=fa[t];
	}
	
	while (l)
	{
		fa[Fa[l]]=t;
		--l;
	}
	
	return t;
}

void dfs()
{
	int i;
	
	fo(i,1,n)
	I[i]=Ls[i];
	
	l=0;
	
	d[1]=1;
	t=1;
	
	while (t)
	{
		if (I[d[t]]==Ls[d[t]])
		{
			++l;
			D[l]=d[t];
			dfn[d[t]][0]=l;
		}
		
		if (I[d[t]])
		{
			d[t+1]=A[I[d[t]]][0];
			I[d[t]]=A[I[d[t]]][1];
			
			++t;
		}
		else
		{
			dfn[d[t]][1]=l;
			--t;
		}
	}
}

void bfs()
{
	int i;
	
	h=0;
	t=1;
	
	B[1]=1;
	bfsx[1]=1;
	bz[1]=1;
	dp[1]=1;
	
	while (h<t)
	{
		for (i=Ls[B[++h]]; i; i=A[i][1])
		if (!bz[A[i][0]])
		{
			bz[A[i][0]]=1;
			dp[A[i][0]]=dp[B[h]]+1;
			
			++t;
			B[t]=A[i][0];
			bfsx[A[i][0]]=t;
		}
	}
}

void Bfs(int T)
{
	int i;
	
	h=0;
	t=1;
	d[1]=T;
	f[T]=1;
	
	while (h<t)
	{
		++h;
		
		for (i=ls[d[h]]; i; i=a[i][1])
		if (!f[a[i][0]])
		{
			f[a[i][0]]=f[d[h]]+1;
			d[++t]=a[i][0];
		}
		
		i=gf(lf[d[h]]); 
		while (dfn[d[h]][0]<=dfn[i][0] && dfn[i][1]<=dfn[d[h]][1])
		{
			if (!f[i])
			{
				f[i]=f[d[h]]+1;
				d[++t]=i;
			}
			
			i=bfsx[i];
			if (i==N)
			break;
			
			if (dp[gf(B[i])]==dp[gf(B[i+1])])
			{
				fa[fa[B[i]]]=fa[B[i+1]];
				i=gf(B[i+1]);
			}
			else
			break;
		}
	}
}

int main()
{
//	freopen("data10.in","r",stdin);
//	freopen("S8_1_3.out","w",stdout);
//	freopen("S8_1_3.in","r",stdin);
	
	scanf("%d",&n);
	fo(i,1,n)
	{
		scanf("%d%d",&b[i],&m);
		
		fo(j,1,m)
		{
			scanf("%d",&k);
			NEW(i,k);
		}
	}
	b[1]=0;
	
	N=n;
	fo(i,1,n)
	if (!Ls[i])
	{
		++N;
		NEW(i,N);
	}
	
	dfs();
	bfs();
	
	fo(i,1,N)
	fa[i]=i;
	
	fo(i,1,n)
	lf[i]=D[dfn[i][0]+b[i]+1];
	
	BZ[1]=1;
	for (i=Ls[1]; i; i=A[i][1])
	BZ[A[i][0]]=1;
	
	fo(j,2,N)
	if (!BZ[j])
	{
		for (i=Ls[j]; i; i=A[i][1])
		if (!BZ[A[i][0]])
		{
			New(j,A[i][0]);
			New(A[i][0],j);
		}
	}
	
	for (i=Ls[1]; i; i=A[i][1])
	Bfs(A[i][0]);
	
	fo(i,n+1,N)
	ans[++tot]=f[i]-1;
	
	sort(ans+1,ans+tot+1);
	
	fo(i,1,tot)
	printf("%d\n",ans[i]);
}