poj 1679 The Unique MST

判断MST的唯一性

用kruskal算法实现，主要利用MST的环性质

1. 先保存所有的边在一个边集数组a中，然后单独去构建一个MST，在a中没能用上的非安全边全部放到另一个边集数组b中
2. 另外在构建MST过程要构建一个邻接表，用vextor来实现，也就是只统计MST之间的连通情况，非安全边的不统计在内

例如 1 2 3（安全边）

     1 3 4（非安全边）

那么邻接表中，与点1相通的点有点2但是没有点3，因为点3不在MST中，所以在MST中遍历的时候是没办法直接从点1到点3的

1. 接下来是就利用MST的环性质，一个MST中不管加入那条非安全边都将会形成一个环。所以我们枚举所有的非安全边，一条非安全边e，（u，v）权值为w，我们从一个顶点u出发去dfs，直到找到另一个顶点v为止。这样我们其实就是找到了这个环，然后原路返回，在返回的过程中查看这个环是否存在一条边的权值是否和e的权值w相同，若存在，我们其实是可以用e去替换这条边的，说明这个MST不是唯一
2. 所以我们枚举所有的非安全边，若所以的非安全边都不能在它们形成的环中找到可以替代的边，那个这个MST就是唯一的
3. 关键是dfs函数的写法，我们设置一个全局变量FIND，FIND=0表示没能找到替换的边，FIND=1表示找到了。dfs有返回值，返回0表示走到了某条路径走到了尽头但是都没有找到点v，要继续找，若是返回1，则说明已经找到了点v，同样是返回，但是这个返回的路径其实就是环的路径，所以没返回到一层就看看当前的边的权值和e的权值是否相同，并随时更改FIND。所以在dfs递归函数的出口处要做判断，最优先的判断是FIND，若FIND=1，那么说明不仅是找到了点v还找到了替换边，那么直接返回。次优先的判断是看dfs的返回值，若是0还要在当前层里面枚举，若不是只需要判断权值就可以返回了

l  说一下WA的地方。其一是，在DFS的时候要有vis数组标记被访问过的点，否则递归太深会爆空间，当时不断爆空间不知道干嘛了第一时间想到数组开大了，但是后来查看过别人的代码开的数组比我还大，后来才想到是递归的问题，很无语………然后就是构建邻接表，是只对MST里面的边构建邻接表，非安全边不要，就是这个原因也WA了很多次

1. 另外这个代码没有考虑MST不连通的情况，但是也AC了。另外也没有考虑什么边的权值为0或者负值但是测试过简单的数据是没错的

 

#include <stdio.h>

#include <string.h>

#include <algorithm>

#include <vector>

using namespace std;

#define N 110

#define M 10010

struct edge

{

    int u,v,w;

}a[M],b[M];



struct mat

{int k; int w;};

vector <struct mat> g[N];



int n,m,sumw;

int mm;  //收集所有非安全边在b边集数组，mm是非安全边的条数

int p[N];  //用于并查集

bool vis[N];

int FIND;  //判断是否找到了可以替换的边





int cmp(struct edge x , struct edge y)

{ return x.w<y.w; }

int find(int x)

{ return p[x]==x ? x : p[x]=find(p[x]); }



void input()

{

    int i,j,u,v,w;

    struct mat tmp;

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

    for(i=1; i<=n; i++)  g[i].clear();  //初始化

    for(i=1; i<=m; i++)

        scanf("%d%d%d",&a[i].u , &a[i].v , &a[i].w);

    return ;

}

void kruskal()

{

    int i,j,x,y;



    struct mat tmp;

    sort(a+1,a+m+1,cmp);



    for(i=1 ;i<=n; i++) p[i]=i;

    mm=0; sumw=0;

    

    for(i=1; i<=m; i++)

    {

        x=find(a[i].u);

        y=find(a[i].v);

        if(x!=y)

        {

            //printf("(%d,%d)",a[i].u,a[i].v);

            sumw+=a[i].w;

            p[x]=y;

            tmp.w=a[i].w;

            tmp.k=a[i].v;  g[a[i].u].push_back(tmp);

            tmp.k=a[i].u;  g[a[i].v].push_back(tmp);

            //因为是无向边

        }

        else

            b[++mm]=a[i];

    }

    //printf("\n");

    //printf("MST的总权值为%d\n",sumw);

    //printf("所有的非安全边 %d\n",mm);

    //for(i=1; i<=mm; i++) printf("%d %d %d\n",b[i].u,b[i].v,b[i].w);

    return ;

}

int dfs(int W , int u , int v)

{

    int i,kk,tmp;

    vis[u]=1;

    if(u==v) return 1;

    for(i=0; i<g[u].size(); i++)

    {

        if( !vis[g[u][i].k] && (tmp=dfs(W,g[u][i].k,v)) ) 

        {

            if(FIND)   return 1;

            if(W==g[u][i].w) 

            { 

                FIND=1;

            //printf("找到的边为(%d,%d)%d\n",u,kk,g[u][i].w); 

            }

            return 1;

        }

        

    }



    return 0;

}

void solve()

{

    int i,j,kk,u,v,tmp,W;

    for(i=1; i<=mm; i++)  //枚举所有的非安全边

    {

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

        u=b[i].u; v=b[i].v; W=b[i].w; 

        vis[u]=1; FIND=0;

        tmp=dfs(W,u,v);

        if(FIND)   break;

        //添加非安全边b[i]，从该边的u点开始dfs知道找到v点为止

        //找到v点后返回， 返回时即环的路径，然后这一查看这些环的线段中是否有权等于W

        //dfs有3个参数，非安全边的权值W，要找的目标顶点v，和当前顶点u

    }

    if(i>mm)  //找完了整个非安全边数组都不能证明MST不唯一，那说明MST是唯一的

        printf("%d\n",sumw);

    else 

        printf("Not Unique!\n");

}



void printff()

{

    int i,j,kk,w;

    printf("打印所有邻接表,注意这个邻接表是MST内的连通情况\n");

    for(i=1; i<=n; i++)

    {

        printf("%d: ",i);

        for(j=0; j<g[i].size(); j++)

            printf("%d(%d) ",g[i][j].k,g[i][j].w);

        printf("\n");

    }

}

int main()

{

    int CASE;

    scanf("%d",&CASE);

    while(CASE--)

    {

        input();

        kruskal();  //先单独构建出MST

        //printff();

        solve();

    }

    return 0;

}