Search is not available for this dataset
name
stringlengths 2
112
| description
stringlengths 29
13k
| source
int64 1
7
| difficulty
int64 0
25
| solution
stringlengths 7
983k
| language
stringclasses 4
values |
|---|---|---|---|---|---|
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
static ArrayList<Integer> a[];
static boolean visited[];
static void dfs(int i) {
visited[i] = true;
for (int j = 0; j < a[i].size(); j++) {
if (!visited[a[i].get(j)])
dfs(a[i].get(j));
}
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int m = scan.nextInt();
a = new ArrayList[n + 1];
for (int i = 0; i < a.length; i++) {
a[i] = new ArrayList<>();
}
visited = new boolean[n + 1];
for (int i = 0; i < m; i++) {
int s = scan.nextInt();
int ss = scan.nextInt();
a[s].add(ss);
a[ss].add(s);
}
if (n == m) {
dfs(1);
boolean f = true;
for (int k = 1; k < n + 1; k++) {
if (!visited[k]) {
f = false;
break;
}
}
if (f)
System.out.println("FHTAGN!");
else
System.out.println("NO");
}
else
System.out.println("NO");
scan.close();
System.exit(0);
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | n,m=map(int,raw_input().split())
w=[[] for _ in xrange(n)]
p=[0]
for _ in xrange(m):
a,b=map(lambda x: int(x)-1,raw_input().split())
if w[a].count(b)==0:
w[a].append(b)
w[b].append(a)
for k in xrange(n):
t=[]
for i in set(p):
for wi in w[i]:
t.append(wi)
p.extend(t)
if len(set(p))==n: break
print ['NO','FHTAGN!'][len(set(p))==n==m]
| PYTHON |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Queue;
import java.util.Scanner;
public class Main {
static int n;
static boolean[] visitedV = new boolean[100];
static boolean[][] visitedE = new boolean[100][100];
static int[][] g = new int[100][100];
static int cycles = 0;
static private void dfs(int i){
visitedV[i] = true;
for(int j=0; j<n; j++){
if(g[i][j]>0 && !visitedV[j]){
visitedE[i][j]=true;
visitedE[j][i]=true;
dfs(j);
}
else if(g[i][j]>0 && visitedV[j] && !visitedE[i][j])
cycles++;
}
}
public static void main (String[] args) throws NumberFormatException, IOException{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String[] parts = in.readLine().split(" ");
n = Integer.parseInt(parts[0]);
int m = Integer.parseInt(parts[1]);
for(int i=0; i<m; i++){
parts = in.readLine().split(" ");
int x = Integer.parseInt(parts[0])-1;
int y = Integer.parseInt(parts[1])-1;
g[x][y] = 1;
g[y][x] = 1;
}
int componenets=0;
for(int i=0; i<n; i++){
if(!visitedV[i]){
dfs(0);
componenets++;
}
}
if(cycles/2 == 1 && componenets==1)
System.out.println("FHTAGN!");
else
System.out.println("NO");
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.*;
import java.io.*;
public class B
{
static int N , a , b ;
static ArrayList<Integer> [] adjList ;
static boolean [] marked ;
public static void main(String[] args) throws IOException
{
// Scanner sc = new Scanner(new File("src/in.txt"));
Scanner sc = new Scanner(System.in);
N = sc.nextInt();
adjList = (ArrayList<Integer>[]) new ArrayList[N];
for (int i = 0; i < N; i++)
adjList[i] = new ArrayList<Integer>();
int m = sc.nextInt();
while (m-->0)
{
int u = sc.nextInt()-1 ;
int v = sc.nextInt()-1 ;
adjList[u].add(v);
adjList[v].add(u);
}
marked = new boolean[N];
if(cc())
{
marked = new boolean[N];
for (int i = 0; i < N; i++)
if(!marked[i])
dfs(i,i);
if(a==0 && b==0)
System.out.println("NO");
else
{
removeEdge(a,b);
a = b = 0 ;
marked = new boolean[N];
for (int j = 0; j < N; j++)
if(!marked[j])
dfs(j,j);
if(a==0 && b==0)
System.out.println("FHTAGN!");
else
System.out.println("NO");
}
}
else
System.out.println("NO");
sc.close();
}
static void removeEdge(int u , int v)
{
int size1 = adjList[u].size();
for (int i = 0; i < size1; i++)
if(adjList[u].get(i) == v)
{
adjList[u].remove(i);
break;
}
int size2 = adjList[v].size();
for (int i = 0; i < size2; i++)
if(adjList[v].get(i)==u)
{
adjList[v].remove(i);
break;
}
}
static boolean cc()
{
int cc = 0 ;
for (int i = 0; i < N; i++)
if(!marked[i])
{
cc++ ;
dfs(i);
}
return cc == 1 ;
}
static void dfs(int u)
{
marked[u] = true ;
for(int w : adjList[u])
if(!marked[w])
dfs(w);
}
static void dfs(int v , int u)
{
marked[v] = true ;
for(int w : adjList[v])
if(!marked[w])
dfs(w,v);
else if(w != u)
{
a = w ;
b = v ;
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long double EPS = 1e-9;
long long cel(long long a, long long b) {
if (a == 0) return 0;
return ((a - 1) / b + 1);
}
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
return (b == 0) ? a : gcd(b, a % b);
}
long long MIN(long long a, int b) {
long long ans;
(a >= b) ? ans = b : ans = a;
return ans;
}
long long MAX(long long a, int b) {
long long ans;
(a >= b) ? ans = a : ans = b;
return ans;
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long po(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) {
ans = (ans * x) % 1000000007;
}
y >>= 1;
x = (x * x) % 1000000007;
}
return ans;
}
vector<int> adj[101];
void dfs(int u, vector<int> &vis) {
vis[u] = 1;
for (int t : adj[u]) {
if (vis[t]) continue;
dfs(t, vis);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, t, x, y, m, k, d, q;
cin >> n >> m;
int A[n + 1][n + 1];
vector<int> chk(n + 1, 0);
for (int i = 0; i < n + 1; i++)
for (int j = 0; j < n + 1; j++) A[i][j] = 0;
for (int i = 0; i < m; i++) {
cin >> x >> y;
chk[x] = chk[y] = 1;
A[x][y] = A[y][x] = 1;
adj[x].push_back(y);
adj[y].push_back(x);
}
if (n != m)
cout << "NO";
else {
bool ok = true;
vector<int> vis(n + 1, 0);
dfs(1, vis);
for (int i = 1; i < n + 1; i++) {
if (!vis[i]) {
ok = false;
break;
}
}
ok ? cout << "FHTAGN!" : cout << "NO";
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from collections import defaultdict
n, m = map(int, input().split())
adj = defaultdict(list)
for i in range(m):
x, y = map(int, input().split())
adj[x].append(y)
adj[y].append(x)
ok = False
cmps = []
v = [0]*(n+1)
for i in range(1, 1+n):
if not v[i]:
q = [i]
cmp = []
while q:
e = q.pop()
if not v[e]:
cmp.append(e)
v[e] = 1
for j in adj[e]:
if not v[j]:
q.append(j)
cmps.append(cmp)
for i in cmps:
if len(i) > 2:
s = 0
for j in i:
s += len(adj[j])
s //= 2
if s == len(i):
ok = True
print("FHTAGN!" if ok and len(cmps)==1 else "NO") | PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | from collections import defaultdict
n, m= map(int, input("").split())
class Graph():
def __init__(self):
self.nodes = {i:Node(i) for i in range(1, n + 1)}
def find(self, i):
if self.nodes[i].parent_id != i:
new_parent_id = self.find(self.nodes[i].parent_id)
self.nodes[i].change_parent_id(new_parent_id)
return self.nodes[i].parent_id
def union(self, i, j, count,is_cycle = False, ):
i_parent_id = self.find(i)
j_parent_id = self.find(j)
if i_parent_id != j_parent_id:
count -= 1
if self.nodes[i_parent_id].rank > self.nodes[j_parent_id].rank:
self.nodes[j_parent_id].change_parent_id(i_parent_id)
else:
self.nodes[i_parent_id].change_parent_id(j_parent_id)
if self.nodes[i_parent_id].rank == self.nodes[j_parent_id].rank:
self.nodes[i_parent_id].change_rank(self.nodes[j_parent_id].rank + 1)
return is_cycle, count
is_cycle = True
return is_cycle, count
class Node():
def __init__(self, id):
self.id = id
self.parent_id = id
self.rank = 0
def change_parent_id(self, new_parent_id):
self.parent_id = new_parent_id
def change_rank(self, new_rank):
self.rank = new_rank
graph = Graph()
num_cycles = 0
count = n
for i in range(m):
a, b = map(int, input("").split())
is_cylce, count = graph.union(a, b, count)
if is_cylce:
num_cycles += 1
if num_cycles == 1 and count == 1:
print('FHTAGN!')
else:
print('NO')
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.*;
import java.util.*;
public class C {
String s = null;
String[] ss = null;
String F = "FHTAGN!";
String N = "NO";
int n;
int m;
class Edge{
public int t = 0;
}
List<Integer>[] edges = null;
public void run() throws Exception{
BufferedReader br = null;
File file = new File("input.txt");
if(file.exists()){
br = new BufferedReader(new FileReader("input.txt"));
}
else{
br = new BufferedReader(new InputStreamReader(System.in));
}
s = br.readLine();
ss = s.split(" ");
n = Integer.parseInt(ss[0]);
m = Integer.parseInt(ss[1]);
edges = new List[n+1];
for(int i = 0; i <= n; i++){
edges[i] = new ArrayList<Integer>();
}
for(int i = 0; i < m; i++){
s = br.readLine();
ss = s.split(" ");
int f = Integer.parseInt(ss[0]);
int t = Integer.parseInt(ss[1]);
edges[f].add(t);
edges[t].add(f);
}
if(n != m){
System.out.println(N);
return;
}
boolean[] f = new boolean[n+1];
List<Integer> next = new ArrayList<Integer>();
next.add(1);
while(next.size() > 0){
int from = next.get(0);
next.remove(0);
if(f[from]){
continue;
}
f[from] = true;
List<Integer> to = edges[from];
for(int i = 0; i < to.size(); i++){
int too = to.get(i);
if(f[too]){
continue;
}
next.add(too);
}
}
boolean check = true;
for(int i = 1; i <= n; i++){
if(!f[i]){
check = false;
}
}
if(check){
System.out.println(F);
return;
}
else{
System.out.println(N);
return;
}
}
/**
* @param args
*/
public static void main(String[] args) throws Exception{
C t = new C();
t.run();
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<int> G[1005];
int vis[1005];
int padre[1005];
int ciclos = 0;
int tot = 0;
void dfs(int u) {
vis[u] = 1;
tot++;
for (int i = (0); i < (G[u].size()); i++) {
int v = G[u][i];
if (!vis[v]) {
padre[v] = u;
dfs(v);
} else if (padre[u] != v and u > v) {
ciclos++;
}
}
}
int main() {
int n, m;
int u, v;
cin >> n >> m;
for (int i = (0); i < (m); i++) {
scanf("%d %d", &u, &v);
u--;
v--;
G[u].push_back(v);
G[v].push_back(u);
}
padre[0] = -1;
dfs(0);
if (n == m and ciclos == 1 and tot == n)
printf("FHTAGN!\n");
else
printf("NO\n");
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class CF199A {
public static void main(String[] args) throws Exception{
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
DisjointSet DJ = new DisjointSet(N);
ArrayList<Integer>[] array = new ArrayList[N];
for(int a=0;a<N;a++)array[a]=new ArrayList<Integer>();
for(int a=0;a<M;a++){
int s = sc.nextInt()-1;
int e = sc.nextInt()-1;
array[s].add(e);
array[e].add(s);
DJ.union(s,e);
}
int deg3 = 0;
for(int a=0;a<N;a++)if(array[a].size()>=3)deg3++;
boolean flag = N==M;// && deg3>=3;
int p = DJ.find(0);
for(int a=0;a<N;a++){
// System.out.println(DJ.find(a));
if(DJ.find(a)!=p){
flag=false;
}
}
// System.out.println(deg3);
System.out.println(flag?"FHTAGN!":"NO");
}
static class DisjointSet {
int[] p, r;
DisjointSet(int s) {
p = new int[s];
r = new int[s];
for (int i = 0; i < s; i++)
p[i] = i;
}
void union(int x, int y) {
int a = find(x);
int b = find(y);
if (a == b)
return;
if (r[a] == r[b])
r[p[b] = a]++;
else
p[a] = p[b] = r[a] < r[b] ? b : a;
}
int find(int x) {
return p[x] = p[x] == x ? x : find(p[x]);
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | // package Graphs;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
public class CTHULHU {
public static void dfs(HashMap<Integer,Integer> a[],int curr,boolean visited[]){
visited[curr]=true;
HashMap<Integer,Integer> friends=a[curr];
for(int f:friends.keySet()){
if(!visited[f]){
dfs(a,f,visited);
}
}
}
public static void main(String[] args)throws IOException {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String line[]=br.readLine().split(" ");
int n=Integer.parseInt(line[0]);
int m=Integer.parseInt(line[1]);
HashMap<Integer,Integer> a[]=new HashMap[n+1];
for(int i=1;i<=n;i++){
a[i]=new HashMap<>();
}
for(int i=1;i<=m;i++){
line=br.readLine().split(" ");
int x=Integer.parseInt(line[0]);
int y=Integer.parseInt(line[1]);
a[x].put(y,1);
a[y].put(x,1);
}
boolean visited[]=new boolean[n+1];
if(m!=n){
System.out.println("NO");
return;
}
dfs(a,1,visited);
boolean flag=true;
for(int i=1;i<=n;i++){
flag=flag&&visited[i];
}
if(flag){
System.out.println("FHTAGN!");
}
else{
System.out.println("NO");
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.*;
public class Main {
static int n, m; // λ
Έλ, μ£μ§
static ArrayList<ArrayList<Integer>> list = new ArrayList<>();
static int[] visit;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
if (n != m) {
System.out.println("NO");
return;
}
visit = new int[n + 1];
visit[0] = 1;
for (int i = 0; i <= n; i++) {
list.add(new <Integer>ArrayList());
}
for (int i = 0; i < m; i++) {
int x = sc.nextInt();
int y = sc.nextInt();
list.get(x).add(y);
list.get(y).add(x);
}
DFS(1);
for (int i = 0; i < visit.length; i++) {
if (0 == visit[i]) {
System.out.println("NO");
return;
}
}
System.out.println("FHTAGN!");
}
public static void DFS(int node) {
visit[node] = 1;
for (int i = 0; i < list.get(node).size(); i++) {
if (0 == visit[list.get(node).get(i)]) {
DFS(list.get(node).get(i));
}
}
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | v, e = map(int, input().split())
E, V = [], set( range(1, v+1) )
for _ in range(e):
a, b = map(int, input().split())
E.append([a, b])
sets = [ set([vertex]) for vertex in V ]
def getSet(vertex):
for s in sets:
if vertex in s: return s
in_tree = 0
for edge in E:
a, b = edge
if a in V: V.remove(a)
if b in V: V.remove(b)
sa, sb = getSet(a), getSet(b)
if sa.isdisjoint(sb):
in_tree += 1
sa |= sb
sets.remove(sb)
print('FHTAGN!' if in_tree == len(E) - 1 and len(V) == 0 else 'NO') | PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | read = lambda: map(int, input().split())
n, m = read()
graph = [set() for _ in range(n + 1)]
for __ in range(m):
u, v = read()
graph[u].add(v)
graph[v].add(u)
def find_cycle(start):
parents, stack = [0] * (n + 1), [(start, -1)]
while stack:
vertex, parent = stack.pop()
parents[vertex] = parent
for neighbour in graph[vertex]:
if neighbour != parent:
if parents[neighbour]:
cycle = set()
cycle.add(neighbour)
while vertex != neighbour:
cycle.add(vertex)
vertex = parents[vertex]
return cycle
stack.append((neighbour, vertex))
return set()
cyc = find_cycle(1)
if not cyc:
print('NO')
exit()
def dfs():
visited = set(cyc)
for start in cyc:
stack = [(v, start) for v in graph[start] if v not in cyc]
while stack:
vertex, parent = stack.pop()
visited.add(vertex)
for neighbour in graph[vertex]:
if neighbour != parent:
if neighbour in visited:
return set()
stack.append((neighbour, vertex))
return visited
print('FHTAGN!' if len(dfs()) == n else 'NO')
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | n, m = [int(i) for i in input().split()]
c = [int(i) for i in range(n+1)]
def find (u):
if u == c[u]:
return u
c[u] = find(c[u])
return c[u]
ciclos = 0
for i in range(m):
x, y = [int(j) for j in input().split()]
x = find(x)
y = find(y)
if find(x) != find(y):
c[x] = c[y] = max(x, y)
else:
ciclos += 1
conexo = True
componente = find(1)
for i in range(2, n+1, 1):
if find(i) != componente:
conexo = False
if conexo and ciclos == 1:
print('FHTAGN!')
else:
print('NO')
exit(0) | PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.ArrayList;
public class Main {
private static StreamTokenizer in;
private static PrintWriter out;
static {
in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
out = new PrintWriter(System.out);
}
private static int nextInt() throws Exception {
in.nextToken();
return (int)in.nval;
}
private static String nextString() throws Exception {
in.nextToken();
return in.sval;
}
public static void main(String[] args) throws Exception {
int n = nextInt(), m = nextInt();
if (n != m) {
out.println("NO");
out.flush();
return;
}
d = new ArrayList[n];
for (int i=0; i<n; i++) {
d[i] = new ArrayList<Integer>();
}
for (int i=0; i<m; i++) {
int u = nextInt() - 1, v = nextInt() - 1;
d[u].add(v);
d[v].add(u);
}
used = new boolean[n];
dfs(0);
for (int i=0; i<n; i++) {
if (!used[i]) {
out.println("NO");
out.flush();
return;
}
}
out.println("FHTAGN!");
out.flush();
}
private static ArrayList<Integer>[] d;
private static int c = 0;
private static boolean[] used;
private static void dfs(int v) {
used[v] = true;
for (int u : d[v]) {
if (!used[u]) {
dfs(u);
}
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* Created by IntelliJ IDEA.
* User: alexsen
* Date: 3/25/12
* Time: 9:49 PM
* To change this template use File | Settings | File Templates.
*/
public class Fhtagn {
protected static int n = 0;
protected static int m = 0;
public static void main(String[] args){
try{
CirclesFinder finder = new CirclesFinder();
Node[] all = readNodes();
if(!preCheck(all)){
System.out.println("NO");
return;
}
if(!finder.fhtagn(all[0])){
System.out.println("NO");
return;
}
if(!postCheck(all)){
System.out.println("NO");
return;
}
System.out.println("FHTAGN!");
}catch(IOException e){
e.printStackTrace();
}
}
protected static Node[] readNodes()throws IOException{
Reader reader = new Reader();
n = reader.next();
m = reader.next();
Node[] all = new Node[n];
for(int i = 0; i < n; ++i){
all[i] = new Node(i);
}
for(int i = 0; i<m; ++i){
int id1 = reader.next()-1;
int id2 = reader.next()-1;
all[id1].getNeighbors().add(all[id2]);
all[id2].getNeighbors().add(all[id1]);
}
return all;
}
protected static boolean preCheck(Node[] all){
if(all.length < 3) return false;
if(m!=n) return false;
for(int i = 0; i < all.length; ++i){
if(all[i].getNeighbors().size==0) return false;
}
return true;
}
protected static boolean postCheck(Node[] all){
for(Node n : all){
if(n.getColor().equals(Color.WHITE)) return false;
}
return true;
}
}
class CirclesFinder{
public boolean find(Node start){
return fhtagn(start);
}
protected boolean fhtagn(Node start){
start.setVisits(1);
start.setColor(Color.GRAY);
dfs(start);
start.setColor(Color.BLACK);
return true;
}
protected void dfs(Node next){
for(int i = 0 ; i < next.getNeighbors().size() ; ++ i)
{
Node n = next.getNeighbors().get(i);
if(n.getColor()==Color.WHITE){
n.setVisits(1);
n.setColor(Color.GRAY);
n.setParent(next);
dfs(n);
n.setColor(Color.BLACK);
}
}
}
}
enum Color{WHITE,GRAY,BLACK};
class Node{
protected Array neighbors;
protected int id;
protected int visits;
protected Color color;
protected Node parent;
Node(int id) {
this.id = id;
neighbors = new Array();
visits = 0;
color = Color.WHITE;
}
public Node getParent() {
return parent;
}
public void setParent(Node parent) {
this.parent = parent;
}
public Color getColor() {
return color;
}
public void setColor(Color color) {
this.color = color;
}
public int getVisits() {
return visits;
}
public void setVisits(int visits) {
this.visits = visits;
}
public Array getNeighbors() {
return neighbors;
}
public int getId() {
return id;
}
}
class Array{
protected Node[] es;
protected int size = 0;
protected int sizeMax = 2;
Array() {
es = new Node[sizeMax];
}
void add(Node e){
if(size+1 == sizeMax){
sizeMax *= 2;
Node[] esNew = new Node[sizeMax];
for(int i = 0; i < size ; ++i){
esNew[i] = es[i];
}
es = esNew;
}
es[size] = e;
++size;
}
int size(){
return size;
}
Node get(int i){
return es[i];
}
}
class Reader{/*
protected int index = 0;
int next(){
return values[index++];
}
int[] values = {6, 6,4, 5,6, 1,3, 2,4, 3,1, 5,4, 6,2, 5};*/
Reader() {
InputStreamReader converter = new InputStreamReader(System.in);
reader = new BufferedReader(converter);
}
int next()throws IOException{
if(needToRead){
needToRead = false;
buffer = reader.readLine();
int iSep = buffer.indexOf(" ");
int result = Integer.parseInt(buffer.substring(0,iSep));
buffer = buffer.substring(iSep+1);
return result;
}
else{
needToRead = true;
return Integer.parseInt(buffer);
}
}
protected String buffer;
protected boolean needToRead=true;
BufferedReader reader;
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author AlexFetisov
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
}
class TaskB {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int n = in.nextInt();
int m = in.nextInt();
boolean[][] g = new boolean[n][n];
int[] deg = new int[n];
for (int i = 0; i < m; ++i) {
int x = in.nextInt() - 1;
int y = in.nextInt() - 1;
g[x][y] = g[y][x] = true;
++deg[x];
++deg[y];
}
boolean[] deleted = new boolean[n];
boolean[] u = new boolean[n];
dfs(0, g, u);
for (int i = 0; i < n; ++i) {
if (!u[i]) {
out.println("NO");
return;
}
}
while (true) {
int id = -1;
for (int i = 0; i < n; ++i) {
if (!deleted[i]) {
if (deg[i] == 1) {
id = i;
break;
}
}
}
if (id == -1) break;
deleted[id] = true;
for (int i = 0; i < n; ++i) {
if (g[id][i]) {
--deg[i];
}
}
}
for (int i = 0; i < n; ++i) {
if (!deleted[i]) {
if (deg[i] != 2) {
out.println("NO");
return;
}
}
}
out.println("FHTAGN!");
}
private void dfs(int v, boolean[][] g, boolean[] u) {
u[v] = true;
for (int i = 0; i < g[v].length; ++i) {
if (!u[i]) {
if (g[v][i]) {
dfs(i, g, u);
}
}
}
}
}
class InputReader {
private BufferedReader reader;
private StringTokenizer stt;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
}
public String nextLine() {
try {
return reader.readLine().trim();
} catch (IOException e) {
return null;
}
}
public String nextString() {
while (stt == null || !stt.hasMoreTokens()) {
stt = new StringTokenizer(nextLine());
}
return stt.nextToken();
}
public int nextInt() {
return Integer.parseInt(nextString());
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.*;
import java.util.*;
public class B {
public static void solution(BufferedReader reader, PrintWriter writer)
throws IOException {
In in = new In(reader);
Out out = new Out(writer);
int n = in.nextInt(), m = in.nextInt();
UnionFind uf = new UnionFind(n);
for (int i = 0; i < m; i++)
uf.union(in.nextInt(), in.nextInt());
out.println(uf.c == 1 && n == m ? "FHTAGN!" : "NO");
}
private static class UnionFind {
private int[] id;
private int c;
public UnionFind(int n) {
id = new int[n + 1];
for (int i = 1; i <= n; i++)
id[i] = i;
c = n;
}
public int find(int i) {
return id[i] == i ? i : (id[i] = find(id[i]));
}
public void union(int p, int q) {
int i = find(p);
int j = find(q);
if (i != j) {
id[j] = i;
c--;
}
}
}
public static void main(String[] args) throws Exception {
BufferedReader reader = new BufferedReader(
new InputStreamReader(System.in));
PrintWriter writer = new PrintWriter(
new BufferedWriter(new OutputStreamWriter(System.out)));
solution(reader, writer);
writer.close();
}
protected static class In {
private BufferedReader reader;
private StringTokenizer tokenizer = new StringTokenizer("");
public In(BufferedReader reader) {
this.reader = reader;
}
public String next() throws IOException {
while (!tokenizer.hasMoreTokens())
tokenizer = new StringTokenizer(reader.readLine());
return tokenizer.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public int[] nextIntArray1(int n) throws IOException {
int[] a = new int[n + 1];
for (int i = 1; i <= n; i++)
a[i] = nextInt();
return a;
}
public int[] nextIntArraySorted(int n) throws IOException {
int[] a = nextIntArray(n);
Random r = new Random();
for (int i = 0; i < n; i++) {
int j = i + r.nextInt(n - i);
int t = a[i];
a[i] = a[j];
a[j] = t;
}
Arrays.sort(a);
return a;
}
public long[] nextLongArray(int n) throws IOException {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public long[] nextLongArray1(int n) throws IOException {
long[] a = new long[n + 1];
for (int i = 1; i <= n; i++)
a[i] = nextLong();
return a;
}
public long[] nextLongArraySorted(int n) throws IOException {
long[] a = nextLongArray(n);
Random r = new Random();
for (int i = 0; i < n; i++) {
int j = i + r.nextInt(n - i);
long t = a[i];
a[i] = a[j];
a[j] = t;
}
Arrays.sort(a);
return a;
}
}
protected static class Out {
private PrintWriter writer;
private static boolean local = System
.getProperty("ONLINE_JUDGE") == null;
public Out(PrintWriter writer) {
this.writer = writer;
}
public void print(char c) {
writer.print(c);
}
public void print(int a) {
writer.print(a);
}
public void printb(int a) {
writer.print(a);
writer.print(' ');
}
public void println(Object a) {
writer.println(a);
}
public void println(Object[] os) {
for (int i = 0; i < os.length; i++) {
writer.print(os[i]);
writer.print(' ');
}
writer.println();
}
public void println(int[] a) {
for (int i = 0; i < a.length; i++) {
writer.print(a[i]);
writer.print(' ');
}
writer.println();
}
public void println(long[] a) {
for (int i = 0; i < a.length; i++) {
writer.print(a[i]);
writer.print(' ');
}
writer.println();
}
public void flush() {
writer.flush();
}
public static void db(Object... objects) {
if (local)
System.out.println(Arrays.deepToString(objects));
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> G[100];
bool B[100];
vector<pair<int, int> > T;
void dfs(int v, int p) {
B[v] = true;
for (int(i) = (0); (i) < (G[v].size()); ++(i)) {
int to = G[v][i];
if (to == p) continue;
if (B[to] == true) {
T.push_back(make_pair(min(v, to), max(v, to)));
continue;
}
dfs(to, v);
}
}
int main() {
cin >> n >> m;
for (int(i) = (0); (i) < (m); ++(i)) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].push_back(v);
G[v].push_back(u);
}
int c = 0;
for (int(i) = (0); (i) < (n); ++(i))
if (B[i] == false) {
c++;
dfs(i, -1);
}
if (c != 1) {
cout << "NO" << endl;
return 0;
}
sort((T).begin(), (T).end());
if (T.empty()) {
cout << "NO" << endl;
return 0;
}
for (int(i) = (1); (i) < (T.size()); ++(i))
if (T[i] != T[i - 1]) {
cout << "NO" << endl;
return 0;
}
cout << "FHTAGN!" << endl;
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
void dfs(int v, vector<vector<int>>& g, vector<bool>& used) {
if (!used[v]) {
used[v] = true;
for (auto u : g[v]) dfs(u, g, used);
}
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> g(n + 1);
vector<bool> used(n + 1);
for (int i = 0; i < m; ++i) {
int x1, x2;
cin >> x1 >> x2;
g[x1].push_back(x2);
g[x2].push_back(x1);
}
dfs(1, g, used);
int j = 1;
while (j <= n && used[j]) ++j;
if (m == n && j > n)
cout << "FHTAGN!";
else
cout << "NO";
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
bool q(vector<vector<int>>& a, vector<int>& v, vector<int>& s, int i, int p) {
v[i] = 1;
s.push_back(i);
for (int j = 0; j < a[i].size(); j++) {
if (v[a[i][j]] == 0) {
bool t = q(a, v, s, a[i][j], i);
if (t) return true;
} else if (a[i][j] != p) {
s.push_back(a[i][j]);
return true;
}
}
s.pop_back();
return false;
}
bool g(vector<vector<int>>& a, vector<int>& v, int& l, int i, vector<int> p) {
v[i] = 1;
l++;
for (int j = 0; j < a[i].size(); j++) {
if (v[a[i][j]] == 0) {
bool t = g(a, v, l, a[i][j], {i});
if (t) return true;
} else if (find(p.begin(), p.end(), a[i][j]) == p.end()) {
return true;
}
}
return false;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> a(n);
for (int i = 0; i < m; i++) {
int s, e;
cin >> s >> e;
a[s - 1].push_back(e - 1);
a[e - 1].push_back(s - 1);
}
vector<int> v(n), s;
bool tt = q(a, v, s, 0, -1);
if (tt == false) {
cout << "NO" << endl;
return 0;
}
vector<int> cm;
vector<int> vn(n);
int el = s[s.size() - 1];
cm.push_back(el);
vn[el] = 1;
for (int j = s.size() - 2; j >= 0; j--) {
if (s[j] == el) break;
cm.push_back(s[j]);
vn[s[j]] = 1;
}
int l = 0;
for (auto i = 0; i < cm.size(); i++) {
int x = cm[i];
vector<int> vt;
if (i > 0)
vt.push_back(cm[i - 1]);
else
vt.push_back(cm[cm.size() - 1]);
if (i < cm.size() - 1)
vt.push_back(cm[i + 1]);
else
vt.push_back(cm[0]);
bool ant = g(a, vn, l, x, vt);
if (ant) {
cout << "NO" << endl;
return 0;
}
}
if (l == n)
cout << "FHTAGN!" << endl;
else
cout << "NO" << endl;
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void checkmin(T &a, T b) {
if (a > b) a = b;
}
const int N = 100;
void dfs(int n, int x, bool *graph, bool *visited) {
for (int i = 0; i < n; i++) {
int y = i;
if (graph[x * N + y] && !visited[y]) {
visited[y] = true;
dfs(n, y, graph, visited);
}
}
}
bool isconnected(int n, bool *graph) {
bool visited[N];
memset(visited, 0x00, sizeof(visited));
dfs(n, 0, graph, visited);
for (int i = 0; i < n; i++)
if (!visited[i]) return false;
return true;
}
int haveloop(int depth, int n, int x, bool *graph, int *visited, int *order,
int &oi) {
order[n - depth] = x;
for (int i = 0; i < n; i++) {
int y = i;
if (graph[x * N + y] == true) {
if (visited[y]) {
if (visited[y] - depth > 1) {
oi = n - visited[y];
return visited[y] - depth + 1;
} else
continue;
}
visited[y] = depth - 1;
int res = haveloop(depth - 1, n, y, graph, visited, order, oi);
if (res != 0) return res;
}
}
return 0;
}
void solve() {
int n, m;
bool graph[N * N];
memset(graph, 0x00, sizeof(graph));
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--;
y--;
graph[x * N + y] = true;
graph[y * N + x] = true;
}
if (!isconnected(n, graph)) {
cout << "NO" << endl;
return;
}
int visited[N];
int order[N + 1], oi;
int len;
len = 0;
memset(visited, 0x00, sizeof(visited));
visited[0] = n;
len = haveloop(n, n, 0, graph, visited, order, oi);
if (len == 0) {
cout << "NO" << endl;
return;
}
bool res = true;
int a, b = order[oi + len - 1];
for (int i = 0; i < len; i++) {
a = b;
b = order[oi + i];
graph[a * N + b] = false;
graph[b * N + a] = false;
memset(visited, 0x00, sizeof(visited));
visited[0] = n;
len = haveloop(n, n, 0, graph, visited, order, oi);
if (len > 0) {
res = false;
break;
}
graph[a * N + b] = true;
graph[b * N + a] = true;
}
if (res)
cout << "FHTAGN!" << endl;
else
cout << "NO" << endl;
}
int main() {
solve();
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int vis[110] = {0};
void dfs(int v);
vector<int> adj[110];
int main() {
int n, m, x, y, i;
scanf("%d", &n);
scanf("%d", &m);
for (int i = (int)0; i < (int)m; i++) {
scanf("%d", &x);
scanf("%d", &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
if (n != m) {
printf("NO\n");
return 0;
}
dfs(1);
for (i = 1; i <= n; i++) {
if (vis[i] == 0) {
printf("NO\n");
return 0;
}
}
printf("FHTAGN!\n");
return 0;
}
void dfs(int v) {
vis[v] = 1;
int i;
for (i = 0; i < adj[v].size(); i++) {
if (vis[adj[v][i]] == 0) dfs(adj[v][i]);
}
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int ind = 0, n;
int used[101];
int g[101][101];
void dfs(int v) {
used[v] = 1;
for (int k = 1; k <= n; k++)
if (g[v][k] == 1)
if (used[k] == 0)
dfs(k);
else if (used[k] == 2)
ind++;
used[v] = 2;
}
int main() {
int m;
cin >> n >> m;
for (int k = 1; k <= m; k++) {
int a, b;
cin >> a >> b;
g[a][b] = g[b][a] = 1;
}
dfs(1);
for (int j = 1; j <= n; j++)
if (used[j] == 0) {
cout << "NO";
return 0;
}
if (ind == 1) {
cout << "FHTAGN!";
return 0;
}
cout << "NO";
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.io.IOException;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.math.BigInteger;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author Alex
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
}
class TaskB {
int count = 0;
boolean[] visited;
public void solve(int testNumber, InputReader in, OutputWriter out){
int n = in.ri(), m = in.ri();
visited = new boolean[n];
int[][] edges = IOUtils.readIntTable(in, m, 2);
BidirectionalGraph g = new BidirectionalGraph(n);
for(int i = 0; i < edges.length; i++) {
g.addSimpleEdge(edges[i][0]-1, edges[i][1]-1);
}
process(0, -1, g, out);
boolean allvisited = true;
for(boolean b : visited) if (!b) allvisited = false;
out.printLine(count == 2 && allvisited ? "FHTAGN!" : "NO");
}
void process(int vertex, int last, Graph graph, OutputWriter out) { //DFS
visited[vertex] = true;
for (int i = graph.firstOutbound(vertex); i != -1; i = graph.nextOutbound(i)) {
int next = graph.destination(i);
if (next == last) continue;
if (visited[next]){
// out.printLine(last, vertex, next);
count++;
continue;
}
// out.printLine(next, graph.weight(i) == 0 ? 0 : vertex);
process(next, vertex, graph, out);
}
}
}
class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public int ri(){
return readInt();
}
public int readInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public void print(Object...objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0)
writer.print(' ');
writer.print(objects[i]);
}
}
public void printLine(Object...objects) {
print(objects);
writer.println();
}
public void close() {
writer.close();
}
}
class IOUtils {
public static int[] readIntArray(InputReader in, int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++)
array[i] = in.readInt();
return array;
}
public static int[][] readIntTable(InputReader in, int rowCount, int columnCount) {
int[][] table = new int[rowCount][];
for (int i = 0; i < rowCount; i++)
table[i] = readIntArray(in, columnCount);
return table;
}
}
class BidirectionalGraph extends Graph {
public int[] transposedEdge;
public BidirectionalGraph(int vertexCount) {
this(vertexCount, vertexCount);
}
public BidirectionalGraph(int vertexCount, int edgeCapacity) {
super(vertexCount, 2 * edgeCapacity);
transposedEdge = new int[2 * edgeCapacity];
}
public int addEdge(int fromID, int toID, long weight, long capacity, int reverseEdge) {
int lastEdgeCount = edgeCount;
super.addEdge(fromID, toID, weight, capacity, reverseEdge);
super.addEdge(toID, fromID, weight, capacity, reverseEdge == -1 ? -1 : reverseEdge + 1);
this.transposedEdge[lastEdgeCount] = lastEdgeCount + 1;
this.transposedEdge[lastEdgeCount + 1] = lastEdgeCount;
return lastEdgeCount;
}
protected int entriesPerEdge() {
return 2;
}
protected void ensureEdgeCapacity(int size) {
if (size > edgeCapacity()) {
super.ensureEdgeCapacity(size);
transposedEdge = resize(transposedEdge, edgeCapacity());
}
}
}
class Graph {
public static final int REMOVED_BIT = 0;
protected int vertexCount;
protected int edgeCount;
private int[] firstOutbound;
private int[] firstInbound;
private Edge[] edges;
private int[] nextInbound;
private int[] nextOutbound;
private int[] from;
private int[] to;
private long[] weight;
public long[] capacity;
private int[] reverseEdge;
private int[] flags;
public Graph(int vertexCount, int edgeCapacity) {
this.vertexCount = vertexCount;
firstOutbound = new int[vertexCount];
Arrays.fill(firstOutbound, -1);
from = new int[edgeCapacity];
to = new int[edgeCapacity];
nextOutbound = new int[edgeCapacity];
flags = new int[edgeCapacity];
}
public int addEdge(int fromID, int toID, long weight, long capacity, int reverseEdge) {
ensureEdgeCapacity(edgeCount + 1);
if (firstOutbound[fromID] != -1)
nextOutbound[edgeCount] = firstOutbound[fromID];
else
nextOutbound[edgeCount] = -1;
firstOutbound[fromID] = edgeCount;
if (firstInbound != null) {
if (firstInbound[toID] != -1)
nextInbound[edgeCount] = firstInbound[toID];
else
nextInbound[edgeCount] = -1;
firstInbound[toID] = edgeCount;
}
this.from[edgeCount] = fromID;
this.to[edgeCount] = toID;
if (capacity != 0) {
if (this.capacity == null)
this.capacity = new long[from.length];
this.capacity[edgeCount] = capacity;
}
if (weight != 0) {
if (this.weight == null)
this.weight = new long[from.length];
this.weight[edgeCount] = weight;
}
if (reverseEdge != -1) {
if (this.reverseEdge == null) {
this.reverseEdge = new int[from.length];
Arrays.fill(this.reverseEdge, 0, edgeCount, -1);
}
this.reverseEdge[edgeCount] = reverseEdge;
}
if (edges != null)
edges[edgeCount] = createEdge(edgeCount);
return edgeCount++;
}
protected final GraphEdge createEdge(int id) {
return new GraphEdge(id);
}
public final int addFlowWeightedEdge(int from, int to, long weight, long capacity) {
if (capacity == 0) {
return addEdge(from, to, weight, 0, -1);
} else {
int lastEdgeCount = edgeCount;
addEdge(to, from, -weight, 0, lastEdgeCount + entriesPerEdge());
return addEdge(from, to, weight, capacity, lastEdgeCount);
}
}
protected int entriesPerEdge() {
return 1;
}
public final int addWeightedEdge(int from, int to, long weight) {
return addFlowWeightedEdge(from, to, weight, 0);
}
public final int addSimpleEdge(int from, int to) {
return addWeightedEdge(from, to, 0);
}
protected final int edgeCapacity() {
return from.length;
}
public final int firstOutbound(int vertex) {
int id = firstOutbound[vertex];
while (id != -1 && isRemoved(id))
id = nextOutbound[id];
return id;
}
public final int nextOutbound(int id) {
id = nextOutbound[id];
while (id != -1 && isRemoved(id))
id = nextOutbound[id];
return id;
}
public final int destination(int id) {
return to[id];
}
public final boolean flag(int id, int bit) {
return (flags[id] >> bit & 1) != 0;
}
public final boolean isRemoved(int id) {
return flag(id, REMOVED_BIT);
}
protected void ensureEdgeCapacity(int size) {
if (from.length < size) {
int newSize = Math.max(size, 2 * from.length);
if (edges != null)
edges = resize(edges, newSize);
from = resize(from, newSize);
to = resize(to, newSize);
nextOutbound = resize(nextOutbound, newSize);
if (nextInbound != null)
nextInbound = resize(nextInbound, newSize);
if (weight != null)
weight = resize(weight, newSize);
if (capacity != null)
capacity = resize(capacity, newSize);
if (reverseEdge != null)
reverseEdge = resize(reverseEdge, newSize);
flags = resize(flags, newSize);
}
}
protected final int[] resize(int[] array, int size) {
int[] newArray = new int[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
private long[] resize(long[] array, int size) {
long[] newArray = new long[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
private Edge[] resize(Edge[] array, int size) {
Edge[] newArray = new Edge[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
protected class GraphEdge implements Edge {
protected int id;
protected GraphEdge(int id) {
this.id = id;
}
}
}
interface Edge {}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
T power(T N, T P) {
return (P == 0) ? 1 : N * power(N, P - 1);
}
template <class T>
bool inside(T a, T b, T c) {
return (b >= a && b <= c);
}
const long long INF64 = (long long)1E18;
double _dist(double x1, double y1, double x2, double y2) {
return sqrt(sqr(x1 - x2) + sqr(y1 - y2));
}
int distsq(int x1, int y1, int x2, int y2) {
return sqr(x1 - x2) + sqr(y1 - y2);
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long toInt64(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double toDouble(string s) {
double r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double LOG(long long N, long long B) { return (log10l(N)) / (log10l(B)); }
string itoa(long long a) {
if (a == 0) return "0";
string ret;
for (long long i = a; i > 0; i = i / 10) ret.push_back((i % 10) + 48);
reverse(ret.begin(), ret.end());
return ret;
}
vector<string> token(string a, string b) {
const char *q = a.c_str();
while (count(b.begin(), b.end(), *q)) q++;
vector<string> oot;
while (*q) {
const char *e = q;
while (*e && !count(b.begin(), b.end(), *e)) e++;
oot.push_back(string(q, e));
q = e;
while (count(b.begin(), b.end(), *q)) q++;
}
return oot;
}
int isvowel(char s) {
s = tolower(s);
if (s == 'a' || s == 'e' || s == 'i' || s == 'o' || s == 'u') return 1;
return 0;
}
int isupper(char s) {
if (s >= 'A' and s <= 'Z') return 1;
return 0;
}
template <class T>
struct Fraction {
T a, b;
Fraction(T a = 0, T b = 1);
string toString();
};
template <class T>
Fraction<T>::Fraction(T a, T b) {
T d = gcd(a, b);
a /= d;
b /= d;
if (b < 0) a = -a, b = -b;
this->a = a;
this->b = b;
}
template <class T>
string Fraction<T>::toString() {
ostringstream sout;
sout << a << "/" << b;
return sout.str();
}
template <class T>
Fraction<T> operator+(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.b + q.a * p.b, p.b * q.b);
}
template <class T>
Fraction<T> operator-(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.b - q.a * p.b, p.b * q.b);
}
template <class T>
Fraction<T> operator*(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.a, p.b * q.b);
}
template <class T>
Fraction<T> operator/(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.b, p.b * q.a);
}
int SET(int N, int pos) { return N = N | (1 << pos); }
int RESET(int N, int pos) { return N = N & ~(1 << pos); }
int check(int N, int pos) { return (N & (1 << pos)); }
int toggle(int N, int pos) {
if (check(N, pos)) return N = RESET(N, pos);
return N = SET(N, pos);
}
void PRINTBIT(int N) {
for (int i = 10; i >= 0; i--) {
bool x = check(N, i);
cout << x;
}
puts("");
}
vector<int> G[1234];
int vis[1234], d[1234];
int back = 0, dfstime = 0;
void dfs(int from, int u) {
d[u] = ++dfstime;
for (int i = 0; i < (int)G[u].size(); i++) {
int v = G[u][i];
if (v == from) continue;
if (vis[v] and d[v] < d[u]) {
back++;
continue;
}
if (vis[v] == 0) {
vis[v] = 1;
dfs(u, v);
}
}
}
int main() {
int n, e;
while (cin >> n >> e) {
for (int i = 0; i <= n; i++) G[i].clear();
dfstime = 0;
memset(vis, 0, sizeof(vis));
;
memset(d, 0, sizeof(d));
;
for (int i = 1; i <= e; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
int c = 0;
back = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
vis[i] = 1;
dfs(-1, i);
c++;
}
}
if (c != 1)
puts("NO");
else {
if (back == 1)
puts("FHTAGN!");
else
puts("NO");
}
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
int main() {
int n, m;
int col[200];
int a, b;
int i, j;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) col[i] = i;
for (i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
a--;
b--;
for (j = 0, b = col[b]; j < n; j++)
if (col[j] == b) col[j] = col[a];
}
for (i = 0; i < n - 1; i++)
if (col[i] != col[i + 1]) {
printf("NO\n");
return 0;
}
if (n == m)
printf("FHTAGN!\n");
else
printf("NO\n");
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
int par[400];
int a[400];
int union_find(int m) {
if (par[m] == m) return m;
return par[m] = union_find(par[m]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n;
for (int i = 1; i <= n; i += 1) par[i] = i;
cin >> m;
int u, v;
int cnt = 0;
for (int i = 0; i < (m); i++) {
cin >> u >> v;
int p = union_find(u);
int q = union_find(v);
if (p == q) {
cnt++;
continue;
}
par[p] = q;
}
int mx = 0;
int frq[1000] = {0};
for (int i = 1; i <= n; i++) mx = max(mx, ++frq[union_find(i)]);
if (n == m && mx == n)
cout << "FHTAGN!" << endl;
else
cout << "NO" << endl;
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m, i, x, sum, y;
vector<int> a[105];
bool visit[105];
void dfs(int i) {
visit[i] = 1;
sum++;
for (int j = 0; j < a[i].size(); j++)
if (!visit[a[i][j]]) dfs(a[i][j]);
}
int main() {
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
if (n != m) {
cout << "NO";
return 0;
}
dfs(1);
if (sum == n)
cout << "FHTAGN!";
else
cout << "NO";
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<int> adj[102];
bool vis[102];
void f(int v) {
vis[v] = 1;
for (int i = (0); i < (adj[v].size()); ++i) {
int u = adj[v][i];
if (!vis[u]) f(u);
}
}
int main(int argc, char **argv) {
int N, M;
cin >> N >> M;
if (M != N) {
puts("NO");
return 0;
}
for (int i = (0); i < (M); ++i) {
int first, second;
cin >> first >> second;
--first, --second;
adj[first].push_back(second);
adj[second].push_back(first);
}
f(0);
int c = 0;
for (int i = (0); i < (N); ++i) c += vis[i];
if (c == N)
puts("FHTAGN!");
else
puts("NO");
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
int n, m;
bool getcycle(int second) {
bool visited[100] = {0};
stack<vector<int> > st;
int cycles = 0;
vector<int> start;
start.push_back(second);
st.push(start);
visited[second] = 1;
while (!st.empty()) {
vector<int> v = st.top();
int cur = v[v.size() - 1];
st.pop();
visited[cur] = 1;
for (int i = 0; i < g[cur].size(); i++) {
if (!visited[g[cur][i]]) {
vector<int> t = v;
t.push_back(g[cur][i]);
st.push(t);
}
}
}
for (int i = 0; i < n; i++) {
if (!visited[i]) return false;
}
return true;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
vector<int> c;
g.push_back(c);
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
bool connected = getcycle(0);
if (connected && n == m)
printf("FHTAGN!");
else
printf("NO");
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | def findSet(u):
if parent[u] != u:
parent[u] = findSet(parent[u])
return parent[u]
def unionSet(u, v):
up = findSet(u)
vp = findSet(v)
if up == vp:
return
if ranks[up] > ranks[vp]:
parent[vp] = up
elif ranks[up] < ranks[vp]:
parent[up] = vp
else:
parent[up] = vp
ranks[vp] += 1
n, m = list(map(int, input("").split()))
parent = [i for i in range(n+1)]
ranks = [0 for i in range(n+1)]
for _ in range(m):
u,v = tuple(map(int, input("").split()))
unionSet(u,v)
if n != m:
print('NO')
else:
cnt = 0
for i in range(1,n+1):
if i == parent[i]: # co 1 tap hop khi co duy nhat 1 phan tu co parent la chinh no
cnt += 1
if cnt > 1:
break
# print(ranks)
if cnt == 1:
print('FHTAGN!')
else:
print('NO')
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long long int Mod = 1000000007;
void dfs(int v, vector<int> G[], bool visited[]) {
visited[v] = true;
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
if (!visited[u]) {
dfs(u, G, visited);
}
}
}
int main() {
int n, m;
cin >> n >> m;
vector<int> G[n + 1];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
bool visited[n + 1];
for (int i = 1; i <= n; i++) {
visited[i] = false;
}
int count = 0;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
count++;
dfs(i, G, visited);
}
}
if (count == 1 && (n == m)) {
cout << "FHTAGN!" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
/*
* Author- Priyam Vora
* BTech 2nd Year DAIICT
*/
import java.io.*;
import java.math.*;
import java.util.*;
import javax.print.attribute.SetOfIntegerSyntax;
public class Graph1 {
private static InputStream stream;
private static byte[] buf = new byte[1024];
private static int curChar;
private static int numChars;
private static SpaceCharFilter filter;
private static PrintWriter pw;
private static long count = 0,mod=1000000007;
private static TreeSet<Integer>ts[]=new TreeSet[200000];
private static HashSet hs=new HashSet();
public static void main(String args[]) throws Exception {
InputReader(System.in);
pw = new PrintWriter(System.out);
//ans();
soln();
pw.close();
}
public static long gcd(long x, long y) {
if (x == 0)
return y;
else
return gcd( y % x,x);
}
private static int BinarySearch(int a[], int low, int high, int target) {
if (low > high)
return -1;
int mid = low + (high - low) / 2;
if (a[mid] == target)
return mid;
if (a[mid] > target)
high = mid - 1;
if (a[mid] < target)
low = mid + 1;
return BinarySearch(a, low, high, target);
}
public static String reverseString(String s) {
StringBuilder sb = new StringBuilder(s);
sb.reverse();
return (sb.toString());
}
public static long pow(long n, long p) {
if(p==0)
return 1;
if(p==1)
return n%mod;
if(p%2==0){
long temp=pow(n, p/2);
return (temp*temp)%mod;
}else{
long temp=pow(n,p/2);
temp=(temp*temp)%mod;
return(temp*n)%mod;
}
}
public static int[] radixSort(int[] f) {
int[] to = new int[f.length];
{
int[] b = new int[65537];
for (int i = 0; i < f.length; i++)
b[1 + (f[i] & 0xffff)]++;
for (int i = 1; i <= 65536; i++)
b[i] += b[i - 1];
for (int i = 0; i < f.length; i++)
to[b[f[i] & 0xffff]++] = f[i];
int[] d = f;
f = to;
to = d;
}
{
int[] b = new int[65537];
for (int i = 0; i < f.length; i++)
b[1 + (f[i] >>> 16)]++;
for (int i = 1; i <= 65536; i++)
b[i] += b[i - 1];
for (int i = 0; i < f.length; i++)
to[b[f[i] >>> 16]++] = f[i];
int[] d = f;
f = to;
to = d;
}
return f;
}
public static int nextPowerOf2(final int a) {
int b = 1;
while (b < a) {
b = b << 1;
}
return b;
}
public static boolean PointInTriangle(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8) {
int s = p2 * p5 - p1 * p6 + (p6 - p2) * p7 + (p1 - p5) * p8;
int t = p1 * p4 - p2 * p3 + (p2 - p4) * p7 + (p3 - p1) * p8;
if ((s < 0) != (t < 0))
return false;
int A = -p4 * p5 + p2 * (p5 - p3) + p1 * (p4 - p6) + p3 * p6;
if (A < 0.0) {
s = -s;
t = -t;
A = -A;
}
return s > 0 && t > 0 && (s + t) <= A;
}
public static float area(int x1, int y1, int x2, int y2, int x3, int y3) {
return (float) Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
}
public static boolean isPrime(int n) {
// Corner cases
if (n <= 1)
return false;
if (n <= 3)
return true;
// This is checked so that we can skip
// middle five numbers in below loop
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
//merge Sort
static long sort(int a[])
{ int n=a.length;
int b[]=new int[n];
return mergeSort(a,b,0,n-1);}
static long mergeSort(int a[],int b[],long left,long right)
{ long c=0;if(left<right)
{ long mid=left+(right-left)/2;
c= mergeSort(a,b,left,mid);
c+=mergeSort(a,b,mid+1,right);
c+=merge(a,b,left,mid+1,right); }
return c; }
static long merge(int a[],int b[],long left,long mid,long right)
{long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
while(i<=(int)mid-1&&j<=(int)right)
{ if(a[i]>a[j]) {b[k++]=a[i++]; }
else { b[k++]=a[j++];c+=mid-i;}}
while (i <= (int)mid - 1) b[k++] = a[i++];
while (j <= (int)right) b[k++] = a[j++];
for (i=(int)left; i <= (int)right; i++)
a[i] = b[i]; return c; }
public static boolean isSubSequence(String large, String small, int largeLen, int smallLen) {
//base cases
if (largeLen == 0)
return false;
if (smallLen == 0)
return true;
// If last characters of two strings are matching
if (large.charAt(largeLen - 1) == small.charAt(smallLen - 1))
isSubSequence(large, small, largeLen - 1, smallLen - 1);
// If last characters are not matching
return isSubSequence(large, small, largeLen - 1, smallLen);
}
// To Get Input
// Some Buffer Methods
public static void InputReader(InputStream stream1) {
stream = stream1;
}
private static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private static boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
private static int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
private static int nextInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
private static long nextLong() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
private static String nextToken() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
private static String nextLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
private static int[] nextIntArray(int n) {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = nextInt();
}
return arr;
}
private static int[][] next2dArray(int n, int m) {
int[][] arr = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
arr[i][j] = nextInt();
}
}
return arr;
}
private static char[][] nextCharArray(int n,int m){
char [][]c=new char[n][m];
for(int i=0;i<n;i++){
String s=nextLine();
for(int j=0;j<s.length();j++){
c[i][j]=s.charAt(j);
}
}
return c;
}
private static long[] nextLongArray(int n) {
long[] arr = new long[n];
for (int i = 0; i < n; i++) {
arr[i] = nextLong();
}
return arr;
}
private static void pArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
pw.print(arr[i] + " ");
}
pw.println();
return;
}
private static void pArray(long[] arr) {
for (int i = 0; i < arr.length; i++) {
pw.print(arr[i] + " ");
}
pw.println();
return;
}
private static void pArray(boolean[] arr) {
for (int i = 0; i < arr.length; i++) {
pw.print(arr[i] + " ");
}
pw.println();
return;
}
private static boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return isWhitespace(c);
}
private interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
//----------------------------------------My Code------------------------------------------------//
private static void soln() {
int n=nextInt();
int m=nextInt();
Graph g=new Graph(n);
int k=m;
while(m-->0){
int v=nextInt();
int w=nextInt();
g.addEdge(v, w);
g.addEdge(w, v);
}
if((g.dfs(1)==0) || n!=k){
System.out.println("NO");
System.exit(0);
}
pw.println("FHTAGN!");
}
//-----------------------------------------The End--------------------------------------------------------------------------//
private static void dfs(int x1,int y1,char[][]a){
boolean Visited[][]=new boolean[3][a[0].length];
int level[][]=new int [3][a[0].length];
Queue<Pair> s=new LinkedList<Pair>();
s.add(new Pair(x1,y1));
level[x1][y1]=0;
int curr=0;
while(!s.isEmpty()){
Pair temp=s.poll();
int x=temp.idx;
int y=temp.val;
Visited[x][y]=true;
pw.println(x+" "+y+"___");
if(curr!=level[x][y]){
for(int i=0;i<3;i++){
for(int j=0;j<a[0].length;j++){
if(a[i][j]!='s' && a[i][j]!='.'){
while(j<a[0].length && a[i][j]!='s' && a[i][j]!='.'){
if(j>=2){
a[i][j-2]=a[i][j];
}
a[i][j]='.';
j++;
}
}
}
}
curr=level[x][y];
/*for(int i=0;i<3;i++){
for(int j=0;j<a[0].length;j++){
pw.print(a[i][j]);
}
pw.println();
}
pw.println();
// return;*/
}
if(( a[x][y]=='.' || a[x][y]=='s')){
//pw.println(x+" "+y+"---");
if( y==a[0].length-1){
pw.println("YES");
return;
}
if(check2(x+1, y+2, a) || check2(x-1, y+2, a)){
s.add(new Pair(x,y));
level[x][y]++;
}else{
if(check(x+1,y,a) ){
s.add(new Pair(x+1,y));
level[x+1][y]=level[x][y]+1;
Visited[x+1][y]=true;
}
if(check(x,y+1,a) ){
s.add(new Pair(x,y+1));
level[x][y+1]=level[x][y]+1;
Visited[x][y+1]=true;
}if(check(x-1,y,a) ){
level[x-1][y]=level[x][y]+1;
Visited[x-1][y]=true;
s.add(new Pair(x-1,y));
}
}
}
} pw.println("NO");
}
private static boolean check2(int x,int y,char a[][]){
if(x>=0 && y>=0 && x<3 && y<a[0].length && a[x][y]=='.')
return true;
return false;
}
private static boolean check(int x,int y,char a[][]){
if(x>=0 && y>=0 && x<3 && y<a[0].length && a[x][y]=='.'){
if(y<a[0].length-2 && a[x][y+2]=='.'){
return true;
}else
return false;
}
return false;
}
}
class Pair implements Comparable<Pair>{
int idx,val;
Pair(int idx,int val){
this.idx=idx;
this.val=val;
}
@Override
public int compareTo(Pair o) {
// TODO Auto-generated method stub
// Sort in increasing order
if(o.idx<idx){
return 1;
}
if(o.idx==idx && o.val<val){
return 1;
}else{
return -1;
}
}
}
class Graph{
private int V,level[][],count=-1,lev_dfs[],degree=0;
private Stack <Integer>st=new Stack();
private LinkedList<Integer > adj[];
private boolean[][] Visite;
private boolean [] Visited;
Graph(int V){
V++;
this.V=(V);
adj=new LinkedList[V];
Visite=new boolean[100][100];
level=new int[100][100];
lev_dfs=new int[V];
for(int i=0;i<V;i++)
adj[i]=new LinkedList<Integer>();
}
void addEdge(int v,int w){
if(adj[v]==null){
adj[v]=new LinkedList();
}
adj[v].add(w);
}
public long getCount(long max){
long pp=0;
for(int i=1;i<V;i++){
if(!Visited[i]){
long d=dfs(i);
pp+=(d*(d-1)/2)-getEd();
pp+=d*max;
max+=d;
}
}
return pp;
}
public int getEd(){
return degree/2;
}
public void get(int from,int to){
int h=lev_dfs[from]-lev_dfs[to];
if(h<=0){
System.out.println(-1);
}else{
System.out.println(h-1);
}
}
private static boolean check(int x,int y,char c[][]){
if((x>=0 && y>=0) && (x<c.length && y<c[0].length) && c[x][y]!='#'){
return true;
}
return false;
}
public int BFS(int x,int y,int k,char[][] c)
{
LinkedList<Pair> queue = new LinkedList<Pair>();
//Visited[s]=true;
queue.add(new Pair(x,y));
int count=0;
level[x][y]=-1;
c[x][y]='M';
while (!queue.isEmpty())
{
Pair temp = queue.poll();
//x=temp.idx;
//y=temp.val;
c[x][y]='M';
// System.out.println(x+" "+y+" ---"+count);
count++;
if(count==k)
{
for(int i=0;i<c.length;i++){
for(int j=0;j<c[0].length;j++){
if(c[i][j]=='M'){
System.out.print(".");
}
else if(c[i][j]=='.')
System.out.print("X");
else
System.out.print(c[i][j]);
}
System.out.println();
}
System.exit(0);
}
// System.out.println(x+" "+y);
// V--;
}
return V;
}
public long dfs(int startVertex){
Visited=new boolean[V];
if(!Visited[startVertex]) {
dfsUtil(startVertex,Visited);
for(int i=1;i<V;i++){
if(!Visited[i])
{
// System.out.println(i+"--");
return 0;
}
}
}
return 1;
}
private long dfsUtil(int startVertex, boolean[] Visited) {//0-Blue 1-Pink
long c=1;
degree=0;
Visited[startVertex]=true;
lev_dfs[startVertex]=0;
st.push(startVertex);
while(!st.isEmpty()){
int top=st.pop();
Iterator<Integer> i=adj[top].listIterator();
degree+=adj[top].size();
while(i.hasNext()){
// System.out.println(top);
int n=i.next();
if( !Visited[n]){
Visited[n]=true;
st.push(n);
c++;
}
}
}
return c;
}
}
class Dsu{
private int rank[], parent[] ,n;
Dsu(int size){
this.n=size+1;
rank=new int[n];
parent=new int[n];
makeSet();
}
void makeSet(){
for(int i=0;i<n;i++){
parent[i]=i;
}
}
int find(int x){
if(parent[x]!=x){
parent[x]=find(parent[x]);
}
return parent[x];
}
void union(int x,int y){
int xRoot=find(x);
int yRoot=find(y);
if(xRoot==yRoot)
return;
if(rank[xRoot]<rank[yRoot]){
parent[xRoot]=yRoot;
}else if(rank[yRoot]<rank[xRoot]){
parent[yRoot]=xRoot;
}else{
parent[yRoot]=xRoot;
rank[xRoot]++;
}
}
}
class Heap{
public static void build_max_heap(long []a,int size){
for(int i=size/2;i>0;i--){
max_heapify(a, i,size);
}
}
private static void max_heapify(long[] a,int i,int size){
int left_child=2*i;
int right_child=(2*i+1);
int largest=0;
if(left_child<size && a[left_child]>a[i]){
largest=left_child;
}else{
largest=i;
}
if(right_child<size && a[right_child]>a[largest]){
largest=right_child;
}
if(largest!=i){
long temp=a[largest];
a[largest]=a[i];
a[i]=temp;
max_heapify(a, largest,size);
}
}
private static void min_heapify(int[] a,int i){
int left_child=2*i;
int right_child=(2*i+1);
int largest=0;
if(left_child<a.length && a[left_child]<a[i]){
largest=left_child;
}else{
largest=i;
}
if(right_child<a.length && a[right_child]<a[largest]){
largest=right_child;
}
if(largest!=i){
int temp=a[largest];
a[largest]=a[i];
a[i]=temp;
min_heapify(a, largest);
}
}
public static void extract_max(int size,long a[]){
if(a.length>1){
long max=a[1];
a[1]=a[a.length-1];
size--;
max_heapify(a, 1,a.length-1);
}
}
}
class MyComp implements Comparator<Long>{
@Override
public int compare(Long o1, Long o2) {
if(o1<o2){
return 1;
}else if(o1>o2){
return -1;
}
return 0;
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class temp {
static ArrayList<Integer> graph[];
static int n;
static boolean visited[];
public static boolean dfs(int v, int parent, boolean[] visited) {
visited[v] = true;
for (int u : graph[v]) {
if (!visited[u]) {
if(dfs(u, v, visited)){
return true;
}
} else if (u != parent)
return true;
}
return false;
}
public static void dfs(int v){
visited[v] = true;
for (int u : graph[v]){
if(!visited[u]){
dfs(u);
}
}
}
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = sc.nextInt();
int m = sc.nextInt();
graph = new ArrayList[n + 1];
visited = new boolean[n + 1];
for (int i = 1; i <= n; i++) {
graph[i] = new ArrayList<Integer>();
}
for (int i = 0; i < m; i++) {
int x = sc.nextInt();
int y = sc.nextInt();
graph[x].add(y);
graph[y].add(x);
}
boolean flag = false;
for (int i = 1; i <= n && !flag; i++) {
if (!visited[i]) {
flag = dfs(i, -1, visited);
}
}
visited = new boolean [n+1];
if(flag) dfs(1);
for(int i = 1 ; i <n+1 && flag ; i++){
flag = visited[i];
}
out.println((flag && n==m)? "FHTAGN!" : "NO");
out.flush();
out.close();
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if (x.charAt(0) == '-') {
neg = true;
start++;
}
for (int i = start; i < x.length(); i++)
if (x.charAt(i) == '.') {
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
} else {
sb.append(x.charAt(i));
if (dec)
f *= 10;
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg ? -1 : 1);
}
public boolean ready() throws IOException {
return br.ready();
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.ArrayList;
import java.util.Scanner;
public class Main {
static int count=0,n;
public static void DFS(ArrayList<ArrayList<Integer>> A,boolean vis[])
{
for (int i = 1; i < n+1; i++) {
if (!vis[i]) {
DFS(A,i,vis);
count++;
}
}
}
public static void DFS(ArrayList<ArrayList<Integer>> A, int v, boolean vis[]) {
vis[v] = true;
for (int i = 0; i < A.get(v).size(); i++) {
if (vis[A.get(v).get(i)] == false)
DFS(A, A.get(v).get(i), vis);
}
}
public static void main (String args[]) {
Scanner in = new Scanner(System.in);
n = in.nextInt();
int m = in.nextInt();
ArrayList<ArrayList<Integer>> A = new ArrayList<ArrayList<Integer>>();
for (int i = 0; i < n+1; i++) {
A.add(new ArrayList<Integer>());
}
boolean vis[] = new boolean[100000];
for (int i = 0; i < n+1; i++) {
vis[i] = false;
}
for (int k = 0; k < m; k++) {
int x = in.nextInt();
int y = in.nextInt();
A.get(x).add(y);
A.get(y).add(x);
}
DFS(A,vis);
if (count==1&&n==m) {
System.out.println("FHTAGN!");
}
else {
System.out.println("NO");
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long long n, m, x, y;
bitset<105> visit;
vector<long long> v[105];
void dfs(long long x) {
visit[x] = true;
for (int i = 0; i < v[x].size(); i++) {
if (visit[v[x][i]] == false) {
dfs(v[x][i]);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1);
for (int i = 1; i <= n; i++) {
if (visit[i] == false) {
cout << "NO" << '\n';
return 0;
}
}
if (n == m) {
cout << "FHTAGN!" << '\n';
} else {
cout << "NO" << '\n';
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
std::vector<int> adj[100];
bool cycle = false;
bool adding = false;
int color[100];
std::vector<int> cyc;
bool on_cyc[100];
void dfs1(int v, int p) {
if (color[v] == 1) {
cycle = true;
adding = true;
cyc.push_back(v);
return;
}
color[v] = 1;
for (int u : adj[v]) {
if (u == p) continue;
dfs1(u, v);
if (cycle) {
if (adding) {
if (v == cyc[0])
adding = false;
else
cyc.push_back(v);
}
return;
}
}
color[v] = 2;
}
bool visited[100];
int cur_root;
bool dfs2(int v, int p) {
if (visited[v]) return false;
visited[v] = true;
for (int u : adj[v]) {
if (u == p) continue;
if (on_cyc[u] && v == cur_root) continue;
if (!dfs2(u, v)) return false;
}
return true;
}
bool visited2[100];
int cnt(int v, int p) {
if (visited2[v]) return 0;
visited2[v] = true;
int ans = 1;
for (int u : adj[v]) {
if (u == p) continue;
ans += cnt(u, v);
}
return ans;
}
int main() {
int n, m;
std::cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y;
std::cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
if (cnt(0, -1) != n) {
std::cout << "NO\n";
return 0;
}
dfs1(0, -1);
if (cycle) {
for (int v : cyc) on_cyc[v] = true;
bool ok = true;
for (int v : cyc) {
cur_root = v;
if (!dfs2(v, -1)) {
ok = false;
break;
}
}
std::cout << (ok ? "FHTAGN!" : "NO") << '\n';
} else {
std::cout << "NO\n";
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class Cthulhu {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
ArrayList<Integer> list[] = new ArrayList[n + 1];
for (int i = 0; i < list.length; i++)
list[i] = new ArrayList<Integer>();
for (int i = 0; i < m; i++) {
int u = in.nextInt();
int v = in.nextInt();
list[u].add(v);
list[v].add(u);
}
in.close();
boolean ok = m == n;
if (ok) {
int count = 0;
Queue<Integer> q = new LinkedList<Integer>();
q.add(1);
boolean[] visited = new boolean[n + 1];
while (!q.isEmpty()) {
int temp = q.poll();
visited[temp] = true;
for (int x : list[temp])
if (!visited[x])
q.add(x);
}
for (boolean x : visited)
if (x)
count++;
ok = count == n;
}
if (ok)
System.out.println("FHTAGN!");
else
System.out.println("NO");
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import static java.lang.Math.*;
import java.util.*;
import java.io.*;
public class _80_d2_C2 {
boolean[][] g = new boolean[110][110];
boolean[] vis = new boolean[110];
public void solve() throws Exception {
int n = nextInt(), m = nextInt();
for (int i=0; i<m; ++i) {
int a=nextInt(), b=nextInt();
g[a][b]=g[b][a]=true;
}
go(1);
println(total==n && m==n ? "FHTAGN!":"NO");
}
int total = 0;
void go(int x) {
vis[x]=true; total++;
for (int i=1; i<110; ++i) if (g[x][i] && !vis[i]) go(i);
}
////////////////////////////////////////////////////////////////////////////
boolean showDebug = true;
double EPS = 1e-7;
int INF = Integer.MAX_VALUE;
long INFL = Long.MAX_VALUE;
double INFD = Double.MAX_VALUE;
int absPos(int i) {
return i<0 ? 0:i;
}
long absPos(long i) {
return i<0 ? 0:i;
}
double absPos(double i) {
return i<0 ? 0:i;
}
int min(int... nums) {
int r = INF;
for (int i: nums)
if (i<r) r=i;
return r;
}
int max(int... nums) {
int r = -INF;
for (int i: nums)
if (i>r) r=i;
return r;
}
long minL(long... nums) {
long r = INFL;
for (long i: nums)
if (i<r) r=i;
return r;
}
long maxL(long... nums) {
long r = -INFL;
for (long i: nums)
if (i>r) r=i;
return r;
}
double minD(double... nums) {
double r = INFD;
for (double i: nums)
if (i<r) r=i;
return r;
}
double maxD(double... nums) {
double r = -INFD;
for (double i: nums)
if (i>r) r=i;
return r;
}
long sumArr(int[] arr) {
long res = 0;
for (int i: arr)
res+=i;
return res;
}
long sumArr(long[] arr) {
long res = 0;
for (long i: arr)
res+=i;
return res;
}
double sumArr(double[] arr) {
double res = 0;
for (double i: arr)
res+=i;
return res;
}
long partsFitCnt(long partSize, long wholeSize) {
return (partSize+wholeSize-1)/partSize;
}
boolean odd(long i) {
return (i&1)==1;
}
long binpow(int x, int n) {
long r = 1;
while (n>0) {
if ((n&1)!=0) r*=x;
x*=x;
n>>=1;
}
return r;
}
boolean isLetter(char c) {
return (c>='a' && c<='z') || (c>='A' && c<='Z');
}
boolean isLowercase(char c) {
return (c>='a' && c<='z');
}
boolean isUppercase(char c) {
return (c>='A' && c<='Z');
}
boolean isDigit(char c) {
return (c>='0' && c<='9');
}
String stringn(String s, int n) {
if (n<1) return "";
StringBuilder sb = new StringBuilder(s.length()*n);
for (int i=0; i<n; ++i) sb.append(s);
return sb.toString();
}
String str(Object o) {
return o.toString();
}
long timer = System.currentTimeMillis();
void startTimer() {
timer = System.currentTimeMillis();
}
void stopTimer() {
System.err.println("time: "+(System.currentTimeMillis()-timer)/1000.0);
}
class InputReader {
private byte[] buf;
private int bufPos = 0, bufLim = -1;
public InputReader(int size) {
buf = new byte[size];
try {
fillBuf();
} catch (IOException e) {}
}
private void fillBuf() throws IOException {
bufLim = System.in.read(buf);
bufPos = 0;
}
char read() throws IOException {
if (bufPos>=bufLim) fillBuf();
return (char)buf[bufPos++];
}
boolean hasInput() throws IOException {
if (bufPos>=bufLim) fillBuf();
return bufPos<bufLim;
}
}
InputReader in = new InputReader(1<<16);
static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out), 1<<16);
Formatter formatter = new Formatter(out);
char nextChar() throws IOException {
return in.read();
}
char nextNonWhitespaceChar() throws IOException {
char c = in.read();
while (c<=' ') c=in.read();
return c;
}
String nextWord() throws IOException {
StringBuilder sb = new StringBuilder();
char c = in.read();
while (c<=' ') c=in.read();
while (c>' ') {
sb.append(c);
c = in.read();
}
return new String(sb);
}
String nextLine() throws IOException {
StringBuilder sb = new StringBuilder();
char c = in.read();
while (c<=' ') c=in.read();
while (c!='\n' && c!='\r') {
sb.append(c);
c = in.read();
}
return new String(sb);
}
int nextInt() throws IOException {
int r = 0;
char c = nextNonWhitespaceChar();
boolean neg = false;
if (c=='-') neg=true;
else r=c-48;
c = nextChar();
while (c>='0' && c<='9') {
r*=10;
r+=c-48;
c=nextChar();
}
return neg ? -r:r;
}
long nextLong() throws IOException {
long r = 0;
char c = nextNonWhitespaceChar();
boolean neg = false;
if (c=='-') neg=true;
else r = c-48;
c = nextChar();
while (c>='0' && c<='9') {
r*=10L;
r+=c-48L;
c=nextChar();
}
return neg ? -r:r;
}
double nextDouble() throws NumberFormatException, IOException {
return Double.parseDouble(nextWord());
}
int[] nextArr(int size) throws NumberFormatException, IOException {
int[] arr = new int[size];
for (int i=0; i<size; i++)
arr[i] = nextInt();
return arr;
}
long[] nextArrL(int size) throws NumberFormatException, IOException {
long[] arr = new long[size];
for (int i=0; i<size; i++)
arr[i] = nextLong();
return arr;
}
double[] nextArrD(int size) throws NumberFormatException, IOException {
double[] arr = new double[size];
for (int i=0; i<size; i++)
arr[i] = nextDouble();
return arr;
}
String[] nextArrS(int size) throws NumberFormatException, IOException {
String[] arr = new String[size];
for (int i=0; i<size; i++)
arr[i] = nextWord();
return arr;
}
char[] nextArrCh(int size) throws IOException {
char[] arr = new char[size];
for (int i=0; i<size; i++)
arr[i] = nextNonWhitespaceChar();
return arr;
}
char[][] nextArrCh(int rows, int columns) throws IOException {
char[][] arr = new char[rows][columns];
for (int i=0; i<rows; i++)
for (int j=0; j<columns; j++)
arr[i][j] = nextNonWhitespaceChar();
return arr;
}
void printf(String s, Object... o) {
formatter.format(s, o);
}
void print(Object o) throws IOException {
out.write(o.toString());
}
void println(Object o) throws IOException {
out.write(o.toString());
out.newLine();
}
void print(Object... o) throws IOException {
for (int i=0; i<o.length; i++) {
if (i!=0) out.write(' ');
out.write(o[i].toString());
}
}
void println(Object... o) throws IOException {
print(o);
out.newLine();
}
void printn(Object o, int n) throws IOException {
String s = o.toString();
for (int i=0; i<n; i++) {
out.write(s);
if (i!=n-1) out.write(' ');
}
}
void printnln(Object o, int n) throws IOException {
printn(o, n);
out.newLine();
}
void printArr(int[] arr) throws IOException {
for (int i=0; i<arr.length; i++) {
if (i!=0) out.write(' ');
out.write(Integer.toString(arr[i]));
}
}
void printArr(long[] arr) throws IOException {
for (int i=0; i<arr.length; i++) {
if (i!=0) out.write(' ');
out.write(Long.toString(arr[i]));
}
}
void printArr(double[] arr) throws IOException {
for (int i=0; i<arr.length; i++) {
if (i!=0) out.write(' ');
out.write(Double.toString(arr[i]));
}
}
void printArr(String[] arr) throws IOException {
for (int i=0; i<arr.length; i++) {
if (i!=0) out.write(' ');
out.write(arr[i]);
}
}
void printArr(char[] arr) throws IOException {
for (char c: arr) out.write(c);
}
void printlnArr(int[] arr) throws IOException {
printArr(arr);
out.newLine();
}
void printlnArr(long[] arr) throws IOException {
printArr(arr);
out.newLine();
}
void printlnArr(double[] arr) throws IOException {
printArr(arr);
out.newLine();
}
void printlnArr(String[] arr) throws IOException {
printArr(arr);
out.newLine();
}
void printlnArr(char[] arr) throws IOException {
printArr(arr);
out.newLine();
}
void debug(Object... o) {
if (showDebug) System.err.println(Arrays.deepToString(o));
}
public static void main(String[] args) throws Exception {
Locale.setDefault(Locale.US);
new _80_d2_C2().solve();
out.flush(); out.close();
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | from collections import deque
n, m = map(int, raw_input().split(' '))
if n != m:
print 'NO'
else:
# the graph input
link = [None] * (m+1)
for i in range(m):
x, y = map(int, raw_input().split(' '))
if not link[x] is None: link[x].append(y)
else: link[x] = [y]
if not link[y] is None: link[y].append(x)
else: link[y] = [x]
# the bfs
procd = [False] * len(link)
discd = [False] * len(link)
queue = deque([1])
while queue:
cur = queue.popleft()
if not discd[cur]:
discd[cur] = True
if not procd[cur]:
if not link[cur] is None: queue.extend(link[cur])
procd[cur] = True
if False in discd[1:]:
print 'NO'
else:
print 'FHTAGN!'
| PYTHON |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | '''
https://codeforces.com/problemset/problem/104/C
'''
def findSet(u):
if parents[u] != u:
parents[u] = findSet(parents[u])
return parents[u]
def unionSet(u, v):
up, vp = findSet(u), findSet(v)
if up == vp: return
if ranks[up] > ranks[vp]:
parents[vp] = up
elif ranks[up] < ranks[vp]:
parents[up] = vp
else:
parents[up] = vp
ranks[vp] += 1
number_of_vertex, number_of_edges = map(int, raw_input().rstrip().split(" "))
if number_of_edges != number_of_vertex: print "NO"
else:
parents = [i for i in range(number_of_vertex+1)]
ranks = [0] * (number_of_vertex+1)
for i in range(number_of_edges):
u, v = map(int, raw_input().rstrip().split(" "))
unionSet(u, v)
number_of_disconnected_node = 0
for index, element in enumerate(parents):
if index == 0: continue
if index == element: number_of_disconnected_node += 1
print "NO" if number_of_disconnected_node > 1 else "FHTAGN!"
| PYTHON |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | function trim(s) {
return s.replace(/^\s+|\s+$/gm, '');
}
function tokenize(s) {
return trim(s).split(/\s+/);
}
function tokenizeIntegers(s) {
var tokens = tokenize(s);
for (var i = 0; i < tokens.length; i += 1) {
tokens[i] = parseInt(tokens[i], 10);
};
return tokens;
}
function printValues() {
var parts = [];
for (var i = 0; i < arguments.length; i += 2) {
parts.push(arguments[i]+' = '+arguments[i+1]);
}
print(parts.join(', '));
}
function main() {
var data = tokenizeIntegers(readline()),
n = data[0], m = data[1],
v2v = {};
if (n != m) {
print('NO');
return;
}
function augment(u, v) {
if (v2v[u] === undefined) {
v2v[u] = [v];
} else {
v2v[u].push(v);
}
}
for (var i = 0; i < m; ++i) {
data = tokenizeIntegers(readline());
var x = data[0], y = data[1];
augment(x, y);
augment(y, x);
}
var seen = {},
cycle = [],
found = false;
function search(u, parent) {
if (seen[u]) {
cycle.push(u);
return true;
}
seen[u] = true;
count += 1;
var vs = v2v[u];
if (vs === undefined) {
return;
}
for (var i = 0; i < vs.length; ++i) {
var v = vs[i];
if (v == parent) {
continue;
}
if (search(v, u)) {
if (cycle[0] == u) {
found = true;
}
if (!found) {
cycle.push(u);
}
return true;
}
}
return false;
}
search(1, -1);
if (cycle.length < 3) {
print('NO');
return;
}
var count = 0;
seen = {};
function visit(u) {
if (seen[u]) {
return;
}
seen[u] = true;
count += 1;
var vs = v2v[u];
for (var i = 0; i < vs.length; ++i) {
visit(vs[i]);
}
}
visit(cycle[0]);
print(count == n ? 'FHTAGN!' : 'NO');
}
main();
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | //package codeforces;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.Closeable;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
public class A implements Closeable {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
PrintWriter writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
A() throws IOException {
// reader = new BufferedReader(new FileReader("input.txt"));
// writer = new PrintWriter(new FileWriter("output.txt"));
}
StringTokenizer stringTokenizer;
String next() throws IOException {
while (stringTokenizer == null || !stringTokenizer.hasMoreTokens()) {
stringTokenizer = new StringTokenizer(reader.readLine());
}
return stringTokenizer.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(next());
}
long nextLong() throws IOException {
return Long.parseLong(next());
}
private int MOD = 1000 * 1000 * 1000 + 7;
int sum(int a, int b) {
a += b;
return a >= MOD ? a - MOD : a;
}
int product(int a, int b) {
return (int) (1l * a * b % MOD);
}
int pow(int x, int k) {
int result = 1;
while (k > 0) {
if (k % 2 == 1) {
result = product(result, x);
}
x = product(x, x);
k /= 2;
}
return result;
}
int inv(int x) {
return pow(x, MOD - 2);
}
void solve() throws IOException {
final int n = nextInt(), m = nextInt();
if(n != m) {
writer.println("NO");
return;
}
class DSU {
int[] parent = new int[n + 1];
int c = n;
{
for(int i = 1; i <= n; i++) {
parent[i] = i;
}
}
int findParent(int x) {
return x == parent[x] ? x : (parent[x] = findParent(parent[x]));
}
void union(int x, int y) {
x = findParent(x);
y = findParent(y);
if(x != y) {
c--;
parent[x] = y;
}
}
}
DSU dsu = new DSU();
for(int i = 0; i < m; i++) {
dsu.union(nextInt(), nextInt());
}
writer.println(dsu.c == 1 ? "FHTAGN!" : "NO");
}
public static void main(String[] args) throws IOException {
try (A a = new A()) {
a.solve();
}
}
@Override
public void close() throws IOException {
reader.close();
writer.close();
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | def read_input():
global n, m, edge
n, m = map(int, input().split())
edge = []
for i in range(m):
u, v = map(int, input().split())
edge.append((u-1, v-1))
def init():
global lab
lab = [-1] * n
def find_set(u):
global lab
if lab[u] < 0:
return u
lab[u] = find_set(lab[u])
return lab[u]
def union(r,s):
global lab
lab[r] = s
def solve():
global edge, cc
init()
cc = n
for e in edge:
r = find_set(e[0])
s = find_set(e[1])
if r != s:
union(r, s)
cc -= 1
if cc == 1 and m==n:
print("FHTAGN!")
else:
print("NO")
if __name__ == '__main__':
read_input()
solve()
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.awt.*;
import java.io.*;
import java.math.*;
import java.util.*;
import static java.lang.Math.*;
public class BetaRound80_Div1_B implements Runnable {
BufferedReader in;
PrintWriter out;
StringTokenizer tok = new StringTokenizer("");
public static void main(String[] args) {
new Thread(null, new BetaRound80_Div1_B(), "", 256 * (1L << 20)).start();
}
public void run() {
try {
long t1 = System.currentTimeMillis();
if (System.getProperty("ONLINE_JUDGE") != null) {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
} else {
in = new BufferedReader(new FileReader("input.txt"));
out = new PrintWriter("output.txt");
}
Locale.setDefault(Locale.US);
solve();
in.close();
out.close();
long t2 = System.currentTimeMillis();
System.err.println("Time = " + (t2 - t1));
} catch (Throwable t) {
t.printStackTrace(System.err);
System.exit(-1);
}
}
String readString() throws IOException {
while (!tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
int readInt() throws IOException {
return Integer.parseInt(readString());
}
long readLong() throws IOException {
return Long.parseLong(readString());
}
double readDouble() throws IOException {
return Double.parseDouble(readString());
}
/** http://pastebin.com/j0xdUjDn */
static class Utils {
private Utils() {}
public static void mergeSort(int[] a) {
mergeSort(a, 0, a.length - 1);
}
private static final int MAGIC_VALUE = 50;
private static void mergeSort(int[] a, int leftIndex, int rightIndex) {
if (leftIndex < rightIndex) {
if (rightIndex - leftIndex <= MAGIC_VALUE) {
insertionSort(a, leftIndex, rightIndex);
} else {
int middleIndex = (leftIndex + rightIndex) / 2;
mergeSort(a, leftIndex, middleIndex);
mergeSort(a, middleIndex + 1, rightIndex);
merge(a, leftIndex, middleIndex, rightIndex);
}
}
}
private static void merge(int[] a, int leftIndex, int middleIndex, int rightIndex) {
int length1 = middleIndex - leftIndex + 1;
int length2 = rightIndex - middleIndex;
int[] leftArray = new int[length1];
int[] rightArray = new int[length2];
System.arraycopy(a, leftIndex, leftArray, 0, length1);
System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
for (int k = leftIndex, i = 0, j = 0; k <= rightIndex; k++) {
if (i == length1) {
a[k] = rightArray[j++];
} else if (j == length2) {
a[k] = leftArray[i++];
} else {
a[k] = leftArray[i] <= rightArray[j] ? leftArray[i++] : rightArray[j++];
}
}
}
private static void insertionSort(int[] a, int leftIndex, int rightIndex) {
for (int i = leftIndex + 1; i <= rightIndex; i++) {
int current = a[i];
int j = i - 1;
while (j >= leftIndex && a[j] > current) {
a[j + 1] = a[j];
j--;
}
a[j + 1] = current;
}
}
}
// solution
int n;
boolean[][] a;
int[] vis;
int[] p;
void solve() throws IOException {
n = readInt();
int m = readInt();
if (n != m) {
out.println("NO"); // missed it
return;
}
a = new boolean[n][n];
for (int i = 0; i < m; i++) {
int x = readInt() - 1;
int y = readInt() - 1;
a[x][y] = a[y][x] = true;
}
vis = new int[n];
p = new int[n];
//boolean[][] tmp = a.clone(); // OH IT WORKS WRONG
boolean[][] tmp = new boolean[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
tmp[i][j] = a[i][j];
}
}
for (int i = 0; i < n; i++) {
if (vis[i] == 0) dfs(i); // find cycle
}
a = tmp;
if (ca == -1) {
out.println("NO");
return;
}
a[ca][cb] = a[cb][ca] = false; // now it's a tree
Arrays.fill(vis, 0);
if (!dfs2(ca)) { // try to find another cycle
out.println("NO");
return;
}
for (int i = 0; i < n; i++) {
if (vis[i] == 0) {
out.println("NO");
return;
}
}
if (path.size() < 3) {
out.println("NO");
} else {
out.println("FHTAGN!");
}
}
int ca = -1, cb = -1;
ArrayList<Integer> path = new ArrayList<Integer>();
void dfs(int v) {
vis[v] = 1;
for (int i = 0; i < n; i++) {
if (a[v][i]) {
p[i] = v;
if (vis[i] == 1) {
if (ca == -1) {
ca = v;
cb = i;
for (int k = v; k != i; k = p[k]) {
path.add(k);
}
path.add(i);
}
}
if (vis[i] == 0) {
a[i][v] = false;
dfs(i);
}
}
}
vis[v] = 2;
}
boolean dfs2(int v) {
vis[v] = 1;
for (int i = 0; i < n; i++) {
if (a[v][i]) {
if (vis[i] == 1) {
return false;
}
if (vis[i] == 0) {
a[i][v] = false;
if (!dfs2(i)) return false;
}
}
}
vis[v] = 2;
return true;
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | def dfsxx(visited,adj,ind, parent):
if(visited[ind]==1): return
visited[ind]=1
for i in adj[ind]:
if(visited[i]==0):
dfsxx(visited,adj,i,parent)
def dfs(visited,adj,ind,parent):
if(visited[ind]==1): return [-1,-1]
visited[ind]=1
for i in adj[ind]:
if(visited[i]==0):
parent[i]=ind
x=dfs(visited,adj,i,parent)
if(x[0]!=-1): return x
elif(visited[i]==1 and i!=parent[ind]):
return [i,ind]
return [-1,-1]
def dfsx(visited,adj,ind,parent,part,ext):
if(visited[ind]==1): return 0
visited[ind]=1
for i in adj[ind]:
if(part[i]==1 and ind==ext): continue
elif(part[i]==1 and ind!=ext and i!=ext): return 1
if(visited[i]==0):
parent[i]=ind
x=dfsx(visited,adj,i,parent,part,ext)
if(x!=0): return 1
elif(visited[i]==1 and i!=parent[ind]):
return 1
return 0
n,m=[int(i) for i in input().split()]
l=[]
adj=[[] for i in range(n)]
part_cycle=[0 for i in range(n)]
for i in range(m):
a,b=[int(x) for x in input().split()]
adj[a-1].append(b-1)
adj[b-1].append(a-1)
parent=[-1 for i in range(n)]
visited=[0 for i in range(n)]
dfsxx(visited,adj,0,parent)
if(sum(visited)!=n):
print("NO")
else:
parent=[-1 for i in range(n)]
visited=[0 for i in range(n)]
x=dfs(visited,adj,0,parent)
if(x[0]==-1):
print("NO")
else:
part_cycle[x[0]]=1; part_cycle[x[1]]= 1;
cycle=[]
ind=x[1]
cycle.append(x[0])
while(ind!=x[0]):
cycle.append(ind)
part_cycle[ind]=1; part_cycle[parent[ind]]=1;
ind=parent[ind]
flag=0
parent=[-1 for i in range(n)]
visited=[0 for i in range(n)]
for i in cycle:
if(i==0): continue
x=dfsx(visited, adj, i, parent,part_cycle,i)
if(x==1):
print("NO")
flag=1
break
if(flag==0):
print("FHTAGN!") | PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | def dfs(x):
global f, tot, t
#print x
f[x] = True
tot += 1
if tot == n:
return
for i in xrange(n):
if a[x][i]:
if f[i]:
t += 1
if t >= 2:
break
a[x][i] = a[i][x] = False
#print x + 1, i + 1
if not f[i]:
dfs(i)
n, m = map(int, raw_input().split())
f = [False] * n
t = 0
a = [[False] * n for _ in xrange(n)]
for i in xrange(m):
x, y = map(int, raw_input().split())
if a[x - 1][y - 1]:
print "NO"
exit()
a[x - 1][y - 1] = True
a[y - 1][x - 1] = True
tot = 0
dfs(0)
if t == 1 and tot == n:
print "FHTAGN!"
else:
print "NO" | PYTHON |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.*;
import java.io.*;
public class Ktuhlu {
/**
* @param args
*/
class Vertex {
public int num;
public boolean wasVisited = false;
Vertex(int a) {
num = a;
}
}
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
Ktuhlu() {
try {
solve();
} catch(IOException ex) {
}
}
StringTokenizer st = new StringTokenizer("");
private String nextToken() throws IOException{
while (!st.hasMoreElements()) {
st = new StringTokenizer(buf.readLine());
}
return st.nextToken();
}
private int nextInt() throws IOException{
return Integer.parseInt(nextToken());
}
private String nextLine() throws IOException{
return nextToken();
}
int v;
Vertex[] vList;
int[][] mat;
Stack<Integer> stack;
int tree;
public int getV(int ver) {
for (int i = 0; i < v; i++) {
if (mat[ver][i] == 1 && vList[i].wasVisited == false)
return i;
}
return -1;
}
public void display(int i) {
System.out.print(vList[i].num);
}
public void dfs() {
vList[0].wasVisited = true;
stack.push(0);
while (!stack.isEmpty()) {
int current = stack.peek();
int v = getV(current);
if (v == -1) {
stack.pop();
} else {
vList[v].wasVisited = true;
stack.push(v);
tree++;
//display(current);
//display(v);
//System.out.println(" ");
}
}
}
public void addEdges(int a, int b) {
mat[a][b] = 1;
mat[b][a] = 1;
}
String res = "NO";
public Boolean isTrue() {
for (int i = 0; i < v; i++) {
if (vList[i].wasVisited == false) {
return false;
}
}
return true;
}
public void solve() throws IOException{
v = nextInt();
int r = nextInt();
stack = new Stack<Integer>();
vList = new Vertex[v];
mat = new int[v][v];
for (int i = 0; i < v; i++) {
vList[i] = new Vertex(i);
}
for (int i = 0; i < v; i++) {
for (int j = 0; j < v; j++) {
mat[i][j] = 0;
}
}
for (int i = 0; i < r; i++) {
int a = nextInt();
int b = nextInt();
addEdges(a - 1, b - 1);
}
if (v == r) {
dfs();
//System.out.println(tree);
if ((tree >= 2) && (isTrue()))
res = "FHTAGN!";
}
System.out.println(res);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
new Ktuhlu();
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int visited[101];
int p[101];
int flag;
int totalVisited(0);
void SCC(int parent, vector<vector<int> > &adjList) {
visited[parent] = 1;
totalVisited++;
for (int i = 0; i < (int)adjList[parent].size(); i++) {
int child = adjList[parent][i];
if (!visited[child]) {
p[child] = parent;
SCC(child, adjList);
} else if (visited[child] && (child != p[parent])) {
flag = 1;
}
}
}
int main() {
int n, m;
cin >> n >> m;
if (n != m) {
cout << "NO" << endl;
return 0;
}
memset(visited, 0, sizeof(visited));
memset(p, 0, sizeof(p));
vector<vector<int> > adjList(n + 1);
for (int i = 0; i < m; i++) {
int node1, node2;
cin >> node1 >> node2;
adjList[node1].push_back(node2);
adjList[node2].push_back(node1);
}
SCC(1, adjList);
if (totalVisited < n)
cout << "NO" << endl;
else if (flag)
cout << "FHTAGN!" << endl;
else
cout << "NO" << endl;
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int N = 10000;
vector<int> graph[N];
vector<int> cycles[N];
void dfs_cycle(int u, int p, int color[], int mark[], int par[],
int& cyclenumber) {
if (color[u] == 2) {
return;
}
if (color[u] == 1) {
cyclenumber++;
int cur = p;
mark[cur] = cyclenumber;
while (cur != u) {
cur = par[cur];
mark[cur] = cyclenumber;
}
return;
}
par[u] = p;
color[u] = 1;
for (int v : graph[u]) {
if (v == par[u]) {
continue;
}
dfs_cycle(v, u, color, mark, par, cyclenumber);
}
color[u] = 2;
}
void addEdge(int u, int v) {
graph[u].push_back(v);
graph[v].push_back(u);
}
void printCycles(int edges, int mark[], int& cyclenumber) {
for (int i = 1; i <= edges; i++) {
if (mark[i] != 0) cycles[mark[i]].push_back(i);
}
for (int i = 1; i <= cyclenumber; i++) {
cout << "Cycle Number " << i << ": ";
for (int x : cycles[i]) cout << x << " ";
cout << endl;
}
}
int main() {
int n, m;
cin >> n >> m;
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
addEdge(a, b);
}
int color[N];
int par[N];
for (int i = 0; i < N; i++) {
par[i] = -1;
}
int mark[N];
int cyclenumber = 0;
int edges = 13;
dfs_cycle(1, 0, color, mark, par, cyclenumber);
bool f = true;
for (int i = 1; i <= n; i++) {
if (par[i] == -1) {
f = false;
;
}
}
if (cyclenumber == 1 && f) {
cout << "FHTAGN!" << endl;
} else {
cout << "NO" << endl;
}
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #!/usr/bin/env python
N, M = map(int, raw_input().split())
if N != M:
print "NO"
exit
else:
V = [[0] * N for i in xrange(N)]
for i in xrange(M):
u, v = map(int, raw_input().split())
V[u-1][v-1] = V[v-1][u-1] = 1
cnt = 0
H = [False] * N
def dfs(v):
if H[v]: return
H[v] = True
global cnt
cnt += 1
for i in xrange(N):
if V[v][i] > 0:
dfs(i)
dfs(0)
if cnt != N:
print "NO"
else:
print "FHTAGN!" | PYTHON |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | def cycle(f):
v = f
cyc[v] = True
v = p[v]
while v != f:
cyc[v] = True
v = p[v]
def dfs(v, par):
global c, p
if c[v] == 2:
return
p[v] = par
if c[v] == 1:
cycle(v)
return True
c[v] = 1
for u in graph[v]:
if u != par:
if dfs(u, v):
return True
c[v] = 2
return False
def dfs1(v):
if used[v]:
return
used[v] = True
for u in graph[v]:
dfs1(u)
n, m = map(int, input().split())
graph = [[] for i in range(n)]
p = [-1] * n
c = [0] * n
cyc = [False] * n
if m != n:
print('NO')
exit(0)
for i in range(m):
a, b = map(int, input().split())
a, b = a - 1, b - 1
graph[a].append(b)
graph[b].append(a)
dfs(0, -1)
used = [False] * n
cnt = 0
for i in range(n):
if cyc[i]:
cnt += 1
dfs1(0)
for i in range(n):
if not used[i]:
print('NO')
exit(0)
if cnt >= 3:
print('FHTAGN!')
else:
print('NO') | PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const long long MAXN = 1e2 + 5;
const double eps = 1e-8;
vector<int> vec[MAXN];
int maze[MAXN][MAXN] = {0};
int vis[MAXN] = {0};
int evis[MAXN][MAXN] = {0};
int ok;
int ringpos = -1;
int dfs(int x) {
vis[x] = 1;
for (int i = 0; i < vec[x].size(); i++) {
int j = vec[x][i];
if (evis[x][j]) continue;
evis[x][j] = evis[j][x] = 1;
if (vis[j] == 0) {
if (dfs(j) == 0) return 0;
} else {
if (ok == -1) {
ok = 1;
ringpos = x;
} else {
ok = 0;
return 0;
}
}
}
return 1;
}
void dfs2(int x, int cur) {
if (x == ringpos && cur != 0) {
if (cur <= 2) ok = 0;
return;
}
for (int i = 0; i < vec[x].size(); i++) {
int j = vec[x][i];
if (evis[x][j]) continue;
evis[x][j] = evis[j][x] = 1;
if (ok == 1) dfs2(j, cur + 1);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i <= n; i++) vec[i].clear();
ok = -1;
memset(evis, 0, sizeof(evis));
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
vec[a].push_back(b);
vec[b].push_back(a);
if (maze[a][b] != 0 || a == b) ok = 0;
maze[a][b] = maze[b][a] = 1;
}
if (ok != 0) {
if (dfs(1) == 0 || ok == -1) ok = 0;
if (ok == 1)
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
ok = 0;
break;
}
}
memset(evis, 0, sizeof(evis));
if (ok == 1) dfs2(ringpos, 0);
}
printf("%s\n", ok ? "FHTAGN!" : "NO");
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.Random;
public class B103 {
static StreamTokenizer sc;
static int[]p;
public static void main(String[] args) throws IOException{
sc = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
int n = nextInt();
int m = nextInt();
if (n != m) {
System.out.println("NO");
return;
}
p = new int[n+1];
for (int i = 1; i <= n; i++) {
make_set(i);
}
Random rm = new Random();
int a,b,x,y;
int cnt = 0;
for (int i = 1; i <= m; i++) {
a = nextInt();
b = nextInt();
x = find_set(a);
y = find_set(b);
if (x != y) {
if (rm.nextInt() % 2==1)
p[x] = y;
else
p[y] = x;
}
else {
cnt++;
}
}
if (cnt==1)
System.out.println("FHTAGN!");
else
System.out.println("NO");
}
private static int find_set(int x) {
if (x==p[x])
return x;
p[x] = find_set(p[x]);
return p[x];
}
private static void make_set(int x) {
p[x] = x;
}
private static int nextInt() throws IOException{
sc.nextToken();
return (int) sc.nval;
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.awt.*;
import java.io.*;
import java.math.*;
import java.util.*;
import static java.lang.Math.*;
public class _BetaRound80_Div1_B implements Runnable {
BufferedReader in;
PrintWriter out;
StringTokenizer tok = new StringTokenizer("");
public static void main(String[] args) {
new Thread(null, new _BetaRound80_Div1_B(), "", 256 * (1L << 20)).start();
}
public void run() {
try {
long t1 = System.currentTimeMillis();
if (System.getProperty("ONLINE_JUDGE") != null) {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
} else {
in = new BufferedReader(new FileReader("input.txt"));
out = new PrintWriter("output.txt");
}
Locale.setDefault(Locale.US);
solve();
in.close();
out.close();
long t2 = System.currentTimeMillis();
System.err.println("Time = " + (t2 - t1));
} catch (Throwable t) {
t.printStackTrace(System.err);
System.exit(-1);
}
}
String readString() throws IOException {
while (!tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
int readInt() throws IOException {
return Integer.parseInt(readString());
}
long readLong() throws IOException {
return Long.parseLong(readString());
}
double readDouble() throws IOException {
return Double.parseDouble(readString());
}
/** http://pastebin.com/j0xdUjDn */
static class Utils {
private Utils() {}
public static void mergeSort(int[] a) {
mergeSort(a, 0, a.length - 1);
}
private static final int MAGIC_VALUE = 50;
private static void mergeSort(int[] a, int leftIndex, int rightIndex) {
if (leftIndex < rightIndex) {
if (rightIndex - leftIndex <= MAGIC_VALUE) {
insertionSort(a, leftIndex, rightIndex);
} else {
int middleIndex = (leftIndex + rightIndex) / 2;
mergeSort(a, leftIndex, middleIndex);
mergeSort(a, middleIndex + 1, rightIndex);
merge(a, leftIndex, middleIndex, rightIndex);
}
}
}
private static void merge(int[] a, int leftIndex, int middleIndex, int rightIndex) {
int length1 = middleIndex - leftIndex + 1;
int length2 = rightIndex - middleIndex;
int[] leftArray = new int[length1];
int[] rightArray = new int[length2];
System.arraycopy(a, leftIndex, leftArray, 0, length1);
System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
for (int k = leftIndex, i = 0, j = 0; k <= rightIndex; k++) {
if (i == length1) {
a[k] = rightArray[j++];
} else if (j == length2) {
a[k] = leftArray[i++];
} else {
a[k] = leftArray[i] <= rightArray[j] ? leftArray[i++] : rightArray[j++];
}
}
}
private static void insertionSort(int[] a, int leftIndex, int rightIndex) {
for (int i = leftIndex + 1; i <= rightIndex; i++) {
int current = a[i];
int j = i - 1;
while (j >= leftIndex && a[j] > current) {
a[j + 1] = a[j];
j--;
}
a[j + 1] = current;
}
}
}
// solution
int n;
boolean[][] a;
int[] vis;
int[] p;
void solve() throws IOException {
n = readInt();
int m = readInt();
a = new boolean[n][n];
for (int i = 0; i < m; i++) {
int x = readInt() - 1;
int y = readInt() - 1;
a[x][y] = a[y][x] = true;
}
vis = new int[n];
p = new int[n];
//boolean[][] tmp = a.clone(); OH IT WORKS WRONG
boolean[][] tmp = new boolean[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
tmp[i][j] = a[i][j];
}
}
for (int i = 0; i < n; i++) {
if (vis[i] == 0) dfs(i);
}
a = tmp;
if (ca == -1) {
out.println("NO");
return;
}
a[ca][cb] = a[cb][ca] = false;
Arrays.fill(vis, 0);
if (!dfs2(ca)) {
out.println("NO");
return;
}
for (int i = 0; i < n; i++) {
if (vis[i] == 0) {
out.println("NO");
return;
}
}
if (path.size() < 3) {
out.println("NO");
} else {
out.println("FHTAGN!");
}
}
int ca = -1, cb = -1;
ArrayList<Integer> path = new ArrayList<Integer>();
void dfs(int v) {
vis[v] = 1;
for (int i = 0; i < n; i++) {
if (a[v][i]) {
p[i] = v;
if (vis[i] == 1) {
if (ca == -1) {
ca = v;
cb = i;
for (int k = v; k != i; k = p[k]) {
path.add(k);
}
path.add(i);
}
}
if (vis[i] == 0) {
a[i][v] = false;
dfs(i);
}
}
}
vis[v] = 2;
}
boolean dfs2(int v) {
vis[v] = 1;
for (int i = 0; i < n; i++) {
if (a[v][i]) {
if (vis[i] == 1) {
return false;
}
if (vis[i] == 0) {
a[i][v] = false;
if (!dfs2(i)) return false;
}
}
}
vis[v] = 2;
return true;
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 50;
int n, m, u, v, cnt, cycle;
vector<int> l[N];
unordered_map<int, bool> visited;
void dfs(int u) {
if (visited[u]) {
return;
}
cnt++;
visited[u] = true;
for (auto i : l[u]) {
if (!visited[i]) {
dfs(i);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> m;
if (n != m) {
cout << "NO";
return 0;
}
for (int i = 1; i <= m; i++) {
cin >> u >> v;
l[u].push_back(v);
l[v].push_back(u);
}
dfs(1);
if (cnt != n) {
cout << "NO";
} else {
cout << "FHTAGN!";
}
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class A {
static boolean[][] adjMat;
static int N, count;
static boolean[] visited;
static void dfs(int u)
{
count++;
visited[u] = true;
for(int i = 0; i < N; ++i)
if(adjMat[u][i] && !visited[i])
dfs(i);
}
public static void main(String[] args) throws IOException
{
Scanner sc = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
N = sc.nextInt(); int m = sc.nextInt();
if(m != N)
out.println("NO");
else
{
adjMat = new boolean[N][N];
visited = new boolean[N];
while(m-->0)
{
int u = sc.nextInt() - 1, v = sc.nextInt() - 1;
adjMat[u][v] = adjMat[v][u] = true;
}
dfs(0);
if(count == N)
out.println("FHTAGN!");
else
out.println("NO");
}
out.flush();
out.close();
}
static class Scanner
{
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s){ br = new BufferedReader(new InputStreamReader(s));}
public Scanner(FileReader r){ br = new BufferedReader(r);}
public String next() throws IOException
{
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {return Integer.parseInt(next());}
public long nextLong() throws IOException {return Long.parseLong(next());}
public String nextLine() throws IOException {return br.readLine();}
public boolean ready() throws IOException {return br.ready();}
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | n, m = map(int, input().split())
if n < 3 or n != m: # minimo 3 vertices para un circulo
print("NO")
else:
V = []
S = []
for i in range(n+1): #Armado de lista para conexiones de vertices
V.append([])
for j in range(m):
x, y = map(int, input().split())
V[x].append(y) #conexion de x con y
V[y].append(x) #conexion de y con x
def DFS(a):
S.append(a)
for v in V[a]:
if not v in S:
DFS(v)
DFS(1) #hay que comenzar en algun punto
if len(S) == n:
print("FHTAGN!")
else:
print("NO")
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
const int N = 100 + 10;
int fa[N];
int find(int x) {
if (fa[x] != x) fa[x] = find(fa[x]);
return fa[x];
}
void Union(int x, int y) {
x = find(x);
y = find(y);
fa[x] = y;
}
int main() {
int n, m, x, y;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &x, &y);
Union(x, y);
}
if (n != m) {
puts("NO");
} else {
bool f = true;
for (int i = 2; i <= n; ++i)
if (find(1) != find(i)) {
f = false;
break;
}
if (f)
puts("FHTAGN!");
else
puts("NO");
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
def makeSet(n):
global parent, ranks
parent = [i for i in range (n + 1)]
ranks = [0 for i in range(n + 1)]
def findSet(u):
if u != parent[u]:
parent[u] = findSet(parent[u])
return parent[u]
# 4
# |
# 3
# / \
# 1 - 2 - 5 - 6
# N == M
# 1 group
def unionSet(u, v):
up = findSet(u)
vp = findSet(v)
if up == vp:
return
if ranks[up] > ranks[vp]:
parent[vp] = up
elif ranks[up] < ranks[vp]:
parent[up] = vp
else:
parent[up] = vp
ranks[vp] += 1
n, m = map(int, input().split())
if n != m:
print('NO')
else:
makeSet(n)
for i in range(m):
u, v = map(int, input().split())
unionSet(u, v)
no_group = 0
for i in range(1, n + 1):
if parent[i] == i:
no_group += 1
print("FHTAGN!" if no_group == 1 else "NO")
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int N = (int)(1e2) + 1;
vector<int> g[N];
int vis[N];
void dfs(int s) {
vis[s] = 1;
for (int i : g[s]) {
if (!vis[i]) dfs(i);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
if (n < 3 || m != n) {
cout << "NO";
return 0;
}
int cc = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cc++;
dfs(i);
}
}
cout << ((cc == 1) ? "FHTAGN!" : "NO");
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.*;
import java.util.*;
public class Ktulhu implements Runnable {
public static void main(String[] args) {
new Thread(new Ktulhu()).run();
}
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer in;
PrintWriter out = new PrintWriter(System.out);
public String nextToken() throws IOException {
while (in == null || !in.hasMoreTokens()) {
in = new StringTokenizer(br.readLine());
}
return in.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
public double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
boolean[][] a;
int[] count;
boolean[] was;
int[] p;
ArrayList<Integer> cicle = new ArrayList<Integer>();
public void color(int v) {
int n = p.length;
if (was[v])
return;
was[v] = true;
for (int i = 0; i < n; i++) {
if (a[v][i])
color(i);
}
}
int cc = -1;
public boolean go(int v, int pp) {
int n = p.length;
if (was[v]) {
if (p[v] != -1 && p[p[v]] != v) {
cc = v;
return true;
}
return false;
}
p[v] = pp;
was[v] = true;
for (int i = 0; i < n; i++) {
if (a[v][i]) {
if (go(i, v)) {
cicle.add(v);
if (v == cc) {
return false;
}
return true;
}
}
}
return false;
}
public void solve() throws IOException {
int n = nextInt();
int m = nextInt();
if (m != n) {
out.println("NO");
return;
}
a = new boolean[n][n];
count = new int[n];
for (int i = 0; i < m; i++) {
int x = nextInt() - 1;
int y = nextInt() - 1;
a[x][y] = true;
a[y][x] = true;
count[x]++;
count[y]++;
}
was = new boolean[n];
p = new int[n];
color(0);
for (int i = 0; i < n; i++) {
if (!was[i]) {
out.println("NO");
return;
}
}
// was = new boolean[n];
//
// go(0, -1);
// int c = 0;
// for (int v : cicle) {
// if (count[v] >= 3){
// c++;
// }
// }
// if (c >= 3) {
out.println("FHTAGN!");
// } else {
// out.println("NO");
// }
}
public void run() {
try {
solve();
out.close();
} catch (IOException e) {
e.printStackTrace();
System.exit(1);
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | from collections import defaultdict
import sys
n, m = [int(num) for num in sys.stdin.readline().split(' ')]
edges = []
for i in range(m):
edges.append([int(num) for num in sys.stdin.readline().split(' ')])
graph = defaultdict(list)
for e in edges:
graph[e[0]].append(e[1])
graph[e[1]].append(e[0])
visited = set()
processed = set()
parent = [-1 for i in range(n + 1)]
cycles = []
def dfs(graph, start):
visited.add(start)
for child in graph[start]:
if child not in processed:
process_edge(start, child)
if child not in visited:
parent[child] = start
dfs(graph, child)
processed.add(start)
def process_edge(v, u):
if u in visited and parent[v] != u:
# back edge
cycle = [u, v]
while parent[v] != u:
v = parent[v]
cycle.append(v)
cycles.append(cycle)
dfs(graph, 1)
if len(cycles) != 1 or len(processed) < n:
print 'NO'
else:
cycle = cycles[0]
cycles = []
for v in cycle:
visited = set(cycle) - set([v])
processed = set(cycle) - set([v])
dfs(graph, v)
if len(cycles) > 0:
print 'NO'
break
else:
print 'FHTAGN!'
| PYTHON |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.ArrayList;
import java.util.Scanner;
public class B103
{
private static ArrayList<Integer> arr;
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();// vertices
int m = sc.nextInt();// edges
int[][] graph = new int[n][n];
for ( int i = 0; i < m; i++ )
{
int x = sc.nextInt() - 1;
int y = sc.nextInt() - 1;
graph[x][y] = 1;
graph[y][x] = 1;
}
arr = new ArrayList<Integer>();
arr.add(0);
dfs(graph, 0, arr);
if(n==m && n>= 3 && arr.size() == n)
{
System.out.println("FHTAGN!");
}
else
{
System.out.println("NO");
}
}
private static void dfs(int[][] graph, int i, ArrayList<Integer> arr)
{
for ( int j = 0; j < graph[i].length; j++ )
{
if ( graph[i][j] == 1 )
{
if ( !arr.contains(j) )
{
arr.add(j);
dfs(graph, j, arr);
}
}
}
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const double eps = 1e-8;
const double pi = acos(-1.0);
bool g[110][110];
int n, m;
bool vis[110];
int flag;
bool dfs(int u, int f) {
vis[u] = 1;
for (int i = 1; i <= n; i++)
if (i != f && g[u][i]) {
if (vis[i]) {
if (flag == 2) return false;
flag++;
} else {
if (!dfs(i, u)) return false;
}
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a][b] = g[b][a] = 1;
}
if (dfs(1, 1)) {
for (int i = 1; i <= n; i++)
if (!vis[i]) {
flag = 0;
break;
}
puts(flag ? "FHTAGN!" : "NO");
} else
puts("NO");
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
struct VectorHash {
size_t operator()(const std::vector<int> &v) const {
std::hash<int> hasher;
size_t seed = 0;
for (int i : v) {
seed ^= hasher(i) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
return seed;
}
};
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
vector<long long int> adj[101];
bool visited[101];
void dfs(long long int node) {
visited[node] = 1;
for (auto i : adj[node]) {
if (!visited[i]) dfs(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m, u, v;
cin >> n >> m;
long long int c = 0;
for (int i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
c++;
dfs(i);
}
}
if (c == 1 and n == m)
cout << "FHTAGN!" << '\n';
else
cout << "NO" << '\n';
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
void dfs(int curVertex, int const& n, int& cnt, bool const* const* const graph,
bool* const vis) {
vis[curVertex] = true;
cnt++;
for (int i = 0; i < n; i++) {
if (graph[curVertex][i] && !vis[i]) {
dfs(i, n, cnt, graph, vis);
}
}
}
int main() {
size_t n = 0;
size_t m = 0;
size_t x = 0;
size_t y = 0;
int cnt = 0;
bool* data = 0;
bool** graph = 0;
bool* vis = 0;
std::cin >> n >> m;
if (m != n) {
std::cout << "NO";
return 0;
}
data = new bool[m * m];
graph = new bool*[m];
vis = new bool[m];
for (int i = 0; i < m; i++) {
graph[i] = &data[i * m];
vis[i] = false;
for (int j = 0; j < m; j++) {
}
}
std::fill_n(vis, m, false);
std::fill_n(data, m * m, false);
for (int i = 0; i < m; i++) {
std::cin >> x >> y;
graph[x - 1][y - 1] = true;
graph[y - 1][x - 1] = true;
}
dfs(0, n, cnt, graph, vis);
if (cnt != n) {
std::cout << "NO";
} else {
std::cout << "FHTAGN!";
}
delete[] vis;
delete[] data;
delete[] graph;
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<int> parent;
vector<int> sz;
int isles(0);
void make_set(int u) {
parent[u] = u;
sz[u] = 1;
}
int find_set(int u) {
if (parent[u] == u) {
return u;
}
return parent[u] = find_set(parent[u]);
}
void union_set(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a == b) {
return;
}
--isles;
if (sz[a] < sz[b]) swap(a, b);
parent[b] = a;
sz[a] += sz[b];
}
int main() {
int n, m;
cin >> n >> m;
isles = n;
parent.resize(n);
sz.resize(n);
int ori, des;
for (int i(0); i < n; i++) {
make_set(i);
}
for (int i(0); i < m; i++) {
cin >> ori >> des;
union_set(ori - 1, des - 1);
}
if (isles > 1 or n != m) {
cout << "NO\n";
} else
cout << "FHTAGN!\n";
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
struct Edge {
int u, v, next;
} edge[100000];
int head[105], num[105];
bool visited[105];
int en, cnt, tt;
void add_edge(int u, int v) {
edge[en].u = u;
edge[en].v = v;
edge[en].next = head[u];
head[u] = en++;
}
void DFS1(int u) {
int v;
visited[u] = true;
for (int id = head[u]; id != -1; id = edge[id].next) {
v = edge[id].v;
if (!visited[v]) DFS1(v);
}
}
void DFS2(int u, int p) {
int v;
num[u] = tt++;
visited[u] = true;
for (int id = head[u]; id != -1; id = edge[id].next) {
v = edge[id].v;
if (v == p) continue;
if (!visited[v])
DFS2(v, u);
else if (num[v] < num[u])
cnt++;
}
}
int main() {
int n, m, u, v;
en = 0;
memset(head, 0xff, sizeof head);
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
memset(visited, false, sizeof visited);
DFS1(1);
cnt = 0;
for (int i = 1; i <= n; i++)
if (!visited[i]) cnt++;
if (cnt)
puts("NO");
else {
memset(visited, false, sizeof visited);
cnt = tt = 0;
DFS2(1, -1);
if (cnt == 1)
puts("FHTAGN!");
else
puts("NO");
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.*;
import java.util.*;
public class C implements Runnable {
public void solve( ) throws Throwable {
int v = in.nextInt( );
boolean g[ ][ ] = new boolean[ v ][ v ];
int edges = in.nextInt( );
for ( int i = 0; i < edges; ++i ) {
int a = in.nextInt( ) - 1;
int b = in.nextInt( ) - 1;
g[ a ][ b ] = g[ b ][ a ] = true;
}
if ( v != edges ) {
out.println( "NO" );
return;
}
for ( int k = 0; k < v; ++k ) {
for ( int i = 0; i < v; ++i ) {
for ( int j = 0; j < v; ++j ) {
if ( g[ i ][ k ] && g[ k ][ j ] ) {
g[ i ][ j ] = true;
}
}
}
}
for ( int i = 0; i < v; ++i ) {
if ( !g[ 0 ][ i ] ) {
out.println( "NO" );
return;
}
}
out.println( "FHTAGN!" );
}
public void run( ) {
in = new FastScanner( System.in );
out = new PrintWriter( new PrintStream( System.out ), true );
try {
solve( );
out.close( );
System.exit( 0 );
} catch( Throwable e ) {
e.printStackTrace( );
}
}
public void debug( Object...os ) {
System.err.println( Arrays.deepToString( os ) );
}
public static void main( String[ ] args ) {
new Thread( new C( ) ).start( );
}
private FastScanner in;
private PrintWriter out;
private static class FastScanner {
private int charsRead;
private int currentRead;
private byte buffer[ ] = new byte[ 0x1000 ];
private InputStream reader;
public FastScanner( InputStream in ) {
reader = in;
}
public int read( ) {
if ( currentRead == -1 ) {
throw new InputMismatchException( );
}
if ( currentRead >= charsRead ) {
currentRead = 0;
try {
charsRead = reader.read( buffer );
} catch( IOException e ) {
throw new InputMismatchException( );
}
if ( charsRead <= 0 ) {
return -1;
}
}
return buffer[ currentRead++ ];
}
public int nextInt( ) {
int c = read( );
while ( isWhitespace( c ) ) {
c = read( );
}
if ( c == -1 ) {
throw new NullPointerException( );
}
if ( c != '-' && !( c >= '0' && c <= '9' ) ) {
throw new InputMismatchException( );
}
int sign = c == '-' ? -1 : 1;
if ( sign == -1 ) {
c = read( );
}
if ( c == -1 || !( c >= '0' && c <= '9' ) ) {
throw new InputMismatchException( );
}
int ans = 0;
while ( !isWhitespace( c ) && c != -1 ) {
if ( !( c >= '0' && c <= '9' ) ) {
throw new InputMismatchException( );
}
int num = c - '0';
ans = ans * 10 + num;
c = read( );
}
return ans * sign;
}
public long nextLong( ) {
int c = read( );
while ( isWhitespace( c ) ) {
c = read( );
}
if ( c == -1 ) {
throw new NullPointerException( );
}
if ( c != '-' && !( c >= '0' && c <= '9' ) ) {
throw new InputMismatchException( );
}
int sign = c == '-' ? -1 : 1;
if ( sign == -1 ) {
c = read( );
}
if ( c == -1 || !( c >= '0' && c <= '9' ) ) {
throw new InputMismatchException( );
}
long ans = 0;
while ( !isWhitespace( c ) && c != -1 ) {
if ( !( c >= '0' && c <= '9' ) ) {
throw new InputMismatchException( );
}
int num = c - '0';
ans = ans * 10 + num;
c = read( );
}
return ans * sign;
}
public boolean isWhitespace( int c ) {
return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == -1;
}
public String next( ) {
int c = read( );
StringBuffer ans = new StringBuffer( );
while ( isWhitespace( c ) && c != -1 ) {
c = read( );
}
if ( c == -1 ) {
return null;
}
while ( !isWhitespace( c ) && c != -1 ) {
ans.appendCodePoint( c );
c = read( );
}
return ans.toString( );
}
public String nextLine( ) {
String ans = nextLine0( );
while ( ans.trim( ).length( ) == 0 ) {
ans = nextLine0( );
}
return ans;
}
private String nextLine0( ) {
int c = read( );
if ( c == -1 ) {
return null;
}
StringBuffer ans = new StringBuffer( );
while ( c != '\n' && c != '\r' && c != -1 ) {
ans.appendCodePoint( c );
c = read( );
}
return ans.toString( );
}
public double nextDouble( ) {
int c = read( );
while ( isWhitespace( c ) ) {
c = read( );
}
if ( c == -1 ) {
throw new NullPointerException( );
}
if ( c != '.' && c != '-' && !( c >= '0' && c <= '9' ) ) {
throw new InputMismatchException( );
}
int sign = c == '-' ? -1 : 1;
double ans = 0;
while ( c != -1 && c != '.' && !isWhitespace( c ) ) {
if ( !( c >= '0' && c <= '9' ) ) {
throw new InputMismatchException( );
}
int num = c - '0';
ans = ans * 10.0 + num;
c = read( );
}
if ( !isWhitespace( c ) && c != -1 && c != '.' ) {
throw new InputMismatchException( );
}
double pow10 = 1.0;
if ( c == '.' ) {
c = read( );
}
while ( !isWhitespace( c ) && c != -1 ) {
pow10 *= 10.0;
if ( !( c >= '0' && c <= '9' ) ) {
throw new InputMismatchException( );
}
int num = c - '0';
ans = ans * 10.0 + num;
c = read( );
}
return ans * sign / pow10;
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
template <typename T>
T pow(T a, T b, long long int m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
template <typename T>
void swap(T *a, T *b) {
T temp = *a;
*a = *b;
*b = temp;
return;
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
unordered_map<long long, long long int, custom_hash> safe_map;
const long long int N = 1e2 + 2;
std::vector<long long int> v[N];
std::vector<bool> visit(N, 0);
void dfs(long long int node) {
if (visit[node]) return;
visit[node] = true;
for (auto i : v[node]) {
dfs(i);
}
return;
}
signed main() {
long long int n, m;
cin >> n >> m;
long long int NoOfCycles = 0;
for (__typeof(m) i = (0) - ((0) > (m)); i != (m) - ((0) > (m));
i += 1 - 2 * ((0) > (m))) {
long long int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (__typeof(n + 1) i = (1) - ((1) > (n + 1));
i != (n + 1) - ((1) > (n + 1)); i += 1 - 2 * ((1) > (n + 1))) {
if (!visit[i]) {
dfs(i);
NoOfCycles++;
}
}
if (NoOfCycles == 1 and n == m) {
cout << "FHTAGN!";
} else {
cout << "NO";
}
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<int> q[208];
bool used[208];
int p[208];
int find(int x) {
if (p[x] == x) return x;
return p[x] = find(p[x]);
}
int main(void) {
bool flag = 0;
int n, m, i, j, x, y;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) p[i] = i;
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
int t1 = find(x), t2 = find(y);
if (t1 != t2) p[t1] = t2;
}
for (i = 1; i <= n; i++)
if (find(p[i]) != find(p[1])) {
flag = 1;
break;
}
if (m == n && flag == 0)
printf("FHTAGN!\n");
else
printf("NO\n");
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Stack;
public class Prob103B
{
public static void main( String[] Args )
{
Scanner scan = new Scanner( System.in );
int v = scan.nextInt(), e = scan.nextInt();
if ( v != e )
System.out.println( "NO" );
else
{
ArrayList<Integer>[] connections = new ArrayList[v];
ArrayList<Integer> ring = new ArrayList<Integer>();
boolean[] visited = new boolean[v];
int[] parent = new int[v];
Arrays.fill( parent, -1 );
int[] numConnections = new int[v];
Arrays.fill( numConnections, -1 );
for ( int x = 0; x < v; x++ )
connections[x] = new ArrayList<Integer>();
for ( int x = 0; x < v; x++ )
{
int a = scan.nextInt() - 1;
int b = scan.nextInt() - 1;
connections[a].add( b );
connections[b].add( a );
}
Stack<Integer> recursion = new Stack<Integer>();
recursion.add( 0 );
int lastOne = 0;
all: while ( !recursion.empty() )
{
int i = recursion.pop();
visited[i] = true;
for ( int x = 0; x < connections[i].size(); x++ )
if ( connections[i].get( x ) != parent[i] )
if ( !visited[connections[i].get( x )] )
{
recursion.push( connections[i].get( x ) );
parent[connections[i].get( x )] = i;
}
else
{
ring.add( i );
numConnections[i] = 0;
lastOne = connections[i].get( x );
break all;
}
}
Arrays.fill( visited, false );
if ( ring.size() == 0 )
System.out.println( "NO" );
else
{
visited[ring.get( ring.size() - 1 )] = true;
while ( ring.get( ring.size() - 1 ) != lastOne )
{
int temp = parent[ring.get( ring.size() - 1 )];
ring.add( temp );
visited[temp] = true;
}
boolean satisfies = true;
visited = new boolean[v];
all: for ( int a = 0; a < ring.size(); a++ )
{
recursion = new Stack<Integer>();
int b = ring.get( a );
visited[b] = true;
for ( int x = 0; x < connections[b].size(); x++ )
if ( !( a > 0 && connections[b].get( x ) == ring.get( a - 1 ) )
&& !( a == 0 && connections[b].get( x ) == ring.get( ring.size() - 1 ) )
&& !( a < ring.size() - 1 && connections[b].get( x ) == ring.get( a + 1 ) )
&& !( a == ring.size() - 1 && connections[b].get( x ) == ring.get( 0 ) ) )
{
recursion.push( connections[b].get( x ) );
parent[connections[b].get( x )] = b;
}
while ( !recursion.empty() )
{
int i = recursion.pop();
visited[i] = true;
for ( int x = 0; x < connections[i].size(); x++ )
if ( !visited[connections[i].get( x )] )
{
recursion.push( connections[i].get( x ) );
parent[connections[i].get( x )] = i;
}
else if ( parent[i] != connections[i].get( x ) )
{
satisfies = false;
break all;
}
}
}
boolean[] allTrue = new boolean[v];
Arrays.fill( allTrue, true );
if ( satisfies && Arrays.equals( allTrue, visited ) )
System.out.println( "FHTAGN!" );
else
System.out.println( "NO" );
}
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m, u, v, cnt = 0;
vector<int> g[3002];
bool vis[3002];
void dfs(int s) {
cnt++;
vis[s] = true;
for (int i = 0; i < g[s].size(); i++) {
if (!vis[g[s][i]]) dfs(g[s][i]);
}
}
int main() {
scanf("%d%d", &n, &m);
if (n != m) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
if (cnt != n)
cout << "NO" << endl;
else
cout << "FHTAGN!" << endl;
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<int> g[101];
int n, m;
bool visited[101];
void dfs(int v) {
visited[v] = true;
for (int i = 0; i < g[v].size(); i++) {
if (!visited[g[v][i]]) dfs(g[v][i]);
}
}
bool isConnected() {
fill(visited, visited + n, false);
dfs(0);
for (int i = 0; i < n; i++)
if (!visited[i]) return false;
return true;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--, y--;
g[x].push_back(y);
g[y].push_back(x);
}
if (n == m && isConnected())
cout << "FHTAGN!" << endl;
else
cout << "NO" << endl;
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.*;
import java.util.*;
public class Main implements Runnable {
private BufferedReader in;
private PrintWriter out;
private StringTokenizer st;
private void eat(String line) {
st = new StringTokenizer(line);
}
private String next() throws IOException {
while (!st.hasMoreTokens()) {
String line = in.readLine();
if (line == null)
return null;
eat(line);
}
return st.nextToken();
}
private int nextInt() throws IOException {
return Integer.parseInt(next());
}
public void run() {
try {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(new OutputStreamWriter(System.out));
eat("");
go();
out.close();
} catch (Exception e) {
e.printStackTrace();
System.exit(-1);
}
}
public static void main(String[] args) {
new Thread(new Main()).start();
}
public final static String YES = "FHTAGN!";
public final static String NO = "NO";
public void go() throws IOException {
int n = nextInt(), m = nextInt();
boolean[][] graph = new boolean[n][n];
for (int i = 0; i < m; ++i) {
int u = nextInt() - 1, v = nextInt() - 1;
graph[u][v] = graph[v][u] = true;
}
out.println(new CthulhuRecognition().isCthulhu(n, m, graph) ? YES : NO);
}
}
class CthulhuRecognition {
enum Color { WHITE, GRAY, BLACK };
private boolean checkTreeDfs(int u, int p, int n, boolean[][] graph, Color[] colors) {
colors[u] = Color.GRAY;
for (int v = 0; v < n; ++v)
if (v != p && graph[u][v] == true) {
if (colors[v] != Color.WHITE)
return false;
if (!checkTreeDfs(v, u, n, graph, colors))
return false;
}
colors[u] = Color.BLACK;
return true;
}
private ArrayList<Integer> checkCycleDfs(int u, int p, int n, boolean[][] graph, Color[] colors,
ArrayDeque<Integer> stack) {
colors[u] = Color.GRAY;
stack.addLast(u);
for (int v = 0; v < n; ++v)
if (v != p && graph[u][v] == true) {
if (colors[v] == Color.GRAY) {
ArrayList<Integer> result = new ArrayList<Integer>();
do {
result.add(stack.peekLast());
} while (stack.pollLast() != v);
return result;
} else {
ArrayList<Integer> result = checkCycleDfs(v, u, n, graph, colors, stack);
if (result != null)
return result;
}
}
colors[u] = Color.BLACK;
stack.pollLast();
return null;
}
public boolean isCthulhu(int n, int m, boolean[][] graph) {
Color[] colors = new Color[n];
Arrays.fill(colors, Color.WHITE);
ArrayList<Integer> cycle = checkCycleDfs(0, -1, n, graph, colors, new ArrayDeque<Integer>());
if (cycle == null || cycle.size() < 3)
return false;
Arrays.fill(colors, Color.WHITE);
boolean[] inCycle = new boolean[n];
for (int u : cycle) {
inCycle[u] = true;
colors[u] = Color.BLACK;
}
for (int u : cycle) {
for (int v = 0; v < n; ++v)
if (graph[u][v] == true && !inCycle[v]) {
if (colors[v] != Color.WHITE)
return false;
if (!checkTreeDfs(v, u, n, graph, colors))
return false;
}
}
for (int u = 0; u < n; ++u)
if (colors[u] != Color.BLACK)
return false;
return true;
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
bool check[maxn] = {false};
vector<vector<int> > edge(maxn);
stack<int> s;
void DFS(int x) {
check[x] = true;
s.push(x);
bool ok = 0;
while (!s.empty()) {
int head = s.top();
s.pop();
for (auto itr1 : edge[head]) {
if (!check[itr1]) {
check[itr1] = true;
s.push(itr1);
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
DFS(1);
bool ok = 1;
for (int i = 1; i <= n; i++) {
if (!check[i]) {
ok = 0;
}
}
cout << ((ok and m == n) ? "FHTAGN!" : "NO");
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int ind = 0, n;
int used[101];
int g[101][101];
void dfs(int v) {
used[v] = 1;
for (int k = 1; k <= n; k++)
if (g[v][k] == 1)
if (used[k] == 0)
dfs(k);
else if (used[k] == 2)
ind++;
used[v] = 2;
}
int main() {
int m;
cin >> n >> m;
for (int k = 1; k <= m; k++) {
int a, b;
cin >> a >> b;
g[a][b] = g[b][a] = 1;
}
dfs(1);
if (n != m) {
cout << "NO";
return 0;
}
for (int j = 1; j <= n; j++)
if (used[j] == 0) {
cout << "NO";
return 0;
}
cout << "FHTAGN!";
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<int> v[10000];
int Visited[10000], parent[10000];
int cnt = 0;
void DFS(int num) {
Visited[num] = 1;
for (int I = 0; I < v[num].size(); I++) {
int val = v[num][I];
if (Visited[val] && parent[num] != val) {
cnt++;
continue;
}
if (parent[num] != val) {
parent[val] = num;
DFS(val);
}
}
}
int main() {
int n = 0, m = 0;
int a = 0, b = 0;
scanf("%d %d", &n, &m);
for (int I = 0; I < 10000; I++) parent[I] = -1;
for (int I = 0; I < m; I++) {
scanf("%d %d", &a, &b);
v[a - 1].push_back(b - 1);
v[b - 1].push_back(a - 1);
}
for (int I = 0; I < n; I++) {
if (!Visited[I]) DFS(I);
}
if (cnt / 2 == 1 && n <= m) {
printf("FHTAGN!\n");
return 0;
}
if (cnt / 2 == 1 && n > m) {
printf("NO\n");
return 0;
}
if (cnt / 2 > 1 || cnt == 0) {
printf("NO\n");
return 0;
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long long n, m;
vector<vector<long long> > adj_list;
vector<bool> visited;
long long cnt = 0;
void dfs(long long node) {
visited[node] = true;
++cnt;
for (auto neigh : adj_list[node]) {
if (!visited[neigh]) {
dfs(neigh);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long n, m;
cin >> n >> m;
if (n != m) {
cout << "NO";
return 0;
}
adj_list.resize(n + 1);
for (long long i = 0; i < m; ++i) {
long long a, b;
cin >> a >> b;
adj_list[a].push_back(b);
adj_list[b].push_back(a);
}
visited.resize(n + 1);
dfs(1);
if (cnt == n) {
cout << "FHTAGN!";
} else {
cout << "NO";
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.*;
import java.io.*;
import java.math.*;
public class Main
{
static class Reader
{
private InputStream mIs;private byte[] buf = new byte[1024];private int curChar,numChars;public Reader() { this(System.in); }public Reader(InputStream is) { mIs = is;}
public int read() {if (numChars == -1) throw new InputMismatchException();if (curChar >= numChars) {curChar = 0;try { numChars = mIs.read(buf);} catch (IOException e) { throw new InputMismatchException();}if (numChars <= 0) return -1; }return buf[curChar++];}
public String nextLine(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isEndOfLine(c));return res.toString() ;}
public String s(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isSpaceChar(c));return res.toString();}
public long l(){int c = read();while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }long res = 0; do{ if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read();}while(!isSpaceChar(c));return res * sgn;}
public int i(){int c = read() ;while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }int res = 0;do{if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read() ;}while(!isSpaceChar(c));return res * sgn;}
public double d() throws IOException {return Double.parseDouble(s()) ;}
public boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }
public boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
}
///////////////////////////////////////////////////////////////////////////////////////////
// RRRRRRRRR AAA HHH HHH IIIIIIIIIIIII LLL //
// RR RRR AAAAA HHH HHH IIIIIIIIIII LLL //
// RR RRR AAAAAAA HHH HHH III LLL //
// RR RRR AAA AAA HHHHHHHHHHH III LLL //
// RRRRRR AAA AAA HHHHHHHHHHH III LLL //
// RR RRR AAAAAAAAAAAAA HHH HHH III LLL //
// RR RRR AAA AAA HHH HHH IIIIIIIIIII LLLLLLLLLLLL //
// RR RRR AAA AAA HHH HHH IIIIIIIIIIIII LLLLLLLLLLLL //
///////////////////////////////////////////////////////////////////////////////////////////
static int n;
static int m;
static LinkedList<Integer> adj[];
static int mark[];
public static void dfs(int pos)
{
if(mark[pos]==1)
return ;
mark[pos]=1;
for(int i:adj[pos])
dfs(i);
}
public static void main(String[] args)throws IOException
{
PrintWriter out= new PrintWriter(System.out);
Reader sc=new Reader();
n=sc.i();
m=sc.i();
if(n!=m)
{
System.out.println("NO");
System.exit(0);
}
adj = new LinkedList[n];
mark=new int[n];
for (int i=0; i<n; ++i)
adj[i] = new LinkedList();
for(int i=0;i<m;i++)
{
int a=sc.i()-1;int b=sc.i()-1;
adj[a].add(b);
adj[b].add(a);
}
dfs(0);
for(int i=0;i<n;i++)
if(mark[i]==0)
{
System.out.println("NO");
System.exit(0);
}
System.out.println("FHTAGN!");
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from collections import defaultdict
n, m = map(int, input().split())
adj = defaultdict(list)
for i in range(m):
x, y = map(int, input().split())
adj[x].append(y)
adj[y].append(x)
cmps = 0
v = [0]*(n+1)
for i in range(1, 1+n):
if not v[i]:
q = [i]
while q:
e = q.pop()
v[e] = 1
for j in adj[e]:
if not v[j]:
q.append(j)
cmps += 1
print("FHTAGN!" if n==m and cmps==1 else "NO") | PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner r = new Scanner(System.in);
int n = r.nextInt();
int m = r.nextInt();
boolean[][] g = new boolean[n][n];
for(int k = 0; k < m; k++){
int i = r.nextInt()-1;
int j = r.nextInt()-1;
g[i][j] = g[j][i] = true;
}
boolean[] v = new boolean[n];
int cnt = 0;
for(int i = 0; i < n; i++)if(!v[i]){
v[i] = true;
cnt++;
dfs(i, v, g, n);
}
if(cnt != 1){
System.out.println("NO");
return;
}
if(n == m)System.out.println("FHTAGN!");
else System.out.println("NO");
}
private static int mdfs(int p, int i, boolean[] v, boolean[][] g, int n) {
int res = 0;
for(int j = 0; j < n; j++){
if(g[i][j]){
// System.out.println(i+", "+j);
if(v[j] && j != p)res++;
if(!v[j]){
v[j] = true;
res += mdfs(i, j, v, g, n);
}
// break;
}
}
return res;
}
private static void dfs(int i, boolean[] v, boolean[][] g, int n) {
for(int j = 0; j < n; j++)if(!v[j] && g[i][j]){
v[j] = true;
dfs(j, v, g, n);
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.*;
import java.util.*;
public class Main {
// class Scanner {
// StreamTokenizer in;
//
// Scanner(InputStream stream) {
// in = new StreamTokenizer(new BufferedReader(new
// InputStreamReader(stream)));
// in.resetSyntax();
// in.whitespaceChars(0, 32);
// in.wordChars(33, 255);
// }
//
// String next() {
// try {
// in.nextToken();
// return in.sval;
// } catch (Exception e) {
// throw new Error();
// }
// }
//
// int nextInt() {
// return Integer.parseInt(next());
// }
//
// long nextLong() {
// return Long.parseLong(next());
// }
//
// double nextDouble() {
// try {
// in.nextToken();
// return in.nval;
// } catch (Exception e) {
// throw new Error();
// }
// }
// }
Scanner in;
PrintWriter out;
void asserT(boolean e) {
if (!e) {
throw new Error();
}
}
Node start;
Node end;
int gCnt = 0;
class Node implements Comparable<Node> {
int idx;
TreeSet<Node> links = new TreeSet<Main.Node>();
int color = 0;
Node parent;
Node(int idx) {
this.idx = idx;
}
void addLink(Node link) {
links.add(link);
}
void dfs2() {
this.color = 1;
for (Node link : links) {
if (link.color == 0) {
link.dfs2();
}
}
}
boolean dfs(Node prev) {
this.color = 1;
for (Node link : links) {
if (link.color == 0) {
link.parent = this;
if (link.dfs(this)) {
return true;
}
} else if (link.color == 1 && link.idx != prev.idx) {
end = this;
start = link;
return true;
}
}
this.color = 2;
return false;
}
boolean dfs3(Node prev) {
if (setCycl.contains(this)) {
gCnt++;
}
this.color = 1;
for (Node link : links) {
if (link.color == 0) {
link.parent = this;
if (link.dfs3(this)) {
return true;
}
} else if (link.color == 1 && link.idx != prev.idx) {
end = this;
start = link;
return true;
}
}
this.color = 2;
return false;
}
@Override
public int compareTo(Node second) {
return this.idx - second.idx;
}
}
TreeSet<Node> setCycl = new TreeSet<Main.Node>();
String no = "NO";
String yes = "FHTAGN!";
void solve() {
int nNodes = in.nextInt();
int nLinks = in.nextInt();
Node nodes[] = new Node[nNodes];
for (int i = 0; i < nodes.length; i++) {
nodes[i] = new Node(i + 1);
}
for (int i = 0; i < nLinks; i++) {
int f = in.nextInt();
int s = in.nextInt();
nodes[f - 1].addLink(nodes[s - 1]);
nodes[s - 1].addLink(nodes[f - 1]);
}
int nComponents = 0;
for (Node node : nodes) {
if (node.color == 0) {
nComponents++;
node.dfs2();
}
}
if (nComponents != 1) {
out.print(no);
return;
}
for (Node node : nodes) {
node.parent = null;
node.color = 0;
}
start = null;
end = null;
for (Node node : nodes) {
if (node.dfs(null)) {
break;
}
}
if (start == null) {
out.print(no);
} else {
ArrayList<Node> cycl = new ArrayList<Main.Node>();
cycl.add(start);
setCycl.add(start);
for (Node v = end; v.idx != start.idx; v = v.parent) {
cycl.add(v);
setCycl.add(v);
}
if (cycl.size() >= 3) {
for (int i = 0; i < cycl.size(); i++) {
Node cur = cycl.get(i);
Node next = cycl.get((i + 1) % cycl.size());
cur.links.remove(next);
next.links.remove(cur);
}
for (Node node : nodes) {
node.parent = null;
node.color = 0;
}
start = null;
end = null;
for (Node node : nodes) {
gCnt = 0;
if (node.dfs3(null)) {
if (gCnt>1){
out.print(no);
return;
}
break;
}
if (gCnt>1){
out.print(no);
return;
}
}
if (start == null) {
out.print(yes);
} else {
out.print(no);
}
} else {
out.print(no);
}
}
}
void run() {
in = new Scanner(System.in);
out = new PrintWriter(System.out);
try {
solve();
} finally {
out.close();
}
}
public static void main(String[] args) {
new Main().run();
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int sz = 1e6 + 10;
using ll = long long;
int n, m;
int par[105];
set<int> st;
int find_rep(int x) { return par[x] == x ? par[x] : par[x] = find_rep(par[x]); }
int main() {
while (scanf("%d %d", &n, &m) == 2) {
for (int i = 0; i <= n; i++) par[i] = i;
for (int i = 0, x, y; i < m; i++) {
cin >> x >> y;
if ((x = find_rep(x)) != (y = find_rep(y))) par[x] = par[y];
}
for (int i = 1; i <= n; i++) st.insert(find_rep(i));
if (n == m && st.size() == 1)
cout << "FHTAGN!\n";
else
cout << "NO\n";
cerr << "-------------\n";
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int arr[110];
int root(int a) {
while (arr[a] != a) {
a = arr[a];
}
return a;
}
void uni(int u, int v) {
int rtu = root(u);
int rtv = root(v);
arr[rtv] = arr[rtu];
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < 110; i++) {
arr[i] = i;
}
int ct = 0;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
if (root(u) != root(v)) {
uni(u, v);
} else {
ct++;
}
}
set<int> rto;
for (int i = 1; i <= n; i++) {
rto.insert(root(i));
}
if (ct == 1 && rto.size() == 1) {
cout << "FHTAGN!";
} else {
cout << "NO";
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class Main1 {
static FastReader input = new FastReader();
static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) throws IOException {
int n = input.nextInt();
int m = input.nextInt();
ArrayList<Integer> g[] = new ArrayList[n + 1];
boolean visited[] = new boolean[n + 1];
g = new ArrayList[n + 1];
visited = new boolean[n + 1];
int deg[] = new int[n + 1];
DSU s = new DSU(n + 1);
for (int i = 1; i < g.length; i++)
g[i] = new ArrayList<>();
Pair cycle = new Pair(0, 0);
boolean foundCycle = false;
boolean isGood = true;
for (int i = 0; i < m; i++) {
int x = input.nextInt();
int y = input.nextInt();
if (!s.isSameSet(x, y)) {
g[x].add(y);
g[y].add(x);
s.mergeSet(x, y);
} else {
if (!foundCycle) {
cycle.x = x;
cycle.y = y;
foundCycle = true;
} else {
isGood = false;
}
}
}
s.mergeSet(0, 1);
if (s.size() != 1 || !isGood || !foundCycle || n < 3) {
out.println("NO");
} else {
out.println("FHTAGN!");
}
out.flush();
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() throws IOException {
while (st == null || !st.hasMoreElements()) {
st = new StringTokenizer(br.readLine());
}
return st.nextToken();
}
int nextInt() throws NumberFormatException, IOException {
return Integer.parseInt(next());
}
long nextLong() throws NumberFormatException, IOException {
return Long.parseLong(next());
}
double nextDouble() throws NumberFormatException, IOException {
return Double.parseDouble(next());
}
String nextLine() throws IOException {
String str = "";
str = br.readLine();
return str;
}
}
static class con {
static int IINF = (int) 1e9;
static int _IINF = (int) -1e9;
static long LINF = (long) 1e15;
static long _LINF = (long) -1e15;
static double EPS = 1e-9;
}
static class Triple implements Comparable<Triple> {
int x;
int y;
int z;
Triple(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
@Override
public int compareTo(Triple o) {
if (x == o.x && y == o.y)
return z - o.z;
if (x == o.x)
return y - o.y;
return x - o.x;
}
@Override
public String toString() {
return "(" + x + ", " + y + ", " + z + ")";
}
}
static class Pair implements Comparable<Pair> {
int x;
int y;
Pair(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public int compareTo(Pair o) {
if (x == o.x)
return y - o.y;
return x - o.x;
}
@Override
public String toString() {
return "(" + x + ", " + y + ")";
}
}
static void shuffle(int[] a) {
for (int i = 0; i < a.length; i++) {
int r = i + (int) (Math.random() * (a.length - i));
int tmp = a[r];
a[r] = a[i];
a[i] = tmp;
}
}
static int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
static class DSU {
int[] p, rank, setSize;
int numSets;
DSU(int n) {
p = new int[n];
rank = new int[n];
setSize = new int[n];
numSets = n;
for (int i = 0; i < n; i++) {
p[i] = i;
setSize[i] = 1;
}
}
int findSet(int n) {
return p[n] = p[n] == n ? n : findSet(p[n]);
}
boolean isSameSet(int n, int m) {
return findSet(n) == findSet(m);
}
void mergeSet(int n, int m) {
if (!isSameSet(n, m)) {
numSets--;
int p1 = findSet(n);
int p2 = findSet(m);
if (rank[p1] > rank[p2]) {
p[p2] = p1;
setSize[p1] += setSize[p2];
} else {
p[p1] = p2;
setSize[p2] += setSize[p1];
if (rank[p1] == rank[p2])
rank[p1]++;
}
}
}
int size() {
return numSets;
}
int setSize(int n) {
return setSize[findSet(n)];
}
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n;
int num[110];
int parent[110];
bool adjMat[110][110];
int numberOfCycles = 0;
void dfs(int cur) {
num[cur] = 789;
for (int i = 1; i <= n; i++)
if (adjMat[cur][i]) {
if (num[i] == 135) {
parent[i] = cur;
dfs(i);
} else if (num[i] == 789 and parent[cur] != i) {
numberOfCycles++;
if (numberOfCycles > 1) {
cout << "NO\n";
exit(0);
}
}
}
num[cur] = 356;
}
int dsuParent[110];
int dsuNumSets;
int findSet(int x) {
return dsuParent[x] == x ? x : (dsuParent[x] = findSet(dsuParent[x]));
}
void dsuUnion(int a, int b) {
if (findSet(a) != findSet(b)) dsuNumSets--;
dsuParent[findSet(a)] = findSet(b);
}
void initDSU() {
dsuNumSets = n;
for (int i = 0; i <= n; i++) dsuParent[i] = i;
}
int main(int argc, char const *argv[]) {
fill_n(&parent[0], 110, -1);
fill_n(&num[0], 110, 135);
int m;
cin >> n >> m;
initDSU();
while (m--) {
int a, b;
cin >> a >> b;
dsuUnion(a, b);
adjMat[a][b] = 1;
adjMat[b][a] = 1;
}
if (dsuNumSets == 1) {
dfs(1);
if (numberOfCycles == 1)
cout << "FHTAGN!\n";
else
cout << "NO\n";
} else {
cout << "NO\n";
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.ArrayList;
import java.util.HashSet;
import java.util.Scanner;
public class Octopus {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
ArrayList<HashSet<Integer>> nodes = new ArrayList<HashSet<Integer>>();
int first, second;
for(int i=0; i<n; i++) {
nodes.add(new HashSet<Integer>());
}
for(int i = 0; i<m; i++) {
first = sc.nextInt() - 1;
second = sc.nextInt() - 1;
nodes.get(first).add(second);
nodes.get(second).add(first);
}
sc.close();
if(n != m) {
System.out.println("NO");
return;
}
boolean[] visited = new boolean[100];
int count = 0;
for(int i=0; i<n; i++) {
if(!visited[i]) {
count++;
dfs(nodes, visited, i);
}
}
if(count == 1) {
System.out.println("FHTAGN!");
}
else {
System.out.println("NO");
}
}
public static void dfs(ArrayList<HashSet<Integer>> nodes, boolean[] visited, int i) {
visited[i] = true;
for(Integer n: nodes.get(i)) {
if(visited[n]) {
continue;
}
dfs(nodes, visited, n);
}
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
public class Main {
static int N;
static int M;
static int edge[][];
static boolean taken[];
static int checkConnectivity(int node) {
int i,j,k;
int res = 1;
taken[node] = true;
for (i=1;i<=N;i++) {
if ((edge[node][i] == 1)&&(taken[i] == false)) {
res += checkConnectivity(i);
}
}
return res;
}
static int last = 0;
static int countNeighbours(int node) {
int i;
int res = 0;
for (i=1;i<=N;i++) {
if (edge[node][i] == 1) {
last = i;
res++;
}
}
return res;
}
static boolean pt[];
static int takeNode(int node) {
//System.out.println(node);
int i,j,k;
pt[node] = true;
int res = 1;
for (i=1;i<=N;i++) {
if ((edge[node][i] == 1)&&(pt[i] == false)) {
res += takeNode(i);
return res;
}
}
return 1;
}
public static void main(String[] args) throws Exception {
int i,j,k;
int x,y;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
N = Integer.parseInt(st.nextToken());
M = Integer.parseInt(st.nextToken());
if (M < 3) {
System.out.println("NO");
return;
}
int start = 0;
edge = new int[N+1][N+1];
boolean inGraph[] = new boolean[N+1];
for (i=0;i<M;i++) {
st = new StringTokenizer(br.readLine());
x = Integer.parseInt(st.nextToken());
y = Integer.parseInt(st.nextToken());
edge[x][y] = 1;
edge[y][x] = 1;
inGraph[x] = true;
inGraph[y] = true;
start = x;
}
int totalInGraph = 0;
for (i=1;i<=N;i++) {
if (inGraph[i] == true)
totalInGraph++;
}
if (totalInGraph < N) {
System.out.println("NO");
return;
}
taken = new boolean[N+1];
int connected = checkConnectivity(start);
if (connected != totalInGraph) {
System.out.println("NO");
return;
}
int numOfNeighbors;
boolean good = true;
while (good == true) {
good = false;
for (i=1;i<=N;i++) {
numOfNeighbors = countNeighbours(i);
if (numOfNeighbors == 1) {
edge[i][last] = 0;
edge[last][i] = 0;
good = true;
}
}
}
int tester = 0;
for (i=1;i<=N;i++) {
for (j=i+1;j<=N;j++) {
if (edge[i][j] == 1) {
tester++;
}
}
}
if (tester < 3) {
System.out.println("NO");
return;
}
for (i=1;i<=N;i++) {
numOfNeighbors = countNeighbours(i);
if ((numOfNeighbors > 0)&&(numOfNeighbors != 2)) {
System.out.println("NO");
return;
}
}
for (i=1;i<=N;i++) {
numOfNeighbors = countNeighbours(i);
if (numOfNeighbors == 2) {
pt = new boolean[N+1];
int score = takeNode(i);
if (score == tester) {
System.out.println("FHTAGN!");
} else {
System.out.println("NO");
}
return;
}
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int N = 110;
int p[N];
vector<int> adj[N];
int n, m;
bool vis[N];
int S = 0, E = 0, cnt = 0;
void dfs(int u) {
vis[u] = 1;
for (auto v : adj[u]) {
if (!vis[v]) {
p[v] = u;
dfs(v);
} else if (p[u] != v) {
if (v == S && u == E) continue;
S = u, E = v, cnt++;
}
}
}
int main() {
for (int i = 0; i < N; i++) p[i] = 1;
scanf("%d %d", &n, &m);
int u, v;
for (int i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1);
if (cnt != 1) {
printf("NO\n");
return 0;
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
printf("NO\n");
return 0;
}
printf("FHTAGN!\n");
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | class Graph():
def __init__(self, number_nodes):
self.nodes = [0] * (number_nodes+1)
for i in range(number_nodes):
self.nodes[i+1] = Node(i+1)
def connect(self, node_1, node_2):
self.find(node_1).neighbors.append(self.find(node_2))
self.find(node_2).neighbors.append(self.find(node_1))
def find(self, i):
return self.nodes[i]
def bfs(self):
stack = []
stack.append(self.nodes[1])
visited = {}
fhtagn = False
while(stack):
current = stack.pop()
if current.value in visited:
continue
visited[current.value] = 1
for neighbor in current.neighbors:
if neighbor.value not in visited:
neighbor.known_by = current
stack.append(neighbor)
else:
if current.known_by != neighbor:
if fhtagn==False:
fhtagn = True
else:
return("NO")
if fhtagn == True and len(visited)+1 == len(self.nodes):
return("FHTAGN!")
return("NO")
class Node():
def __init__(self, value):
self.value = value
self.neighbors = []
self.known_by = self
vertices, edges = [int(s) for s in input().split()]
graph = Graph(vertices)
for i in range(edges):
node_1, node_2 = [int(s) for s in input().split()]
graph.connect(node_1, node_2)
print(graph.bfs()) | PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import static java.lang.Math.*;
import java.util.*;
import java.io.*;
public class _80_d2_C {
boolean[][] g = new boolean[110][110];
boolean[] vis = new boolean[110];
int n;
public void solve() throws Exception {
n = nextInt(); int m = nextInt();
int v = n;
for (int i=0; i<m; ++i) {
int a=nextInt(), b=nextInt();
g[a][b]=g[b][a]=true;
}
boolean ok = true;
while (ok) {
ok = false;
for (int i=1; i<=n; ++i) {
int cnt = 0;
int sused = 0;
for (int j=1; j<=n; ++j) {
if (g[i][j]) {
cnt++; sused=j;
}
}
if (cnt==1) {
ok = true;
g[i][sused]=g[sused][i]=false;
v--;
}
}
}
int total = 0;
for (int i=1; i<=n; ++i) {
int cnt = 0;
for (int j=1; j<=n; ++j) {
if (g[i][j]) cnt++;
}
if (cnt==0) continue;
if (cnt!=2) {
println("NO"); return;
}
total++;
}
if (total<3) {
println("NO"); return;
}
tu: for (int i=0; i<=n; ++i) for (int j=1; j<=n; ++j) if (g[i][j]) {go(i); break tu;}
debug(total, total2);
println(v==total2 && total2==total ? "FHTAGN!":"NO");
}
int total2 = 0;
void go(int x) {
if (!vis[x]) total2++;
vis[x]=true;
for (int i=1; i<=n; ++i) if (g[x][i] && !vis[i]) go(i);
}
////////////////////////////////////////////////////////////////////////////
boolean showDebug = true;
double EPS = 1e-7;
int INF = Integer.MAX_VALUE;
long INFL = Long.MAX_VALUE;
double INFD = Double.MAX_VALUE;
int absPos(int i) {
return i<0 ? 0:i;
}
long absPos(long i) {
return i<0 ? 0:i;
}
double absPos(double i) {
return i<0 ? 0:i;
}
int min(int... nums) {
int r = INF;
for (int i: nums)
if (i<r) r=i;
return r;
}
int max(int... nums) {
int r = -INF;
for (int i: nums)
if (i>r) r=i;
return r;
}
long minL(long... nums) {
long r = INFL;
for (long i: nums)
if (i<r) r=i;
return r;
}
long maxL(long... nums) {
long r = -INFL;
for (long i: nums)
if (i>r) r=i;
return r;
}
double minD(double... nums) {
double r = INFD;
for (double i: nums)
if (i<r) r=i;
return r;
}
double maxD(double... nums) {
double r = -INFD;
for (double i: nums)
if (i>r) r=i;
return r;
}
long sumArr(int[] arr) {
long res = 0;
for (int i: arr)
res+=i;
return res;
}
long sumArr(long[] arr) {
long res = 0;
for (long i: arr)
res+=i;
return res;
}
double sumArr(double[] arr) {
double res = 0;
for (double i: arr)
res+=i;
return res;
}
long partsFitCnt(long partSize, long wholeSize) {
return (partSize+wholeSize-1)/partSize;
}
boolean odd(long i) {
return (i&1)==1;
}
long binpow(int x, int n) {
long r = 1;
while (n>0) {
if ((n&1)!=0) r*=x;
x*=x;
n>>=1;
}
return r;
}
boolean isLetter(char c) {
return (c>='a' && c<='z') || (c>='A' && c<='Z');
}
boolean isLowercase(char c) {
return (c>='a' && c<='z');
}
boolean isUppercase(char c) {
return (c>='A' && c<='Z');
}
boolean isDigit(char c) {
return (c>='0' && c<='9');
}
String stringn(String s, int n) {
if (n<1) return "";
StringBuilder sb = new StringBuilder(s.length()*n);
for (int i=0; i<n; ++i) sb.append(s);
return sb.toString();
}
String str(Object o) {
return o.toString();
}
long timer = System.currentTimeMillis();
void startTimer() {
timer = System.currentTimeMillis();
}
void stopTimer() {
System.err.println("time: "+(System.currentTimeMillis()-timer)/1000.0);
}
class InputReader {
private byte[] buf;
private int bufPos = 0, bufLim = -1;
public InputReader(int size) {
buf = new byte[size];
try {
fillBuf();
} catch (IOException e) {}
}
private void fillBuf() throws IOException {
bufLim = System.in.read(buf);
bufPos = 0;
}
char read() throws IOException {
if (bufPos>=bufLim) fillBuf();
return (char)buf[bufPos++];
}
boolean hasInput() throws IOException {
if (bufPos>=bufLim) fillBuf();
return bufPos<bufLim;
}
}
InputReader in = new InputReader(1<<16);
static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out), 1<<16);
Formatter formatter = new Formatter(out);
char nextChar() throws IOException {
return in.read();
}
char nextNonWhitespaceChar() throws IOException {
char c = in.read();
while (c<=' ') c=in.read();
return c;
}
String nextWord() throws IOException {
StringBuilder sb = new StringBuilder();
char c = in.read();
while (c<=' ') c=in.read();
while (c>' ') {
sb.append(c);
c = in.read();
}
return new String(sb);
}
String nextLine() throws IOException {
StringBuilder sb = new StringBuilder();
char c = in.read();
while (c<=' ') c=in.read();
while (c!='\n' && c!='\r') {
sb.append(c);
c = in.read();
}
return new String(sb);
}
int nextInt() throws IOException {
int r = 0;
char c = nextNonWhitespaceChar();
boolean neg = false;
if (c=='-') neg=true;
else r=c-48;
c = nextChar();
while (c>='0' && c<='9') {
r*=10;
r+=c-48;
c=nextChar();
}
return neg ? -r:r;
}
long nextLong() throws IOException {
long r = 0;
char c = nextNonWhitespaceChar();
boolean neg = false;
if (c=='-') neg=true;
else r = c-48;
c = nextChar();
while (c>='0' && c<='9') {
r*=10L;
r+=c-48L;
c=nextChar();
}
return neg ? -r:r;
}
double nextDouble() throws NumberFormatException, IOException {
return Double.parseDouble(nextWord());
}
int[] nextArr(int size) throws NumberFormatException, IOException {
int[] arr = new int[size];
for (int i=0; i<size; i++)
arr[i] = nextInt();
return arr;
}
long[] nextArrL(int size) throws NumberFormatException, IOException {
long[] arr = new long[size];
for (int i=0; i<size; i++)
arr[i] = nextLong();
return arr;
}
double[] nextArrD(int size) throws NumberFormatException, IOException {
double[] arr = new double[size];
for (int i=0; i<size; i++)
arr[i] = nextDouble();
return arr;
}
String[] nextArrS(int size) throws NumberFormatException, IOException {
String[] arr = new String[size];
for (int i=0; i<size; i++)
arr[i] = nextWord();
return arr;
}
char[] nextArrCh(int size) throws IOException {
char[] arr = new char[size];
for (int i=0; i<size; i++)
arr[i] = nextNonWhitespaceChar();
return arr;
}
char[][] nextArrCh(int rows, int columns) throws IOException {
char[][] arr = new char[rows][columns];
for (int i=0; i<rows; i++)
for (int j=0; j<columns; j++)
arr[i][j] = nextNonWhitespaceChar();
return arr;
}
void printf(String s, Object... o) {
formatter.format(s, o);
}
void print(Object o) throws IOException {
out.write(o.toString());
}
void println(Object o) throws IOException {
out.write(o.toString());
out.newLine();
}
void print(Object... o) throws IOException {
for (int i=0; i<o.length; i++) {
if (i!=0) out.write(' ');
out.write(o[i].toString());
}
}
void println(Object... o) throws IOException {
print(o);
out.newLine();
}
void printn(Object o, int n) throws IOException {
String s = o.toString();
for (int i=0; i<n; i++) {
out.write(s);
if (i!=n-1) out.write(' ');
}
}
void printnln(Object o, int n) throws IOException {
printn(o, n);
out.newLine();
}
void printArr(int[] arr) throws IOException {
for (int i=0; i<arr.length; i++) {
if (i!=0) out.write(' ');
out.write(Integer.toString(arr[i]));
}
}
void printArr(long[] arr) throws IOException {
for (int i=0; i<arr.length; i++) {
if (i!=0) out.write(' ');
out.write(Long.toString(arr[i]));
}
}
void printArr(double[] arr) throws IOException {
for (int i=0; i<arr.length; i++) {
if (i!=0) out.write(' ');
out.write(Double.toString(arr[i]));
}
}
void printArr(String[] arr) throws IOException {
for (int i=0; i<arr.length; i++) {
if (i!=0) out.write(' ');
out.write(arr[i]);
}
}
void printArr(char[] arr) throws IOException {
for (char c: arr) out.write(c);
}
void printlnArr(int[] arr) throws IOException {
printArr(arr);
out.newLine();
}
void printlnArr(long[] arr) throws IOException {
printArr(arr);
out.newLine();
}
void printlnArr(double[] arr) throws IOException {
printArr(arr);
out.newLine();
}
void printlnArr(String[] arr) throws IOException {
printArr(arr);
out.newLine();
}
void printlnArr(char[] arr) throws IOException {
printArr(arr);
out.newLine();
}
void debug(Object... o) {
if (showDebug) System.err.println(Arrays.deepToString(o));
}
public static void main(String[] args) throws Exception {
Locale.setDefault(Locale.US);
new _80_d2_C().solve();
out.flush(); out.close();
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.*;
public class ck {
private static InputStream stream;
private static PrintWriter pw;
// static int a;
// static int b;
// static int f = 0;
static int n;
static int m;
// static int prob[];
// static int dp[];
// static int x1;
// static int x2;
// static int y1;
// static int y2;
// static int[][] dir = {{1,0},{0,1},{-1,0},{0,-1}};
// static ArrayList<Integer> ans;
// static int m;
// static int arr[][];
// static int arr[];
// static char[][] arr;
static int[] visited;
static ArrayList<Integer> arr[];
public static void main(String[] args) throws NumberFormatException, IOException{
//InputReader(System.in);
//pw = new PrintWriter(System.out);
Scanner in = new Scanner(System.in);
n = in.nextInt();
m = in.nextInt();
in.nextLine();
arr = new ArrayList[n];
visited = new int[n];
for(int i = 0;i<n;i++){
arr[i] = new ArrayList();
}
for(int i = 0;i<m;i++){
int a = in.nextInt()-1;
int b = in.nextInt()-1;
arr[a].add(b);
arr[b].add(a);
}
dfs(0);
int f =0;
for(int i = 0;i<n;i++){
if(visited[i] == 0){
f = 1;
break;
}
}
// System.out.println(f + " " + n+ " " +m);
if(f == 1){
System.out.println("NO");
}else if( f == 0 && n == m){
System.out.println("FHTAGN!");
}else if(f == 0 && m != n){
System.out.println("NO");
}
}
public static void dfs(int i){
if(visited[i] == 1){
return;
}
visited[i] = 1;
//System.out.println(i);
for(int j = 0;j<arr[i].size();j++){
if(arr[i].get(j)!=i)
dfs(arr[i].get(j));
}
}
public static void InputReader(InputStream stream1) {
stream = stream1;
}
// public static void bfs(int s){
//
//
// if(visited[s] == 1){
// return;
// }
// c++;
// visited[s] = 1;
// Queue<Integer> q=new LinkedList<Integer>();
// q.add(s);
//
// while(!q.isEmpty()){
// int top=q.poll();
// v++;
// Iterator<Integer> i= adj[top].listIterator();
// while(i.hasNext()){
// int n=i.next();
// if(visited[n] == 0){
// q.add(n);
// visited[n]=1;
//
// }
// }
// }
//
//
// }
//
//
//
// public static void dfs(int i,int j){
// System.out.println(i + " " + j + " " + arr[i][j]);
// if(i == x2 && j == y2 && arr[i][j] == 'X'){
// f = 1;
// return;
// }else if(i == x2 && j == y2){
//
// for(int p = 0;p<4;p++){
// int t1 = i + dir[p][0];
// int t2 = j + dir[p][1];
//
// i =t1;j =t2;
//
//
// if(i < 0 || i >=n || j < 0 || j >= m){
// // fooled you/...
// }else if(arr[t1][t2] == '.'){
// System.out.println(i + " " + j+ " " + " insisis" + " " + arr[i][j]);
// f = 1;
// return;
// }
// }
//
// return;
// }else if(arr[i][j] == 'X' && i != x1 && j != y1){
// return;
// }else if(arr[i][j] == 'X' && i == x1 && j == y1){
// for(int p = 0;p<4;p++){
// int t1 = i + dir[p][0];
// int t2 = j + dir[p][1];
// i =t1;j =t2;
// if(i < 0 || i >=n || j < 0 || j >= m){
// // fooled you/...
// }else if(arr[t1][t2] == '.'){
// dfs(t1,t2);
// }
// }
//
// }
//
// int t1 = i;
// int t2 = j;
//// if(t1 == 3 && t2 == 4){
//// System.out.println(i + " " + j + " inside");
//// }
////
// for(int k = 0;k<4;k++){
//
// i = t1 + dir[k][0];
// j = t2 + dir[k][1];
//
// if(t1 == 0 && t2 == 6){
// System.out.println(i + " " + j + " inside");
// }
//
// if(i < 0 || i >=n || j < 0 || j >= m){
// // fooled you/...
// }else if(arr[i][j] == '.'){
// arr[t1][t2] = 'X';
// dfs(i,j);
// }else if(i == x2 & j == y2 && arr[i][j] == 'X'){
// dfs(i,j);
// }
// }
//
//
//
//
// }
public static boolean isPrime(int n) {
// Corner cases
if (n <= 1)
return false;
if (n <= 3)
return true;
// This is checked so that we can skip
// middle five numbers in below loop
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
public static void Range(int[] numbers, int target) {
if (numbers == null)
return;
int low = 0, high = numbers.length - 1;
// get the start index of target number
int startIndex = -1;
while (low <= high) {
int mid = (high - low) / 2 + low;
if (numbers[mid] > target) {
high = mid - 1;
} else if (numbers[mid] == target) {
startIndex = mid;
high = mid - 1;
} else
low = mid + 1;
}
// get the end index of target number
int endIndex = -1;
low = 0;
high = numbers.length - 1;
while (low <= high) {
int mid = (high - low) / 2 + low;
if (numbers[mid] > target) {
high = mid - 1;
} else if (numbers[mid] == target) {
endIndex = mid;
low = mid + 1;
} else
low = mid + 1;
}
if (startIndex != -1 && endIndex != -1){
for(int i=0; i+startIndex<=endIndex;i++){
if(i>0)
System.out.print(',');
System.out.print(i+startIndex);
}
}
}
// union code starts
private static void initialize( int Arr[ ],int size[], int N)
{
for(int i = 0;i<N;i++)
{
Arr[ i ] = i ;
size[ i ] = 1;
}
}
private static int root(int Arr[ ],int i)
{
while(Arr[ i ] != i) //chase parent of current element until it reaches root
{
Arr[ i ] = Arr[ Arr[ i ] ] ;
i = Arr[ i ];
}
return i;
}
private static void union(int Arr[ ],int size[ ],int A,int B)
{
int root_A = root(Arr,A);
int root_B = root(Arr,B);
if(root_A != root_B){
if(size[root_A] < size[root_B ])
{
Arr[ root_A ] = Arr[root_B];
size[root_B] += size[root_A];
}
else
{
Arr[ root_B ] = Arr[root_A];
size[root_A] += size[root_B];
}
}
}
private static boolean find(int Arr[],int A,int B)
{
if( root(Arr,A)==root(Arr,B) ) //if A and B have the same root, it means that they are connected.
return true;
else
return false;
}
// union code ends
// // Segment tree code begins
//
//
// static void build(int node,int start,int end)
// {
// if(start==end)
// tree[node]=a[start];
// else
// {
// int mid=(start+end)/2;
// build(2*node,start,mid);
// build(2*node+1,mid+1,end);
// if(tree[2*node]<tree[2*node+1])
// tree[node]=tree[2*node];
// else
// tree[node]=tree[2*node+1];
// }
// }
//
//
// static void update(int node,int start,int end,int idx,int val)
// {
// if(start==end)
// {
// a[idx]=val;
// tree[node]=val;
// }
// else
// {
// int mid=(start+end)/2;
// if(idx>=start&&idx<=mid)
// update(2*node,start,mid,idx,val);
// else
// update(2*node+1,mid+1,end,idx,val);
// if(tree[2*node]<tree[2*node+1])
// tree[node]=tree[2*node];
// else
// tree[node]=tree[2*node+1];
// }
// }
//
// static int query(int node,int start,int end,int l,int r)
// {
// if(l>end||start>r)
// return 100005;
// if(l<=start&&r>=end)
// return tree[node];
// int p1,p2;
// int mid=(start+end)/2;
// p1=query(2*node,start,mid,l,r);
// p2=query(2*node+1,mid+1,end,l,r);
// if(p1<p2)
// return p1;
// else
// return p2;
// }
//
//
//
//}
}
class Node{
int a;
int b;
}
class MyComp2 implements Comparator<Node>{
@Override
public int compare(Node o1, Node o2) {
if(o1.b>o2.b){
return 1;
}else if(o1.b<o2.b){
return -1;
}else{
return 0;
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.*;
import java.util.*;
public class Main {
static class UnionFind {
Map<Integer, Node> map = new HashMap<>();
class Node {
int val;
Node parent;
int rank;
public Node(int val) {
this.val = val;
}
}
public void makeSet(int u) {
Node newNode = new Node(u);
newNode.rank = 1;
newNode.parent = newNode;
map.put(u, newNode);
}
public boolean union(int u, int v) {
Node nodeU = map.get(u);
Node nodeV = map.get(v);
Node parentU = find(nodeU);
Node parentV = find(nodeV);
if (parentU == parentV)
return false;
if (parentU.rank >= parentV.rank) {
parentV.parent = parentU;
parentU.rank+=parentV.rank;
} else if (parentU.rank < parentV.rank) {
parentU.parent = parentV;
parentV.rank+=parentU.rank;
}
return true;
}
public Node find(Node u) {
Node parent = u.parent;
if (parent == u)
return parent;
return find(u.parent);
}
public int find(int u) {
return find(map.get(u)).val;
}
public int findNodeRank(int u) {
return find(map.get(u)).rank;
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
UnionFind u = new UnionFind();
for(int i = 1; i <= n; i++) {
u.makeSet(i);
}
int countCycle = 0;
for(int i = 0; i < m; i++) {
int u1 = sc.nextInt();
int u2 = sc.nextInt();
boolean re = u.union(u1,u2);
if (!re) countCycle++;
}
//System.out.println(countCycle);
if (countCycle > 1 || countCycle == 0) System.out.println("NO");
else {
int countGroup = 0;
for(int i = 1; i <= n; i++) {
if (i == u.find(i)) countGroup++;
}
// System.out.println(countGroup);
if (countGroup > 1) System.out.println("NO");
else System.out.println("FHTAGN!");
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.*;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class cf103b {
static BufferedReader __in;
static PrintWriter __out;
static StringTokenizer input;
static int par[], deg[], sz[];
static int find(int u) {
return par[u] == u ? u : (par[u] = find(par[u]));
}
static void union(int u, int v) {
int a = find(u), b = find(v);
if(a != b) {
par[b] = a;
deg[a] += deg[b];
sz[a] += sz[b];
}
}
public static void main(String[] args) throws IOException {
__in = new BufferedReader(new InputStreamReader(System.in));
__out = new PrintWriter(new OutputStreamWriter(System.out));
int n = rni(), m = ni();
par = new int[n];
deg = new int[n];
sz = new int[n];
for(int i = 0; i < n; ++i) {
par[i] = i;
sz[i] = 1;
}
for(int i = 0; i < m; ++i) {
int x = rni() - 1, y = ni() - 1;
union(x, y);
++deg[find(x)];
}
prln(n == m && sz[find(0)] == n ? "FHTAGN!" : "NO");
close();
}
// references
// IBIG = 1e9 + 7
// IRAND ~= 3e8
// IMAX ~= 2e10
// LMAX ~= 9e18
// constants
static final int IBIG = 1000000007;
static final int IRAND = 327859546;
static final int IMAX = 2147483647;
static final int IMIN = -2147483648;
static final long LMAX = 9223372036854775807L;
static final long LMIN = -9223372036854775808L;
// util
static int minof(int a, int b, int c) {return min(a, min(b, c));}
static int minof(int... x) {return x.length == 1 ? x[0] : x.length == 2 ? min(x[0], x[1]) : min(x[0], minstarting(1, x));}
static int minstarting(int offset, int... x) {assert x.length > 2; return offset == x.length - 2 ? min(x[offset], x[offset + 1]) : min(x[offset], minstarting(offset + 1, x));}
static long minof(long a, long b, long c) {return min(a, min(b, c));}
static long minof(long... x) {return x.length == 1 ? x[0] : x.length == 2 ? min(x[0], x[1]) : min(x[0], minstarting(1, x));}
static long minstarting(int offset, long... x) {assert x.length > 2; return offset == x.length - 2 ? min(x[offset], x[offset + 1]) : min(x[offset], minstarting(offset + 1, x));}
static int maxof(int a, int b, int c) {return max(a, max(b, c));}
static int maxof(int... x) {return x.length == 1 ? x[0] : x.length == 2 ? max(x[0], x[1]) : max(x[0], maxstarting(1, x));}
static int maxstarting(int offset, int... x) {assert x.length > 2; return offset == x.length - 2 ? max(x[offset], x[offset + 1]) : max(x[offset], maxstarting(offset + 1, x));}
static long maxof(long a, long b, long c) {return max(a, max(b, c));}
static long maxof(long... x) {return x.length == 1 ? x[0] : x.length == 2 ? max(x[0], x[1]) : max(x[0], maxstarting(1, x));}
static long maxstarting(int offset, long... x) {assert x.length > 2; return offset == x.length - 2 ? max(x[offset], x[offset + 1]) : max(x[offset], maxstarting(offset + 1, x));}
static int powi(int a, int b) {if(a == 0) return 0; int ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
static long powl(long a, int b) {if(a == 0) return 0; long ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
static int floori(double d) {return (int)d;}
static int ceili(double d) {return (int)ceil(d);}
static long floorl(double d) {return (long)d;}
static long ceill(double d) {return (long)ceil(d);}
// input
static void r() throws IOException {input = new StringTokenizer(__in.readLine());}
static int ri() throws IOException {return Integer.parseInt(__in.readLine());}
static long rl() throws IOException {return Long.parseLong(__in.readLine());}
static int[] ria(int n) throws IOException {int[] a = new int[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Integer.parseInt(input.nextToken()); return a;}
static long[] rla(int n) throws IOException {long[] a = new long[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Long.parseLong(input.nextToken()); return a;}
static char[] rcha() throws IOException {return __in.readLine().toCharArray();}
static String rline() throws IOException {return __in.readLine();}
static int rni() throws IOException {input = new StringTokenizer(__in.readLine()); return Integer.parseInt(input.nextToken());}
static int ni() {return Integer.parseInt(input.nextToken());}
static long rnl() throws IOException {input = new StringTokenizer(__in.readLine()); return Long.parseLong(input.nextToken());}
static long nl() {return Long.parseLong(input.nextToken());}
// output
static void pr(int i) {__out.print(i);}
static void prln(int i) {__out.println(i);}
static void pr(long l) {__out.print(l);}
static void prln(long l) {__out.println(l);}
static void pr(double d) {__out.print(d);}
static void prln(double d) {__out.println(d);}
static void pr(char c) {__out.print(c);}
static void prln(char c) {__out.println(c);}
static void pr(char[] s) {__out.print(new String(s));}
static void prln(char[] s) {__out.println(new String(s));}
static void pr(String s) {__out.print(s);}
static void prln(String s) {__out.println(s);}
static void pr(Object o) {__out.print(o);}
static void prln(Object o) {__out.println(o);}
static void prln() {__out.println();}
static void pryes() {__out.println("yes");}
static void pry() {__out.println("Yes");}
static void prY() {__out.println("YES");}
static void prno() {__out.println("no");}
static void prn() {__out.println("No");}
static void prN() {__out.println("NO");}
static void pryesno(boolean b) {__out.println(b ? "yes" : "no");};
static void pryn(boolean b) {__out.println(b ? "Yes" : "No");}
static void prYN(boolean b) {__out.println(b ? "YES" : "NO");}
static void prln(int... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
static void prln(long... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
static <T> void prln(Collection<T> c) {int n = c.size() - 1; Iterator<T> iter = c.iterator(); for(int i = 0; i < n; __out.print(iter.next()), __out.print(' '), ++i); __out.println(iter.next());}
static void flush() {__out.flush();}
static void close() {__out.close();}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
import java.util.LinkedList;
import java.util.Scanner;
import java.util.Stack;
public class Main2 {
static Scanner s = new Scanner(System.in);
static int n,m;
static Node[][] map = null;
static int[][] checkMap = null;
static LinkedList<Integer>[] startWith = null;
static LinkedList<Integer>[] endWith = null;
static LinkedList<Node> edgeList = new LinkedList<>();
static Stack<Node> isDoing = new Stack<>();
static String end = "NO";
static boolean endFlag = true;
static int[] arr = null;
public static void main(String[] args) {
init();
if(n==m && endFlag){
solve();
}
System.out.println(end);
}
public static void init(){
n = s.nextInt();
m = s.nextInt();
map = new Node[n+1][n+1];
checkMap = new int[n+1][n+1];
startWith = new LinkedList[n+1];
endWith = new LinkedList[n+1];
arr = new int[n+1];
for(int i=1;i<n+1;i++){
startWith[i] = new LinkedList<>();
endWith[i] = new LinkedList<>();
}
for(int i=0;i<m;i++){
int start = s.nextInt();
int end = s.nextInt();
if(start>end){
int temp = start;
start = end;
end =temp;
}
Node insert = new Node(start,end,i);
startWith[start].push(end);
endWith[end].push(start);
map[start][end] =insert;
edgeList.add(insert);
///
arr[start]+=1;
arr[end]+=1;
//
}
for(int i=1;i<n+1;i++){
if(arr[i]==0){
endFlag=false;
break;
}
}
}
static void solve(){
Node curNode = edgeList.pop();
dfs(curNode,-1,-1);
if(m==0){
end = "FHTAGN!";
}
}
static void dfs(Node curNode,int prv_x,int prv_y){
int x = curNode.x;int y = curNode.y;
if(checkMap[x][y] !=0)
return;
checkMap[x][y] = 1; //μ§κΈ 체νΉμ€
if(prv_x==-1 && prv_y == -1){
startWith[x].remove(startWith[x].indexOf(y));
endWith[y].remove(endWith[y].indexOf(x));
}
m--;
//xλ₯Όμνμμ
/*System.out.println(curNode.x+" "+curNode.y+" μμ κ°λλ€ μλ°");*/
while(!startWith[x].isEmpty()){
int next_y = startWith[x].pop(); //x,next_yλ‘
if( y != next_y &&(x!=prv_x || next_y!=prv_y)){
/*System.out.println(x+" "+next_y+" λ‘κ°λ€"+" "+startWith[x].size());*/
dfs(map[x][next_y],x,y);
}
}
while(!endWith[x].isEmpty()){
int next_x = endWith[x].pop(); //next_x , xλ‘
if((next_x != x ||x !=y )&&(next_x!= prv_x || x != prv_y)){
/*System.out.println(next_x+" "+x+" λ‘κ°λ€");*/
dfs(map[next_x][x],x,y);
}
}
//xλ
//yλ₯Όμνμμ
while(!startWith[y].isEmpty()){
int next_y = startWith[y].pop(); //y,next_yλ‘
if((y!=x || next_y != y)&&(y!=prv_x || next_y != prv_y)){
/*System.out.println(y+" "+next_y+" λ‘κ°λ€");*/
dfs(map[y][next_y],x,y);
}
}
while(!endWith[y].isEmpty()){
int next_x = endWith[y].pop(); //next_x , yλ‘
if((next_x != x || y !=y)&&(next_x != prv_x||y!= prv_y)){
/*System.out.println(next_x+" "+y+" λ‘κ°λ€");*/
dfs(map[next_x][y],x,y);
}
}
//yλ
}
static class Node{
int x,y;
int nodeIndex = -1;
public Node(int x,int y,int nodeIndex){
this.x= x;
this.y = y;
this.nodeIndex = nodeIndex;
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.*;
/**
* Cf104C
*/
public class Cf104C {
static int arr[][];
static boolean isCycle = false;
static boolean visited[];
static int n, foundNodes = 0, cycles = 0;
static void dfs2(int node) {
if(!visited[node]) {
//System.out.println("Visit " + node);
foundNodes++;
visited[node] = true;
for(int i = 1; i <= n; i++) {
if(arr[node][i] == 1) {
dfs2(i);
}
}
}
}
static void dfs(int node, int parent) {
if(visited[node]) {
isCycle = true;
//System.out.println("A cycle");
cycles++;
arr[node][parent] = 0;
arr[parent][node] = 0;
return;
}
// System.out.println("Visiting " + node);
visited[node] = true;
for(int i = 1; i <= n; i++) {
if(arr[node][i] == 1 && i != parent) {
dfs(i, node);
}
}
visited[node] = false;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int m;
n = sc.nextInt();
m = sc.nextInt();
isCycle = false;
arr = new int[n+1][n+1];
visited = new boolean[n+1];
int a, b;
for(int i = 0; i < m; i++) {
a = sc.nextInt();
b = sc.nextInt();
arr[a][b] = 1;
arr[b][a] = 1;
}
dfs2(1);
if (foundNodes == n) {
for(int i = 0; i<= n; i++) {
visited[i] = false;
}
dfs(1, 1);
if (isCycle) {
if(cycles > 1) {
System.out.println("NO");
}
else {
System.out.println("FHTAGN!");
}
} else {
System.out.println("NO");
}
} else {
System.out.println("NO");
}
}
} | JAVA |
Subsets and Splits