LA4080最短路树的应用

/*LA4080最短路树的应用
这道题的目的就是让人去合理运用最短路算法中的信息？
求两两点之间的距离之和，一般让人去想到Floyd,或者n次的DIJ，但是Floyd算法虽然精简，但是可用的信息比较少，一次就要n^3的复杂度，
如果直接这样做，肯定会超时，然而dij就灵活的多，有的信息能重复使用。
思想：
1、从每个源点出发，会产生一个最短路树，即是除了根节点之外，每个节点只有一个前驱，这个符合dij路径的唯一性
2、对于一条边，如果这条边不在这条树上，肯定不会影响这棵树根节点i的dij距离和
3、如果在树上，则对于树的根结点，要重新算一次dij
细节：因为我们在计算的时候，只是模拟的把其中的边删除，所以一定不要影响原图的信息
*/
#include<iostream>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<cmath>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define maxn 110
#define maxe 2100
#define INF 100000000
using namespace std;
int N,M,L;
int C,NC;
//set<int>Tree[maxn];//存储没课最短路树上的所有边
bool Tree[maxn][maxe];
int tot[maxn];//每个节点的单源最短距离之和
int nextint(){int x;scanf("%d",&x);return x;}
struct Edge
{
    int u,v,dis;
};
struct Node
{
    int d,u;
    bool operator<(const Node &x)const{
        return d>x.d;
    }
};
struct Dijkstra
{
    int n,m;
    vector<Edge>edge;
    vector<int>G[maxn];
    bool vis[maxn];
    int d[maxn],p[maxn];

    void init(int n)
    {
        this->n=n;
        edge.clear();
        for(int i=0;i<=n;i++) G[i].clear();
    }

    void add(int u,int v,int c){
        edge.push_back((Edge){u,v,c});
        m=edge.size();
        G[u].push_back(m-1);
    }

    int dij(int s,int earse)//源点、应该删除的边earse和earse+1
    {
        memset(vis,0,sizeof(vis));
        for(int i=0;i<=n;i++) d[i]=INF;
        d[s]=0;
        priority_queue<Node>Q;
        Q.push((Node){0,s});
        while(!Q.empty()){
            Node x=Q.top();Q.pop();
            int u=x.u;
            if (vis[u]) continue;
            vis[u]=true;
            for(int i=0;i<G[u].size();i++)
            {
                if (earse>=0&& ( G[u][i]==earse || G[u][i]==earse+1)) continue;//开始把变量弄错了啊
                Edge &e=edge[G[u][i]];
                if (d[e.v]>d[u]+e.dis){
                    d[e.v]=d[u]+e.dis;
                    p[e.v]=G[u][i];
                    Q.push((Node){d[e.v],e.v});
                }
            }
        }
        if (earse>=0)
        {
            int tot=0;
            for(int i=1;i<=n;i++)
            {
                if (i==s) continue;
                if(d[i]<INF) tot+=d[i];else tot+=L;
            }
            return tot;
        }
        else
        {
            tot[s]=0;
            for(int i=1;i<=n;i++)
            {
                if (i==s) continue;
                if(d[i]<INF) tot[s]+=d[i];else tot[s]+=L;
            }
            for(int i=1;i<=n;i++)//树上有n-1条边
            {
                if(i==s) continue;
                Tree[s][p[i]]=true;
            }
            return -1;
        }
    }
}Dij;
void read()
{
    Dij.init(N);
    for(int i=0;i<M;i++)
    {
        int u,v,d;
        u=nextint();v=nextint();d=nextint();
        Dij.add(u,v,d);
        Dij.add(v,u,d);
    }
}
void init_c()//每个点dij，记录tree，和tot[i]
{
    memset(Tree,0,sizeof(Tree));
    C=0;
    for(int i=1;i<=N;i++) {Dij.dij(i,-2);C+=tot[i];}//-2：暂时没有要删除的边
}
void solve()
{
    NC=0;
    for(int i=0;i<2*M;i+=2)//枚举每条边,记得是无向图，一条边，存储了两个
    {
        int T=0;
        for(int j=1;j<=N;j++)
        {
            if (Tree[j][i] || Tree[j][i+1]) T+=Dij.dij(j,i);//以j为源点的单源最短和，i是暂时删除的边
            else T+=tot[j];
        }
        NC=max(NC,T);
    }
    printf("%d %d
",C,NC);
}
int main()
{
    while(cin>>N>>M>>L)
    {
        read();
        init_c();
        solve();
    }
}