UVA1416 Warfare And Logistics

UVA1416 Warfare And Logistics

链接：http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=36232

【题意】

  给出一个无向图，定义C =∑(d[i][j])  ，其中d[][]表示两点间的最短距离，求出C并求出删除一条边后的最大C2。

【思路】

  最短路树。

  简单地想我们可以用floyd或SPFA求出两点间的最短距离，然后枚举删除m条边再次进行这项工作。

  其实这里我们不用重新全部计算，因为如果所删除的边不在scr的最短路树上，那么这棵树不会被破坏。因此我们可以提前在求C的时候记录每一个scr最短路树上的边以及这棵最短路树的总权值，依旧枚举删边，判断是否需要重新计算即可。

  理论上时间需要O(n^3)，实践中应该能跑O(n^2)。

  需要注意的是有重边的时候应该用次短边代替。

【代码】

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
#define FOR(a,b,c) for(int a=(b);a<=(c);a++)
using namespace std;

const int maxn = 100+10,maxm=1000+10;
const int INF=1e9;
struct Edge{
    int u,v,w,next;
};

int n,m,L;

struct SPFA{
    int n;
    Edge e[2*maxm];
    int en,front[maxn];
    int inq[maxn],d[maxn];
    int p[maxn];
    queue<int> q;
    
    void init(int n){
        this->n=n;
        en=-1;
        memset(front,-1,sizeof(front));
    }
    void AddEdge(int u,int v,int w) {
         en++; e[en].u=u; e[en].v=v; e[en].w=w; e[en].next=front[u]; front[u]=en;
    }
    void solve(int s) {
        memset(inq,0,sizeof(inq));
        memset(p,0,sizeof(p));
        for(int i=1;i<=n;i++) d[i]=INF;
    
        d[s]=0; inq[s]=1; q.push(s);
        while(!q.empty()) {
            int u=q.front(); q.pop(); inq[u]=0;
            for(int i=front[u];i>=0;i=e[i].next) {
                int v=e[i].v,w=e[i].w;
                if(w>0 && d[v]>d[u]+w) {         //w<0表示此边已断 
                    d[v]=d[u]+w;
                    p[v]=i;
                    if(!inq[v]) {
                        inq[v]=1;
                        q.push(v);
                    }
                }
            }
        }
    }
}spfa;

vector<int> gr[maxn][maxn];  //保存ij之间所有的边 
int idx[maxn][maxn];         //边ij在SPFA中对应的编号 
int used[maxn][maxn][maxn];  //used[scr][u][v]表示在scr为根的最短路树上边uv是否出现 
int sum_single[maxn];        //scr的最短路树的d[]之和

int CALC_C() {
    int ans=0;
    memset(used,0,sizeof(used));
    FOR(scr,1,n) 
    {
        spfa.solve(scr);
        sum_single[scr]=0;
        FOR(v,1,n)
        {
           if(v!=scr) {
                   int u=spfa.e[spfa.p[v]].u;
                   used[scr][u][v]=used[scr][v][u]=1;
           }
           sum_single[scr] += spfa.d[v]==INF? L : spfa.d[v];
        }
        ans += sum_single[scr];
    }
    return ans;
}
int CALC_C2(int a,int b) {
    int ans=0;
    FOR(scr,1,n)
    {
          if(!used[scr][a][b]) ans+=sum_single[scr];  
          //如果边ij没有出现在i的最短路树上则无须重新计算 
          else
          {
                spfa.solve(scr);
                FOR(v,1,n) ans += spfa.d[v]==INF?L: spfa.d[v];
          }
    }
    return ans;
}

int main() 
{
    while(scanf("%d%d%d",&n,&m,&L)==3)  //==3 否则会TLE 
    {
        int u,v,w;
        spfa.init(n);
        FOR(i,1,n) FOR(j,1,n) gr[i][j].clear();
        while(m--) {
            scanf("%d%d%d",&u,&v,&w);
            gr[u][v].push_back(w);
            gr[v][u].push_back(w);
        }
        FOR(i,1,n) FOR(j,i+1,n) if(!gr[i][j].empty()){
            sort(gr[i][j].begin(),gr[i][j].end());
            spfa.AddEdge(i,j,gr[i][j][0]);
            idx[i][j]=spfa.en;
            spfa.AddEdge(j,i,gr[i][j][0]);
            idx[j][i]=spfa.en;
        }
        int c=CALC_C(),c2=-1;
        FOR(i,1,n) FOR(j,i+1,n) if(!gr[i][j].empty()){
            int& e1=spfa.e[idx[i][j]].w;
            int& e2=spfa.e[idx[j][i]].w;
            if(gr[i][j].size()==1) e1=e2=-1;
            else e1=e2=gr[i][j][1];          //用次短边代替 
            c2=max(c2,CALC_C2(i,j));         //"删除" ij之间的边之后计算c2
            e1=e2=gr[i][j][0];
        }
        printf("%d %d
",c,c2);
    }
    return 0;
}