Play on Words UVA - 10129 图的欧拉回路

 

题目链接

题意：

有一些秘密的门包含着非常有趣的单词迷题， 考古学家队伍必须解决它们才能够打开大门。 因为没有其他方法能偶打开这些门， 所以解决那些迷题对我们非常重要。
在每个门上有很多个有磁力的盘子，盘子上面写着单词。 必须重新移动放置这些盘子，让它们形成一个队列：队列中，除了第一个单词，每个单词的开头和上一个单词的结尾字母一样。例如， motorola的后面可以接上acm。
你的任务是写一个程序， 读入一系列单词，然后计算确定它们是否有可能被排成这样的队列。

分析：

本题考察对欧拉回路概念的理解，和对dfs的掌握。

有向图形成欧拉回路有两个条件：

• 首先图在无向情况下必须是连通图，可以用dfs加标记来判断。
• 最多只能有两个点的出入度不同，而且一个恰好出度比入度大1(起点)，另一个入度比出度大1(终点)。

根据上面两点判断即可。

注意：当该图有起点时(当首尾相连时无)必须从起点开始dfs！！若首尾相连，任何一点都为起点。

#include <bits/stdc++.h>
using namespace std;
int matrix[30][30], vis[30][30];
vector<pair<int,int>> vector1;
int id_get(char ch) { return ch-'a'+1; }
struct Node {
    //入度，出度数目，是否为起点（大于0为起点，小于零为终点）
    int in, out, is_head;
    Node():
            in(0), out(0), is_head(0){}
};

void dfs(int u) {
    for(int i = 1; i <= 26; i++) {
        if(matrix[u][i] && !vis[u][i]) {
            vis[u][i] = vis[i][u] = 1;
            dfs(i);
        }
    }
}

int main() {
    freopen("i.txt","r",stdin);
    freopen("o.txt","w",stdout);
    int n,m;
    cin >> n;
    string str;
    while(n--) {
        memset(matrix,0,sizeof(matrix));
        memset(vis,0,sizeof(vis));
        vector1.clear();
        bool flag = true;
        cin >> m; int cnt = 0;
        int t = m;
        Node nodes[30];
        int arr[30];
        while(m--) {
            cin >> str;
            matrix[id_get(str[0])][id_get(str[str.length()-1])] = 1;
            vector1.emplace_back(id_get(str[0]),id_get(str[str.length()-1]));
            Node &t1 = nodes[id_get(str[0])];
            t1.out++, t1.is_head++;
            nodes[id_get(str[0])] = t1;
            Node &t2 = nodes[id_get(str[str.length()-1])];
            t2.in++, t2.is_head--;
            nodes[id_get(str[str.length()-1])] = t2;
        }
        //判断出入度不同的点，不是起点就是终点
        //还有一种为首位相连的图，下面有判断
        for(int i = 1; i <= 26; i++) {
            if(nodes[i].in!=nodes[i].out)
                arr[cnt++] = i;
        }
        if(cnt==2) {
            int i1 = arr[0], i2 = arr[1];
            if(nodes[i1].is_head>0 && nodes[i2].is_head<0) {
                //找起点，从起点开始dfs标记
                dfs(i1);
                //看起点和终点的出入度是否符合要求
                if(nodes[i1].out-nodes[i1].in!=1 || nodes[i2].in-nodes[i2].out!=1)
                    flag = false;
            }
            else if(nodes[i1].is_head<0 && nodes[i2].is_head>0) {
                dfs(i2);
                if(nodes[i1].in-nodes[i1].out!=1 || nodes[i2].out-nodes[i2].in!=1)
                    flag = false;
            }
            else flag = false;
        }
        //图的首位相连，此时任意一点都为起点。
        if(cnt==0) dfs(vector1[0].first);
        for (auto &i : vector1) {
            if(!vis[i.first][i.second])
                flag = false;
        }
        if(t==1) flag = true;//排除单个点情况
        if(flag) cout << "Ordering is possible." << endl;
        else cout << "The door cannot be opened." << endl;
    }
}

#include <iostream>
#include <cstdio>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <cstring>
#include <cmath>
#include <stack>
#include <queue>
using namespace std;
const int maxn = 30;
int graph[maxn][maxn];
int in_degree[maxn];
int out_degree[maxn];
int vis[maxn][maxn];

void dfs(int u) {
    for(int i = 0; i < maxn; i++) {
        if(graph[u][i] && !vis[u][i]) {
            vis[u][i] = 1;
            dfs(i);
        }
    }
}

bool judge_euler() {
    bool flag = true;
    vector<int> vec;
    int num = 0;
    for(int i = 0; i < maxn; i++) {
        if(in_degree[i] != out_degree[i]) {
            vec.push_back(i);
            num++;
        }
    }
    if(num == 2) {
        int n1 = vec[0], n2 = vec[1];
        if(in_degree[n1] > out_degree[n1]) {
            dfs(n2);
            if(in_degree[n1]-1!=out_degree[n1] || in_degree[n2]+1!=out_degree[n2])
                flag = false;
        }
        else {
            dfs(n1);
            if(in_degree[n2]-1!=out_degree[n2] || in_degree[n1]+1!=out_degree[n1])
                flag = false;
        }
    }
    else if(!num) {
        bool ft = true;
        for(int i = 0; i < maxn; i++) {
            for(int j = 0; j < maxn; j++) {
                if(graph[i][j]) {
                    dfs(i);
                    ft = false;
                    break;
                }
            }
            if(!ft) break;
        }
    }
    else flag = false;
    for(int i = 0; i < maxn; i++) {
        for(int j = 0; j < maxn; j++) {
            if(graph[i][j]) {
                if(!vis[i][j]) {
                    flag = false;
                }
            }
        }
    }
    return flag;
}

int main() {
    // freopen("i.txt", "r", stdin);
    // freopen("o.txt", "w", stdout);
    int n;
    cin >> n;
    while(n--) {
        int m;
        cin >> m;
        int t = m;
        memset(graph, 0, sizeof(graph));
        memset(in_degree, 0, sizeof(in_degree));
        memset(out_degree, 0, sizeof(out_degree));
        memset(vis, 0, sizeof(vis));
        while(m--) {
            string str_t;
            cin >> str_t;
            int len = (int)str_t.size();
            graph[str_t[0]-'a'][str_t[len-1]-'a'] = 1;
            out_degree[str_t[0]-'a']++;
            in_degree[str_t[len-1]-'a']++;
        }
        if(t==1 || judge_euler())
            cout << "Ordering is possible." << endl;
        else
            cout << "The door cannot be opened." << endl;
    }
    return 0;
}