题目描述
Description
平行宇宙，或者叫做多重宇宙论，这是一种在物理学里尚未被证实的理论。
我们假想，在某个事件点(以时间为轴)之后，宇宙的运行轨迹会出现许多可能，而这些可能的宇宙是平行的。举例来说，从我们现在存在的这个宇宙开始，每过一个时刻，宇宙就会分成很多个，在这些宇宙中，会有成为警察的你，会有成为总理的你，等等。而这些不同的宇宙是相互平行的，且在之后的发展中也是平行，不会相交。
现在我们进入正题。
我们正在使用计算机读数据，数据有K行，每行一个非负整数。我们需要按如下方式读取数据:
1、首先读入第一个数，需要支付1的代价。
2、我们假设读入的数是x，那么我们需要读入接下来x个数。
3、如果文件已经读完，则读入结束；否则我们接着再读一个数(需要支付 1 1 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 i 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
0 0
Sample Output
1
3
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的连边，可能会连出n2条边
因为树的形态不变，所以可以从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]);
}