POJ1094——拓撲排序和它的唯一性

比較模板的topological-sort題，關鍵在於每個元素都嚴格存在唯一的大小關系，而一般的拓撲排序只給出一個可能解，這就需要每趟排序的過程中監視它是不是總堅持一條唯一的路徑。

算法導論里面的拓撲排序運用的是DFS the DAG，記錄每個頂點的進入時間和離開時間，根據其先后插入單鏈表的做法。而我認為一種方法是更直觀的，就是維護一個入度為0的頂點集合（我用的隊列其實沒差），每次對其中一個加入結果序列——同時刪除它的所有出邊——更新其他點的入度的做法，在我的算法數據結構實現模板里有正確實現https://github.com/jily16/ACMCodes（打廣告

在判斷拓撲排序結果唯一性時這種方法也表現出了一個優勢，每次訪問0入度集合時查看大小，當元素多於1的時候可行的選擇就出現了分歧——即可判定此DAG的拓撲排序不唯一（當然本題的信息在不斷更新，所以不能立刻判死）。

AC代碼：

#include <vector>
#include <iostream>
#include <queue>
using namespace std;
//POJ1094
int const INF = 0x3f3f3f3f;
//返回空數組說明暫時不行
//cyclic說明矛盾
vector<int> ts(vector<vector<int> > const &g, bool &cyclic)
{
    int n = g.size();
    vector<int> d(n);
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            if (g[i][j] < INF)
            {
                ++d[j];
            }
        }
    }
    queue<int> q;
    for (int i = 0; i < n; ++i) if (d[i] == 0) q.push(i);
    int d0;
    int tot = 0;
    bool not_unique = false;
    vector<int> ans;
    while (!q.empty())
    {
        if (q.size() > 1)
        {
            not_unique = true;    //解不唯一
        }
        d0 = q.front();
        q.pop();
        ans.push_back(d0);
        ++tot;
        for (int i = 0; i < n; ++i)
        {
            if (d[i] != 0 && g[d0][i] < INF)
            {
                --d[i];
                if (d[i] == 0)
                {
                    q.push(i);
                }
            }
        }
    }
    if (tot != n) cyclic = true;
    if (not_unique) return vector<int>();
    else return ans;
}
int main()
{
    int n, m;
    while (cin >> n >> m && n && m)
    {
        bool done = false;
        vector<vector<int> > g;
        char alp1, alp2;
        char lessthan;
        int num1, num2;
        for (int i = 0; i < m; ++i)
        {
            cin >> alp1 >> lessthan >> alp2;
            if (done) continue;
            num1 = alp1 - 'A';
            num2 = alp2 - 'A';
            int bignum = max(num1, num2);
            //extend the graph
            if (g.size() < bignum + 1)
            {
                int ori_size = g.size();
                for (int i = 0; i < ori_size; ++i)
                {
                    for (int j = 0; j < bignum + 1 - ori_size; ++j)
                    {
                        g[i].push_back(INF);
                    }
                }
                for (int i = 0; i < bignum + 1 - ori_size; ++i)
                {
                    g.push_back(vector<int>(bignum + 1, INF));
                }
            }
            g[num1][num2] = 1;
            //judge from here
            bool cycle = false;
            if (g.size() < n)
            {
                ts(g, cycle);
                if (cycle)
                {
                    cout << "Inconsistency found after " << i + 1 << " relations.\n";
                    done = true;
                }
                else
                {
                    if (i == m - 1)
                    {
                        cout << "Sorted sequence cannot be determined.\n";
                        done = true;
                    }
                }
            }
            else
            {
                vector<int> ans = ts(g, cycle);
                if (cycle)
                {
                    cout << "Inconsistency found after " << i + 1 << " relations.\n";
                    done = true;
                }
                else
                {
                    if (ans.size() != 0)
                    {
                            cout << "Sorted sequence determined after " << i + 1 << " relations: ";
                            for (int i = 0; i < n; ++i) cout << (char)(ans[i] + 'A');
                            cout << ".\n";
                            done = true;
                    }
                    else
                    {
                        if (i < m - 1) continue;
                        else
                        {
                            cout << "Sorted sequence cannot be determined.\n";
                            done = true;
                        }
                    }
                }
            }
        }
    }
    return 0;
}