货车运输

Problem’s Website

  • 货车运输

    Solution

  • 对于这道题目,重点是建模,我们可以把每条道路的载重看成道路的边权,因为要求载重最大,我们可以对图搞一个最大生成树,然后对于两个点u,v,其两点的最短路径中的最大边权即为最大载重,最短路径肯定是两点的LCA。

    Code

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<algorithm>
    #define gc getchar()
    #define Maxn 10010
    #define Maxm 50010
    using namespace std;
    int sc() {
    int xx=0,ff=1; char cch;
    while(cch<'0'|| cch>'9') {
    if(cch=='-') ff=-ff; cch=gc;
    }
    while(cch>='0'&& cch<='9') {
    xx=xx*10+(cch-48); cch=gc;
    }
    return xx*ff;
    }
    struct EDGE {
    int u,v,dis;
    bool operator < (const EDGE &x) const {
    return dis>x.dis;
    }
    }a[Maxm];
    struct TREE {
    int next,to,dis;
    }edge[Maxn*2];
    int n,m,cnt,q;
    int father[Maxn],head[Maxn*2],deep[Maxn];
    bool vis[Maxn];
    int f[Maxn][21],Dis[Maxn][21];
    namespace DY {
    void ADD(int from,int to,int dis) {
    edge[++cnt].next=head[from];
    edge[cnt].to=to;
    edge[cnt].dis=dis;
    head[from]=cnt;
    }
    void D_F(int son,int fa) {
    vis[son]=1;
    deep[son]=deep[fa]+1;
    for(int i=1; i<=20; i++) {
    f[son][i]=f[f[son][i-1]][i-1];
    Dis[son][i]=min(Dis[son][i-1],Dis[f[son][i-1]][i-1]);
    }
    for(int i=head[son]; i; i=edge[i].next) {
    int to=edge[i].to;
    if(to==fa||vis[to]) continue;
    // deep[to]=deep[son]+1;
    f[to][0]=son;
    Dis[to][0]=edge[i].dis;
    D_F(to,son);
    }
    }
    int find(int x) {
    return x==father[x]? x: father[x]=find(father[x]);
    }
    int LCA(int x,int y) {
    if(find(x)!=find(y)) return -1;
    int res=0x7fffffff/3;
    if(deep[x]<deep[y]) swap(x,y);
    for(int i=20; i>=0; i--) {
    if(deep[f[x][i]]>=deep[y]) {
    res=min(res,Dis[x][i]);
    x=f[x][i];
    }
    }
    if(x==y) return res;
    for(int i=20; i>=0; i--) {
    if(f[x][i]!=f[y][i]) {
    res=min(res,min(Dis[x][i],Dis[y][i]));
    x=f[x][i]; y=f[y][i];
    }
    }
    return min(res,min(Dis[x][0],Dis[y][0]));
    }
    void main() {
    n=sc(); m=sc();
    for(int i=1; i<=m; i++)
    a[i].u=sc(),a[i].v=sc(),a[i].dis=sc();
    sort(a+1,a+1+m);
    for(int i=1; i<=n; i++)
    father[i]=i;
    for(int i=1; i<=m; i++) {
    int aa=find(a[i].u);
    int bb=find(a[i].v);
    if(aa!=bb) {
    // num+=a[i].dis;
    father[aa]=bb;
    ADD(a[i].u,a[i].v,a[i].dis);
    ADD(a[i].v,a[i].u,a[i].dis);
    }
    }
    for(int i=1; i<=n; i++) {
    if(!vis[i]) {
    // deep[i]=1;
    D_F(i,0);
    // f[1][0]=1;
    Dis[i][0]=0x7fffffff/3;
    }
    }
    q=sc();
    while(q--) {
    int u=sc(),v=sc();
    printf("%d\n",LCA(u,v));
    }
    }
    };
    int main() {
    DY::main();
    return 0;
    }

rp++