tyvj4878 道路修建 双连通分量+单调队列

Description

---

A国是一个商业高度发达的国家。它包含了n座城市，每座城商业都很发达。但不幸的是，A国的交通并没有像其商业那么发达，它仅仅保证了任意两座城市之间有路径存在，而且只存在唯一的一条！

拥有雄厚经济实力的商人们决定集资修建一条路，但在修建方案上各个商人都希望新建成的道路对自己利益最大。最终他们决定造一条路，使得两个城市间所需经过道路的数量的最大值尽可能小。为此他们提出了很多修建方案，但他们并不知道每一方案新建道路后最远城市间的最大值为多少，他们有多种修建方案，你能告诉他们每一方案对应的最远城市间的最大值吗？

Solution

---

今天做了一道加强版。。写了3.8k

首先这一定是环套树，答案可以是树上的最长链或者从某一叶子出发跨越环结束于某叶子的路径

先跑连通分量把环抠出来，两次bfs求出每棵树上最长链。我们记以环上节点x为根的子树中以x为起点的最长路径为dis[x]，那么跨过环的答案一定形如dis[x]+dis[y]+get_dis(x,y)这样。

我们把环上的点复制一份，那么就可以只考虑顺时针的距离。如果边权为1，下标相减就是两点的距离。如果边权不等，那么前缀和就能算环上点的距离

观察这个柿子。dis[x]+sum[x]是常数，等价于我们要求某一区间内最大的dis[y]-sum[y]，这个上单调队列即可

然后可能会有重边和自环。这个就离线排序保留最短边就行了

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <stack>
#include <vector>
#include <queue>
#include <map>
#define rep(i,st,ed) for (register int i=st;i<=ed;++i)
#define fill(x,t) memset(x,t,sizeof(x))

typedef long long LL;
const int N=2000005;

struct edge {int x,y,w,next;} e[N*2],g[N*2];

int ls[N],fa[N],edCnt=1;
int dfn[N],low[N],bel[N];
int a[N],q[N],col[N],yqw;
int size[N],whf[N],max,n;

LL sum[N],dis[N],lxf[N],wjp[N],ans;

std:: stack <int> stack;
std:: map <int,bool> map[N];

bool vis[N],inq[N],used[N],flag;

inline int read() {
	int x=0,v=1; char ch=getchar();
	for (;ch<'0'||ch>'9';v=(ch=='-')?(-1):v,ch=getchar());
	for (;ch<='9'&&ch>='0';x=x*10+ch-'0',ch=getchar());
	return x*v;
}

void add_edge(int x,int y,int w) {
	e[++edCnt]=(edge) {x,y,w,ls[x]}; ls[x]=edCnt;
	e[++edCnt]=(edge) {y,x,w,ls[y]}; ls[y]=edCnt;
}

void dfs1(int now,int fa) {
	dfn[now]=low[now]=++dfn[0];
	vis[now]=true; stack.push(now);
	for (int i=ls[now];i;i=e[i].next) {
		if (e[i].y==fa) continue;
		if (!dfn[e[i].y]) {
			dfs1(e[i].y,now);
			low[now]=std:: min(low[now],low[e[i].y]);
		} else if (vis[e[i].y]) low[now]=std:: min(dfn[e[i].y],low[now]);
	}
	if (low[now]==dfn[now]) {
		int y=0; bel[0]++;
		while (y!=now) {
			y=stack.top(); stack.pop();
			bel[y]=bel[0];
			size[bel[0]]++;
			vis[y]=false;
		}
	}
}

void dfs2(int now,int fa) {
	a[++a[0]]=now;
	if (a[0]==yqw) return (void) (flag=true);
	for (int i=ls[now];i;i=e[i].next) {
		if (flag) continue;
		if (!vis[e[i].y]) continue;
		if (e[i].y==fa) continue;
		dfs2(e[i].y,now);
	}
}

void dfs3(int now,int c) {
	col[now]=c;
	for (int i=ls[now];i;i=e[i].next) {
		if (col[e[i].y]||vis[e[i].y]) continue;
		dfs3(e[i].y,c);
	}
}

int bfs(int st) {
	int ret=0; used[st]=true;
	std:: queue <int> que;
	que.push(st); dis[st]=0;
	for (;!que.empty();) {
		int now=que.front(); que.pop();
		if (dis[now]>dis[ret]) ret=now;
		for (int i=ls[now];i;i=e[i].next) {
			if (col[e[i].y]==col[st]&&!used[e[i].y]) {
				dis[e[i].y]=dis[now]+e[i].w;
				used[e[i].y]=true;
				que.push(e[i].y);
			}
		}
	}
	return ret;
}

bool cmp(edge a,edge b) {
	if (a.x==b.x&&a.y==b.y) return a.w<b.w;
	if (a.x==b.x) return a.y<b.y;
	return a.x<b.x;
}

int main(void) {
	freopen("data.in","r",stdin);
	// freopen("myp.out","w",stdout);
	n=read(); int st,chp=0;
	rep(i,1,n) {
		int x=read(),y=read(),w=read();
		if (x>y) std:: swap(x,y);
		g[i]=(edge) {x,y,w};
	}
	std:: sort(g+1,g+n+1,cmp);
	rep(i,1,n) {
		if (g[i].x==g[i].y) {
			chp=true;
			continue;
		}
		if (g[i].x==g[i-1].x&&g[i].y==g[i-1].y) {
			chp=true;
			continue;
		}
		add_edge(g[i].x,g[i].y,g[i].w);
	}
	if (chp) {
		int ret=bfs(1);
		fill(used,0);
		ans=dis[bfs(ret)];
		printf("%lld\n", ans+1);
		return 0;
	}
	dfs1(1,0);
	rep(i,1,n) if (size[bel[i]]!=1) {
		st=i; ++yqw;
		vis[i]=true;
	}
	dfs2(st,0);
	rep(i,1,a[0]) dfs3(a[i],i);
	rep(i,1,a[0]) a[a[0]+i]=a[i];
	fill(used,0);
	rep(i,1,a[0]) {
		max=bfs(a[i]);
		for (int j=ls[a[i]];j;j=e[j].next) {
			if (e[j].y==a[i+1]) sum[i+1]=sum[i]+e[j].w;
		}
		wjp[i]=dis[max]-sum[i];
		lxf[i]=dis[max]+sum[i];
	}
	fill(used,0);
	rep(i,a[0]+1,a[0]*2) {
		max=bfs(a[i-a[0]]);
		for (int j=ls[a[i]];j;j=e[j].next) {
			if (e[j].y==a[i+1]) sum[i+1]=sum[i]+e[j].w;
		}
		wjp[i]=dis[max]-sum[i];
		lxf[i]=dis[max]+sum[i];
	}
	int h=1,t=1; q[1]=1;
	rep(i,2,a[0]*2) {
		while (h<=t&&sum[i]-sum[q[h]]>sum[a[0]+1]/2) h++;
		if (h<=t) ans=std:: max(ans,lxf[i]+wjp[q[h]]);
		while (h<=t&&wjp[q[t]]<=wjp[i]) t--;
		q[++t]=i;
	}
	rep(i,1,n) if (size[bel[i]]!=1) {
		vis[i]=true;
	} else vis[i]=false;
	fill(used,0);
	rep(i,1,a[0]) whf[i]=bfs(a[i]);
	fill(used,0);
	rep(i,1,a[0]) {
		int ret=bfs(whf[i]);
		ans=std:: max(ans,dis[ret]);
	}
	printf("%lld\n", ans+1);
	return 0;
}