-NOIp2013 Day1T3 货车运输(truck.cpp/.c/.pas)

时间：2022-04-20 04:02:03

题目

货车运输 (truck.cpp/c/pas)
题目描述 Description
A 国有 n 座城市，编号从 1 到 n，城市之间有 m 条双向道路。每一条道路对车辆都有重量限制，简称限重。现在有 q
辆货车在运输货物，司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。
输入描述 Input Description
第一行有两个用一个空格隔开的整数 n，m，表示 A 国有 n 座城市和 m 条道路。
接下来 m 行每行 3 个整数 x、y、z，每两个整数之间用一个空格隔开，表示从 x 号城市到 y 号城市有一条限重为 z 的道路。注意：x不等于 y，两座城市之间可能有多条道路。
接下来一行有一个整数 q，表示有 q 辆货车需要运货。
接下来 q 行，每行两个整数x、y，之间用一个空格隔开，表示一辆货车需要从 x 城市运输货物到 y 城市，注意：x 不等于 y。
输出描述 Output Description
输出共有 q 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。如果货车不能到达目的地，输出-1。
样例输入 Sample Input
4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3
样例输出 Sample Output
3
-1
3
数据范围及提示 Data Size & Hint
对于 30%的数据，0 < n < 1,000，0 < m < 10,000，0 < q < 1,000；
对于 60%的数据，0 < n < 1,000，0 < m < 50,000，0 < q < 1,000；
对于 100%的数据，0 < n < 10,000，0 < m < 50,000，0 < q < 30,000，0 ≤ z ≤ 100,000。

主要思路（大致方向）

这一题是Noip2013Day1的压轴题，必定有它的难度(提高+/省选-)
这是一道大算法题（并查集，kruskal最大生成树，倍增，lca最近公共祖先，深搜） 骗小部分分的暴力算法就不说了，下面来谈一谈正解
做这道题的步骤:
Step(1)：Kruskal生成最大生成树
Step(2)：lca求最近公共祖先
Step(3)：在连接两个点的n条路径里面找最小，即正确答案

本题算法

由于本题算法较多，在这里给大家把相关的链接奉上

数据结构--并查集的原理及实现—— [ hapjin博客园 ]

最小生成树之Kruskal算法—— [ Enstein_Jun CSDN博客 ]

白话系列 倍增算法—— [ jarjingx CSDN博客 ]

LCA 最近公共祖先—— [ Angel_Kitty 博客园 ]

深度优先搜索的实现—— [ 神奕 CSDN博客 ]

为什么要用KrusKal求最大生成树

如图，点1至点2可能存在有多条路径，我们为了要找到最大的限重，就一定会选择限重最大的那一条边，而不会去选择另外限重极小的边
所以这个时候，我们就需要对Kruskal最小生成树算法改写排序规则使其成为最大生成树，两个点之间只保留一条最大限重边
处理过后原本m条边就降到了n-1条边，对空间和时间都有优化
-NOIp2013 Day1T3 货车运输(truck.cpp/.c/.pas)

为什么要用LCA求出最近公共祖先

当前所有的道路都已经构成了一棵最大生成树，要找到点X和点Y的一条连通路径，就必须找到他们的公共祖先，便可以找到一条路径出来
如图，点X和点Y的最近公共祖先是节点1，这就找到了他们之间的一条连通路径
-NOIp2013 Day1T3 货车运输(truck.cpp/.c/.pas)-NOIp2013 Day1T3 货车运输(truck.cpp/.c/.pas)
看到这里可能有小伙伴想问 为什么只求最近公共祖先，而不继续向上求呢?万一上面还有更大的限重呢？
因为往上求也是徒劳，找到的最近公共祖先的路就必须要经过
看到这一幅图，如果按照小伙伴们想的继续向上找，发现节点0和节点1的限重是无穷大，但是下面最大生成树的限重都很小，所以即使上面的限重很大，但仍无法改变最大生成树里的限重很小，更无法改变你要经过那些限重很小路段的事实
-NOIp2013 Day1T3 货车运输(truck.cpp/.c/.pas)
所以我们只需要把最大生成树求出来就好了，不需要再往上找

程序

#include <iostream>
#include <iomanip>
#include <cstdio>
#define Maxn 50000+10
#define m1 10000+10
using namespace std;

int n,m,que; //题目给的数据
int num_edge,head[m1]; 
struct Edge{int next,to,dis;}edge[Maxn];
//上面两行存储邻接表
struct kru{int x,y,z;}ks[Maxn]; //用来处理Kruskal
int set[Maxn],flag[m1],deep[m1]; 
//楼上一堆标记
int weight[m1][100],f[m1][100];
// f[i][j] i走了2^j到达的点，用于倍增
// weight[i][j] 点i到点2^j中许多段距离的最小值

template<class T>void read(T &x){//读入优化，不解释了
    x=0;int f=0;char ch=getchar();
    while(ch<'0'||ch>'9')  {f|=(ch=='-');ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    x=f?-x:x;
    return;
}

void add_edge(int from,int to,int dis){//邻接表，不解释了
    edge[++num_edge].next=head[from];
    edge[num_edge].to=to;
    edge[num_edge].dis=dis;
    head[from]=num_edge;
}

int find(int a){ //查找祖先
    if(set[a] != a) set[a]=find(set[a]);
    return set[a];
}
//并查集忘了的同学可以翻书
bool built(int x,int y){ //检查并记录他们的祖先
    int s1=find(x), s2=find(set[y]);
    if(s1!=s2) {set[s1]=s2;  return 1;}
    return 0;
}

bool cmp(kru x,kru y){return x.z>y.z;} //从大到小排序

void kruskal(){ //求最大生成树
    for(int i=1;i<=n;i++) set[i]=i;//初始化父亲节点
    sort(ks+1,ks+1+m,cmp); //重新排序，大到小
    int num=0; //记录边数
    for(int i=1;i<=m;i++)
      if(built(ks[i].x,ks[i].y)) { //这里用到了并查集
        add_edge(ks[i].x,ks[i].y,ks[i].z);
        add_edge(ks[i].y,ks[i].x,ks[i].z);
        //存到邻接表里面，因为它是无向图，所以存两遍
        num++;
        if(num==n-1) break; //满足最大生成树了，就break
    }
}

void dfs(int k){ //dfs求的是每一个节点在树的第几层
    for(int i=head[k];i!=0;i=edge[i].next)
        if(!flag[edge[i].to]) {
            int g=edge[i].to;
            flag[g]=1; deep[g]=deep[k]+1;
            f[g][0]=k; weight[g][0]=edge[i].dis;
            dfs(g);
        }
}

int lca(int x,int y){
    int ans=0x7fffffff; //提前ans最大化
    if(deep[x]<deep[y]) swap(x,y); //规定一下x必须高于y
    //任何数都可以用2^j表示，从大到小是为了让找的次数尽量的少
    for(int i=20;i>=0;i--)
        if(deep[f[x][i]]>=deep[y]) { ans=min(ans,weight[x][i]); x=f[x][i]; }
        //这里把y提到和x一样的高度，由此来找他们的最近公共祖先
    if(x==y) return ans; //如果y提上来之后就找到了最近公共祖先
                                   //直接结束
    for(int i=20;i>=0;i--)
        if(f[x][i]!=f[y][i]) { ans=min(ans,min(weight[x][i],weight[y][i])); x=f[x][i],y=f[y][i]; }
        //不断的把x,y往上面提，直到找到他们的最近公共祖先
        ans=min(ans,min(weight[x][0],weight[y][0])); //在最大里面找最小
        return ans;
}

int main()
{
    freopen("truck.in","r",stdin);
    freopen("truck.out","w",stdout);
    read(n),read(m);
    for(int i=1;i<=m;i++) read(ks[i].x),read(ks[i].y),read(ks[i].z);
    //先读入图
    kruskal();  //kruskal求最大生成树
    memset(weight,0x7f,sizeof(weight)); //初始化权值最大值
    for(int i=1;i<=n;i++)//记录每一个点的层数，lca需要用到
        if(!flag[i]){ flag[i]=1,deep[i]=1,f[i][0]=i; dfs(i); }
    for(int i=1;i<=20;i++)
        for(int j=1;j<=n;j++){//倍增优化
            f[j][i]=f[f[j][i-1]][i-1];
            weight[j][i]=min(weight[j][i-1],weight[f[j][i-1]][i-1]);
        }
    read(que); //读入司机的需求数
    for(int i=1;i<=que;i++){
        int x,y; read(x),read(y);
        if(find(x)!=find(y)) printf("-1\n"); //如果两个节点的祖先不一致则无解
        else printf("%d\n",lca(x,y)); //否则就lca找答案
    }
    return 0;
}

题解就到这里啦，有什么疑问或不足请评论或私信哦~
欢迎各路大佬指(chai)点(tai)本蒟蒻
标签：

相关文章