UVA-11354

4 篇文章 0 订阅
3 篇文章 0 订阅

题意:最小瓶颈路,给出一张n个点m条边的无向图, 每条边有一个危险度,有q个询问, 每次给出两个点s、t,找一条路, 使得路径上的最大危险度最小。

思路一:并查集(按秩合并),求一个最小生成树, 任意两点在生成树上有唯一路径, 而且这条路径上的最大危险值一定最小。 但是n和q都太大, 如果直接顺着树走,每次询问最大复杂度O(n), 那么复杂度高达O(n^2),会超时。 并查集在用了路径压缩之后效率高达O(n), 但是却破坏了树形结构, 所以不能用路径压缩。 然而我们经常忽视了按秩合并这个方法, 即使不用路径压缩, 仅仅靠按秩合并, 复杂度也可低至O(logn)。 因此我们只需按秩合并, 然后询问的时候向根回溯就行了, 复杂度mlogn。

思路二:最小生成树+LCA,求出最小生成树然后把它变成有根树,令parent[i][j]表示节点 i向上走 2^j步到达的节点,cost[i][j]记录这一过程中经过所有边的最大边权,depth[i]记录节点i的深度,那么可以有如下状态转移
parent[i][j]=parent[parent[i][j−1]][j−1]
cost[i][j]=max{cost[i][j−1],cost[parent[i][j−1]][j−1]}

递推的边界是 parent[i][0]和cost[i][0],它们以及 depth[i]都可以通过一次树上的dfs处理出来。之后查询函数就和求LCA类似,先让不同两个节点 u,v到达同一深度,然后共同向上走寻找LCA,在这个过程中不断更新答案。

参考博客:https://blog.csdn.net/qq_36778821/article/details/77477350

https://blog.csdn.net/xiao_k666/article/details/82532503

代码一(思路一):

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
int n,m;
int pre[50000+10],ra[50000+10],vis[50000+10],e[50000+10];
struct node
{
    int u,v,w;
}p[100000+10];
bool cmp(node x,node y)
{
    return x.w<y.w;
}
int Find(int x)
{
    return pre[x]==x?x:Find(pre[x]);
}
void Union(int a,int b,int c)
{
    int x=Find(a);
    int y=Find(b);
    if(x==y)
        return ;
    if(ra[x]<ra[y])
    {
        pre[x]=y;
        e[x]=c;//e数组记录路径上的大小
    }
    else
    {
        pre[y]=x;
        e[y]=c;
        if(ra[x]==ra[y])
            ra[x]++;//ra数组就是记录树的高度,也就是所谓的秩
    }
}
int qurey(int x,int y)//查询
{
    int ans1=0,ans2=-1;
    int cnt=x;//先从x往y查找,
    while(true)
    {
        vis[cnt]=ans1;
        if(cnt==pre[cnt])
            break;
        ans1=max(ans1,e[cnt]);
        cnt=pre[cnt];
    }
    cnt=y;
    while(true)
    {
        if(vis[cnt]>=0)//如果刚刚x在y下面,那么就能扫到y,这里判断一下是的话就可以直接返回了,
        {
            ans2=max(ans2,vis[cnt]);
            break;
        }
        if(cnt==pre[cnt])
            break;
        ans2=max(ans2,e[cnt]);
        cnt=pre[cnt];
    }
    cnt=x;
    while(true)//如果x是在y上面,那刚刚x以上的树节点的vis值就被改变了,需要复原,以便下一次的查询,
    {
        vis[cnt]=-1;
        if(cnt==pre[cnt])
            break;
        cnt=pre[cnt];
    }
    return ans2;
}
void init()
{
    sort(p,p+m,cmp);
    for(int i=1;i<=n;i++)
    {
        pre[i]=i;
        ra[i]=0;
        vis[i]=-1;
    }
    for(int i=0;i<m;i++)
        Union(p[i].u,p[i].v,p[i].w);
}
int main()
{
    int kase=0;
    while(cin>>n>>m)
    {
        if(kase)
            cout<<endl;
        else
            kase++;
        for(int i=0;i<m;i++)
            cin>>p[i].u>>p[i].v>>p[i].w;
        init();
        int q;
        cin>>q;
        for(int i=0;i<q;i++)
        {
            int u,v;
            cin>>u>>v;
            cout<<qurey(u,v)<<endl;
        }
    }
    return 0;
}

代码二(思路二):

#include<bits/stdc++.h>
using namespace std;

const int inf=2e9;
const int maxn=50005;
const int logn=20;

struct Edge{
	int from,to,dist;
	Edge(int f,int t,int d):from(f),to(t),dist(d){}
	bool operator<(const Edge& e)const{
		return dist<e.dist;
	}
};

int n,m,q;
int par[maxn];
vector<Edge> edges,g[maxn];

int find(int x){ return par[x]==x?x:par[x]=find(par[x]); }

///构建一颗最小生成树
void kruscal(){
	for(int i=0;i<n;++i){ par[i]=i;g[i].clear(); }
	sort(edges.begin(),edges.end());
	int cnt=0;
	for(int i=0;i<m;++i){
		Edge& e=edges[i];
		int x=find(e.from);
		int y=find(e.to);
		if(x!=y){
			par[x]=y;
			g[e.from].push_back(Edge(e.from,e.to,e.dist));
			g[e.to].push_back(Edge(e.to,e.from,e.dist));
			if(++cnt==n-1) break;
		}
	}
}

int depth[maxn];
int parent[maxn][logn];
int cost[maxn][logn];
///dfs 就行ST表初始化
void dfs(int u,int fa,int d,int w){
	depth[u]=d;
	parent[u][0]=fa;
	cost[u][0]=w;
	for(int i=0;i<g[u].size();++i){
		Edge& e=g[u][i];
		int v=e.to;
		if(v!=fa) dfs(v,u,d+1,e.dist);
	}
}
///初始化
void init(){
	dfs(0,-1,0,0);
	for(int j=1;(1<<j)<n;++j){
		for(int i=0;i<n;++i){
			int a=parent[i][j-1];
			if(a==-1){
				parent[i][j]=-1;
				cost[i][j]=0;
			}
			else{
				parent[i][j]=parent[a][j-1];
				cost[i][j]=max(cost[i][j-1],cost[a][j-1]);
			}
		}
	}
}

int query(int u,int v){
	int ans=-inf,log=0;
	if(depth[u]<depth[v]) swap(u,v);
	while( (1<<(log+1)) <= depth[u]) ++log;
	///倍增法求最大值
	for(int k=log;k>=0;--k){
		if((depth[u]-depth[v])>>k&1){
			ans=max(ans,cost[u][k]);
			u=parent[u][k];
		}
	}
	if(u==v) return ans;
	for(int k=log;k>=0;--k){
		if(parent[u][k]!=-1 && parent[u][k]!=parent[v][k]){
			ans=max(ans,cost[u][k]);
			ans=max(ans,cost[v][k]);
			u=parent[u][k];
			v=parent[v][k];
		}
	}
	ans=max(ans,cost[u][0]);
	ans=max(ans,cost[v][0]);
	return ans;
}

int main(){
	int kase=0;
	while(scanf("%d%d",&n,&m)==2){
		if(kase) puts("");
		kase=1;
		edges.clear();
		for(int i=0;i<m;++i){
			int u,v,w;
			scanf("%d%d%d",&u,&v,&w);
			edges.push_back(Edge(u-1,v-1,w));
		}
		kruscal();
		init();
		scanf("%d",&q);
		while(q--){
			int u,v;
			scanf("%d%d",&u,&v);
			printf("%d\n",query(u-1,v-1));
		}
	}
	return 0;
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值