NOI 2013 快餐店

9 篇文章 0 订阅
1 篇文章 0 订阅

Description:

n n n个点, n n n条边的图,求一个点,使得这个点到其它的点的最大距离最小(注意:这个点可以在边上)。
n ≤ 1 0 5 , L i ≤ 1 0 9 n\le10^5,L_i\le10^9 n105,Li109

Solution:

  • 因为它是一个 n n n个点 n n n条边的图。
  • 那么它是一个基环树。
  • 首先,一定会先考虑分类讨论。我们优先解决环上。
  • 对于点在环上时,我们可以发现,最大距离一定是环上与该点对立的点的距离+对立点的子树的最大深度,且这种对立点至多会有2个。
  • 那么考虑对立点有2个时,发现这两个对立点之间的边使无用的,即可以删除。
  • 那么由此启发,我们可以枚举一条环边删除,那么答案即为剩下的这棵树的直径除2。
  • 但枚举环边,这样复杂度是 Θ ( n 2 ) \Theta(n^2) Θ(n2)的。
  • 那么我们考虑数据结构来优化。
  • 对于一条要删除的环边 ( k , k + 1 ) (k,k+1) (k,k+1),我们找直径,由两次dfs找直径启发,我们从 k k k点向左找最远距离的点,再从该点找最远的距离,同理,从 k + 1 k+1 k+1点向右找。
  • 那么由环上距离,我们知道 D i s t ( i , j ) = m x [ i ] + m x [ j ] + { d i s [ j ] − d i s [ i ] , i ≤ j L e n − d i s [ j ] + d i s [ i ] , i > j Dist(i,j)=mx[i]+mx[j]+\begin{cases} dis[j]-dis[i],i\le j \\ Len-dis[j]+dis[i],i>j\end{cases} Dist(i,j)=mx[i]+mx[j]+{dis[j]dis[i],ijLendis[j]+dis[i],i>j
  • 我们可以考虑线段树来维护环上每个点到其它点的最大距离。
  • 这样复杂度就是 Θ ( n log ⁡ n ) \Theta(n\log n) Θ(nlogn)

Code:

#include<bits/stdc++.h>
using namespace std;
#define REP(i,f,t) for(int i=(f),i##_end_=(t);i<=i##_end_;++i)
#define SREP(i,f,t) for(int i=(f),i##_end_=(t);i<i##_end_;++i)
#define DREP(i,f,t) for(int i=(f),i##_end_=(t);i>=i##_end_;--i)
#define ll long long
template<class T>inline bool chkmin(T&x,T y){return x>y?x=y,1:0;}
template<class T>inline bool chkmax(T&x,T y){return x<y?x=y,1:0;}
template<class T>inline void rd(T&x){
	x=0;char c;
	while((c=getchar())<48);
	do x=(x<<1)+(x<<3)+(c^48);
	while((c=getchar())>47);
}

const int N=2e5+2;

int n;

int qwq,head[N];
struct edge{
	int to,nxt;
	ll w;
}E[N<<1];
void addedge(int x,int y,ll z){E[qwq]=(edge){y,head[x],z};head[x]=qwq++;}
#define EREP(x) for(int i=head[x];~i;i=E[i].nxt)

int dfn[N],low[N],tim;
int stk[N<<1],top;
bool vis[N];

int chain[N],len;
bool belong[N];

ll ans;

void tarjan(int x,int f){
	dfn[x]=low[x]=++tim;
	stk[++top]=x;
	bool flag=1;
	EREP(x){
		int y=E[i].to;
		if(y==f and flag){flag=0;continue;}
		if(!dfn[y]) tarjan(y,x),chkmin(low[x],low[y]);
		else chkmin(low[x],dfn[y]);
	}
	if(dfn[x]==low[x]){
		if(stk[top]!=x){
			do {
				chain[++len]=stk[top];
				belong[stk[top]]=1;
			}while(x!=stk[top--]); 
		}
		else top--;
	}
}

struct p70{
	
	bool mark[N<<1];
	ll Mx,Id;
	
	void dfs1(int x,int f,ll d){
		if(chkmax(Mx,d)) Id=x;
		EREP(x){
			if(mark[i])continue;
			if(E[i].to!=f) dfs1(E[i].to,x,d+E[i].w);
		}
	}
	
	void dfs2(int x,int f,ll d){
		if(chkmax(Mx,d)) Id=x;
		EREP(x){
			if(mark[i])continue;
			if(E[i].to!=f) dfs2(E[i].to,x,d+E[i].w); 
		}
	}
	
	void solve(){
		
		ans=1e18;
		
		REP(p,1,len){
			int x=chain[p],y=chain[p%len+1];
			EREP(x){
				if(E[i].to==y) {
					mark[i]=mark[i^1]=1;
					
					Mx=Id=-1;
					dfs1(1,0,0);
					Mx=-1;
					dfs2(Id,0,0);
					
					chkmin(ans,Mx);
					
					mark[i]=mark[i^1]=0;
				}
			}
		}
		
		printf("%.1lf\n",1.0*ans/2);
	}
}p1;

ll dep[N<<1],dis[N],sum[N<<1];
ll mx[N],Sum[N];

ll Dist(int x,int d){
	if(!~x) return -1e18;
	return dep[x]+((d==1)?-sum[x]:sum[x]);
}

struct p100{
	
	ll dfs(int x,int f,ll d,int id){
		chkmax(dep[id],d);
		mx[x]=Sum[x]=0;
		EREP(x){
			int y=E[i].to;
			if(y==chain[id%len+1]) dis[id]=E[i].w;
			if(y==f or belong[y])continue;
			ll t=dfs(y,x,d+E[i].w,id)+E[i].w;
			chkmax(Sum[x],mx[x]+t);
			chkmax(mx[x],t);
		}
		return mx[x];
	}
	

	struct Tree{
		#define lson L,mid,p<<1
		#define rson mid+1,R,p<<1|1
		#define family tree[p],tree[p<<1],tree[p<<1|1]
		 
		struct node{
			int L,R;
			int id1,id2;
			ll mx1,mx2;
		}tree[N<<2];
		
		void Up(node &A,node L,node R){
			if(L.mx1>R.mx1)A.mx1=L.mx1,A.id1=L.id1;
			else A.mx1=R.mx1,A.id1=R.id1;
			if(L.mx2>R.mx2)A.mx2=L.mx2,A.id2=L.id2;
			else A.mx2=R.mx2,A.id2=R.id2;
		}
		
		void build(int L,int R,int p){
			tree[p].L=L,tree[p].R=R;
			if(L==R){
				tree[p].mx1=Dist(L,1);
				tree[p].mx2=Dist(L,2);
				tree[p].id1=tree[p].id2=L;
				return; 
			} 
			int mid=(L+R)>>1;
			build(lson),build(rson);
			Up(family); 
		}
		
		int query(int L,int R,int p,int op){
			if(L>R)return -1;
			if(tree[p].L==L and tree[p].R==R) return op==1?tree[p].id1:tree[p].id2;
			int mid=(tree[p].L+tree[p].R)>>1;
			if(R<=mid) return query(L,R,p<<1,op);
			else if(L>mid) return query(L,R,p<<1|1,op);
			else {
				int l=query(lson,op),r=query(rson,op);
				return Dist(l,op)>Dist(r,op)?l:r; 
			}
		}
		
	}T; 

	void solve(){
		REP(i,1,len){
			dfs(chain[i],0,0,i);
			sum[i]=sum[i-1]+dis[i-1];
		}
		
		REP(i,1,len){
			dep[i+len]=dep[i];
			if(i>1) sum[i+len]=sum[i+len-1]+dis[i-1];
			else sum[i+len]=sum[len]+dis[len];
		}
		
		ans=1e18;
		
		T.build(1,len<<1,1);
		
		REP(i,1,len){
			int l1=T.query(i,i+len-1,1,1);
			int l2=T.query(i,i+len-1,1,2);
			int tmp;
			ll Mx=0;
			
			if(l1==l2){
				int r1=T.query(i,l1-1,1,1);
				tmp=T.query(l1+1,i+len-1,1,1);
				if(Dist(tmp,1)>Dist(r1,1))r1=tmp;
				
				int r2=T.query(i,l2-1,1,2);
				tmp=T.query(l2+1,i+len-1,1,2);
				if(Dist(tmp,2)>Dist(r2,2))r2=tmp;
				
					
				Mx=Dist(l1,1)+Dist(r2,2);
				chkmax(Mx,Dist(l2,2)+Dist(r1,1));
			}
			else Mx=Dist(l1,1)+Dist(l2,2);
			chkmin(ans,Mx);
		}
		REP(i,1,n) chkmax(ans,Sum[i]);
		
		printf("%.1lf\n",1.0*ans/2);
	}
}p2;

int main(){
//	freopen("foodshop.in","r",stdin);
//	freopen("foodshop.out","w",stdout);
	rd(n);
	memset(head,-1,sizeof head);
	REP(i,1,n){
		int a,b;ll c;
		rd(a),rd(b),rd(c);
		addedge(a,b,c);
		addedge(b,a,c);
	}
	
	tarjan(1,0);

	if(n<=3000) p1.solve();
	else p2.solve();
	
	return 0;
}

Summary:

  • 对于基环树的问题,还是常规的抽出环,在环上做文章。
  • 分类讨论,数据结构(常见:线段树,单调队列,单调栈)维护都是解决环上问题的必然操作。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值