POJ1679 The Unique MST 次小生成树

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>

using namespace std;

const int N = 128;

int g[N][N], vis[N], dis[N], pre[N], used[N][N], mmax[N][N];
int n, m;

struct Node{

    int u, len;
    Node(){};
    Node(int iu, int il):u(iu), len(il){};
    bool operator <(const Node& other)const{return len > other.len;}

};

int prim(int s)
{
    int ret = 0;
    memset(dis, INT_MAX, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    memset(used, 0, sizeof(used));
    priority_queue<Node> pq;
    dis[s] = 0;
    pq.push(Node(s, 0));
    while(!pq.empty())
    {
        Node top = pq.top();
        pq.pop();
        int v = top.u;
        if(!vis[v])
        {
            ret += top.len;
            vis[v] = 1;
            used[v][pre[v]] = used[pre[v]][v] = 1;
            for(int i = 1; i <= n; i++)
            {
                if(vis[i] && i != v)
                {
                    mmax[i][v] = mmax[v][i] = max(mmax[v][pre[i]], top.len);
                }
                if(!vis[i] && g[v][i] < dis[i])
                {
                    dis[i] = g[v][i];
                    pre[i] = v;
                    pq.push(Node(i, dis[i]));
                }
            }
        }
    }
    return ret;
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &m);
        memset(g, INT_MAX, sizeof(g));
        for(int i = 0; i < m; i++)
        {
            int x, y, w;
            scanf("%d%d%d", &x, &y, &w);
            g[x][y] = g[y][x] = w;
        }
        int prt = prim(1);
        int ans = INT_MAX;
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                if(!used[i][j] && g[i][j] != INT_MAX)
                {
                    ans = min(ans, g[i][j] - mmax[i][j]);
                }
            }
        }
        if(ans) printf("%d\n", prt);
        else printf("Not Unique!\n");
    }

    return 0;
}