例题5.13 战争和物流 LA4080

1.题目描述：点击打开链接

2.解题思路：本题要求计算每对结点的最短路长度之和，以及删除一条边后最大的c值。前者直接用Dijkstra算法即可得到。问题是如何高效求解后者。这里可以利用最短路树来求解。可以证明，如果删除的边不在最短路树上，那么最短路树上的边到源点的最短路是不变的。如果是最短路树上的边，就需要重新求解最短路，并累计和。对于每个源点，只需要求解n次单源最短路，因此总的时间复杂度为O(N^2MlogN)。

3.代码：

#include<iostream>
#include<algorithm>
#include<cassert>
#include<string>
#include<sstream>
#include<set>
#include<bitset>
#include<vector>
#include<stack>
#include<map>
#include<queue>
#include<deque>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cctype>
#include<list>
#include<complex>
#include<functional>
using namespace std;

#define me(s) memset(s,0,sizeof(s))
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
typedef long long ll;
typedef pair <int,int> P;


const int INF=1e9;
const int N=100+10;

struct Edge{int from,to,dist;};

struct Dijkstra
{
    int n,m;
    vector<Edge>edges;
    vector<int>g[N];
    int d[N],p[N];

    void init(int n)
    {
        this->n=n;
        rep(i,n)g[i].clear();
        edges.clear();
    }
    void addedge(int u,int v,int dist)
    {
        edges.pb(Edge{u,v,dist});
        m=edges.size();
        g[u].pb(m-1);
    }
    void dijkstra(int s)
    {
        fill(d,d+n,INF);
        d[s]=0;
        priority_queue<P,vector<P>,greater<P> >q;
        q.push(P(0,s));
        while(!q.empty())
        {
            P x=q.top();q.pop();
            int u=x.second;
            if(d[u]<x.first)continue;
            for(int i=0;i<g[u].size();i++)
            {
                int id=g[u][i];
                Edge&e=edges[id];
                if(e.dist>0&&d[e.to]>d[u]+e.dist)
                {
                    d[e.to]=d[u]+e.dist;
                    p[e.to]=id;
                    q.push(P(d[e.to],e.to));
                }
            }
        }
    }
};

Dijkstra solver;

int n,m,L;

vector<int>g[N][N]; // 两点之间的原始边权
int used[N][N][N]; //used[src][a][b]表示源点为src的最短路树是否包含边a->b
int idx[N][N]; //idx[u][v]为边u->v在Dijkstra求解器中的编号
int sum_single[N]; // sum_single[src]表示源点为src的最短路树的所有d之和
int compute_c()
{
    int ans=0;
    me(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()
{
    while(~scanf("%d%d%d",&n,&m,&L))
    {
        solver.init(n);
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
            g[i][j].clear();
        for(int i=0;i<m;i++)
        {
            int a,b,s;
            scanf("%d%d%d",&a,&b,&s);a--,b--;
            g[a][b].pb(s);
            g[b][a].pb(s);
        }

        for(int i=0;i<n;i++)
            for(int j=i+1;j<n;j++)
            if(!g[i][j].empty())
        {
            sort(g[i][j].begin(),g[i][j].end());
            solver.addedge(i,j,g[i][j][0]);
            idx[i][j]=solver.m-1;
            solver.addedge(j,i,g[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(!g[i][j].empty())
        {
            int&e1=solver.edges[idx[i][j]].dist;
            int&e2=solver.edges[idx[j][i]].dist;
            if(g[i][j].size()==1)e1=e2=-1;
            else e1=e2=g[i][j][1]; //大二短边
            c2=max(c2,compute_newc(i,j));
            e1=e2=g[i][j][0]; //恢复
        }
        printf("%d %d\n",c,c2);
    }
}