POJ1789 Truck History 最小生成树 ＋ 路径压缩

　　首先要强调一点 这不是一道ACM题，这是他妹的一道英语阅读理解。

　　题意：输入N  代表有Ｎ种汽车。每两种汽车之间有一条边，边的权值的定义为　两串字符串之间有几个不同的字母。。。稠密图。。。。普利姆　或者　克鲁斯卡尔　＋　路径压缩

　　我认为后者能通吃所以很无耻的不会第一种。。。。。

　　

#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <queue>

using namespace std;

char s[2010][10];

struct E
{
    int u,v,w;
}edge[4000100];

bool cmp(E a,E b)
{
    return a.w < b.w;
}

int mark[2010];

int Min;

int find(int x)
{
   int k,j,r;
   r = x;
   while(r != mark[r])
        r = mark[r];
    k = x;
    while(k != r)
    {
        j = mark[k];
        mark[k] = r;
        k = j;
    }
    return r;
}

void merge(int top)
{
    int i;
    int fu,fv;
    for(i = 0;i < top; i++)
    {

        fu = find(edge[i].u);
        fv = find(edge[i].v);

        if(fu != fv)
        {
            Min += edge[i].w;
            mark[fu] = fv;
        }
    }
    printf("The highest possible quality is 1/%d.
",Min);
}

int main()
{
    int n,i,j,k,top,sum;

    while(scanf("%d",&n) && n)
    {
        for(i = 0;i < n; ++i)
            scanf("%s",s[i]);

        for(i = 0;i < n; ++i)
            mark[i] = i;

        for(i = 0,top = 0;i < n; ++i)
            for(j = i+1;j < n; ++j)
            {
                for(sum = 0,k = 0;k < 7; k++)
                    if(s[i][k] != s[j][k])
                        ++sum;
                edge[top].u = i;
                edge[top].v = j;
                edge[top].w = sum;
                ++top;
            }
        sort(edge,edge+top,cmp);

        Min = 0;
        merge(top);
    }
    return 0;
}

　　再谈路径压缩

　　递归和非递归两种方式

　　递归：　　

int find(int x)       //查找x元素所在的集合,回溯时压缩路径
{
    if (x != parent[x])
    {
        parent[x] = find(parent[x]);     //回溯时的压缩路径
    }        　　　　　　　　　　　　 //从x结点搜索到祖先结点所经过的结点都指向该祖先结点
    return parent[x];
}

　　显然当我们需要用路径压缩的时候　　递归方法也很容易溢出。。。。。。

　　非递归：

　　

int find(int x)
{
    int k, j, r;
    r = x;
    while(r != parent[r])     //查找跟节点
        r = parent[r];      //找到跟节点，用r记录下
    k = x;        
    while(k != r)             //非递归路径压缩操作
    {
        j = parent[k];         //用j暂存parent[k]的父节点
        parent[k] = r;        //parent[x]指向跟节点
        k = j;                    //k移到父节点
    }
    return r;         //返回根节点的值            
}