POJ2337 欧拉路径字典序输出

最新推荐文章于 2022-08-26 21:26:51 发布

原创最新推荐文章于 2022-08-26 21:26:51 发布 · 871 阅读

0 ·

CC 4.0 BY-SA版权

ACM_想法题同时被 2 个专栏收录

132 篇文章

订阅专栏

ACM_欧拉路

5 篇文章

订阅专栏

本文介绍了一种通过并查集和前向星解决给定单词能否仅使用一次并连接在一起的问题的方法。具体步骤包括将每个单词视为边，记录入度和出度以判断欧拉路径或回路，确保所有节点属于同一连通子集，并通过排序和深度优先搜索找到路径。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：
给一些单词，问是否可以每个单词只用一次，然后连接在一起（不一定要成环，能连接在一起就行）。

思路：
这个题目的入手点比较好想，其实就是问欧拉路径，先说下解题步骤，然后在细说
（1）把每个单词看成一条边，单词的首字母和尾字母是点
（2）然后记录入度，出度，根据入度出度判断是不是欧拉路径或者回路
（3）别往了判断所有点是不是属于同一个连通子集，这个可以用并查集啥的
（4）把所有的边都排序下，至于是什么顺序，根据自己的存图方式去排
（5）欧拉路径就从头开始（要是欧拉回路就找个最小的点）深搜找出路径

之前也没写过输出欧拉路径啥的啊！看有人说可以用栈递归存边，然后就在纸上画了几个8想想，觉得有道理，就自己写了一个欧拉路的(其实很简单)，至于排序的地方，我想的是直接在存边之前先把边排序下，因为欧拉路径输出的时候也是比较简单“画6的感觉”，要求字典序最小，因为我用的是前向星，其实这个东西建边是倒叙的，就是a-b a-c a-d 的顺序进去，那么访问的时候是a-d,a-c,a-b这样的，全都是抱着试一试，结果直接a了。虽然是简单题，但是挺高兴啊。

#include<stack>
#include<stdio.h>
#include<string.h>
#include<algorithm>

#define N_node 30
#define N_edge 1000 + 100

using namespace std;

typedef struct
{
    int to ,next;
}STAR;

typedef struct
{
    char str[30];
}EDGE;

STAR E[N_edge];
EDGE edge[N_edge];
int list[N_node] ,tot;
int mer[N_node];
int mark[N_edge];
int deg[N_node];
stack<int>mysk;

bool camp(EDGE a ,EDGE b)
{
    return strcmp(a.str ,b.str) > 0;
}

void add(int a ,int b)
{
    E[++tot].to = b;
    E[tot].next = list[a];
    list[a] = tot;
}

int finds(int x)
{
    return x == mer[x] ? x : mer[x] = finds(mer[x]);
}

void DFS(int s)
{
    for(int k = list[s] ;k ;k = E[k].next)
    {
        if(mark[k]) continue;
        mark[k] = 1;
        DFS(E[k].to);
        mysk.push(k);
    }
}

int main ()
{
    int t ,n ,i ,j;
    int mkc[30];
    scanf("%d" ,&t);
    while(t--)
    {
        scanf("%d" ,&n);
        memset(deg ,0 ,sizeof(deg));
        memset(mkc ,0 ,sizeof(mkc));
        for(i = 1 ;i <= 26 ;i ++)
        mer[i] = i;
        for(i = 1 ;i <= n ;i ++)
        {
            scanf("%s" ,edge[i].str);
            int a = edge[i].str[0] - 'a' + 1;
            int b = edge[i].str[strlen(edge[i].str)-1] - 'a' + 1;
            mer[finds(a)] = finds(b);
            mkc[a] = mkc[b] = 1;
            deg[a] ++;
            deg[b] --;
        }

        int s = 0 ,z = 0 ,f = 0 ,min;
        for(i = 1 ;i <= 26 ;i ++)
        {
            if(mkc[i])
            {
                if(mer[i] == i) s ++;
                if(!deg[i]) continue;
                if(deg[i] == 1)
                z ++ ,min = i;
                else if(deg[i] == -1) f ++;
                else s ++;
            }
        }


        if(s != 1 || f + z != 0 && f + z != 2)
        {
            printf("***\n");
            continue;
        }

        sort(edge + 1 ,edge + n + 1 ,camp);
        memset(list ,0 ,sizeof(list));
        tot = 1;
        for(i = 1 ;i <= n ;i ++)
        {
            int a = edge[i].str[0] - 'a' + 1;
            int b = edge[i].str[strlen(edge[i].str)-1] - 'a' + 1;
            add(a ,b);
        }

        if(z + f == 0) min = edge[n].str[0] - 'a' + 1;

        while(!mysk.empty())
        mysk.pop();
        memset(mark ,0 ,sizeof(mark));
        DFS(min);

        while(!mysk.empty())
        {
            int tou = mysk.top();
            mysk.pop();
            if(mysk.empty())
            printf("%s\n" ,edge[tou-1].str);
            else printf("%s." ,edge[tou-1].str);
        }
    }
    return 0;
}