• NOIP提高组 2013货车运输


    觉得题目水的离开
    不屑的大佬请离开
    不会图论的请离开
    …….
    感谢您贡献的访问量

    ————————————华丽的分割线————————————

    题面:

    题目描述
    A 国有 n 座城市,编号从 1 到 n,城市之间有 m 条双向道路。每一条道路对车辆都有重量限制,简称限重。现在有 q 辆货车在运输货物, 司机们想知道每辆车在不超过车辆限重的情况下,最多能运多重的货物。
    输入输出格式
    输入格式:
    输入文件名为 truck.in。
    输入文件第一行有两个用一个空格隔开的整数 n,m,表示 A 国有 n 座城市和 m 条道路。 接下来 m 行每行 3 个整数 x、 y、 z,每两个整数之间用一个空格隔开,表示从 x 号城市到 y 号城市有一条限重为 z 的道路。注意: x 不等于 y,两座城市之间可能有多条道路 。
    接下来一行有一个整数 q,表示有 q 辆货车需要运货。
    接下来 q 行,每行两个整数 x、y,之间用一个空格隔开,表示一辆货车需要从 x 城市运输货物到 y 城市,注意: x 不等于 y 。
    输出格式:
    输出文件名为 truck.out。
    输出共有 q 行,每行一个整数,表示对于每一辆货车,它的最大载重是多少。如果货车不能到达目的地,输出-1。
    输入输出样例
    输入样例#1:
    4 3
    1 2 4
    2 3 3
    3 1 1
    3
    1 3
    1 4
    1 3
    输出样例#1:
    3
    -1
    3
    说明
    对于 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。


    解题思路:

    听大佬说这题是一道树剖水题。本蒟蒻表示没学过,只会用最大生成树和倍增LCA做。
    首先题目要求尽可能多的运输货物,运输货物只与两个点之间任意一条路径的最小边有关,贪心的想一下,让选择的路径最小边最大不就行了吗?只要对图做一遍最大生成树形成最大生成树的森林,然后用一个minn数组在倍增处理fa的时候倍增处理一下边的最小值,最后当询问的两个点不属于一棵树输出-1,否则做一遍LCA,在minn数组中取出最小边的值即可。
    常数巨大的代码:

    # include <math.h>
    # include <stdio.h>
    # include <stdlib.h>
    # include <iostream>
    # include <string.h>
    # include <algorithm>
    using namespace std;
    
    # define N 100001
    # define IL inline
    # define RG register
    # define UN unsigned
    # define ll long long
    # define oo 2147483647
    # define mem(a, b) memset(a, b, sizeof(a))
    # define max(a, b) ((a) > (b)) ? (a) : (b)
    # define min(a, b) ((a) < (b)) ? (a) : (b)
    
    IL int Get(){
        RG char c = '!'; RG int num = 0, z = 1;
        while(c != '-' && (c > '9' || c < '0')) c = getchar();
        if(c == '-') z = -1, c = getchar();
        while(c >= '0' && c <= '9') num = num * 10 + c - '0', c = getchar();
        return num * z;
    }
    
    int n, m, ft[N], nt[N], to[N], f[N], cnt;
    int Fa[N], deep[N], fa[N][20], minn[N][20];
    struct Edge{
        int u, v, f;
        IL bool operator < (Edge b) const{
            return f > b.f;
        }
    } edge[N];
    
    IL int Find(RG int x){
        return (x == Fa[x]) ? x : Fa[x] = Find(Fa[x]);
    }
    
    IL void Add(RG int u, RG int v, RG int ff){
        nt[cnt] = ft[u]; to[cnt] = v; f[cnt] = ff; ft[u] = cnt++;
    }
    
    IL void Dfs(RG int u){
        for(RG int i = ft[u]; i != -1; i = nt[i]){
            RG int v = to[i];
            if(!deep[v]){
                deep[v] = deep[u] + 1;
                fa[v][0] = u; minn[v][0] = f[i];
                Dfs(v);
            }
        }
    }
    
    IL int Lca(RG int u, RG int v){
        RG int ans = oo;
        if(deep[v] < deep[u]) swap(u, v);
        for(RG int j = 14; j >= 0; j--)
            if(fa[v][j] && deep[fa[v][j]] >= deep[u]){
                ans = min(ans, minn[v][j]);
                v = fa[v][j];
            }
        if(u == v) return ans;
        for(RG int j = 14; j >= 0; j--)
            if(fa[u][j] != fa[v][j]){
                ans = min(ans, minn[u][j]);
                ans = min(ans, minn[v][j]);
                u = fa[u][j];
                v = fa[v][j];
            }
        ans = min(ans, minn[u][0]);
        ans = min(ans, minn[v][0]);
        return ans;
    }
    
    int main(){
        mem(ft, -1);
        n = Get(); m = Get();
        for(RG int i = 1; i <= n; i++) Fa[i] = i;
        for(RG int i = 1; i <= m; i++)
            edge[i] = (Edge){Get(), Get(), Get()};
        sort(edge + 1, edge + m + 1);
        RG int t = 0, i = 0;
        while(i <= m){
            i++;
            RG int u = Find(edge[i].u), v = Find(edge[i].v);
            if(u != v){
                t++;
                Fa[u] = Fa[v];
                Add(edge[i].u, edge[i].v, edge[i].f);
                Add(edge[i].v, edge[i].u, edge[i].f);
            }
            if(t == n - 1) break;
        }
        for(RG int i = 1; i <= n; i++)
            if(!deep[i]) deep[i] = 1, Dfs(i);
        for(RG int j = 1; (1 << j) <= n; j++)
            for(RG int i = 1; i <= n; i++){
                minn[i][j] = min(minn[i][j - 1], minn[fa[i][j - 1]][j - 1]);
                fa[i][j] = fa[fa[i][j - 1]][j - 1];
            }
        RG int q = Get();
        while(q--){
            RG int u = Get(), v = Get();
            if(Find(u) != Find(v)) printf("-1
    ");
            else printf("%d
    ", Lca(u, v));
        }
        return 0;
    }

    龟速285ms过

  • 相关阅读:
    设计模式-简单工厂模式、工厂模式、抽象工厂模式-(创建型模式)
    设计模式-类间关系
    设计模式-六大基本原则
    设计模式-总起
    [转载]常见的移动端H5页面开发遇到的坑和解决办法
    [转载]Angular4 组件通讯方法大全
    【angular5项目积累总结】文件下载
    【转载】Vue 2.x 实战之后台管理系统开发(二)
    [转载]Vue 2.x 实战之后台管理系统开发(一)
    WordPress翻译中 __()、_e()、_x、_ex 和 _n 的用法及区别
  • 原文地址:https://www.cnblogs.com/cjoieryl/p/8206426.html
Copyright © 2020-2023  润新知