poj 1679 The Unique MST

次小生成树学习：

顾名思义，次小生成树，就是将图的所有生成树排序后，权值第二小的生成树。

次小生成树的朴素求法是很好想的，即首先求出最小生成树，之后枚举最小生成树中的所有边，将当前枚举的边“禁止使用”，在这基础之上再求最小生成树，将所有边枚举之后的结果取最小值，那就是次小生成树。这个算法简单暴力，但是可想而知的复杂度是比较大的，在图是稠密图的时候，复杂度接近O(n^3)。在规模较大的时候不建议使用。

另一个推荐的求法：在添加最小生成树的边之外的边时，会形成环，这个时候，把在这个环中，且在最小生成树中的边给去掉，这时候就形成了另一个生成树。如何实现这个算法的呢？实际上，对于两个点u，v，我们遍历最小生成树，找出u到v的边中的最大权值的边，用一个数组maxn[u][v]保存起来。当我们往最小生成树中加边时，就直接用w - max[u][v] + 当前添加边的权值，这个式子计算出此时生成树的权值之和。那么maxn[u][v]这个数组是如何求得呢？嗯，bfs，即广度优先搜索，对每一个点都遍历一次生成树，每次更新的值都是当前点到其他点的权值。之后就枚举不在生成树的边进行计算，把每次的结果都保存下来，取最小的，就是次小生成树啦。（或许第k小生成树可以这么求？）这个算法的复杂度为O(n^2)。

例题：

https://vjudge.net/problem/POJ-1679

题意：

这题问的是最小生成树是否唯一。

思路：

那么很显然的，如果说最小生成树不唯一的话，那么最小生成树与次小生成树的权值肯定相等，因为对于在最小生成树中的边来说，至少存在一条不在其中的边，与在其中的边的权值相等，这样才满足不唯一，所以只需要求出次小生成树，判断其与最小生成树是否相等就可以了。

PS：通过这题还学会了用邻接链表表示图，用vector很方便的，就是把以每个点为起点的边搞到一起就ok。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;

struct node
{
    int x,y,w;
} e[6000];

struct ord
{
    int p,dis;
};

vector<node> v[105];

int par[105];
int maxn[105][105];

bool used[6000],vis[6000];

void init(int n)
{
    for (int i = 1;i <= n;i++)
        par[i] = i;
}

int fin(int x)
{
    if (x == par[x]) return x;
    else return par[x] = fin(par[x]);
}

void unit(int x,int y)
{
    x = fin(x);
    y = fin(y);

    if (x != y) par[x] = y;
}

bool cmp(node aa,node bb)
{
    return aa.w < bb.w;
}

void adde(int x,int y,int dis)
{
    node t;
    t.x = x;
    t.y = y;
    t.w = dis;
    v[x].push_back(t);
}

void bfs(int k)
{
    memset(used,0,sizeof(used));

    ord now,nex;

    now.p = k;now.dis = 0;
    used[k] = true;

    queue<ord> qq;

    while (!qq.empty()) qq.pop();

    qq.push(now);

    while (!qq.empty())
    {
        //printf("dsfsd
");
        ord t = qq.front();qq.pop();

        int x = t.p,tmaxn = t.dis;

        for (int i = 0;i < v[x].size();i++)
        {
            node tt = v[x][i];

            nex.dis = tt.w;nex.p = tt.y;

            if (!used[nex.p])
            {
                if (tmaxn > nex.dis) nex.dis = tmaxn;
                used[nex.p] = true;
                maxn[k][nex.p] = nex.dis;
                qq.push(nex);
            }
        }
    }
}

int main()
{
    int t;

    scanf("%d",&t);

    while (t--)
    {
        int n,m;

        scanf("%d%d",&n,&m);

        init(n);

        memset(v,0,sizeof(v));
        memset(vis,0,sizeof(vis));
        memset(used,0,sizeof(used));

        for (int i = 0;i < m;i++)
        {
            scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].w);
        }

        sort(e,e+m,cmp);

        int ans = 0;

        for (int i = 0;i < m;i++)
        {
            int x = e[i].x,y = e[i].y;

            if (fin(x) == fin(y)) continue;

            unit(x,y);

            vis[i] = true;

            ans += e[i].w;

            adde(x,y,e[i].w);
            adde(y,x,e[i].w);
        }

        for (int i = 1;i <= n;i++)
        {
            bfs(i);
        }

        int minn = 100000000;

        for (int i = 0;i < m;i++)
        {
            if (!vis[i])
            {
                int tans = ans;
                int x = e[i].x,y = e[i].y;

                tans -= maxn[x][y];

                tans += e[i].w;

                if (tans < minn) minn = tans;
            }


        }

        if (minn == ans) printf("Not Unique!
");
        else printf("%d
",ans);
    }

    return 0;
}