HDOJ3594-Cactus（仙人掌图）

最新推荐文章于 2025-05-27 08:03:10 发布

原创最新推荐文章于 2025-05-27 08:03:10 发布 · 626 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#强连通图

图论专栏收录该内容

10 篇文章

订阅专栏

Cactus

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 66 Accepted Submission(s): 37

Problem Description

1. It is a Strongly Connected graph.
2. Each edge of the graph belongs to a circle and only belongs to one circle.
We call this graph as CACTUS.

There is an example as the figure above. The left one is a cactus, but the right one isn’t. Because the edge (0, 1) in the right graph belongs to two circles as (0, 1, 3) and (0, 1, 2, 3).

Input

The input consists of several test cases. The first line contains an integer T (1<=T<=10), representing the number of test cases.
For each case, the first line contains a integer n (1<=n<=20000), representing the number of points.
The following lines, each line has two numbers a and b, representing a single-way edge (a->b). Each case ends with (0 0).
Notice: The total number of edges does not exceed 50000.

Output

For each case, output a line contains “YES” or “NO”, representing whether this graph is a cactus or not.

Sample Input

Sample Output

YES
NO

Author

alpc91

题意：判断一个图是否为仙人掌图。

具体判断标准在下面的pdf里有证明。

代码中的关系也是pdf中的

pdf:http://files.cnblogs.com/ambition/cactus_solution.pdf

#include <iostream>
#include <string>
#include <string.h>
#include <algorithm>
#include <cmath>
#include <vector>
#include <stdio.h>
#include <stack>
using namespace std;
int n;
const int maxn = 20010;
const int maxm = 50010;
struct Node {
    int v, nex;
}node[maxm];
int low[maxn], pre[maxn];
int count[maxn];
int head[maxn], visited[maxn];
int size;
void add(int u, int v) {
    node[size].nex = head[u];
    node[size].v = v;
    head[u] = size++;
}
int flag, dfs_clock;
void dfs(int u) {
    if (flag)
        return;
    low[u] = pre[u] = ++dfs_clock;
    visited[u] = 1;
    for (int i = head[u]; i != -1; i = node[i].nex) {
        int v = node[i].v;
        if (visited[v] == 2) {//仙人掌图性型之一 ： 不能有横向边
            flag = 1;
            return;
        }
        if (!pre[v]) {
            dfs(v);
            if (low[v] > pre[u]) {//性质二 ： low[u] <= pre[v]
                flag = 1;
                return;
            }
            if (low[v] < pre[u]) {
                ::count[u]++;//性质三
                low[u] = min(low[u], low[v]);
            }
            
        } else if (low[v] < pre[u]){
            ::count[u]++;//性质三
            low[u] = min(low[u], pre[v]);
        }
        if (::count[u] > 1) {
            flag = 1;
            return;
        }
    }
    visited[u] = 2;
}
int main() {
        //freopen("1.txt", "r", stdin);
    int t;
    cin >> t;
    while (t--) {
        cin >> n;
        flag = 0;
        dfs_clock = 0;
        size = 0;
        memset(head, -1, sizeof(head));
        memset(::count, 0, sizeof(::count));
        memset(pre, 0, sizeof(pre));
        memset(node, 0, sizeof(node));
        memset(visited, 0, sizeof(visited));
        memset(low, 0, sizeof(low));
        int u, v;
        while (cin >> u >> v && (u + v)) {
            add(u, v);
        }
        dfs(0);
        if (flag || dfs_clock < n)
            cout << "NO\n";
        else
            cout << "YES\n";
    }
}