51nod11443-路径和树（图论，最短路，最小生成树）

1443 路径和树

题目来源： CodeForces

基准时间限制：1.5 秒 空间限制：131072 KB 分值: 160 难度：6级算法题

收藏

关注

给定一幅无向带权连通图G = (V, E) (这里V是点集，E是边集)。从点u开始的最短路径树是这样一幅图G1 = (V, E1)，其中E1是E的子集，并且在G1中，u到所有其它点的最短路径与他在G中是一样的。

现在给定一幅无向带权连通图G和一个点u。你的任务是找出从u开始的最短路径树，并且这个树中所有边的权值之和要最小。

Input

单组测试数据。
第一行有两个整数n和m(1 ≤ n ≤ 3*10^5, 0 ≤ m ≤ 3*10^5)，表示点和边的数目。
接下来m行，每行包含3个整数 ui, vi, wi ，表示ui和vi之间有一条权值为wi的无向边(1 ≤ ui,vi ≤ n, 1 ≤ wi ≤ 10^9)。
输入保证图是连通的。
最后一行给出一个整数u (1 ≤ u ≤ n)，表示起点。

Output

输出这棵树的最小的权值之和。

Input示例

3 3
1 2 1
2 3 1
1 3 2
3

Output示例

2

 /*
 利用spfa求出最短路之后， 然后根据dist数组中的值去寻找某个点最短路径的上一条边，然后对这些边求最小生成树
 这里会出现一个问题，是否在求出每个点的最短路的上一条边之后，这个子图就变成了一个最小生成树了呢？
 有可能，但也有可能出现这种情况：
 某个点到起点的最短路可以通过多种路径实现，这种情况下，但是如果不用最小生成树的话，无法确定最小生成树中是哪一条路径
 因此需要求最短路
 ex:
 6 8
 1 2 30
 1 3 20
 2 3 50
 4 2 100
 2 5 40
 3 5 10
 3 6 50
 5 6 60
 4
 答案为：
 230
 */
 #include<bits/stdc++.h>
 #define LL long long
 #define MAXN 300005
 using namespace std;
 int n, m;
 LL dist[MAXN];
 int inQueue[MAXN], root[MAXN];
 int in[MAXN];
 vector <pair< int, LL> > G[MAXN];
 queue <int> Q;
 struct Edge
 {
     int u, v;
     LL cost;
     Edge(int U = -, int V = -, LL C = -)
     {
         u = U;
         v = V;
         cost = C;
     }
     bool operator < (const Edge& x) const
     {
         return cost < x.cost;
     }
 };
 vector <Edge> edge;
 int findRoot(int x)
 {
     if(x == root[x]) return x;
     else
         return root[x] = findRoot(root[x]);
 }
 void unite(int x, int y)
 {
     x = findRoot(x);
     y = findRoot(y);
     if(x == y) return;
     root[x] = root[y];
 }
 void spfa(int star)
 {
     memset(dist, -, sizeof(dist));
     memset(inQueue, , sizeof(inQueue));
     while(!Q.empty()) Q.pop();
     dist[star] = ;
     inQueue[star] = ;
     Q.push(star);
     while(!Q.empty())
     {
         int now = Q.front();
         Q.pop();
         inQueue[now] = ;
         int siz = G[now].size();
         for(int i = ; i < siz; i++)
         {
             int v = G[now][i].first;
             LL cost = G[now][i].second;
             if(dist[v] == - || dist[v] > dist[now] + cost)
             {
                 dist[v] = dist[now] + cost;
                 if(!inQueue[v])
                 {
                     inQueue[v] = ;
                     Q.push(v);
                 }
             }
         }
     }
 }
 LL Kruskal()
 {
     LL res = ;
     memset(in, , sizeof(in));
     sort(edge.begin(), edge.end());
     int siz = edge.size();
     for(int i = ; i < siz; i++)
     {
         int u = edge[i].u, v = edge[i].v;
         LL cost = edge[i].cost;
         if(in[v] || findRoot(u) == findRoot(v)) continue;
         in[v] = ;
         unite(u, v);
         res += cost;
     }
     return res;
 }
 int main()
 {
     freopen("data.in","r",stdin);
     while(scanf("%d%d", &n, &m) != EOF)
     {
         for(int i = ; i <= n; i++)
         {
             G[i].clear();
             root[i] = i;
         }
         for(int i = ; i < m; i++)
         {
             int u, v, cost;
             scanf("%d%d%d", &u, &v, &cost);
             G[u].push_back(make_pair(v, (LL)cost));
             G[v].push_back(make_pair(u, (LL)cost));
         }
         int star;
         scanf("%d", &star);
         spfa(star);
         edge.clear();
         LL sum=;
 //        cout<<star<<endl;
 //        for(int i=1;i<=n;i++){
 //            cout<<dist[i]<<"\t";
 //        }
 //        cout<<endl;
         for(int i = ; i <= n; i++)
         {
             //cout<<22222<<endl;
             ///if(i!=star){
                 int siz = G[i].size();
                 //cout<<siz<<endl<<endl;
                 for(int j = ; j < siz; j++)
                 {

                     int v = G[i][j].first;
                     LL cost = G[i][j].second;
                     if(dist[v] == dist[i] + cost)
                     {
                         edge.push_back(Edge(i, v, cost));
                         //sum+=cost;
                         //cout<<111111<<endl;
                         //cout<<i<<"\t"<<v<<"\t"<<sum<<endl;
                         //break;
                     }
                 }
             ///}
         }
        printf("%lld\n", Kruskal());
         //printf("%lld\n",sum);
     }
     return ;
 }