训练指南 UVALive - 4080(最短路Dijkstra + 边修改 + 最短路树)

Posted luowentao

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了训练指南 UVALive - 4080(最短路Dijkstra + 边修改 + 最短路树)相关的知识,希望对你有一定的参考价值。


layout: post
title: 训练指南 UVALive - 4080(最短路Dijkstra + 边修改 + 最短路树)
author: "luowentaoaa"
catalog: true
mathjax: true
tags:
- Dijkstra
- 最短路树
- 图论
- 训练指南


Warfare And Logistics

UVALive - 4080

题意

①先求任意两点间的最短路径累加和,其中不连通的边权为L ②删除任意一条边,求全局最短路径和的最大值

题解

刚看到题目是让各点之间的最短路径和,所以立马想到啦floyd算法求最短路,然后发现还要去掉一条边后求最短路中的最大值,则floyd会超时,所以打算用dijkstra+堆优化做,首先枚举n个顶点求各个顶点之间的最短路径,并求出最短路树,然后枚举每条边,如果这条边在最短路树中,则再求一遍该点的最短路径即可,如果不在最短路树中,则直接利用第一次求得最短路即可。

所谓的最短路树是指在求最短路的同时,记录最短路径并且标记那些点之间的连线有用到。

如果在枚举某个作为起点的时候这删去的点没有用到那就直接加上答案即可,这样时间就省去了一个m

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=998244353;
const int maxn=100+10;
const int inf=1000000000;
struct Edge{
    int from,to,dist;
};
struct HeapNode{
    int d,u;
    bool operator <(const HeapNode& rhs)const{
        return d>rhs.d;
    }
};
struct Dijkstra{
    int n,m;              ///点数和边数  点编号0~N-1
    vector<Edge>edges;    ///边列表
    vector<int>G[maxn];   ///每个节点出发的边编号
    bool done[maxn];      /// 是否已永久标号
    int d[maxn];          /// s到各个点的距离
    int p[maxn];          /// 最短路中的上一条边

    void init(int n){
        this->n=n;
        for(int i=0;i<n;i++)G[i].clear();
        edges.clear();
    }
    void AddEdge(int from,int to,int dist){ ///无向图调用两次
        edges.push_back((Edge){from,to,dist});
        m=edges.size();
        G[from].push_back(m-1);
    }
    void dijkstra(int s){
        priority_queue<HeapNode>Q;
        for(int i=0;i<n;i++)d[i]=inf;
        d[s]=0;
        memset(done,0,sizeof(done));
        Q.push((HeapNode){0,s});
        while(!Q.empty()){
            HeapNode x=Q.top();Q.pop();
            int u=x.u;
            if(done[u])continue;
            done[u]=true;
            for(int i=0;i<G[u].size();i++){
                Edge& e=edges[G[u][i]];
                if(e.dist>0&&d[e.to]>d[u]+e.dist){
                    d[e.to]=d[u]+e.dist;
                    p[e.to]=G[u][i];
                    Q.push((HeapNode){d[e.to],e.to});
                }
            }
        }
    }
};

Dijkstra solver;
int n,m,L;
vector<int>gr[maxn][maxn];
int used[maxn][maxn][maxn];
int idx[maxn][maxn];
int sum_single[maxn];

int compute_c(){
    int ans=0;
    memset(used,0,sizeof(used));
    for(int src=0;src<n;src++){
        solver.dijkstra(src);
        sum_single[src]=0;
        for(int i=0;i<n;i++){
            if(i!=src){
                int fa=solver.edges[solver.p[i]].from;
                used[src][fa][i]=used[src][i][fa]=1;
            }
            sum_single[src]+=(solver.d[i]==inf?L:solver.d[i]);
        }
        ans+=sum_single[src];
    }
    return ans;
}
int compute_newc(int a,int b){
    int ans=0;
    for(int src=0;src<n;src++)
        if(!used[src][a][b])ans+=sum_single[src];
        else{
            solver.dijkstra(src);
            for(int i=0;i<n;i++)
                ans+=(solver.d[i]==inf?L:solver.d[i]);
        }
    return ans;
}
int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    while(cin>>n>>m>>L){
        solver.init(n);
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)gr[i][j].clear();
        for(int i=0;i<m;i++){
            int a,b,s;
            cin>>a>>b>>s;a--;b--;
            gr[a][b].push_back(s);
            gr[b][a].push_back(s);
        }
        for(int i=0;i<n;i++)
        for(int j=i+1;j<n;j++)if(!gr[i][j].empty()){
            sort(gr[i][j].begin(),gr[i][j].end());
            solver.AddEdge(i,j,gr[i][j][0]);
            idx[i][j]=solver.m-1;
            solver.AddEdge(j,i,gr[i][j][0]);
            idx[j][i]=solver.m-1;
        }
        int c=compute_c();
        int c2=-1;
        for(int i=0;i<n;i++)
        for(int j=i+1;j<n;j++)if(!gr[i][j].empty()){
            int &e1=solver.edges[idx[i][j]].dist;
            int &e2=solver.edges[idx[j][i]].dist;
            if(gr[i][j].size()==1)e1=e2=-1;
            else e1=e2=gr[i][j][1];
            c2=max(c2,compute_newc(i,j));
            e1=e2=gr[i][j][0];
        }
        cout<<c<<" "<<c2<<endl;
    }
    return 0;
}

以上是关于训练指南 UVALive - 4080(最短路Dijkstra + 边修改 + 最短路树)的主要内容,如果未能解决你的问题,请参考以下文章

UVA1416(LA4080) Warfare And Logistics (单源最短路)

UvaLive 4080 Warfare And Logistics

训练指南 UVA - 10917(最短路Dijkstra + 基础DP)

训练指南 UVA - 11374(最短路Dijkstra + 记录路径 + 模板)

训练指南 UVA - 11478(最短路BellmanFord+ 二分+ 差分约束)

训练指南 UVA - 11090(最短路BellmanFord+ 二分判负环)