并查集

概念：

　　并：合并两个元素所在的组

　　查：查询两个元素是否属于同一个组

核心代码：　

int par[MAX_N];        //父节点
int rank[MAX_N];    //树的高度

//初始化
void init(int n)
{
    for(int i = 0; i < n; i++)
    {
        par[i] = i;    //初始时一个树一个节点
        rank[i] = 0;
    }
}

//查询树的根
int find(int x)
{
    if(par[x] == x)
    {
        return x;
    }
    else
    {
        return par[x] = find(par[x]);    //递归 依次查询
    }
}

//合并x和y所属的集合
void unite(int x, int y)
{
    x = find(x);    //x的根
    y = find(y);    //y的根

    if(x == y)    //同一个根节点
    {
        return;
    }
    if(rank[x] < rank[y])        //从高度小的往高度大的合并
    {
        par[x] = y;
    }
    else
    {
        par[y] = x;
        if(rank[x] == rank[y])    //相等 rank++
            rank[x]++;
    }
}

//判断x和y是否同属于一个集合
int same(int x, int y)
{
    return find(x) == find(y);
}

 

例题：

　　题目链接：http://codeforces.com/gym/100989/problem/B

　　题意：

　　　　给定dp[]数组，它描述的是两个字符串a[]与b[]的关系情况。要求根据dp[]数组推出a[]与b[]。

　　　　dp[]数组所描述关系：

function LCS (A[1..R], B[1..C])
    DP = array(0..R, 0..C)
    for i := 0..R
       DP[i,0] = 0
    for j := 0..C
       DP[0,j] = 0
    for i := 1..R
        for j := 1..C
            if A[i] = B[j]
                DP[i,j] := DP[i-1,j-1] + 1
            else
                DP[i,j] := max(DP[i,j-1], DP[i-1,j])
    return DP[R,C]

　　思路：

　　　　并查集在这里的运用是，将a[]数组中与b[]数组中相等的元素合并在一棵树，再根据合并情况给两字符串赋值。

　　　　val_trees[]将a[]与b[]中相同的合并在一棵树，然后依次小到大对不在一棵树上的a[]赋值，max_ch记录当前最

　　　　大字符，然后再依次判断b[]中元素是否与a[]中的元素在一棵树上。是的话，把相等的那个字符赋值给它，不

　　　　然就赋值为max_ch+1的那个字符（与a[]不存在相等关系的元素们可以是不同字符也可以是相同字符）。而且

　　　　a[]中是允许有相同的元素的，比如a[1]=b[2]=a[3]之类的。

　　代码：

#include <iostream>

using namespace std;

const int MAXN = 32;

int dp[MAXN][MAXN], val_trees[MAXN * 2];
char a[MAXN], b[MAXN];

int root(int i)
{
    return val_trees[i] == i ? i : val_trees[i] = root(val_trees[i]);
}

int main(const int argc, const char *argv[])
{
    int la, lb;
    char max_ch = 'a';

    cin >> la >> lb;

    for (int i = 0; i < la + lb; i++)
    {
        val_trees[i] = i;
    }

    for (int i = 0; i <= la; i++)
        for (int j = 0; j <= lb; cin >> dp[i][j++]);

    for (int i = 0; i < la; i++)
    {
        for (int j = 0; j < lb; j++)
        {
            int dp_temp = dp[i + 1][j + 1];
            if (dp_temp != dp[i][j + 1] && dp_temp != dp[i + 1][j])
            {
                val_trees[root(la + j)] = root(i);
            }
        }
    }

    for (int i = 0; i < la; i++)
    {
        if ((a[i] = root(i) + 'a') > max_ch)
        {
            max_ch = a[i];
        }
    }
    max_ch++;

    for (int i = 0; i < lb; i++)
    {
        int ia = root(la + i);
        b[i] = ia < la ? a[ia] : max_ch;
    }

    cout << a << endl << b << endl;

    return 0;
}