poj 2337 之 有向图 欧拉路径输出

/*
poj 2337 之 有向图 欧拉路径输出 
 
每个单词看作一条有向边，顶点即为单词首尾字母，然后求欧拉路径即可。
 
1）为保证字典序，先对单词按字典序排序
2）深搜，输出单词序列
*/

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <cstddef>
#include <iterator>
#include <algorithm>
#include <string>
#include <locale>
#include <cmath>
#include <vector>
#include <cstring>
#include <map>
#include <utility>
#include <queue>
#include <stack>
#include <set>
#include <functional>
using namespace std;
typedef pair<int, int> PII;
typedef long long int64;
const int INF = 0x3f3f3f3f;
const int modPrime = 3046721;
const double eps = 1e-9;
const int MaxN = 1010;
const int MaxM = 30;
const char Opt[4] = { '+', '-', '*', '/' };

int n;

struct Edge
{
    int to;
    int nextEdge;
    int index;
    bool isVisited;
};
Edge edge[MaxN];
int head[MaxM];

int startPot = INF;
int in[MaxM];
int out[MaxM];
vector<string> wordVec;
vector<int> eulerPath;

int total = 0;


//Union-Find Sets
int ftr[MaxM];
int rnk[MaxM];
void ufsIni()
{
    for (int i = 0; i < MaxM; ++i)
    {
        ftr[i] = i;
        rnk[i] = 0;
    }
}
int ufsFind(int x)
{
    if (x == ftr[x]) return x;
    return ftr[x] = ufsFind(ftr[x]);
}
void ufsUnite(int x, int y)
{
    x = ufsFind(x);
    y = ufsFind(y);
    if (x == y) return;

    if (rnk[x] > rnk[y])
    {
        ftr[y] = x;
    }
    else
    {
        ftr[x] = y;
        if (rnk[x] == rnk[y])
        {
            ++rnk[y];
        }
    }
}

void addEdge(int u, int v, int index)
{
    edge[total].to = v;
    edge[total].index = index;
    edge[total].nextEdge = head[u];
    edge[total].isVisited = false;
    head[u] = total++;
}


bool isExistEulerpath(int n)
{
    
    ufsIni();
    for (int i = 0; i < n; ++i)
    {
        string word;
        cin >> word;
        wordVec.push_back(word);
    }
    sort(wordVec.begin(), wordVec.end(), greater<string>());
    set<int> potSet;
    for (int i = 0; i < n; ++i)
    {
        string word = wordVec[i];
        int fromCh = word[0] - 'a', toCh = word[word.size() - 1] - 'a';
        ++out[fromCh];
        ++in[toCh];
        addEdge(fromCh, toCh, i);
        potSet.insert(fromCh);
        potSet.insert(toCh);
        startPot = min(startPot, min(fromCh, toCh));
        ufsUnite(fromCh, toCh);
    }
    for (set<int>::iterator it = potSet.begin(); it != potSet.end(); ++it)
    {
        if (ufsFind(ftr[*it]) != ufsFind(ftr[*(potSet.begin())]))
        {
            return false;
        }
    }
    int tmpU = 0, tmpV = 0;
    for (set<int>::iterator it = potSet.begin(); it != potSet.end(); ++it)
    {
        if (out[*it] - in[*it] == 1)
        {
            ++tmpU;
            if (tmpU > 1)
            {
                return false;
            }
            startPot = *it;
        }
        else
        {
            if (out[*it] - in[*it] == -1)
            {
                ++tmpV;
                if (tmpV > 1)
                {
                    return false;
                }
            }
            else
            {
                if (out[*it] - in[*it] != 0)
                {
                    return false;
                }
            }
        }
    }
    if (!((0 == tmpU && 0 == tmpV) || (1 == tmpU && 1 == tmpV)))
    {
        return false;
    }
    return true;
}


void Solve(int pos)
{
    for (int i = head[pos]; i != -1; i = edge[i].nextEdge)
    {
        if (!edge[i].isVisited)
        {
            edge[i].isVisited = true;
            Solve(edge[i].to);
            eulerPath.push_back(edge[i].index);
        }
    }
}

int main()
{
#ifdef HOME
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    
    int T;
    cin >> T;
    while (T--)
    {
        startPot = INF;
        total = 0;
        fill(head, head + MaxM, -1);
        fill(in, in + MaxM, 0);
        fill(out, out + MaxM, 0);
        cin >> n;
        if (isExistEulerpath(n))
        {
            Solve(startPot);
            for (vector<int>::reverse_iterator rIt = eulerPath.rbegin(); rIt != eulerPath.rend(); ++rIt)
            {
                cout << wordVec[*rIt];
                if (rIt != eulerPath.rend() - 1)
                {
                    cout << ".";
                }
                else
                {
                    cout << endl;
                }
            }
        }
        else
        {
            cout << "***" << endl;
        }
        wordVec.clear();
        eulerPath.clear();
    }
    

#ifdef HOME
    cerr << "Time elapsed: " << clock() / CLOCKS_PER_SEC << " ms" << endl;
    _CrtDumpMemoryLeaks();
#endif
    return 0;
}