堆栈应用（五）：离线等价类

1、问题描述

例子：假定 n= 1 4， R= { ( 1 , 11 )， ( 7 , 11 )， ( 2 , 1 2 )， ( 1 2 , 8 )， ( 11 , 1 2 )， ( 3 , 1 3 )， ( 4 , 1 3 )， ( 1 3 , 1 4 )，( 1 4 , 9 )， ( 5 , 1 4 )， ( 6 , 1 0 ) }。我们忽略了所有形如 ( a , a )的关系，因为按照反身属性，这些关系是隐含的。同样也忽略了所有的对称关系。比如 ( 1 , 11) € R，按对称属性应有 ( 11,1) €R。其他被忽略的关系是由传递属性可以得到的属性。例如根据 ( 7 , 11) 和( 11 , 1 2 )，应有(7,12) €R。如果(a , b) €R，则元素a 和b 是等价的。等价类（ equivalence class）是指相互等价的元素的最大集合。 “最大”意味着不存在类以外的元素，与类内部的元素等价。
考察例 中的等价关系。由于元素 1 与11， 11 与1 2是等价的，因此，元素 1 , 11 , 1 2是等价的，它们应属于同一个等价类。不过，这三个元素还不能构成一个等价类，因为还有其他的元素与它们等价（如 7）。所以 { 1 , 11 , 1 2 } 不是等价元素的最大集合。集合 { 1 , 2 , 7 , 8 , 11 , 1 2 } 才是一个等价类。关系 R还定义了另外两个等价类： { 3 , 4 , 5 , 9 , 1 3 , 1 4 } 和{ 6 , 1 0 }。

定义：假定有一个具有 n 个元素的集合U= { 1， 2， . . .， n}，另有一个具有 r 个关系的集合 R= { (i1, j1) ,(i2 , j2 ), ..., (ir , jr ) } 。关系 R是一个等价关系（ equivalence relation），当且仅当如下条件为真时成立：
• 对于所有的 a，有(a, a) €R 时（即关系是反身的）。
• 当且仅当 (b, a) € R时(a, b) €R（即关系是对称的）。
• 若(a, b) €R且(b, c) €R，则有(a, c) € R（即关系是传递的）。
在给出等价关系 R时，我们通常会忽略其中的某些关系，这些关系可以利用等价关系的反身、对称和传递属性来获得。
在离线等价类（ o ffline equiralence class）问题中，已知 n 和R，确定所有的等价类。注意每个元素只能属于某一个等价类。

2、解决方法：

可以为n个元素分别建立一个链表，链表其他元素为与当前元素等价的元素。从头扫描元素，对于未输出过的元素，将其先压入一个堆栈，然后扫描对应这个元素的链表，并对这个链表中的元素重复着一过程。直到堆栈为空。

3、代码实现：

堆栈实现见：堆栈的链表方式实现

#ifndef OFFLINEEQUIRALENCECLASS_H
#define OFFLINEEQUIRALENCECLASS_H

#include <iostream>
#include "Chain.h"
#include "LinkedStack.h"
using std::cout;
using std::cin;
using std::endl;

class offlineEC
{
public:
    offlineEC(int n):num(n)
    {
        C = new Chain<int>[n + 1];
    }

    ~offlineEC(){
        if (C!=NULL)
        {
            delete[] C;
        }
    }

    friend void Offline_Equiralence();
    
private:
    Chain<int>* C;//存储等价关系的链表
    int num;//元素个数
    void findEquiralence();//查找等价类
};


void offlineEC::findEquiralence()
{
    bool *outflag = new bool[num + 1];//标识当前元素是否已经输出到一个等价类了
    LinkedStack<int> S;
    ChainIterator<int> CI;//迭代器，遍历链表中的元素

    for (int i = 1; i < num + 1; ++i)
    {
        outflag[i] = false;
    }

    for (int i = 1; i < num + 1; ++i)
    {
        if (!outflag[i])//若没有输出过，则是一个新的等价类的开始
        {
            cout << "新的等价类：" << i;
            outflag[i] = true;
            S.Add(i);
            while (!S.IsEmpty())//若堆栈不为空，说明还有属于这个等价类的元素
            {
                int j;
                S.Delete(j);
                int* q = CI.Initialize(C[j]);
                while (q)//遍历对应的链表，因为一个链表内的元素属于同一个等价类
                {
                    if (!outflag[*q])
                    {
                        cout << " " << *q;
                        outflag[*q] = true;
                        S.Add(*q);
                    }
                    q = CI.Next();
                }
            }
            cout << endl;
        }
    }
}

void Offline_Equiralence()
{
    int n, r;
    cout << "输入元素的个数：" << endl;
    cin >> n;
    if (n<2)
    {
        std::cerr << "error:元素个数太少" << endl;
        exit(1);
    }

    cout << "输入关系对的个数：" << endl;
    cin >> r;
    if (r<1)
    {
        std::cerr << "error:关系对至少应有1个" << endl;
        exit(1);
    }

    offlineEC EC(n);
    cout << "输入关系对：" << endl;
    int a, b;
    for (int i = 0; i < r;++i)
    {
        cout << "输入一对关系对：";
        cin >> a;
        cin >> b;
        while (a>n||b>n||a<=0||b<=0)
        {
            std::cerr << "error:元素值输入有误,重新输入" << endl;
            cout << "输入一对关系对：";
            cin >> a;
            cin >> b;
        }

        EC.C[a].Insert(0, b);
        EC.C[b].Insert(0, a);
    }

    EC.findEquiralence();
}
#endif

运行：

#include "OfflineEquiralenceClass.h"

int main()
{
    Offline_Equiralence();

    system("pause");
    return 0;
}

运行结果：