acwing1148——秘密的牛奶运输（求次小生成树）

https://www.acwing.com/problem/content/description/1150/

农夫约翰要把他的牛奶运输到各个销售点。

运输过程中，可以先把牛奶运输到一些销售点，再由这些销售点分别运输到其他销售点。

运输的总距离越小，运输的成本也就越低。

低成本的运输是农夫约翰所希望的。

不过，他并不想让他的竞争对手知道他具体的运输方案，所以他希望采用费用第二小的运输方案而不是最小的。

现在请你帮忙找到该运输方案。

注意：：

如果两个方案至少有一条边不同，则我们认为是不同方案；
费用第二小的方案在数值上一定要严格小于费用最小的方案；
答案保证一定有解；
输入格式
第一行是两个整数 N,M，表示销售点数和交通线路数；

接下来 M 行每行 3 个整数 x,y,z，表示销售点 x 和销售点 y 之间存在线路，长度为 z。

输出格式
输出费用第二小的运输方案的运输总距离。

数据范围
1≤N≤500,
1≤M≤104,
1≤z≤109,
数据中可能包含重边。

输入样例：
4 4
1 2 100
2 4 200
2 3 250
3 4 100
输出样例：
450

做法：先求出来最小生成树，然后依次枚举每一个不在树（最小生成树）中的边，然后将其加入最小生成树中，（则此时树中一定存在回路）所以去掉树（回路）中一条边权最大的边（不是新加入的边）。

思路：
1，求出最小生成树，标记每一个树边，同时建立最小生成树。
2，在深搜枚举每个点到达其他点的最小边和次小边。需要注意的是，次小边是需要严格大于最小边的，否则对于最小树边和当前枚举的非树边长度相同时，就不能替换了，但此时却可以替换长度次大的树边。所以次小边需要严格小于最小边。
3，枚举每一条非树边，找出替换后的树的最小权值。

ac代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;

typedef long long ll;
const int N = 505;
const int M = 10005;

struct Node{
    int a,b;
    ll w;
    bool operator < (const Node t)const {
        return w<t.w;
    }
}g[M];
struct edge{
    int v,ne;
    ll w;
}e[N*2];
int idx,h[N],f[N],vis[N];
ll one,two;
int n,m;
ll d1[N][N],d2[N][N];//最小生成树中任意两点距离的最大值，和次大值
bool st[M];//将所有在最小生成树中边标记为0
void add(int a,int b,ll c){
    e[idx].v = b;
    e[idx].w = c;
    e[idx].ne = h[a];
    h[a] = idx++;
}

int find(int x){
    if(x != f[x]) f[x] = find(f[x]);
    return f[x];
}

void merge(int x,int y){
    x = find(x);y = find(y);f[y] = x;
}

//先求出来最小生成树
void kru(){
    int i,j;
    int cnt = 0;
    for(i = 1;i<=n;i++) f[i] = i;
    sort(g+1,g+1+m);
    for(i = 1;i<=m;i++){
        int x = g[i].a,y = g[i].b;
        ll w = g[i].w;
        if(find(x) == find(y))  continue;
        cnt++;
        one = w + one;
        st[i] = true;
        //建立最小生成树
        add(x,y,w);
        add(y,x,w);
        merge(x,y);
        if(cnt == n-1)  break;
    }
    return;
}

void dfs(int x,int y){//y表示跟结点，x表示当前遍历的点
    int i;
    vis[x] = 1;
    for(i = h[x];i!=-1;i = e[i].ne){
        int v = e[i].v;
        ll w = e[i].w;
        if(vis[v])  continue;
        //如果更新最大值
        d1[y][v] = d1[v][y] = max(w,d1[y][x]);
        if(w == d1[y][x])   d2[y][v] = d2[v][y] = d2[y][x];
        else    d2[y][v] = d2[v][y] = max(d2[y][x],min(w,d1[y][x]));
        dfs(v,y);
    }
}

int main(){
    int i,j;
    cin>>n>>m;
    memset(h,-1,sizeof h);
    for(i = 1;i<=m;i++){
        scanf("%d %d %lld",&g[i].a,&g[i].b,&g[i].w);
    //    cin>>g[i].a>>g[i].b>>g[i].w;
    }
    //先求最小生成树
    kru();
    
    //dfs一遍求出最小树中任意两点的距离的最大值,以及次大值
    for(i = 1;i<=n;i++){
        memset(vis,0,sizeof vis);
        dfs(i,i);
    }
    //进行枚举每一个不在最小生成树里的边
    two = 1e12;
    for(i = 1;i<=m;i++){
        if(st[i])   continue;
        int x = g[i].a,y = g[i].b;
        ll w = g[i].w;
        ll res;
        if(w == d1[x][y]){
            res = one + w - d2[x][y];
        }else
            res = one + w - d1[x][y];
        two = min(two,res);
    }
    
    cout<<two<<endl;
    
    return 0;
}