逛森林

这是一道模板题

首先，对任意时刻，$u$->$v$这条路径上的点都是不会变动的（就是说，比如，如果某时刻从$1$到$4$的路径为$1$->$3$->$4$，那么对之后的任意时刻，这条路径都是这个，既不会改变顺序，也不会新增节点，更不会删除已有节点），所以我们可以把所有有效的操作一存起来最后再建边

那么这里利用倍增优化建边

倍增的分治结构是什么？

这个分治的状态是不是就出来了？注意绿边的边权为0

比如说我现在有一个传送门，是从$x_0$->$x_1$这条链到$x_2$->$x_4$这条链，那么我就会从$f[x_0][0]$的out点连一条边权为$w$的出边到虚拟节点$T$，再从$T$连一条边权为0的入边到$f[x_2][1]$的in点，由于绿边的边权为0，显然就等价于从$x_0$->$x_1$这条链上的每一个点都连了一条边权为$w$的出边到$x_2$->$x_4$这条链上的每一个点

那么这个的复杂度是多少？首先考虑树上的边，总共是$O(m)$条，然后考虑绿边，因为每个树上的点顶多向上跳$logn$次，所以in点和out点的个数就是$O(nlogn)$，由前文描述可得每个in点和out点至多会连三条有向边，所以绿边的个数就是$O(nlogn)$，然后在考虑虚拟节点的边，对每一次操作，我们最多跳$logn$步，每跳一步就会连边，所以一共是$O(mlogn)$的条边，最后跑dij，总共的时间复杂度为$O((nlogn+mlogn)logn)$

考虑优化，利用st表的思想，对一条长度为$2^k+p$的链，我们将其分成两步，前$2^k$和后$2^k$个节点的in点和out点分别按照上述方法连边，尽管有重复连边，但是不影响答案，时间复杂度被优化到了$O((nlogn+m)logn)$，如下图

这两个区间代表的节点进行连边就好了

其他的优化建边

update 2024.5.12

我们来说一下代码的细节

首先，千万不要认为我们对每个点都会建一颗有$O(nlogn)$个节点的树，从而导致节点总数是$O(n^{2}logn)$，因为我们dfs到某一个点的时候，这条链上的其余点的树都已经建好了，不用再重新建，听不懂的话就看代码

然后，在求连边的节点时，不要用st表的写法（预处理出Log数组然后求出最大长度），因为这不是链，而是树；我们应该直接对代码中LCA的部分进行改动（然而这样的话时间复杂度就没办法优化了）

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=5e4+10,M=1e6+10,INF=0x3f3f3f3f;
int n,m,s,cnt,tot;
int fa[N];
int End[M<<5],Len[M<<5],Last[M<<2],Next[M<<5],dis[M<<2];
int dep[N],f[N][20],in[N][20],out[N][20];
bool vis[M<<2],mark[M];
int u[M][3],v[M][3],w[M],op[M];
vector<int> G[N];
struct Node
{
	int Num,dis;
	bool operator<(const Node &a) const
	{
		return a.dis<dis;
	}
};
priority_queue<Node> q;
int getfa(int x)
{
	return fa[x]==x?x:fa[x]=getfa(fa[x]);
}
void merge(int x,int y)
{
	fa[getfa(x)]=getfa(y);
}
void add(int x,int y,int z) 
{
	End[++tot]=y,Len[tot]=z,Next[tot]=Last[x],Last[x]=tot;
}
void init(int x,int fa)
{
	dep[x]=dep[fa]+1;
	for(int i=0;i<=17;i++)
    {
    	f[x][i+1]=f[f[x][i]][i];
    	in[x][i+1]=++cnt,add(cnt,in[x][i],0),add(cnt,in[f[x][i]][i],0);
		out[x][i+1]=++cnt,add(out[x][i],cnt,0),add(out[f[x][i]][i],cnt,0);
		//in表示出点，out表示入点 
	}
    for(int i=1;i<=G[x].size();i++)
    {
    	int v=G[x][i-1];
        if(v!=fa)
        {
            f[v][0]=x;
            in[v][0]=++cnt,add(cnt,v,0),add(cnt,x,0);
			out[v][0]=++cnt,add(v,cnt,0),add(x,cnt,0);
            init(v,x);
        }
    }
}
void LCA(int ver,int id)//直接对LCA的代码进行改动连边 
{
	int x=u[ver][id],y=v[ver][id];
    if(x==y) 
    {
    	if(id==1) add(x,cnt,0);
    	else add(cnt,x,0);
    	return;
	} 
    if(dep[x]<dep[y]) swap(x,y);
    for(int i=17;i>=0;i--)
    {
        if(dep[f[x][i]]>=dep[y])
        {
        	if(id==1) add(out[x][i],cnt,0);
        	else add(cnt,in[x][i],0);
        	x=f[x][i];
		}
        if(x==y) return;
        if(dep[x]==dep[y]) break;
    }
    for(int i=17;i>=0;i--)
    {
        if(f[x][i]!=f[y][i])
        {
        	if(id==1) add(out[x][i],cnt,0),add(out[y][i],cnt,0);
        	else add(cnt,in[x][i],0),add(cnt,in[y][i],0);
            x=f[x][i];
            y=f[y][i];
        }
    }
    if(id==1) add(out[x][0],cnt,0),add(out[y][0],cnt,0);
    else add(cnt,in[x][0],0),add(cnt,in[y][0],0);
    return;
}
void Dij()
{
    Node temp;
    temp.Num=s;
    temp.dis=0;
    dis[s]=0;
    q.push(temp);
    while(!q.empty())
    {
        int u=q.top().Num;
        q.pop();
        if(vis[u]==1) continue;
        vis[u]=1;
        for(int i=Last[u];i;i=Next[i])
        {
            int v=End[i];
            if(dis[v]>dis[u]+Len[i])
            {
                dis[v]=dis[u]+Len[i];
                temp.Num=v;
                temp.dis=dis[v];
                q.push(temp);
            }
        }
    }
}
int main()
{
	scanf("%d%d%d",&n,&m,&s);
	memset(dis,0x3f,sizeof(dis));
	cnt=n;//cnt表示节点总数 
	for(int i=1;i<=n;i++) fa[i]=i;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&op[i],&u[i][1],&v[i][1]);
		if(op[i]==1) 
		{
			scanf("%d%d%d",&u[i][2],&v[i][2],&w[i]);
			mark[i]=1;//mark表示这次操作是否有效 
			for(int j=1;j<=2;j++)
			if(getfa(u[i][j])!=getfa(v[i][j]))
			{
				mark[i]=0;
				break;
			}
		}
		else 
		{
			scanf("%d",&w[i]);
			if(getfa(u[i][1])!=getfa(v[i][1]))
			{
				mark[i]=1;
				merge(u[i][1],v[i][1]);
				G[u[i][1]].push_back(v[i][1]); 
				G[v[i][1]].push_back(u[i][1]);
				//注意树中的边一定要和最终图的边分开存
				//如果存一起的话
				//在init过程中，由于我们要加边
				//就会把边加进去，破坏树的结构 
			}
		}
	}
	for(int i=1;i<=n;i++)
	if(!dep[i]) init(i,0);
	//注意森林的每一颗树都要init
	//因为加了传送门之后可能连通 
	for(int i=1;i<=m;i++)
	if(op[i]==1&&mark[i])
	{
		for(int j=1;j<=2;j++)
		{
			cnt++;//创建虚拟节点 
			LCA(i,j);
		}
		add(cnt-1,cnt,w[i]);//两个虚拟节点连边 
	}
	else if(op[i]==2&&mark[i])
	add(u[i][1],v[i][1],w[i]),add(v[i][1],u[i][1],w[i]);//注意树中的边也要添加到最终图中 
	Dij();
	for(int i=1;i<=n;i++)
	printf("%d ",dis[i]>INF/2?-1:dis[i]);
	return 0;
}