Catenyms

最新推荐文章于 2021-10-17 00:21:37 发布

_hehe_

最新推荐文章于 2021-10-17 00:21:37 发布

阅读量1.2k

点赞数 1

分类专栏：图论——欧拉路径(回路) 文章标签： acm poj 欧拉回路

本文链接：https://blog.csdn.net/wty__/article/details/21535739

版权

图论——欧拉路径(回路) 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

题目链接

前言：
是这个题的复杂版，增加了输出路径的一项（以边为基础输出）
重点：
输出字典序最小的解，可以先对输入进行排序可以保证搜索的时候先进入小的点

const int MAXN = 1100;

const int MAXV = 30;
const int MAXE = 1100;

struct Edge
{
    int from, to, id;
};

struct Direct_Euler
{
    int n, m;
    int out[MAXV];
    bool vis[MAXE];
    vector<int> G[MAXV];
    vector<Edge> edges;
    stack<int> sk;
    vector<int> ans;

    void init(int n)
    {
        this->n = n;
        edges.clear();
        REP(i, n)
        {
            out[i] = 0;
            G[i].clear();
        }
    }

    void addEdge(int a, int b, int id)
    {
        edges.push_back((Edge) { a, b, id });
        m = edges.size();
        G[a].push_back(m - 1);
        out[a]++; out[b]--;
    }

    void dfs(int u, int ind)
    {
        REP(i, G[u].size())
        {
            int x = G[u][i];
            Edge& e = edges[x];
            if (!vis[x])
            {
                vis[x] = true;
                dfs(e.to, x);
            }
        }
        if (ind >= 0)
            sk.push(ind);
    }

    //返回1:欧拉回路  返回2：欧拉路经
    int solve(int s)
    {
        ans.clear();
        int cnt = 0;
        REP(i, n)
        {
            if (out[i] == 1)
            {
                if (++cnt > 1)
                    return 0;
                s = i;
            }
            else if (out[i] > 1 || out[i] < -1)
                return 0;
        }
        while (!sk.empty()) sk.pop();
        REP(i, m) vis[i] = false;
        dfs(s, -1);
        REP(i, m)
            if (!vis[i])
                return 0;
        while (!sk.empty())
        {
            ans.push_back(sk.top());
            sk.pop();
        }
        return cnt != 0 ? 1 : 2;
    }
} graph;

string ipt[MAXN];

int main()
{
    int T, n;
    RI(T);
    FE(kase, 1, T)
    {
        graph.init(30);
        RI(n);
        REP(i, n)
            cin >> ipt[i];
        sort(ipt, ipt + n);
        REP(i, n)
            graph.addEdge(ipt[i][0] - 'a', ipt[i][(int)ipt[i].length() - 1] - 'a', i);
        if (graph.solve(ipt[0][0] - 'a'))
        {
            vector<int>& ans = graph.ans;
            REP(i, ans.size())
                cout << ipt[graph.edges[ans[i]].id] << (i == (int)ans.size() - 1 ? '\n' : '.');
        }
        else
            puts("***");
    }
    return 0;
}