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.Scanner;
public class Cthulhu {
static int[][] graph;
static int num;
static int result=0;
static int[] check;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
num = sc.nextInt();
check = new int[num + 1];
int edge = sc.nextInt();
sc.nextLine();
graph = new int[num + 1][num + 1];
for (int i = 0; i < edge; i++) {
int x = sc.nextInt();
int y = sc.nextInt();
sc.nextLine();
graph[x][y] = 1;
graph[y][x] = 1;
}
int count = 0;
if (num != edge)
System.out.print("NO");
else {
for (int i = 1; i < num + 1; i++) {
if (graph[1][i] == 1) {
graph[1][i] = 2;
graph[i][1] = 2;
check[1] = 1;
find(1, i);
}
}
for (int i = 1; i < num + 1; i++) {
if (check[i] == 0) {
System.out.print("NO");
result = 1;
break;
}
}
if (result == 0) {
System.out.print("FHTAGN!");
}
}
}
public static void find(int before,int x){
for(int i=1;i<num+1;i++) {
check[x]++;
if(graph[x][i]==1 && i!=before) {
graph[x][i]=2;
graph[i][x]=2;
find(x, 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 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Stack;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer k;
int n,m,a,b;
k = new StringTokenizer(in.readLine());
n = Integer.parseInt(k.nextToken());
m = Integer.parseInt(k.nextToken());
LinkedList<Integer> ar [] = new LinkedList[n];
for (int i = 0; i < n; i++) {
ar[i] = new LinkedList<Integer>();
}
for (int i = 0; i < m; i++) {
k = new StringTokenizer(in.readLine());
a = Integer.parseInt(k.nextToken());
b = Integer.parseInt(k.nextToken());
ar[a-1].add(b-1);
ar[b-1].add(a-1);
}
boolean visited [] = new boolean[n];
boolean cycle = false;int no_cycles=0;
Stack<Integer> st = new Stack<Integer>();
st.add(0);
int node;
while(!st.empty()){
node = st.pop();
if(!visited[node]){
for (int i = 0; i < ar[node].size(); i++) {
a = ar[node].get(i);
if(!visited[a])
st.add(a);
}
visited[node]=true;
}
else{
no_cycles++;
}
}
for (int i = 0; i < visited.length; i++) {
if(!visited[i]){
no_cycles=0;
break;
}
}
if(no_cycles==0 || no_cycles >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.util.*;
import java.lang.*;
import java.io.*;
public class Codechef
{ static PrintWriter out=new PrintWriter(System.out);static FastScanner in = new FastScanner(System.in);static class FastScanner {BufferedReader br;StringTokenizer stok;FastScanner(InputStream is) {br = new BufferedReader(new InputStreamReader(is));}
String next() throws IOException {while (stok == null || !stok.hasMoreTokens()) {String s = br.readLine();if (s == null) {return null;}
stok = new StringTokenizer(s);}return stok.nextToken();}
int ni() throws IOException {return Integer.parseInt(next());}long nl() throws IOException {return Long.parseLong(next());}double nd() throws IOException {return Double.parseDouble(next());}char nc() throws IOException {return (char) (br.read());}String ns() throws IOException {return br.readLine();}
int[] nia(int n) throws IOException{int a[] = new int[n];for (int i = 0; i < n; i++)a[i] = ni();return a;}long[] nla(int n) throws IOException {long a[] = new long[n];for (int i = 0; i < n; i++)a[i] = nl();return a;}
double[] nda(int n)throws IOException {double a[] = new double[n];for (int i = 0; i < n; i++)a[i] = nd();return a;}int [][] imat(int n,int m) throws IOException{int mat[][]=new int[n][m];for(int i=0;i<n;i++){for(int j=0;j<m;j++)mat[i][j]=ni();}return mat;}
}
static long mod=Long.MAX_VALUE,ans=0;
static ArrayList<Integer>arr[];
static boolean visited[];
static int a[];
public static void main (String[] args) throws java.lang.Exception
{ int i,j;
HashMap<Integer,Integer> hm=new HashMap<Integer,Integer>();
/* if(hm.containsKey(z))
hm.put(z,hm.get(z)+1);
else
hm.put(z,1);
*/
HashSet<Integer> set=new HashSet<Integer>();
PriorityQueue<Integer> pq=new PriorityQueue<Integer>();
int n=in.ni();
int m=in.ni();
a=new int[n+1];
arr=new ArrayList[n+1];
visited=new boolean[n+1];
for(i=0;i<=n;i++)
arr[i]=new ArrayList<Integer>();
for(i=0;i<m;i++)
{ int p=in.ni();
int q=in.ni();
arr[q].add(p);
arr[p].add(q);
}
dfs(1);
if(ans==n && n==m)
out.println("FHTAGN!");
else
out.println("NO");
out.close();
}
static void dfs(int x)
{ if(visited[x])
return;
visited[x]=true;
ans++;
for(int c:arr[x])
dfs(c);
return;
}
static class pair implements Comparable<pair>{
int x, y;
public pair(int x, int y){this.x = x; this.y = y;}
@Override
public int compareTo(pair arg0)
{ if(x<arg0.x) return -1;
else if(x==arg0.x)
{ if(y<arg0.y) return -1;
else if(y>arg0.y) return 1;
else return 0;
}
else return 1;
}
}
static long gcd(long a,long b)
{ if(b==0)
return a;
return gcd(b,a%b);
}
static long exponent(long a,long n)
{ long ans=1;
while(n!=0)
{ if(n%2==1)
ans=(ans*a)%mod;
a=(a*a)%mod;
n=n>>1;
}
return ans;
}
static int binarySearch(int a[], int item, int low, int high)
{ if (high <= low)
return (item > a[low])? (low + 1): low;
int mid = (low + high)/2;
if(item == a[mid])
return mid+1;
if(item > a[mid])
return binarySearch(a, item, mid+1, high);
return binarySearch(a, item, low, mid-1);
}
static void merge(int arr[], int l, int m, int r) {
int n1 = m - l + 1; int n2 = r - m; int L[] = new int [n1]; int R[] = new int [n2];
for (int i=0; i<n1; ++i) L[i] = arr[l + i]; for (int j=0; j<n2; ++j) R[j] = arr[m + 1+ j]; int i = 0, j = 0; int k = l; while (i < n1 && j < n2) { if (L[i] <= R[j]) { arr[k] = L[i]; i++; } else{ arr[k] = R[j]; j++; } k++; } while (i < n1){ arr[k] = L[i]; i++; k++; } while (j < n2) { arr[k] = R[j]; j++; k++; }
}
static void Sort(int arr[], int l, int r) {if (l < r) { int m = (l+r)/2; Sort(arr, l, m); Sort(arr , m+1, r); merge(arr, l, m, r); } }
static void sort(int a[])
{Sort(a,0,a.length-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 | n,m=map(int,raw_input().split())
a=[[0 for j in xrange(n)]for i in xrange(n)]
for i in xrange(m):
x,y=map(int,raw_input().split())
a[x-1][y-1]=a[y-1][x-1]=1
b=[0 for j in xrange(n)]
t=0
cycle=[]
def rec(q,q1):
global t
global cycle
if b[q]==1:
cycle.append(q)
t=1
return
b[q]=1
for i in xrange(n):
if i==q1: continue
if a[q][i]==1: rec(i,q)
if t==2:return
if t==1:
if q==cycle[0]:
t=2
return
cycle.append(q)
return
def rec1(q,q1):
if b[q]==1:return
b[q]=1
for i in xrange(n):
if i==q1: continue
if a[q][i]==1: rec1(i,q)
rec(0,-1)
if t==0:
print "NO"
exit()
b=[0 for j in xrange(n)]
rec1(0,-1)
if not (0 in b) and m==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.Scanner;
public class Main {
static int vNum;
static int eNum;
static boolean[][] graph;
static boolean[][] graph2;
static boolean[] used;
static int[] cc;
static int cycleQuantity = 0;
static int ccNum;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
vNum = scanner.nextInt();
eNum = scanner.nextInt();
graph = new boolean[vNum][vNum];
graph2 = new boolean[vNum][vNum];
used = new boolean[vNum];
if(vNum == 0 || eNum == 0){
System.out.println("NO");
return;
}
for (int i = 0; i < eNum; i++) {
int a = scanner.nextInt() - 1;
int b = scanner.nextInt() - 1;
graph[a][b] = true;
graph[b][a] = true;
}
solve();
if(cycleQuantity == 1 && ccNum == 1){
System.out.println("FHTAGN!");
}
else {
System.out.println("NO");
}
}
static void solve() {
used = new boolean[vNum];
cc = new int[vNum];
ccNum = 0;
for (int v = 0; v < vNum; v++) {
if (!used[v]) {
ccNum++;
dfs(v);
}
}
}
static void dfs(int v) {
used[v] = true;
for (int nv = 0; nv < vNum; nv++) {
if (nv != v && used[nv] && !graph2[v][nv] && graph[v][nv]) {
cycleQuantity++;
}
graph2[v][nv] = true;
graph2[nv][v] = true;
if (!used[nv] && graph[v][nv]) {
dfs(nv);
}
}
}
}
| 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.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Cthulhu {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//System.out.println(false && false);
Reader r=new Reader();
int n=r.nextInt();
int m=r.nextInt();
Graph g=new Graph();
List<Integer> graph[]=g.createGraph(n);
for(int i=0;i<m;i++){
int x=r.nextInt();
int y=r.nextInt();
g.addEdge(graph, x, y);
}
boolean ans=g.DFS(graph, 0);
//System.out.println(ans);
if(!ans)System.out.println("NO");
else System.out.println("FHTAGN!");
}
static class Graph{
int colour[];
int parent[],cycles=0,comp=0;
public List<Integer> [] createGraph(int n){
List<Integer> graph[]=new List[n];
for(int i=0;i<graph.length;i++)graph[i]=new ArrayList<Integer>();
colour=new int[n];
parent=new int[n];
return graph;
}
public void addEdge(List<Integer> graph[],int s,int d){
graph[s-1].add(d-1);
graph[d-1].add(s-1);
}
public boolean DFS(List<Integer> graph[],int s){
Arrays.fill(colour, 'W');
for(int i=0;i<colour.length;i++){
if(colour[i]=='W'){
DFS_Visit(graph, i,-1);
comp++;
}
}
//System.out.println(cycles);
if(comp>1 || cycles!=1)
return false;
return true;
}
public void DFS_Visit(List<Integer> graph[],int s,int parent){
colour[s]='G';
int size=graph[s].size();
//System.out.println(parent+1+"->"+(s+1));
for(int i=0;i<size;i++){
int get=graph[s].get(i);
// System.out.println((s+1)+"get"+(get+1)+" "+(parent+1));
if(get==parent)continue;
if(colour[get]=='W'){
this.parent[get]=s;
DFS_Visit(graph, get,s);
}
else if(colour[get]=='G'){cycles++;}
}
colour[s]='B';
}
}
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException {
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException {
byte[] buf = new byte[1000000];
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n')
break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (c == '.')
while ((c = read()) >= '0' && c <= '9')
ret += (c - '0') / (div *= 10);
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException {
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (din == null)
return;
din.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 | #include <bits/stdc++.h>
using namespace std;
const long long N = 105;
const long long INF = 100000000000;
const long long mod = 1000000007;
long long parent[N];
void pre() {
for (int i = 0; i < N; i++) parent[i] = i;
}
long long root(long long v) {
return parent[v] = (v == parent[v]) ? v : root(parent[v]);
}
void solve() {
long long n, m, x, y, sx, sy, z, fx, fy;
pre();
cin >> n >> m;
int cnt = 0;
while (m--) {
cin >> x >> y;
int rootx = root(x);
int rooty = root(y);
if (rootx == rooty)
cnt++;
else {
parent[rooty] = rootx;
}
}
int cnt1 = 0;
for (int i = 1; i <= n; i++) {
if (parent[i] == i) {
cnt1++;
}
}
if (cnt1 == 1 && cnt == 1)
cout << "FHTAGN!\n";
else
cout << "NO\n";
}
int main() {
int t;
t = 1;
while (t--) 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 | # Problem from Codeforces
# http://codeforces.com/problemset/problem/103/B
parent = dict()
ranks = dict()
def make_set(N):
global parent, ranks
parent = [i for i in range(N + 5)]
ranks = [0 for i in range(N + 5)]
def find_set(u):
if parent[u] != u:
parent[u] = find_set(parent[u])
return parent[u]
def union_set(u, v):
up = find_set(u)
vp = find_set(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
def solution():
m, n = map(int, input().split())
if m != n:
print('NO')
return
make_set(m)
for i in range(m):
a, b = map(int, input().split())
union_set(a, b)
top_parent = find_set(1)
for i in range(2, m):
if find_set(i) != top_parent:
print('NO')
return
print('FHTAGN!')
solution()
| 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.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main {
private static int n;
private static int m;
private static int[] root, size, deep;
static int cicles;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
st = new StringTokenizer(br.readLine());
n = Integer.parseInt(st.nextToken());
m = Integer.parseInt(st.nextToken());
root = new int[n];
size = new int[n];
deep = new int[n];
for (int i = 0; i < n; i++) {
root[i] = i;
size[i] = 1;
deep[i] = 0;
}
cicles = 0;
while (m-- > 0) {
st = new StringTokenizer(br.readLine());
int u = Integer.parseInt(st.nextToken()) - 1;
int v = Integer.parseInt(st.nextToken()) - 1;
union(u, v);
}
if (solve()) System.out.println("FHTAGN!");
else System.out.println("NO");
}
private static boolean solve() {
int current = find(0);
for (int i = 1; i < n; i++) {
if (find(i) != current) return false;
}
return cicles == 1;
}
private static void union(int u, int v) {
if (deep[u] < deep[v] || (deep[u] == deep[v] && size[u] < size[v])) {
trueUnion(u, v);
} else {
trueUnion(v, u);
}
}
private static void trueUnion(int u, int v) {
if (find(u) == find(v)) cicles++;
else {
update(u, v);
}
}
private static int update(int u, int v) {
if (root[u] == u) return root[u] = root[v];
return root[u] = update(root[u], v);
}
private static int find(int u) {
if (root[u] == u) return u;
return root[u] = find(root[u]);
}
}
// 1500578796015
| 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 | 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 = {};
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) {
//print('u = '+u+', parent = '+parent);
if (seen[u]) {
cycle.push(u);
return true;
}
seen[u] = true;
count += 1;
var vs = v2v[u];
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;
}
for (var u = 1; u <= n; ++u) {
if (v2v[u] !== undefined) {
search(u, -1);
break;
}
}
//print(found);
//print(cycle.join(' '));
if (cycle.length < 3 || n != m) {
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 | #include <bits/stdc++.h>
using namespace std;
void dfs(int node, vector<int> adj[], bool vis[], int &flag, int par) {
if (vis[node]) return;
vis[node] = true;
flag += 1;
for (auto it : adj[node]) {
if (!vis[it]) dfs(it, adj, vis, flag, node);
}
}
int main() {
int n, m;
cin >> n >> m;
vector<int> adj[n + 1];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
bool vis[n + 1];
memset(vis, false, sizeof(vis));
int flag = 0;
dfs(1, adj, vis, flag, -1);
bool flag1 = true;
if (flag != n || m != 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.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
public class B103 {
static class guy {
LinkedList<guy> guys;
public guy() {
guys = new LinkedList<guy>();
}
public void die() {
guys.poll().guys.remove(this);
}
public void add(guy o) {
guys.add(o);
o.guys.add(this);
}
public boolean dumb() {
return guys.size() == 1;
}
}
public static void main(String[] args) throws Exception {
BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
String[] s = r.readLine().split(" ");
int n = Integer.parseInt(s[0]);
int m = Integer.parseInt(s[1]);
if (m != n) {
System.out.println("NO");
return;
}
guy guys[] = new guy[n];
for (int x = 0; x < n; x++) {
guys[x] = new guy();
}
for (int x = 0; x < n; x++) {
s = r.readLine().split(" ");
int a = Integer.parseInt(s[0]) - 1, b = Integer.parseInt(s[1]) - 1;
guys[a].add(guys[b]);
}
int count = n;
for (int x = 0; x < n; x++) {
for (int y = 0; y < n; y++) {
if (guys[y].dumb()) {
guys[y].die();
count--;
}
}
}
for (int x = 0; x < n; x++) {
if (guys[x].guys.size() == 2) {
guy start = guys[x];
start.guys.pollLast();
while (start.guys.size() == 1) {
guy next = start.guys.get(0);
start.die();
start = next;
count--;
}
if (count == 0) {
System.out.println("FHTAGN!");
} else
System.out.println("NO");
return;
}
}
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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Main {
static int cycle=0;
public static void main(String[] args) throws NumberFormatException, IOException {
BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
PrintWriter pr=new PrintWriter(System.out);
StringTokenizer str=new StringTokenizer(r.readLine());
int n=Integer.parseInt(str.nextToken());
int m=Integer.parseInt(str.nextToken());
boolean a[][]=new boolean[n+1][n+1];
for(int i=1;i<=m;i++)
{
str=new StringTokenizer(r.readLine());
int x=Integer.parseInt(str.nextToken());
int y=Integer.parseInt(str.nextToken());
a[x][y]=a[y][x]=true;
}
boolean b[]=new boolean[n+1];
int parent[]=new int[n+1];
dfs(a,b,parent,1,n);
boolean check=true;
for(int i=1;i<=n;i++)
{
check=check&&b[i];
}
if(check&&cycle==2)
{
pr.println("FHTAGN!");
}
else
pr.println("NO");
pr.flush();
pr.close();
}
public static void dfs(boolean a[][],boolean b[],int parent[],int root,int n)
{
b[root]=true;
for(int i=1;i<=n;i++)
{
if(a[root][i])
{
if(b[i])
{
if(i!=parent[root])
cycle++;
}
else
{
parent[i]=root;
dfs(a,b,parent,i,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;
const int M = 100;
vector<int> adj[M];
bool seen[M];
int n, m;
int ans;
int find_cycle(int p, int u) {
seen[u] = 1;
for (int i : adj[u]) {
if (i == p) continue;
if (seen[i] || find_cycle(u, i)) return 1;
seen[i] = 0;
}
return 0;
}
void dfs(int u) {
seen[u] = 1;
for (int i : adj[u]) {
if (!seen[i]) dfs(i);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 0; i < n; i++) {
memset(seen, 0, sizeof seen);
int cycle_len = 0;
if (find_cycle(-1, i)) {
for (int j = 0; j < n; j++) cycle_len += seen[j];
}
ans = max(ans, cycle_len);
}
memset(seen, 0, sizeof seen);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (!seen[i]) {
dfs(i);
cnt++;
}
}
if (ans > 2 && cnt == 1 && n == m)
printf("FHTAGN!\n");
else
printf("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>
using namespace std;
bool cmp(pair<long long int, char> p1, pair<long long int, char> p2) {
return p1.first > p2.first;
}
long long int k = 0;
vector<vector<long long int> > graph;
vector<long long int> vis, cycvisit;
vector<long long int> cycedge;
bool ans = false;
void dfs(long long int node) {
vis[node] = 1;
long long int i, j;
for (i = 0; i < graph[node].size(); i++) {
if (vis[graph[node][i]] == 2 and cycvisit[node] == false and
cycvisit[graph[node][i]] == false and k == 0) {
ans = true;
cycedge[graph[node][i]] += 1;
cycedge[node] += 1;
cycvisit[graph[node][i]] = true;
cycvisit[node] = true;
} else if (vis[graph[node][i]] == 2 and
(cycvisit[node] != false or cycvisit[graph[node][i]] != false)) {
ans = false;
k++;
}
if (vis[graph[node][i]] == 0) {
dfs(graph[node][i]);
}
}
vis[node] = 2;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, n, m, x, y;
cin >> n >> m;
graph.resize(n + 1);
vis.resize(n + 1);
cycedge.resize(n + 1);
cycvisit.resize(n + 1);
for (i = 1; i <= n; i++) {
vis[i] = 0;
cycedge[i] = 0;
cycvisit[i] = false;
}
for (i = 1; i <= m; i++) {
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
dfs(1);
for (i = 1; i <= n; i++)
if (vis[i] == 0 or cycedge[i] > 2) ans = false;
if (ans == true)
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 |
import java.util.Scanner;
public class spinningTree {
public int [] parentNodes;
spinningTree(int n) {
parentNodes = new int[n];
for (int i=0;i<n;i++){
parentNodes[i]=i+1;
}
}
public int find_set(int x){
if (x==parentNodes[x-1]){
return x;
}
return parentNodes[x-1]=find_set(parentNodes[x-1]);
}
public int count=0;
public void merge (int a,int b){
if (find_set(a)!=find_set(b)){
parentNodes[find_set(a)-1]=parentNodes[find_set(b)-1];
}
else
count++;
}
public static void main(String[] args) {
// TODO Auto-generated method
Scanner input = new Scanner (System.in);
int n = input.nextInt();
int m= input.nextInt();
spinningTree test = new spinningTree(n);
int[][] edgez=new int[m][2];
for (int j=0;j<m;j++){
edgez[j][0]=input.nextInt();
edgez[j][1]=input.nextInt();
test.merge(edgez[j][0],edgez[j][1]);
}
boolean check=false;
int x=0;
for (int j=0;j<n;j++){
if (j==0){
x=test.find_set(j+1);
}
if (x!=test.find_set(j+1)){
check=true;
break;
}
}
if ((test.count==1)&&(!check)){
System.out.print("FHTAGN!");
}
else
{
System.out.print("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 cthulhuCF {
public static int disjoint[];
public static int size[];
public static int find(int v) {
if (disjoint[v] == -1) {
return v;
}
disjoint[v] = find(disjoint[v]);
return disjoint[v];
}
public static void union(int u, int v) {
int uroot = find(u);
int vroot = find(v);
if (uroot == vroot) {
return;
}
if (size[uroot] < size[vroot]) {
disjoint[uroot] = vroot;
size[vroot] = size[uroot] + size[vroot];
} else {
disjoint[vroot] = uroot;
size[uroot] = size[uroot] + size[vroot];
}
}
public static void main (String[]args) {
Scanner scan = new Scanner (System.in);
int nodeNumber = scan.nextInt();
int edgeNumber = scan.nextInt();
disjoint = new int [nodeNumber];
size = new int [nodeNumber];
Arrays.fill(disjoint, -1);
Arrays.fill(size, 1);
int cycleNumber = 0;
for (int i = 0; i < edgeNumber; i++) {
int firstNode = scan.nextInt();
int secondNode = scan.nextInt();
firstNode--;
secondNode--;
if ((find(firstNode) == find(secondNode)) && (find(firstNode) != -1)) {
cycleNumber++;
}
union(firstNode, secondNode);
}
if ((cycleNumber == 1) && (size[find(0)] == nodeNumber)) {
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;
const int N = 150;
int a, b, c, n, m;
int root[N];
void make_set(int vertex) { root[vertex] = vertex; }
int find_set(int vertex) {
if (root[vertex] != vertex) root[vertex] = find_set(root[vertex]);
return root[vertex];
}
void union_set(int vertex1, int vertex2) {
int leader1 = find_set(vertex1);
int leader2 = find_set(vertex2);
root[leader1] = leader2;
}
int main() {
scanf("%d%d\n", &n, &m);
if (m != n) {
puts("NO");
return 0;
}
for (a = 0; a < n; a++) make_set(a);
for (a = 0; a < m; a++) {
int vertex1, vertex2;
scanf("%d%d\n", &vertex1, &vertex2);
union_set(vertex1 - 1, vertex2 - 1);
}
for (a = 0; a < n - 1; a++)
if (find_set(a) != find_set(a + 1)) {
puts("NO");
return 0;
}
puts("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>
int father[105];
int find(int x) {
if (x != father[x]) father[x] = find(father[x]);
return father[x];
}
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
int a, b, i;
for (i = 1; i <= n; i++) father[i] = i;
for (i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
father[find(a)] = find(b);
}
int count = 0;
for (i = 1; i <= n; i++)
if (father[i] == i) count++;
if (count == 1 && m == 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.Scanner;
public class Cthulhu {
static int counter = 0 ;
static int n ;
static int size ;
static boolean[][] g ;
static boolean[] visited ;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
int m ;
int i , j ;
n = scan.nextInt();
m = scan.nextInt();
size = n+1 ;
g = new boolean[size][size];
visited = new boolean[size];
for (i=0 ; i<size ; i++)
{
for (j=0 ; j<size ; j++)
{
g[i][j] = false;
}
visited[i] = false;
}
for (int line=0 ; line<m ; line++)
{
i = scan.nextInt();
j = scan.nextInt();
g[i][j] = true ;
g[j][i] = true ;
}
// for (i=0 ; i<size ; i++)
// {
// for (j=0 ; j<size ; j++)
// {
// System.out.print(g[i][j]+" ");
// }
// System.out.println();
// }
if (n==m)
{
dfs(1);
if (counter==n)
System.out.println("FHTAGN!");
else
System.out.println("NO");
}
// else if ((n != m) || (counter!=n))
// {
//
// }
else
System.out.println("NO");
// System.out.println("counter="+counter);
}
static void dfs(int i){
// int k , l ;
// System.out.println("dfs");
// for (k=0 ; k<size ; k++)
// {
// for (l=0 ; l<size ; l++)
// {
// System.out.print(g[k][l]+" ");
// }
// System.out.println();
// }
visited[i] = true;
// System.out.println("dfs_counter="+counter);
counter++ ;
for(int j = 0;j<size;j++)
{
// System.out.println("i = "+i+"j = "+j+" ; g[i][j] = "+g[i][j]+" ; visited[j] = "+visited[j]);
if(g[i][j] && !visited[j])
{
dfs(j);
}
}
}
}
| 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>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
long long INF = 1000 * 1000 * 1000;
vector<int> p;
vector<int> r;
void make_set(int v) {
p[v] = v;
r[v] = 0;
}
int find_set(int v) {
if (v == p[v]) return v;
return p[v] = find_set(p[v]);
}
void union_set(int a, int b) {
a = find_set(a);
b = find_set(b);
if (r[a] < r[b]) swap(a, b);
p[b] = a;
if (r[a] == r[b]) r[a]++;
}
int main() {
int n, m;
cin >> n >> m;
p.resize(n + 1);
r.resize(n + 1);
for (int i = 1; i <= n; ++i) make_set(i);
int c = 0;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a = find_set(a);
b = find_set(b);
if (a == b) c++;
union_set(a, b);
}
int a = find_set(1);
for (int i = 2; i <= n; ++i)
if (a != find_set(i)) {
cout << "NO";
return 0;
}
if (c == 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.DataInputStream;
import java.io.InputStream;
public class Cthulhu {
static boolean w [][];
static boolean ww [][];
static int cycle [] ;
static int ic = 0;
static boolean ch [];
static int cyc = -1;
static int n ;
static int reach ;
public static void main(String [] args) throws Exception{
FS in = new FS(System.in);
n = in.nextInt();
int m = in.nextInt();
if(m>n) {
System.out.println("NO");
return;
}
w = new boolean [n][n];
ww = new boolean [n][n];
ch = new boolean[n];
cycle = new int[n];
for(int i = 0 ; i < m ; i++){
int j = in.nextInt()-1;
int k = in.nextInt()-1;
w[j][k] = true;
w[k][j] = true;
ww[j][k] = true;
ww[k][j] = true;
}
reach = 0;
DFS(0,0);
if(cyc==-1){
System.out.println("NO");
return;
}
if(reach==n){
System.out.println("FHTAGN!");
}
else{
System.out.println("NO");
}
}
public static void DFS(int a ,int k){
if(ch[a]){
if(cyc!=-1){
System.out.println("NO");
System.exit(0);
}
else {
cyc = a;
ic = k;
}
}
else{
cycle[k]= a;
ch[a]=true;
reach++;
for(int i = 0 ; i < n ; i++){
if(w[a][i]){
w[a][i]=w[i][a]=false;
DFS(i,k+1);
}
}
}
}
}
class FS
{
final private int BUFFER_SIZE = 1 << 17;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public FS(InputStream in)
{
din = new DataInputStream(in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String nextString() throws Exception
{
StringBuffer sb=new StringBuffer("");
byte c = read();
while (c <= ' ') c = read();
do
{
sb.append((char)c);
c=read();
}while(c>' ');
return sb.toString();
}
public char nextChar() throws Exception
{
byte c=read();
while(c<=' ') c= read();
return (char)c;
}
public int nextInt() throws Exception
{
int ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = c == '-';
if (neg) c = read();
do
{
ret = ret * 10 + c - '0';
c = read();
} while (c > ' ');
if (neg) return -ret;
return ret;
}
public long nextLong() throws Exception
{
long ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = c == '-';
if (neg) c = read();
do
{
ret = ret * 10 + c - '0';
c = read();
} while (c > ' ');
if (neg) return -ret;
return ret;
}
private void fillBuffer() throws Exception
{
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) buffer[0] = -1;
}
private byte read() throws Exception
{
if (bufferPointer == bytesRead) fillBuffer();
return buffer[bufferPointer++];
}
} | 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;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
public class Task103B {
static boolean[] visited;
static List<List<Integer>> g;
public static void main(String[] args) throws IOException {
InputScanner is = new InputScanner();
int n = is.nextInt();
int m = is.nextInt();
g = new ArrayList<>(n + 1);
visited = new boolean[n + 1];
for (int i = 0; i <= n + 1; i++) g.add(new ArrayList<>());
for (int i = 0; i < m; i++) {
int a = is.nextInt();
int b = is.nextInt();
g.get(a).add(b);
g.get(b).add(a);
}
int x = 0;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
x++;
dfs(i);
}
}
if (x == 1 && n == m) {
System.out.println("FHTAGN!");
} else System.out.println("NO");
}
static void dfs(int n) {
visited[n] = true;
for (Integer i : g.get(n))
if (!visited[i]) dfs(i);
}
static class InputScanner {
BufferedReader br;
StringTokenizer st;
public InputScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public String next() throws IOException {
if (st == null || !st.hasMoreTokens()) {
String line = br.readLine();
st = new StringTokenizer(line);
}
return st.nextToken();
}
public int nextInt() throws IOException {
String next = next();
return Integer.parseInt(next);
}
public long nextLong() throws IOException {
String next = next();
return Long.parseLong(next);
}
}
}
| 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;
import java.io.PrintStream;
import java.util.StringTokenizer;
public class Main {
public BufferedReader input;
public PrintStream output;
public StringTokenizer stoken = new StringTokenizer("");
int n;
int m;
int mas [][];
int count_versh = 0;
boolean visited [];
public static void main(String[] args) throws IOException {
new Main();
}
Main() throws IOException{
input = new BufferedReader(
new InputStreamReader(System.in)
);
output = System.out;
n = nextInt();
m = nextInt();
mas = new int [n][n];
for (int i=0; i<m; i++){
int x = nextInt()-1;
int y = nextInt()-1;
mas[x][y] = 1;
mas[y][x] = 1;
}
int v = 0;
visited = new boolean [n];
boolean key = dfs(v);
output.print( (n==m) && (key) ? "FHTAGN!" : "NO" );
input.close();
output.close();
}
private boolean dfs(int v) {
count_versh++;
visited[v] = true;
for (int i=0; i<n; i++){
if ((mas[v][i]==1) && (!visited[i])){
dfs(i);
}
}
return ( count_versh==n ? true : false );
}
private int nextInt() throws NumberFormatException, IOException {
return Integer.parseInt(nextString());
}
private String nextString() throws IOException {
while (!stoken.hasMoreTokens()){
String st = input.readLine();
stoken = new StringTokenizer(st);
}
return stoken.nextToken();
}
}
| 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 = 110;
int n, m;
int fa[maxn];
bool vis[maxn];
int findset(int x) { return fa[x] == -1 ? x : fa[x] = findset(fa[x]); }
int Bind(int u, int v) {
int fu = findset(u);
int fv = findset(v);
if (fu != fv) {
fa[fu] = fv;
return 1;
}
return 0;
}
int main() {
cin >> n >> m;
memset(fa, -1, sizeof fa);
int num = n;
bool f = true, ff = true;
while (m--) {
int u, v;
cin >> u >> v;
int tmp = Bind(u, v);
num -= tmp;
if (tmp == 0) {
if (ff) {
ff = false;
} else
f = false;
}
}
if (num != 1 || !f || ff)
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;
long long n, m, st = -1, en = -1, c = 0, t = 0;
vector<long long> ad[105];
map<long long, long long> vis, p;
void dfs(long long i, long long pa = 0) {
p[i] = pa;
t++;
vis[i] = 1;
for (auto x : ad[i]) {
if (x == pa) continue;
if (vis[x]) {
c++;
} else
dfs(x, i);
}
}
void solve() {
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
ad[x].push_back(y);
ad[y].push_back(x);
}
dfs(1);
c = c / 2;
if (c > 1 || c == 0 || t < n)
cout << "NO";
else
cout << "FHTAGN!";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long TESTS = 1;
while (TESTS--) {
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 | import java.util.*;
public class Cthulu {
public static class Graph
{
public int V;
ArrayList<Integer> adjList[];
public Graph(int V)
{
this.V = V;
adjList = new ArrayList[V];
for(int i = 0; i < V ; i++){
adjList[i] = new ArrayList<Integer>();
}
}
public void addEdge(int src, int dest, boolean bidirectional)
{
this.adjList[src].add(dest);
if (bidirectional) {
this.adjList[dest].add(src);
}
}
public void printGraph()
{
for(int v = 0; v < this.V; v++)
{
System.out.println("Vertex "+ v + ":");
System.out.print("Conntected to ");
for(Integer pCrawl: this.adjList[v]){
System.out.print(pCrawl + " ");
}
System.out.println("\n");
}
}
public void dfs(int s, boolean[] visited) {
if (visited[s]) return;
visited[s] = true;
//process
for (int u: adjList[s]) {
dfs(u,visited);
}
}
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int m = input.nextInt();
if (n!=m) {
System.out.println("NO");
System.exit(0);
}
Graph g = new Graph(m);
for (int i = 0; i<m; i++) {
g.addEdge(input.nextInt()-1, input.nextInt()-1, true);
}
boolean[] visited = new boolean[n];
g.dfs(0,visited);
for (int i = 0; i<n; i++) {
if (!visited[i]) {
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 java.util.*;
import java.io.*;
public class Main implements Runnable {
boolean[] visited;
public void solve() throws IOException {
int n = nextInt();
int m = nextInt();
if (n != m) {
System.out.println("NO");
return;
}
boolean[][] board = new boolean[n][n];
visited = new boolean[n];
for (int i = 0; i < board.length; i++) {
int a = nextInt() - 1;
int b = nextInt() - 1;
board[a][b] = true;
board[b][a] = true;
}
dfs(board, 0);
for (int i = 0; i < n; i++) {
if (!visited[i]) {
System.out.println("NO");
return;
}
}
System.out.println("FHTAGN!");
}
void dfs(boolean[][] board, int ind) {
visited[ind] = true;
for (int i = 0; i < board.length; i++) {
if (board[ind][i] && !visited[i]) {
dfs(board, i);
}
}
}
int answer(int[] a, int[] b) {
int n = a.length;
b = b.clone();
a = a.clone();
for (int i = 0; i < n; i++) {
if (b[i] >= 0) {
merge(a, i, b[i]);
}
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] < 0) {
cnt++;
}
}
return cnt;
}
void merge(int[] arr, int a, int b) {
a = get(arr, a);
b = get(arr, b);
if (a != b) {
arr[a] = b;
}
}
int get(int[] arr, int a) {
if (arr[a] < 0) {
return a;
}
return arr[a] = get(arr, arr[a]);
}
void shuffle(int[] a) {
int N = a.length;
for (int i = 0; i < N / 2; i++) {
int j = (int) (Math.random() * N);
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
void print(int[] a) {
System.out.println();
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
}
void print(int[][] arr) {
System.out.println();
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
boolean nextPermutation(int[] arr) {
int f = -1;
for (int i = arr.length - 2; i >= 0; i--) {
if (arr[i + 1] > arr[i]) {
f = i;
break;
}
}
if (f == -1) {
return false;
}
int s = -1;
for (int i = arr.length - 1; i >= 0; i--) {
if (arr[i] > arr[f]) {
s = i;
break;
}
}
int d = arr[f];
arr[f] = arr[s];
arr[s] = d;
f++;
int l = arr.length - 1;
while (f < l) {
d = arr[f];
arr[f] = arr[l];
arr[l] = d;
f++;
l--;
}
return true;
}
//-----------------------------------------------------------
public static void main(String[] args) {
new Main().run();
}
public void run() {
try {
in = new BufferedReader(new InputStreamReader(System.in));
tok = null;
solve();
in.close();
} catch (IOException e) {
System.exit(0);
}
}
public String nextToken() throws IOException {
while (tok == null || !tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
public long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
public double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
BufferedReader in;
StringTokenizer tok;
}
| 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 | num_nodes,num_edges = map(int,input().split())
edges = {}
for i in range(num_edges):
node1,node2 = map(int,input().split())
keys = list(edges.keys())
if node1 in keys:
edges[node1].append(node2)
else:
edges[node1]=[node2]
if node2 in keys:
edges[node2].append(node1)
else:
edges[node2]=[node1]
def get_neighbors(edges,node):
neighbors = edges[node]
return neighbors
def DFS(edges, node):
explorados = {node}
to_explore = []
for n in get_neighbors(edges, node):
to_explore.append(n)
while len(to_explore)>0:
atual = to_explore[-1]
to_explore.pop(-1)
explorados.add(atual)
neighbors = get_neighbors(edges,atual)
for n in neighbors:
if n not in explorados:
to_explore.append(n)
return explorados
total = 0
for node1 in list(edges.keys()):
explorados_final = DFS(edges,node1)
if len(explorados_final)>=num_nodes:
total+=1
if total>=3 and num_edges==num_nodes:
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 int INF = 1e18;
const long long int N = 1e5 + 5;
long long int mod = 998244353;
void dfs(long long int node, long long int rank, vector<long long int> &vis,
vector<vector<long long int>> &g, long long int &cnt) {
vis[node] = rank;
for (auto &nbr : g[node]) {
if (vis[nbr] == -1) {
dfs(nbr, rank + 1, vis, g, cnt);
} else if (rank - vis[nbr] >= 2) {
cnt++;
}
}
}
void null() {
long long int n, m;
cin >> n >> m;
vector<vector<long long int>> g(n + 1);
for (long long int i = 0; i < m; i++) {
long long int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
vector<long long int> vis(n + 1, -1);
long long int cnt = 0;
dfs(1, 1, vis, g, cnt);
for (long long int i = 1; i < n + 1; i++) {
if (vis[i] == -1) {
cout << "NO\n";
return;
}
}
if (cnt == 1)
cout << "FHTAGN!";
else
cout << "NO";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
cout << setprecision(4);
cout << fixed;
long long int t = 1;
clock_t start, end;
start = clock();
while (t--) {
null();
}
end = clock();
double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
}
| 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 MAX_N = 100;
vector<int> g[MAX_N];
vector<bool> mark(MAX_N, false);
void dfs(int v, int n) {
int vis = 0;
stack<int> s;
s.push(v);
mark[v] = true;
while (s.empty() == false) {
int u = s.top();
vis++;
s.pop();
for (int i = 0; i < g[u].size(); i++) {
if (mark[g[u][i]] == false) {
s.push(g[u][i]);
mark[g[u][i]] = true;
}
}
}
if (vis != n) {
cout << "NO" << endl;
} else {
cout << "FHTAGN!" << endl;
}
}
int main() {
int n, m;
cin >> n >> m;
int inp1, inp2;
if (n != m) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < m; i++) {
cin >> inp1 >> inp2;
inp1--;
inp2--;
g[inp1].push_back(inp2);
g[inp2].push_back(inp1);
}
dfs(0, 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.io.*;
import java.awt.geom.Point2D;
import java.text.*;
import java.math.*;
import java.util.*;
public class Main implements Runnable {
final String filename = "";
boolean[] meetBefore;
boolean[][] a;
public void deepSearch(int x) {
for (int i = 0; i < a[x].length; i++)
if (a[x][i] && !meetBefore[i]) {
meetBefore[i] = true;
deepSearch(i);
}
}
public void solve() throws Exception {
int n = iread();
int m = iread();
a = new boolean[n][n];
for (int i = 0; i < m; i++) {
int x = iread() - 1;
int y = iread() - 1;
a[x][y] = a[y][x] = true;
}
meetBefore = new boolean[n];
deepSearch(0);
boolean f = false;
for (int i = 0; i < n; i++)
if (!meetBefore[i]) {
f = true;
break;
}
if(f||m!=n)
out.write("NO");
else
out.write("FHTAGN!");
}
public void run() {
try {
in = new BufferedReader(new InputStreamReader(System.in));
out = new BufferedWriter(new OutputStreamWriter(System.out));
// in = new BufferedReader(new FileReader(filename+".in"));
// out = new BufferedWriter(new FileWriter(filename+".out"));
solve();
out.flush();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
public int iread() throws Exception {
return Integer.parseInt(readword());
}
public double dread() throws Exception {
return Double.parseDouble(readword());
}
public long lread() throws Exception {
return Long.parseLong(readword());
}
BufferedReader in;
BufferedWriter out;
public String readword() throws IOException {
StringBuilder b = new StringBuilder();
int c;
c = in.read();
while (c >= 0 && c <= ' ')
c = in.read();
if (c < 0)
return "";
while (c > ' ') {
b.append((char) c);
c = in.read();
}
return b.toString();
}
public static void main(String[] args) {
try {
Locale.setDefault(Locale.US);
} catch (Exception e) {
}
// new Thread(new Main()).start();
new Thread(null, new Main(), "1", 1 << 25).start();
}
} | 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, cnt = 0;
bool vst[101] = {}, g[101][101] = {};
inline void dfs(int a) {
++cnt;
vst[a] = 1;
for (int i = 1; i <= n; ++i)
if (g[a][i] && !vst[i]) dfs(i);
}
int main() {
int m, x, y;
scanf("%d%d", &n, &m);
if (n == m) {
while (m--) {
scanf("%d%d", &x, &y);
g[x][y] = 1;
g[y][x] = 1;
}
dfs(1);
if (cnt == n) {
printf("FHTAGN!");
return 0;
}
}
printf("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 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
import java.util.Scanner;
/**
*
* @author JAVA
*/
public class C_800 {
static boolean v[][];
static int count = 0;
static boolean t[];
static int n;
public static void main(String[] args) {
Scanner in =new Scanner(System.in);
n = in.nextInt();
int m = in.nextInt();
v = new boolean[n][n];
t = new boolean[n];
for (int i =0; i<m; i++){
int x = in.nextInt()-1;
int y = in.nextInt()-1;
v[x][y] = v[y][x] = true;
}
dfs(0);
if (n == count && m==n)
System.out.println("FHTAGN!");
else
System.out.println("NO");
}
static void dfs(int i) {
if (t[i])
return;
count++;
t[i] = true;
for (int j=0; j<n; j++){
if (v[i][j])
dfs(j);
}
}
}
| 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 = 1e2 + 5;
int vis[N], n, m;
vector<int> adj[N];
void DFS(int u) {
vis[u] = 1;
for (auto v : adj[u]) {
if (!vis[v]) DFS(v);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
int comps = 0;
for (int i = 0; i < n; i++) {
if (!vis[i]) {
DFS(i);
comps++;
}
}
if (comps == 1 && n == m)
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;
string FILENAME = "filename";
struct dsuNode {
int V, R = 0;
dsuNode* P = NULL;
dsuNode(int val) { V = val; }
};
dsuNode* dsuID(dsuNode* ND) {
dsuNode* old = ND;
while ((*ND).P != NULL) ND = (*ND).P;
if (old != ND) (*old).P = ND;
return ND;
}
void dsuJoin(dsuNode* A, dsuNode* B) {
dsuNode *AP = dsuID(A), *BP = dsuID(B);
if ((*AP).R == (*BP).R) (*BP).R++;
if ((*AP).R <= (*BP).R)
(*AP).P = BP;
else
(*BP).P = AP;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
unordered_map<int, unordered_set<int>> G;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
G[a].insert(b);
G[b].insert(a);
}
unordered_set<int> incl;
dsuNode* dsu[n + 1];
for (int i = 0; i < n + 1; i++) dsu[i] = new dsuNode(i);
int count = 0, cc = 0;
for (int i = 1; i <= n; i++) {
incl.insert(i);
cc++;
for (auto& nb : G[i]) {
if (!incl.count(nb)) continue;
if ((*dsuID(dsu[nb])).V == (*dsuID(dsu[i])).V) {
count++;
continue;
};
dsuJoin(dsu[nb], dsu[i]);
cc--;
}
}
if (count == 1 && cc == 1)
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 | #include <bits/stdc++.h>
using namespace std;
const int maxN = 100 + 10;
int n, m;
bool mark[maxN];
int par[maxN];
vector<int> v[maxN];
bool be[maxN][maxN];
int ans = 0;
void dfs(int x) {
mark[x] = true;
for (int i = 0; i < v[x].size(); i++) {
int tmp = v[x][i];
if (mark[tmp] == false) {
par[tmp] = x;
dfs(tmp);
} else if (mark[tmp] == true && tmp != par[x] && be[x][tmp] == false &&
be[tmp][x] == false) {
ans++;
be[x][tmp] = true;
be[tmp][x] = true;
}
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
par[1] = -1;
int tk = 0;
for (int i = 1; i <= n; i++)
if (mark[i] == false) {
tk++;
dfs(1);
}
if (ans == 1 && tk == 1)
cout << "FHTAGN!";
else
cout << "NO";
int _;
cin >> _;
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;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int vis[100007], cnt, head[10007];
struct node {
int u, v, next;
} e[10007];
inline void ins(int u, int v) {
e[++cnt] = (node){u, v, head[u]};
head[u] = cnt;
}
inline void insert(int u, int v) { ins(u, v), ins(v, u); }
void dfs(int x) {
vis[x] = 1;
for (int i = head[x]; i; i = e[i].next)
if (!vis[e[i].v]) dfs(e[i].v);
}
int main() {
int n = read(), m = read();
for (int i = 1; i <= m; i++) insert(read(), read());
dfs(1);
for (int i = 1; i <= n; i++)
if (!vis[i]) {
printf("NO");
return 0;
}
if (n == m)
printf("FHTAGN!");
else
printf("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.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class Cthulhu {
static ArrayList<Integer> [] adj;
static boolean [] visited;
public static void dfs(int u)
{
visited[u]=true;
int n=adj[u].size();
for (int i=0;i<n;i++)
{
int v=adj[u].get(i);
if(!visited[v])
dfs(v);
}
}
public static void main(String[] args) throws IOException {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
if(n!=m)
{
System.out.println("NO");
return;
}
adj=new ArrayList [n+1];
for (int i=1;i<=n;i++)
adj[i]=new ArrayList ();
while(m-->0)
{
int u=sc.nextInt();
int v=sc.nextInt();
adj[u].add(v);
adj[v].add(u);
}
visited=new boolean [n+1];
dfs(1);
for (int i=1;i<=n;i++)
if(!visited[i])
{
System.out.println("NO");
return;
}
System.out.println("FHTAGN!");
}
}
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 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 50;
int n, m, u, v, cnt, cycle;
vector<int> l[N];
int visited[N];
void dfs(int u, int par) {
if (visited[u] == 1) {
cycle++;
return;
}
if (visited[u] == 2) {
return;
}
cnt++;
visited[u]++;
for (auto i : l[u]) {
if (i != par && visited[i] < 2) {
dfs(i, u);
}
}
visited[u] = 2;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
l[u].push_back(v);
l[v].push_back(u);
}
dfs(1, 0);
if (cnt < n || cycle > 1 || cycle < 1) {
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 | #include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class T>
inline T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
inline T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(a, max(b, c, d));
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(a, min(b, c, d));
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T gcd(T a, T b) {
T t;
if (a < b) {
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
} else {
while (b) {
t = b;
b = a % b;
a = t;
}
return a;
}
}
inline void judge() {
freopen("JHOSM.in", "r", stdin);
freopen("JHOSM.out", "w", stdout);
freopen("JHOSM.err", "w", stderr);
;
cout << setprecision(20) << fixed;
}
inline bool dig(char chr) { return (chr >= '0' && chr <= '9') ? true : false; }
const int mod = (int)(1e9) + 7;
const long long inf = 1e9 + 7;
const int dx[] = {0, 1, 0, -1, 0, 1, -1, 1, -1};
const int dy[] = {-1, 0, 1, 0, -1, 1, -1, -1, 1};
int n;
int g[110][110];
int vis[110];
int CantVertVis;
void dfs(int x) {
vis[x] = 1;
CantVertVis++;
for (int i = 1; i <= n; i++) {
if (!vis[i] && g[x][i]) dfs(i);
}
}
inline void JHOSM() {
int m;
cin >> n >> m;
int M = m;
memset(vis, 0, sizeof(vis));
int u, v;
while (M--) {
cin >> u >> v;
g[u][v] = g[v][u] = 1;
}
if (m == n) {
CantVertVis = 0;
dfs(1);
if (CantVertVis == n)
cout << "FHTAGN!" << '\n';
else
cout << "NO" << '\n';
} else
cout << "NO" << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
int T = 1;
while (T--) JHOSM();
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 | n, m = map(int, input().split())
if n < 3 or n != m:
print('NO')
exit()
e, f = [[] for i in range(n + 1)], set()
for j in range(m):
x, y = map(int, input().split())
e[x].append(y)
e[y].append(x)
def dfs(x):
f.add(x)
for y in e[x]:
if not y in f:
dfs(y)
dfs(1)
print('FHTAGN!' if len(f) == 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 |
import java.util.ArrayList;
import java.util.Scanner;
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author Eslam Ashraf
*/
public class C80 {
static boolean [][] g;
static int [] visit;
static int n ;
static int [] parent;
static int cycleCounter;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
n = in.nextInt();
int m = in.nextInt();
g = new boolean[n][n];
visit = new int[n];
parent = new int[n];
for(int i =0 ; i < n ;i++)parent[i]=i;
int first , second;
for(int i =0 ;i < m ;i++){
first = in.nextInt()-1;
second = in.nextInt()-1;
g[first][second]=true;
g[second][first]=true;
}
int comp=0;
for(int i =0 ; i < n ;i++)
if(visit[i]==0){
dfs(i);
comp++;
}
if(comp>1){
System.out.println("NO");
System.exit(0);
}
visit= new int [n];
cycleCounter=0;
detectCycle(0);
// System.out.println(cycleCounter);
if(cycleCounter==1)System.out.println("FHTAGN!");
else System.out.println("NO");
}
public static void dfs(int x ){
visit[x]=1;
for(int i =0 ;i < n ;i++)
if(g[x][i] && visit[i]==0)
dfs(i);
}
public static void detectCycle(int x){
visit[x]=1;//grey
for(int j =0 ;j < n ;j++)
if(g[x][j]){
if(visit[j]==0){//tree edge
parent[j]=x;
detectCycle(j);
}
else if(visit[j]==1 && parent[x] != j ){//back edge
cycleCounter++;
}
}
visit[x]=2;//black
}
}
| 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 | r=lambda:map(int,raw_input().split())
n,m = r()
graph = [[] for i in range (n+1)]
for i in range(m):
s,t = r()
graph[s] += [t]
graph[t] += [s]
visit = set()
def dfs(u):
visit.add(u)
for v in graph[u]:
if(not (v in visit)):
dfs(v)
dfs(1)
if len(visit) == n == m:
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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
import java.util.StringTokenizer;
public class Ctulhu {
/**
* Ctulhu & Co
* @author AAM
*/
public static final int ADJ = 1;
public static final int NADJ = 0;
public static final int VISITED = 1;
public static final int NVISITED = 0;
public static void main(String[] args) throws IOException {
Stack<Integer> stack = new Stack<Integer>();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String tempString = br.readLine();
StringTokenizer st = new StringTokenizer(tempString, " ");
int n = Integer.parseInt(st.nextToken());
int m = Integer.parseInt(st.nextToken());
// vertices initialized with NVISITED
int v[] = new int[n];
// edges initialized with NADJ
int e[][] = new int[n][n];
int x, y;
for (int i = 0; i < m; i++) {
tempString = br.readLine();
st = new StringTokenizer(tempString, " ");
x = Integer.parseInt(st.nextToken());
y = Integer.parseInt(st.nextToken());
e[x - 1][y - 1] = ADJ;
e[y - 1][x - 1] = ADJ;
}
// The Idea
if (n == m) {
v[0] = VISITED;
stack.push(0);
int current = 0;
while (!stack.empty()) {
current = stack.pop();
for (int i = 0; i < n; i++) {
if (e[current][i] == ADJ && v[i] == NVISITED) {
stack.push(i);
v[i] = VISITED;
}
}
}
boolean isConnected = true;
for (int i = 0; i < n; i++) {
if (v[i] == 0) {
System.out.println("NO");
isConnected = false;
break;
}
}
if (isConnected)
System.out.println("FHTAGN!");
}
else
System.out.println("NO");
br.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.*;
import java.util.*;
public class ClosingTweets {
static ArrayList<Integer>[] list;
static boolean[] visited;
public static void dfs(int i){
visited[i]=true;
for(int x:list[i]){
if(!visited[x]){
dfs(x);
}
}
}
public static void main(String args[] ) throws Exception {
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int count=0;
int m=in.nextInt();
visited=new boolean[n+1];
list=new ArrayList[n+1];
for(int i=1; i<=n; i++){
list[i]=new ArrayList<Integer>();
}
int x,y;
for(int i=0; i<m; i++){
x=in.nextInt();
y=in.nextInt();
list[x].add(y);
list[y].add(x);
}
if(m!=n){
System.out.println("NO");
System.exit(0);
}
else
{
for(int i = 1 ; i <= n ;i++)
{
if(!visited[i])
{
count++;
if(count > 1)
{
System.out.println("NO");
System.exit(0);;
}
dfs(i);
}
}
}
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 | #include <bits/stdc++.h>
using namespace std;
vector<long long int> g[1000];
long long int c = 1, vis[1001];
void DFS(long long int k) {
vis[k] = 1;
for (long long int i = 0; i < g[k].size(); i++) {
if (!vis[g[k][i]]) {
DFS(g[k][i]);
c++;
}
}
}
int main() {
long long int n, m;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
DFS(1);
if (c == n && 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 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 120;
int n, m;
vector<int> adlist[maxn];
bool visited[maxn];
int vt[maxn];
int t = 0;
void input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
adlist[a].push_back(b);
adlist[b].push_back(a);
}
}
int finds = 0;
void dfs(int root) {
vt[root] = t++;
visited[root] = true;
for (int i = 0; i < adlist[root].size(); i++) {
if (!visited[adlist[root][i]])
dfs(adlist[root][i]);
else {
if (vt[adlist[root][i]] - vt[root] > 1) finds++;
}
}
}
int main() {
input();
int u = 0;
for (int i = 0; i < n; i++) {
if (!visited[i]) {
dfs(i);
u++;
}
}
if (u > 1) {
puts("NO");
} else if (finds == 1) {
puts("FHTAGN!");
} else
puts("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.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Cthulhu {
static ArrayList<Integer> adjlist[];
static int visited[];
static int visited_num, cycles;
static final int UNVISITED = 0;
static final int VISITED = 1;
static final int EXPLORED = 2;
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = sc.nextInt(), m = sc.nextInt();
adjlist = new ArrayList[n];
for (int i = 0; i < n; i++)
adjlist[i] = new ArrayList<>();
for (int i = 0; i < m; i++) {
int u = sc.nextInt() - 1, v = sc.nextInt() - 1;
adjlist[u].add(v);
adjlist[v].add(u);
}
cycles = 0;
visited_num = 0;
visited = new int[n];
dfs(0, -1);
if (visited_num == n && cycles == 1)
out.println("FHTAGN!");
else
out.println("NO");
out.flush();
out.close();
}
static void dfs(int u, int p) {
visited[u] = VISITED;
visited_num++;
for (int v : adjlist[u])
if (visited[v] == UNVISITED)
dfs(v, u);
else if (visited[v] == VISITED && v != p)
cycles++;
visited[u] = EXPLORED;
}
static class Scanner {
BufferedReader br;
StringTokenizer st;
public Scanner(FileReader f) {
br = new BufferedReader(f);
}
public Scanner(InputStream in) {
br = new BufferedReader(new InputStreamReader(in));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public String nextLine() throws IOException {
return br.readLine();
}
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 boolean Ready() throws IOException {
return br.ready();
}
public void waitForInput(long time) {
long ct = System.currentTimeMillis();
while(System.currentTimeMillis() - ct < time) {};
}
}
}
| 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 const MAXN = 2e5 + 10, MAXM = 2e6 + 10;
long long n, m, T, a[MAXN];
long long e[MAXN], ne[MAXM], h[MAXN], idx, vis[MAXN];
void add(long long a, long long b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; }
long long tmp = 0;
void dfs(long long u, long long fa) {
for (long long i = h[u]; ~i; i = ne[i]) {
long long j = e[i];
if (j == fa) continue;
if (vis[j] == 1) {
tmp++;
continue;
}
vis[j] = 1;
dfs(j, u);
}
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(h, -1, sizeof h);
cin >> n >> m;
for (long long i = 1; i <= m; ++i) {
long long a, b;
cin >> a >> b;
add(a, b), add(b, a);
}
vis[1] = 1;
dfs(1, -1);
long long flg = 1;
if (tmp / 2 != 1) flg = 0;
for (long long i = 1; i <= n; ++i) {
if (vis[i] == 0) flg = 0;
}
if (!flg)
cout << "NO";
else
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;
int n, m;
vector<vector<int> > adj;
bool visi[300];
int back;
void dfs(int u, int p) {
visi[u] = true;
for (int i = 0; i < (int)(int((adj[u]).size())); i++) {
int v = adj[u][i];
if (v == p) continue;
if (visi[v]) {
back++;
} else
dfs(v, u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
adj = vector<vector<int> >(n, vector<int>());
int u, v;
for (int i = 0; i < (int)(m); i++) {
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(0, 0);
if (back != 2) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < (int)(n); i++)
if (!visi[i]) {
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 |
import java.util.Arrays;
import java.util.Scanner;
public class Cthulhu {
Scanner in;
void solve() {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
if (n != m) {
System.out.println("NO");
return;
}
DisjointSet ds = new DisjointSet(m);
for (int i = 0; i < m; i++) {
ds.union(sc.nextInt() - 1, sc.nextInt() - 1);
}
if (ds.count() == 1) {
System.out.println("FHTAGN!");
} else {
System.out.println("NO");
}
}
public class DisjointSet {
public int[] parent;
public DisjointSet(int n) {
parent = new int[n];
Arrays.fill(parent, -1);
}
public int root(int x) {
return parent[x] < 0 ? x : (parent[x] = root(parent[x]));
}
public boolean equiv(int x, int y) {
return root(x) == root(y);
}
public void union(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (parent[y] < parent[x]) {
int d = x;
x = y;
y = d;
}
parent[x] += parent[y];
parent[y] = x;
}
}
public int count() {
int ct = 0;
for (int i = 0; i < parent.length; i++) {
if (parent[i] < 0)
ct++;
}
return ct;
}
}
public static void main(String[] args) throws Exception {
new Cthulhu().solve();
}
}
| 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, cur = 0;
vector<vector<int> > g;
vector<char> used;
void dfs(int v) {
used[v] = true;
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!used[to]) {
dfs(to);
}
}
}
int main(int argc, char *argv[]) {
scanf("%d%d", &n, &m);
if (m != n) {
printf("NO");
return 0;
}
g.resize(n);
used.resize(n, false);
for (int i = 0; i < m; ++i) {
int from, to;
scanf("%d%d", &from, &to);
--from;
--to;
g[from].push_back(to);
g[to].push_back(from);
}
dfs(0);
for (int i = 0; i < n; ++i) {
if (!used[i]) {
printf("NO");
return 0;
}
}
printf("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;
int n, m;
int f[103];
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void up(int x, int y) {
int fx = find(x);
int fy = find(y);
f[fx] = fy;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; i++) f[i] = i;
int x, y;
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
if (find(x) != find(y)) up(x, y);
}
int flag = 0;
if (n != m) flag = 1;
for (int i = 2; i <= n; i++)
if (find(1) != find(i)) {
flag = 1;
break;
}
if (flag)
printf("NO\n");
else
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 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer z = new StringTokenizer(in.readLine());
int n = Integer.parseInt(z.nextToken()),
m = Integer.parseInt(z.nextToken());
union_find uf = new union_find(n);
int cycle=0;
//System.out.println("-------------");
for (int i = 0; i < m; i++) {
z = new StringTokenizer(in.readLine());
int a = Integer.parseInt(z.nextToken()),
b = Integer.parseInt(z.nextToken());
if(uf.find(a-1) == uf.find(b-1))cycle++;
uf.union(a-1, b-1);
}
int x = uf.find(0);
for (int i = 1; i < n; i++)
if(uf.find(i)!=x)cycle=0;
if(cycle ==1)System.out.println("FHTAGN!");
else System.out.println("NO");
}
static class union_find {
int[] set, height, weight;
public union_find(int n) {
set = new int[n];
height = new int[n];
for (int i = 0; i < n; i++) {
set[i] = i;
height[i] = 0;
}
}
public int find(int index) {
if (index == set[index]) {
return index;
}
set[index] = find(set[index]);
return set[index];
}
public void union(int a, int b) {
a= find(a);
b= find(b);
if (height[find(a)] > height[b]) {
set[b] = a;
height[a] = Math.max(height[a], height[b] + 1);
} else {
set[a] = b;
height[b] = Math.max(height[b], height[a] + 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 | #include <bits/stdc++.h>
using namespace std;
string vow = "aeiou";
int month[] = {-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int dxhorse[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const int dyhorse[] = {1, -1, 2, -2, 2, -2, 1, -1};
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const long double pie = 3.1415926535897932384626;
const long long mod = 1e9 + 7;
void bad() {
cout << "NO";
cout << "\n";
;
exit(0);
}
const int N = 101;
vector<int> g[N];
int n, m;
void read() {
cin >> n >> m;
if (n != m) bad();
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
}
bool vis[N];
void dfs(int node) {
vis[node] = 1;
for (auto &i : g[node]) {
if (vis[i]) continue;
;
dfs(i);
}
}
void solve(int test_case) {
read();
dfs(1);
for (int i = 1; i <= n; i++) {
if (vis[i] == false) {
bad();
}
}
cout << "FHTAGN!";
cout << "\n";
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int i = 1; i <= t; i++) {
solve(i);
}
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 | //I AM THE CREED
/* //I AM THE CREED
/* package codechef; // don't place package name! */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.*;
import java.awt.Point;
public class Main{
static int[] g=new int[101];
static int[] size=new int[101];
public static int find(int node){
if(g[node]==-1){
return node;
}
g[node]=find(g[node]);
return g[node];
}
public static void union(int x, int y){
int parentx=find(x);
int parenty=find(y);
g[parentx]=parenty;
size[parenty]+=size[parentx];
}
public static void main(String[] args) throws IOException
{
//Solution-In other, a graph is Cthulhu when we can make the graph acyclic by removing one edge
//Let's use DSU for implementation
Scanner input = new Scanner(System.in);
Arrays.fill(g, -1);
Arrays.fill(size, 1);
while(input.hasNext()){
int n=input.nextInt();
int edges=input.nextInt();
int cyclic_edges=0;
for(int i=0;i<edges;i++){
int u=input.nextInt();
int v=input.nextInt();
if(find(u)==find(v)){
cyclic_edges++;
continue;
}
union(u, v);
}
boolean connected=false;
for(int i=0;i<101;i++){
connected=(size[i]==n)||connected;
}
System.out.println(cyclic_edges==1 && connected?"FHTAGN!":"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;
const int MAXN = 300010;
int n, m, fa[105];
int g[105][105], deg[105];
queue<int> q;
int fnd(int x) { return fa[x] == x ? x : fa[x] = fnd(fa[x]); }
int main() {
scanf("%d%d", &n, &m);
if (m != n) {
printf("NO");
return 0;
}
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u][v] = g[v][u] = 1;
deg[u]++;
deg[v]++;
fa[fnd(u)] = fnd(v);
}
for (int i = 2; i <= n; i++)
if (fnd(i) != fnd(1)) {
printf("NO");
return 0;
}
for (int i = 1; i <= n; i++)
if (deg[i] == 1) q.push(i);
while (q.size()) {
int x = q.front();
q.pop();
for (int y = 1; y <= n; y++)
if (g[x][y]) {
if (--deg[y] == 1) q.push(y);
}
}
int cnt = 0;
for (int i = 1; i <= n; i++)
if (deg[i] > 1) cnt++;
if (cnt < 3)
printf("NO");
else
printf("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 | import java.io.*;
import java.util.*;
public class Solution {
static int used[], cnt=0;
static ArrayList<ArrayList<Integer>> g;
public static void dfs(int v){
used[v] = 1;
cnt++;
for (int i = 0; i < g.get(v).size(); i++)
if (used[g.get(v).get(i)]==0) dfs(g.get(v).get(i));
}
public static void main(String [] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer tokenizer = new StringTokenizer(br.readLine());
int n = Integer.parseInt(tokenizer.nextToken()), m = Integer.parseInt(tokenizer.nextToken());
if (n != m){ System.out.print("NO"); return;}
g = new ArrayList<ArrayList<Integer>>();
used = new int[n];
for (int i =0 ; i < n; i++) g.add(new ArrayList<Integer>());
for (int i = 0 ; i < m; i++){
tokenizer = new StringTokenizer(br.readLine());
int u = Integer.parseInt(tokenizer.nextToken())-1, v = Integer.parseInt(tokenizer.nextToken())-1;
g.get(u).add(v);
g.get(v).add(u);
}
dfs(0);
if (cnt== n) System.out.print("FHTAGN!");
else System.out.print("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 |
/*
* BATPROBATPROBATPROBATPROBATPROBATPROBATPROBATPROBATPROBATPROBATPR
* BATPROBATPROBATPROBATPROBATPROBATPROBATPROBATPROBATPROBATPROBATPR
* BAT. `PROBATPROBA|\___/|TPROBATPROB' .ATP
* BATPR. `OBATPROBAT| |PROBATPROBA' .TPROB
* BATPRO. `BATPROBA/ \TPROBATP' .ROBATP
* BATPROB. .ATPROBA
* BATPROB' `ATPROBA
* BATPRO' `BATPRO
* BATPROBATPROBATP`---._ _.---'ROBATPROBATPROBA
* BATPROBATPROBATPROBATPR--. .--OBATPROBATPROBATPROBATP
* BATPROBATPROBATPROBATPROBAT-. .-PROBATPROBATPROBATPROBATPRO
* BATPROBATPROBATPROBATPROBATPRO. .BATPROBATPROBATPROBATPROBATPRO
* BATPROBATPROBATPROBATPROBATPROB\ /ATPROBATPROBATPROBATPROBATPROBA
* BATPROBATPROBATPROBATPROBATPROBAVTPROBATPROBATPROBATPROBATPROBATP
*
*/
import java.io.*;
import java.util.*;
public class Main {
static ArrayList<ArrayList<Integer>> adj = new ArrayList<>(110);
static HashSet<ArrayList<Integer>> cycles = new HashSet<>();
static void dfs(boolean[] vis, ArrayList<Integer> ls, int curr) {
vis[curr] = true;
for (int v : adj.get(curr)) {
if (vis[v] == false) {
ls.add(v);
dfs(vis, ls, v);
ls.remove(ls.size() - 1);
} else {
if (v == ls.get(0) && ls.size() > 2) {
ArrayList<Integer> ls2 = new ArrayList<>(ls);
Collections.sort(ls2);
cycles.add(ls2);
}
}
}
}
static void dfs2(boolean[] vis, int curr) {
vis[curr] = true;
for (int v : adj.get(curr)) {
if (vis[v] == false) {
dfs2(vis, v);
}
}
}
public static void main(String[] args) throws FileNotFoundException {
// InputReader in = new InputReader(new FileInputStream("in.txt"));
InputReader in = new InputReader(System.in);
int n, m;
n = in.nextInt();
m = in.nextInt();
for (int i = 0; i <= n; i++) {
adj.add(i, new ArrayList<Integer>());
}
for (int i = 0; i < m; i++) {
int a, b;
a = in.nextInt();
b = in.nextInt();
adj.get(a).add(b);
adj.get(b).add(a);
}
for (int i = 1; i <= n; i++) {
ArrayList<Integer> ls = new ArrayList<>();
ls.add(i);
dfs(new boolean[110], ls, i);
}
if (cycles.size() != 1) {
System.out.println("NO");
} else {
boolean[] vis = new boolean[110];
ArrayList<Integer> ls = new ArrayList<>((ArrayList<Integer>) cycles.toArray()[0]);
dfs2(vis, ls.get(0));
for (int i = 1; i <= n; i++) {
if (vis[i] == false) {
System.out.println("NO");
System.exit(0);
}
}
System.out.println("FHTAGN!");
}
}
}
class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 256000 * 4);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public String nextLine() throws IOException {
return reader.readLine();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
} | 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> adj[101];
bool vis[101];
void dfs(int u) {
vis[u] = true;
for (auto v : adj[u]) {
if (!vis[v]) dfs(v);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
int M = m;
while (M--) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
if (n != m)
cout << "NO";
else {
dfs(1);
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cout << "NO";
return 0;
}
}
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 | #include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897923846;
const long long int MOD = 1000000007;
const long long int N = 998244353;
long long int power(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
long long int modinverse(long long int a) { return power(a, MOD - 2); }
vector<vector<long long int> > adj;
vector<long long int> vis, par;
bool hm = false;
void dfs(long long int node, long long int parent) {
vis[node] = 1;
for (auto x : adj[node]) {
if (x == parent) continue;
if (vis[x] == 0) {
dfs(x, node);
}
}
}
void solve() {
long long int n, m;
cin >> n >> m;
vis.resize(n, 0);
par.resize(n, -1);
adj.resize(n);
for (long long int i = 0; i < m; i++) {
long long int x, y;
cin >> x >> y;
--x, --y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(0, -1);
for (long long int i = 0; i < n; i++) {
if (vis[i] == 0) {
cout << "NO\n";
return;
}
}
if (m == n)
cout << "FHTAGN!\n";
else
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int test = 1;
while (test--) {
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\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 | import java.util.*;
import java.math.*;
import java.io.*;
public class C {
private void solve() throws IOException {
int n = nextInt();
int m = nextInt();
boolean[][] adj = new boolean[n][n];
for (int i = 0; i < m; i++) {
int from = nextInt() - 1;
int to = nextInt() - 1;
adj[from][to] = adj[to][from] = true;
}
if (n != m) {
System.out.println("NO");
return;
}
//connected;
Queue<Integer> q = new LinkedList<Integer>();
boolean[] vis = new boolean[n];
q.add(0);
vis[0] = true;
while(!q.isEmpty()) {
int cur = q.poll();
for (int i = 0; i < adj.length; i++)
if (adj[cur][i] && !vis[i]) {
vis[i] = true;
q.add(i);
}
}
for (int i = 0; i < vis.length; i++) {
if (!vis[i]) {
System.out.println("NO");
return;
}
}
System.out.println("FHTAGN!");
}
public static void main(String[] args) {
new C().run();
}
BufferedReader reader;
StringTokenizer tokenizer;
PrintWriter writer;
public void run() {
try {
reader = new BufferedReader(new InputStreamReader(System.in));
tokenizer = null;
writer = new PrintWriter(System.out);
solve();
reader.close();
writer.close();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
int[] readIntArray(int size) throws IOException {
int[] res = new int[size];
for (int i = 0; i < size; i++) {
res[i] = nextInt();
}
return res;
}
long[] readLongArray(int size) throws IOException {
long[] res = new long[size];
for (int i = 0; i < size; i++) {
res[i] = nextLong();
}
return res;
}
double[] readDoubleArray(int size) throws IOException {
double[] res = new double[size];
for (int i = 0; i < size; i++) {
res[i] = nextDouble();
}
return res;
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
BigInteger nextBigInteger() throws IOException {
return new BigInteger(nextToken());
}
String nextToken() throws IOException {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
}
| 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>
const int maxn = 105;
int n, m, fa[maxn], cnt;
bool flag;
inline int find(int x) {
if (fa[x] != x) fa[x] = find(fa[x]);
return fa[x];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
int fx = find(u), fy = find(v);
if (fx != fy) {
fa[fy] = fx;
cnt++;
} else {
if (flag) {
printf("NO\n");
return 0;
}
flag = 1;
cnt++;
}
}
if (flag && cnt == n) {
printf("FHTAGN!");
} 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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* Created by IntelliJ IDEA.
* User: alexsen
* Date: 3/25/12
* Time: 9:49 PM
*/
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;
}
finder.fhtagn(all[0]);
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;
return true;
}
protected static boolean postCheck(Node[] all){
for(Node n : all){
if(n.getColor().equals(Color.WHITE)) return false;
}
return true;
}
}
class CirclesFinder{
protected void fhtagn(Node start){
start.setVisits(1);
start.setColor(Color.GRAY);
dfs(start);
start.setColor(Color.BLACK);
}
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{
/*int next(){
return values[index++];
}
int[] values = {6, 5,5, 6,4, 6,3, 1,5, 1, 1, 2};*/
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 int index = 0;
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 | #include <bits/stdc++.h>
using namespace std;
const long long int N = 500000;
vector<long long int> g[N];
long long int color[N];
void dfs(long long int k, long long int par, long long int &cyclenumber) {
if (color[k] == 2)
return;
else if (color[k] == 1) {
cyclenumber++;
return;
}
color[k] = 1;
for (auto i : g[k]) {
if (i != par) dfs(i, k, cyclenumber);
}
color[k] = 2;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
long long int i;
for (i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
long long int cyclenumber = 0;
for (long long int i = 0; i < n; i++) color[i] = 0;
long long int connected = 0;
for (i = 1; i <= n; i++)
if (color[i] == 0) {
connected++;
dfs(i, 0, cyclenumber);
}
if (cyclenumber == 1 && connected == 1)
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;
int n, m, a, b;
bool vis[101];
vector<int> edges[101];
void dfs(int u) {
vis[u] = 1;
for (int i = 0; i < edges[u].size(); ++i)
if (!vis[edges[u][i]]) dfs(edges[u][i]);
}
bool spojny() {
dfs(1);
for (int i = 1; i <= n; ++i)
if (!vis[i]) return 0;
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &a, &b);
edges[a].push_back(b);
edges[b].push_back(a);
}
if (n > 2 && spojny() && n == m)
printf("FHTAGN!\n");
else
printf("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 | prev = {}
def dfs(g):
root = g.keys()[0]
prev[root] = None
visited = {root:1}
Q = [root]
cycle_pts = []#[(father,son),...]
while len(Q) > 0:
v = Q[-1]#Q.pop()
#print "v:",v
has_neighbor = False
for x in g[v]:
#print "sosed:", x
if not visited.has_key(x):
Q.append(x)
#print "appendal:", x
visited[x] = 1
prev[x] = v
has_neighbor = True
break
elif x in Q[:-2]:
#print "cycle:%d, %d" % (x,v)
cycle_pts.append((x,v))
if not has_neighbor:
Q.pop()
cycles = []
for father,son in cycle_pts:
#dobi pot od son do father
cycle = [son]
cur = son
while prev[cur] != father:
cycle.append(prev[cur])
cur = prev[cur]
cycle.append(father)
cycles.append(cycle)
return cycles,visited
n,m = map(int, raw_input().split(" "))
g = {i:[] for i in range(1,n+1)}
for i in range(m):
a,b = map(int, raw_input().split(" "))
g[a].append(b)
g[b].append(a)
cycles,visited = dfs(g)
if len(visited.keys()) == n and n == m:
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 | n, m = [int(i) for i in input().split()]
adj = [[] for i in range(n+1)]
seen = [False for i in range(n+1)]
pai = [0 for i in range(n+1)]
ciclos = 0
def dfs (u):
seen[u] = True
global ciclos
for v in adj[u]:
if not seen[v]:
pai[v] = u
dfs(v)
elif v != pai[u]:
ciclos += 1
for i in range(m):
x, y = [int(i) for i in input().split()]
adj[x].append(y)
adj[y].append(x)
dfs(1)
conexo = True
for i in range(1, n+1, 1):
if not seen[i]:
conexo = False
if not conexo:
print('NO')
elif ciclos/2 == 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 | #include <bits/stdc++.h>
int fa[1010];
int find(int x) {
if (x != fa[x]) fa[x] = find(fa[x]);
return fa[x];
}
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; i++) fa[i] = i;
int flag, a, b, num, flag2;
flag = num = flag2 = 0;
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
if (flag2) continue;
int px = find(a), py = find(b);
if (px != py) {
num++;
fa[px] = py;
} else {
if (!flag) {
num++;
flag = 1;
} else
flag2 = 1;
}
}
if (!flag2 && flag && num == 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 | #include <bits/stdc++.h>
using namespace std;
int n, m, a[100][100];
int col[100];
int cycles;
void dfs(int p, int u) {
col[u] = 1;
for (int i = 0; i < n; i++)
if (a[u][i] && i != p) {
if (col[i] == 1) cycles++;
if (col[i] == 0) dfs(u, i);
}
col[u] = 2;
}
int main() {
cin >> n >> m;
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
a[x][y] = 1;
a[y][x] = 1;
}
dfs(-1, 0);
for (int i = 0; i < n; i++)
if (col[i] == 0) cycles = 0;
if (cycles == 1)
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 | import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.*;
public class apples {
static ArrayList<Integer> ar[];
static boolean visited[];
static int count;
static void dfs(int u){
//System.out.println(u);
count++;
visited[u] = true;
for(int v:ar[u]){
if(!visited[v]){
dfs(v);
}
}
}
public static void main(String args[]) throws IOException{
//FileReader in = new FileReader("C:/test.txt");
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
String line[] = bf.readLine().split(" ");
int n = Integer.parseInt(line[0]);
int m = Integer.parseInt(line[1]);
ar = new ArrayList[n];
for(int i=0; i<n; i++){
ar[i] = new ArrayList<Integer>();
}
for(int i=0; i<m; i++){
String s[] = bf.readLine().split(" ");
int u = Integer.parseInt(s[0])-1;
int v = Integer.parseInt(s[1])-1;
ar[u].add(v);
ar[v].add(u);
}
count=0;
visited = new boolean[n];
dfs(0);
if(count==n){
if(m==n &&n>=3 ){
System.out.println("FHTAGN!");
}else
System.out.println("NO");
}else{
System.out.println("NO");
}
//System.out.println(count);
}
public class pair implements Comparable<pair>{
int a;
int b;
int c;
public pair(int a, int b,int c) {
this.a = a;
this.b = b;
this.c = c;
}
public int compareTo(pair o) {
if(a!=o.a)
return a-o.a;
else if(b!=o.b)
return b-o.b;
else
return c-o.c;
}
}
//
} | 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;
import java.util.ArrayList;
public class Cthulhu {
static ArrayList<Integer>[]adjList;
static int []dfs_num; //0-->UNVISITED 1-->VISITED 2-->EXPLORED
static int []dfs_parent;
static int cycles=0;
public static void main(String []args) throws NumberFormatException, IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s=br.readLine();
//System.out.println(s);
String []r= s.split(" ");
//System.out.println(r[0]+" "+r[1]+" ");
int n = Integer.parseInt(r[0]);
int m= Integer.parseInt(r[1]);
adjList=new ArrayList[n];
dfs_num=new int[n];
dfs_parent=new int[n];
for(int i=0;i<n;i++)
adjList[i]=new ArrayList<Integer>();
for(int i=0;i<m;i++){
String []a=br.readLine().split(" ");
int start = Integer.parseInt(a[0]);
int end = Integer.parseInt(a[1]);
adjList[start-1].add(end);
adjList[end-1].add(start);
}
int count=0;
for(int i=0;i<n;i++){
if(dfs_num[i]==0){
graph_check(i);
count++;
}
}
if(count==1&&cycles==1&&n==m)
System.out.println("FHTAGN!");
else
System.out.println("NO");
}
public static void graph_check(int s){
dfs_num[s]=2;
for(int m:adjList[s]){
if(dfs_num[m-1]==0){//EXPLORED-->UNVISITED
dfs_parent[m-1]=s+1;
graph_check(m-1);
}
else if(dfs_num[m-1]==2){//EXPLORED-->EXPLORED
if(dfs_parent[s]!=m)
cycles++;
}
}
dfs_num[s]=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
n,m=map(int, raw_input().split())
d=defaultdict(list)
for i in range(m):
u,v=map(int,raw_input().split())
d[u].append(v)
d[v].append(u)
vis = [0]*(n+1)
q=[1]
vis[1]=1
c=0
while q:
x=q.pop()
c+=1
for i in d[x]:
if not vis[i]:
q.append(i)
vis[i]=1
if c==m and c==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 | #include <bits/stdc++.h>
using namespace std;
int m, n, s;
bool vis[102];
vector<int> q[102];
void dfs(int a) {
vis[a] = true;
s++;
for (int i = 0; i < q[a].size(); i++)
if (vis[q[a][i]] == false) dfs(q[a][i]);
}
int main() {
cin >> n >> m;
int r1, r2;
for (int i = 0; i < m; i++) {
cin >> r1 >> r2;
q[r1].push_back(r2);
q[r2].push_back(r1);
}
if (n != m) {
cout << "NO" << endl;
return 0;
}
dfs(1);
if (s == 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 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Writer;
import java.util.StringTokenizer;
public class Solution {
int n;
int m;
boolean[][] a;
boolean[] b;
int count;
public void check(int pos) {
if (b[pos]) {
++count;
return;
}
b[pos] = true;
for (int i = 0; i < n; ++i) {
if (a[pos][i]) {
a[pos][i] = false;
a[i][pos] = false;
check(i);
}
}
}
public void solve() throws IOException {
n = getInt();
m = getInt();
a = new boolean[n][n];
b = new boolean[n];
for (int i = 0; i < m; ++i) {
int p = getInt() - 1;
int q = getInt() - 1;
a[p][q] = true;
a[q][p] = true;
}
check(0);
for (int i = 0; i < n; ++i) {
if (!b[i]) {
out.print("NO");
return;
}
for (int j = 0; j < n; ++j) {
if (a[i][j]) {
out.print("NO");
return;
}
}
}
if (count == 1) {
out.print("FHTAGN!");
} else {
out.print("NO");
}
}
public static void main(String[] args) throws IOException {
Solution solution = new Solution();
solution.run(new InputStreamReader(System.in),
new OutputStreamWriter(System.out));
System.exit(0);
}
private BufferedReader reader;
private StringTokenizer tokenizer;
private String separator;
public PrintWriter out;
public final byte getByte() throws IOException {
return Byte.parseByte(getToken());
}
public final double getDouble() throws IOException {
return Double.parseDouble(getToken());
}
public final int getInt() throws IOException {
return Integer.parseInt(getToken());
}
public final String getLine() throws IOException {
if (tokenizer.hasMoreTokens()) {
return tokenizer.nextToken(separator);
}
return reader.readLine();
}
public final long getLong() throws IOException {
return Long.parseLong(getToken());
}
public final short getShort() throws IOException {
return Short.parseShort(getToken());
}
public final String getToken() throws IOException {
while (!tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
public final boolean isEndOfLine() {
return !tokenizer.hasMoreTokens();
}
public final void putBlank() {
out.print(' ');
}
public final void run(Reader reader, Writer writer) throws IOException {
this.reader = new BufferedReader(reader);
out = new PrintWriter(writer);
tokenizer = new StringTokenizer("");
separator = System.getProperty("line.separator");
separator = Character.toString(separator.charAt(separator.length() - 1));
solve();
out.flush();
}
}
| 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<vector<int> > adj;
vector<int> order, m, cc;
int cycle = 0, cnt = 0;
int cycle_check(int here) {
int ret = order[here];
m.push_back(here);
for (int there : adj[here]) {
if (order[there] == -1) {
order[there] = order[here] + 1;
ret = min(ret, cycle_check(there));
} else if (order[there] < order[here] - 1) {
cycle++;
ret = min(ret, order[there]);
}
}
if (ret == order[here]) {
cc.push_back(here);
while (m.back() != here) {
cc.push_back(m.back());
m.pop_back();
}
m.pop_back();
if (cc.size() == 1) {
cc.clear();
}
}
return ret;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
adj = vector<vector<int> >(n + 1);
order = vector<int>(n + 1, -1);
while (m--) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int n_component = 0;
for (int i = 1; i <= n; i++) {
if (order[i] == -1) {
n_component++;
order[i] = 0;
cycle_check(1);
}
}
if (cycle == 1 && cc.size() >= 3 && n_component == 1) {
printf("FHTAGN!\n");
} else {
printf("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 | A, B=map(int,input().split())
A_=[[] for i in range(A)]
for i in range(B):
a, b=map(int,input().split())
A_[b-1].append(a-1)
A_[a-1].append(b-1)
color=[0 for i in range(A)]
def dfs(a):
global color
color[a]=1
for i in A_[a]:
if color[i]==0:
dfs(i)
dfs(0)
if sum(color)==A:
if A==B:
print('FHTAGN!')
else:
print('NO')
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 int MAX_N = 444;
vector<int> graph[MAX_N];
bool was[MAX_N];
void dfs(int u) {
was[u] = true;
for (int i = 0; i < graph[u].size(); i++) {
int to = graph[u][i];
if (!was[to]) dfs(to);
}
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
int u, v;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
dfs(1);
for (int i = 1; i <= n; i++) {
if (!was[i]) {
cout << "NO";
return 0;
}
}
if (n != m)
cout << "NO";
else
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;
long long parent[10001];
long long cnt = 0, cnt1 = 0;
void make_set(int v) { parent[v] = v; }
int find_set(int v) {
if (v == parent[v]) return v;
return find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a == b) cnt++;
if (a != b) parent[b] = a;
}
int main() {
int n, m;
cin >> n >> m;
for (int k = 1; k <= n; k++) make_set(k);
for (int k = 1; k <= m; k++) {
int l, t;
cin >> l >> t;
union_sets(l, t);
}
for (int k = 1; k <= n; k++)
if (parent[k] == k) cnt1++;
if (cnt == 1 && cnt1 == 1)
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;
bool vis[105];
vector<int> g[105];
int dfs(int u) {
vis[u] = true;
for (int i = 0; i < g[u].size(); i++) {
int to = g[u][i];
if (!vis[to]) dfs(to);
}
}
int main() {
int n, m;
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);
}
if (n < 3)
cout << "NO" << endl;
else {
if (n != m)
cout << "NO" << endl;
else {
bool valid = true;
dfs(0);
for (int i = 0; i < n; i++)
if (!vis[i]) valid = false;
if (!valid)
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 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
public class D {
public static void main(String[] args) throws IOException {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String input=br.readLine();
String[] a=input.split(" ");
int n=Integer.parseInt(a[0]);
int m=Integer.parseInt(a[1]);
boolean[][] connects=new boolean[n+1][n+1];
for(int j=0;j<m;j++) {
input=br.readLine();
String[] b=input.split(" ");
connects[Integer.parseInt(b[0])][Integer.parseInt(b[1])]=true;
connects[Integer.parseInt(b[1])][Integer.parseInt(b[0])]=true;
}
Stack<Integer> st=new Stack<Integer>();
boolean[] visited=new boolean[n+1];
st.push(1);
visited[1]=true;
while(!st.isEmpty()) {
int vertex=st.pop();
for(int i=1;i<=n;i++) {
if(!visited[i]&&connects[vertex][i]) {
st.push(i);
visited[i]=true;
}
}
}
boolean checkAllVisited=true;
for(int i=1;i<visited.length;i++) {
if(!visited[i]) {
checkAllVisited=false;
}
}
if(n==m && checkAllVisited) {
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.io.*;
import java.util.*;
public class Main {
static int n, m, loopCount;
static boolean[] isVisited;
static int[][] g;
private static void solve(InputReader in, OutputWriter out) {
n = in.nextInt();
m = in.nextInt();
g = new int[n + 1][n + 1];
for (int i = 0; i < m; i++) {
int u = in.nextInt();
int v = in.nextInt();
g[u][v] = g[v][u] = 1;
}
loopCount = 0;
isVisited = new boolean[n + 1];
dfs(-1, 1);
int unvisitedCount = 0;
for (int i = 1; i <= n; i++) {
if (!isVisited[i]) {
unvisitedCount++;
}
}
out.print((loopCount == 2 && unvisitedCount == 0) ? "FHTAGN!" : "NO");
}
private static void dfs(int prev, int cur) {
isVisited[cur] = true;
for (int next = 1; next <= n; next++) {
if (g[cur][next] == 1 && next != prev) {
if (isVisited[next]) {
loopCount++;
} else {
dfs(cur, next);
}
}
}
}
private static int gcd(int a, int b) {
if (b == 0) {
return a;
} else
return gcd(b, a % b);
}
private static void shuffleArray(int[] array) {
int index;
Random random = new Random();
for (int i = array.length - 1; i > 0; i--) {
index = random.nextInt(i + 1);
if (index != i) {
array[index] ^= array[i];
array[i] ^= array[index];
array[index] ^= array[i];
}
}
}
public static void main(String[] args) {
InputReader in = new InputReader(System.in);
OutputWriter out = new OutputWriter(System.out);
solve(in, out);
in.close();
out.close();
}
private static class InputReader {
private BufferedReader br;
private StringTokenizer st;
InputReader(InputStream is) {
br = new BufferedReader(new InputStreamReader(is));
st = null;
}
String nextLine() {
String line = null;
try {
line = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return line;
}
String next() {
while (st == null || !st.hasMoreTokens()) {
String line = nextLine();
if (line == null) return null;
st = new StringTokenizer(line);
}
return st.nextToken();
}
byte nextByte() {
return Byte.parseByte(next());
}
short nextShort() {
return Short.parseShort(next());
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
void close() {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static class OutputWriter {
BufferedWriter bw;
OutputWriter(OutputStream os) {
bw = new BufferedWriter(new OutputStreamWriter(os));
}
void print(int i) {
print(Integer.toString(i));
}
void println(int i) {
println(Integer.toString(i));
}
void print(long l) {
print(Long.toString(l));
}
void println(long l) {
println(Long.toString(l));
}
void print(double d) {
print(Double.toString(d));
}
void println(double d) {
println(Double.toString(d));
}
void print(boolean b) {
print(Boolean.toString(b));
}
void println(boolean b) {
println(Boolean.toString(b));
}
void print(char c) {
try {
bw.write(c);
} catch (IOException e) {
e.printStackTrace();
}
}
void println(char c) {
println(Character.toString(c));
}
void print(String s) {
try {
bw.write(s);
} catch (IOException e) {
e.printStackTrace();
}
}
void println(String s) {
print(s);
print('\n');
}
void close() {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
| 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<vector<int>> adj(105);
vector<int> vis(105, 0);
int vert;
void dfs(int src) {
vis[src] = 1;
vert++;
for (auto i : adj[src]) {
if (!vis[i]) dfs(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1);
if (vert == n && n == m)
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 | # 103B
__author__ = 'artyom'
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 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
public class graph {
static ArrayList<Integer>[] adjList;
static boolean[] vis;
static boolean[] vis2;
static int[] parent;
static int[] counter;
static int[] level;
static int dfs1(int v) {
vis[v] = true;
int c = 0;
for (int u : adjList[v]) {
if (u != parent[v] && vis[u]) {
c++;
}
if (!vis[u]) {
parent[u] = v;
c += dfs1(u);
}
}
return c;
}
static void reach(int v) {
int c = 1;
int t = v;
while (adjList[v].get(0) != t) {
c++;
v = adjList[v].get(0);
}
v = t;
while (adjList[v].get(0) != t) {
counter[v] = c;
v = adjList[v].get(0);
}
}
static void fill(boolean[] Arr) {
for (int i = 0; i < Arr.length; i++) {
Arr[i] = false;
}
}
static int count(boolean[] Arr) {
int c = 0;
for (int i = 0; i < Arr.length; i++) {
if (!Arr[i]) {
c++;
}
}
return c;
}
static int dfs(int u) {
vis[u] = true;
vis2[u] = true;
for (int v : adjList[u]) {
if (counter[v] != 0) {
counter[u] = counter[v] + 1;
return counter[v] + 1;
} else if (vis[v]) {
reach(v);
}
if (!vis[v]) {
int x = dfs(v) + 1;
// counter[v] = x;
return x;
}
}
return 0;
}
static void bfs(int s) {
Queue<Integer> q = new LinkedList<>();
q.add(s);
vis[s] = true;
level[s] = 0;
while (!q.isEmpty()) {
int u = q.poll();
for (int v : adjList[u])
if (!vis[v]) {
vis[v] = true;
level[v] = level[u] + 1;
q.add(v);
}
}
}
public static void main(String[] args) throws IOException, InterruptedException {
PrintWriter pw = new PrintWriter(System.out);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// int n = Integer.parseInt(br.readLine());
StringTokenizer st = new StringTokenizer(br.readLine());
;
int V = Integer.parseInt(st.nextToken());
int E = Integer.parseInt(st.nextToken());
adjList = new ArrayList[V];
vis = new boolean[V];
parent = new int[V];
Arrays.fill(parent, -1);
level = new int[V];
for (int i = 0; i < V; i++)
adjList[i] = new ArrayList<>();
for (int i = 0; i < E; i++) {
st = new StringTokenizer(br.readLine());
int u = Integer.parseInt(st.nextToken());
int v = Integer.parseInt(st.nextToken());
adjList[u - 1].add(v - 1);
adjList[v - 1].add(u - 1);
}
int count = 0;
for (int i = 0; i < V; i++) {
if (!vis[i]) {
count += dfs1(i);
}
}
vis=new boolean[V];
bfs(0);
System.out.println(count==2&&count(vis)==0 ? "FHTAGN!" : "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 Cthulhu {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int m = scan.nextInt();
if(n != m){
System.out.println("NO");
return;
}
ArrayList<Integer>[] adj = new ArrayList[n];
for(int i = 0; i < n; i++)
adj[i] = new ArrayList<Integer>();
for(int i = 0; i < m; i++){
int u = scan.nextInt()-1;
int v = scan.nextInt()-1;
adj[u].add(v);
adj[v].add(u);
}
boolean[] v = new boolean[n];
ArrayDeque<Integer> bfs = new ArrayDeque<Integer>();
v[0] = true;
bfs.add(0);
while(!bfs.isEmpty()){
int p = bfs.poll();
for(int i = 0; i < adj[p].size(); i++){
int x = adj[p].get(i);
if(!v[x]){
v[x] = true;
bfs.add(x);
}
}
}
for(int i = 0; i < n; i++){
if(!v[i]){
System.out.println("NO");
return;
}
}
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 | class Node:
def __init__(self, parent, rank):
self.parent = parent
self.rank = rank
def findRoot(s, u):
if s[u].parent != u:
s[u].parent = findRoot(s, s[u].parent)
return s[u].parent
def union(s, u, v):
ru = findRoot(s, u)
rv = findRoot(s, v)
if ru != rv:
if s[ru].rank < s[rv].rank:
s[ru].parent = rv
elif s[ru].rank > s[rv].rank:
s[rv].parent = ru
else:
s[rv].parent = ru
s[ru].rank += 1
return True
return False
if __name__ == "__main__":
n, m = map(int, input().split())
if n != m:
print("NO")
exit(0)
s = []
for i in range(n + 1):
s.append(Node(i, 0))
cnt = 0
for i in range(m):
u, v = map(int, input().split())
if union(s, u, v) == False:
cnt += 1
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;
int n, m;
void dfs(vector<int> tab[], int a, bool vis[]) {
if (!vis[a]) vis[a] = true;
for (int i = 0; i < tab[a].size(); ++i) {
if (!vis[tab[a][i]]) {
dfs(tab, tab[a][i], vis);
}
}
}
int main() {
int x, y;
cin >> n >> m;
vector<int> tab[n];
bool vis[n];
for (int i = 0; i < n; ++i) {
vis[i] = false;
}
int c = m;
while (c--) {
cin >> x >> y;
x--;
y--;
tab[x].push_back(y);
tab[y].push_back(x);
}
dfs(tab, 0, vis);
for (int i = 0; i < n; ++i) {
if (!vis[i]) {
cout << "NO" << endl;
return 0;
}
}
if (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 | #include <bits/stdc++.h>
using namespace std;
template <class U, class V>
ostream& operator<<(ostream& os, const pair<U, V>& p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class U, class V>
istream& operator>>(istream& in, pair<U, V>& p) {
in >> p.first >> p.second;
return in;
}
long long n, f, s;
vector<vector<long long>> al;
void dfsvis(long long u, bool* mark) {
mark[u] = 1;
for (long long v : al[u]) {
if (!mark[v]) {
dfsvis(v, mark);
}
}
}
bool iscon() {
bool mark[n];
memset(mark, 0, sizeof(mark));
;
dfsvis(0, mark);
for (long long i = 0; i < n; i++) {
if (!mark[i]) {
return 0;
}
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
long long m;
cin >> n >> m;
al = vector<vector<long long>>(n);
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
al[u - 1].push_back(v - 1), al[v - 1].push_back(u - 1);
}
if (!iscon()) {
cout << "NO";
return 0;
}
if (m - (n - 1) == 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.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Cthulhu {
static ArrayList<Integer>adj[];
static int dfs_num [];
static int cycleLen,cnt;
public static void main(String[] args) throws IOException {
Scanner sc=new Scanner(System.in);
cycleLen=cnt=0;
int n=sc.nextInt();
int m=sc.nextInt();
adj=new ArrayList[n];
dfs_num=new int[n];
Arrays.fill(dfs_num, -1);
for(int i=0;i<n;++i)
adj[i]=new ArrayList<Integer>();
while(m-->0) {
int x=sc.nextInt()-1;
int y=sc.nextInt()-1;
adj[x].add(y);
adj[y].add(x);
}
dfs(0,0,-1);
for(int i=0;i<n;++i)
if(dfs_num[i]==-1)
cnt=7;
System.out.println(cnt==2 && cycleLen>2?"FHTAGN!":"NO");
}
public static void dfs(int node,int prevNum,int prevNode) {
if(dfs_num[node]!=-1) {//System.out.println(node+" "+prevNode+" "+dfs_num[node]+" "+prevNum);
cnt++;
cycleLen=Math.max(cycleLen, prevNum-dfs_num[node]+1);
return;
}
else
dfs_num[node]=prevNum+1;
for(int v:adj[node]) {
if(v!=prevNode)
dfs(v,dfs_num[node],node);
}
}
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 | #include <bits/stdc++.h>
const int magicconst = 73743071;
using namespace std;
bool b[105];
bool c[105][105];
int n, m;
void dfs(int v) {
if (b[v]) return;
b[v] = 1;
for (int i = 0; i < (int)(n); ++i)
if (c[v][i]) dfs(i);
}
int main() {
scanf("%d%d", &n, &m);
if (n != m) {
printf("NO");
return 0;
}
memset(c, 0, sizeof c);
for (int i = 0; i < (int)(m); ++i) {
int q, w;
scanf("%d%d", &q, &w);
c[q - 1][w - 1] = c[w - 1][q - 1] = 1;
}
memset(b, 0, sizeof b);
dfs(0);
for (int i = 0; i < (int)(n); ++i) {
if (!b[i]) {
printf("NO");
return 0;
}
}
printf("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<long long> adj[500];
long long vis[500];
long long ans;
void dfs(long long fr, long long m) {
vis[fr] = 1;
for (auto it : adj[fr]) {
if (it != m) {
if (vis[it])
ans++;
else
dfs(it, fr);
}
}
}
int main() {
long long n, m;
scanf("%lld%lld", &n, &m);
long long i;
long long x, y, w;
long long fr;
for (i = 0; i < m; i++) {
scanf("%lld%lld", &x, &y);
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
if (!i) fr = x;
}
dfs(1, -1);
for (i = 0; i < n; i++) {
if (!vis[i]) {
cout << "NO\n";
return 0;
}
}
if (ans == 2)
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>
using namespace std;
bool p[128][128], q[128][128];
int cnt[128], n;
bool mark[128];
void dfs(int u) {
if (mark[u]) return;
mark[u] = true;
for (int v = 1; v <= n; ++v)
if (p[u][v]) dfs(v);
}
bool gao() {
int m, a, b, i, j, t, f;
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &a, &b);
q[a][b] = q[b][a] = p[a][b] = p[b][a] = true;
++cnt[a];
++cnt[b];
}
bool flag;
dfs(1);
for (i = 1; i <= n; ++i)
if (!mark[i]) return false;
t = n;
do {
flag = false;
for (i = 1; i <= n; ++i)
if (cnt[i] == 1) {
cnt[i] = -1;
--t;
flag = true;
for (j = 1; j <= n; ++j)
if (q[i][j]) {
q[j][i] = q[i][j] = false;
--cnt[j];
}
}
} while (flag);
if (t < 3) return false;
for (i = 1; i <= n; ++i)
if (cnt[i] != -1 && cnt[i] != 2) return false;
return true;
}
int main() {
puts(gao() ? "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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Nhat M. Nguyen
*/
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);
Codeforces_103B solver = new Codeforces_103B();
solver.solve(1, in, out);
out.close();
}
static class Codeforces_103B {
InputReader in;
OutputWriter out;
public void solve(int testNumber, InputReader in, OutputWriter out) {
this.in = in;
this.out = out;
int n = in.nextInt();
int m = in.nextInt();
DSU dsu = new DSU(n);
// ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
// for (int u = 0; u < n; u++) {
// adj.add(new ArrayList<>());
// }
for (int i = 0; i < m; i++) {
int u = in.nextInt() - 1;
int v = in.nextInt() - 1;
// adj.get(u).add(v);
// adj.get(v).add(u);
dsu.union(u, v);
}
if (dsu.count() == 1 && m == n) {
out.println("FHTAGN!");
} else {
out.println("NO");
}
}
}
static class DSU {
public int n;
public int[] parent;
public int[] rank;
public DSU(int n) {
this.n = n;
parent = new int[n];
rank = new int[n];
for (int i = 0; i < n; i++) {
parent[i] = i;
rank[i] = 0;
}
}
public int find(int u) {
while (parent[u] != u) {
u = parent[u];
}
return u;
}
public void union(int u, int v) {
int rootU = find(u);
int rootV = find(v);
if (rootU == rootV) return;
if (rank[rootU] < rank[rootV]) {
parent[rootU] = rootV;
} else if (rank[rootU] > rank[rootV]) {
parent[rootV] = rootU;
} else {
parent[rootV] = rootU;
rank[rootU]++;
}
}
public int count() {
int res = 0;
for (int i = 0; i < n; i++) {
if (parent[i] == i) {
res++;
}
}
return res;
}
}
static class OutputWriter {
private PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(Object... objects) {
for (Object object : objects) {
writer.print(object);
}
}
public void println(Object... objects) {
print(objects);
writer.println();
}
public void close() {
writer.close();
}
}
static class InputReader {
private final int BUFFER_SIZE = 32768;
private InputStream stream;
private byte[] buffer = new byte[BUFFER_SIZE + 1];
private int pointer = 1;
private int readLength = 0;
private int lastWhiteSpace = '\n';
public InputReader(InputStream stream) {
this.stream = stream;
}
private void fillBuffer() {
try {
readLength = stream.read(buffer, 1, BUFFER_SIZE);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private byte get() {
if (pointer > readLength) {
pointer = 1;
fillBuffer();
if (readLength <= 0) return -1;
}
return buffer[pointer++];
}
public char nextChar() {
int c = get();
while (isWhiteSpace(c)) {
c = get();
}
return (char) c;
}
public int nextInt() {
int c = nextChar();
int sign = 1;
if (c == '-') {
sign = -1;
c = get();
}
int abs = 0;
do {
if (c < '0' || c > '9') throw new InputMismatchException();
abs *= 10;
abs += c - '0';
c = get();
} while (!isWhiteSpace(c));
lastWhiteSpace = c;
return abs * sign;
}
public boolean isWhiteSpace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -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 | #include <bits/stdc++.h>
using namespace std;
int vis[int(1e5 + 10)];
void bfs(vector<vector<int> > Adj, int s) {
vis[s] = 1;
queue<int> Q;
Q.push(s);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (auto v : Adj[u]) {
if (vis[v] == 0) {
vis[v] = 1;
Q.push(v);
}
}
}
}
int main() {
vector<vector<int> > Adj;
int n, m;
cin >> n >> m;
Adj.resize(n);
memset(vis, 0, sizeof vis);
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
Adj[x].push_back(y);
Adj[y].push_back(x);
}
int cnx = 0;
for (int i = 0; i < n; ++i) {
if (vis[i] == 0) {
bfs(Adj, i);
++cnx;
}
}
if (cnx == 1) {
if (n == m)
cout << "FHTAGN!\n";
else
cout << "NO\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>
const int MAXN = 110;
int n, m;
int f[MAXN];
int getf(int p) { return f[p] == p ? p : f[p] = getf(f[p]); }
int main() {
scanf("%d %d\n", &n, &m);
int i, s, t;
if (n == 1 || n != m) {
printf("NO\n");
return 0;
}
for (int i = 1; i <= n; ++i) f[i] = i;
int c = 0;
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &s, &t);
if (getf(s) != getf(t)) {
f[getf(s)] = getf(t);
} else {
if (c) {
printf("NO\n");
return 0;
}
++c;
}
}
printf("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 | import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
public static InputReader in;
public static PrintWriter pw;
public static void main(String args[]) {
new Thread(null, new Runnable() {
public void run() {
try{
solve();
}
catch(Exception e){
e.printStackTrace();
}
}
}, "1", 1 << 26).start();
}
static ArrayList<Integer>[] g;
static long edje=0;
static boolean vis[];
static int parent[];
static int col[];
static int val[];
static int degree[];
static int f[];
static boolean visited[];
static int edjes=0;
static int a[][];
static HashSet<Pair> set;
public static void solve(){
in = new InputReader(System.in);
pw = new PrintWriter(System.out);
int n=in.nextInt();
int m=in.nextInt();
if(m!=n)
{
System.out.println("NO");
System.exit(0);
}
g=new ArrayList[n+1];
for(int i=0;i<=n;i++)
g[i]=new ArrayList<Integer>();
for(int i=0;i<m;i++)
{
int x=in.nextInt();
int y=in.nextInt();
g[x].add(y);
g[y].add(x);
}
visited=new boolean[n+1];
dfs(1);
for(int i=1;i<=n;i++)
{
if(!visited[i])
{
System.out.println("NO");
System.exit(0);
}
}
System.out.println("FHTAGN!");
}
private static void dfs(int curr) {
visited[curr]=true;
for(int x:g[curr])
{
if(!visited[x])
dfs(x);
}
}
/*public static boolean dfs1(int s,int t,int col)
{
vis[s]=true;
Stack<Integer> st=new Stack<Integer>();
st.push(s);
int temp=0;
while(!st.isEmpty())
{
int top=st.pop();
for(int p:g[top])
{
if(!vis[p]&&two[top][p].contains(col))
{
st.push(p);
vis[p]=true;
if(p==t)
{
return true;
}
}
}
}
return false;
}
/* private static void TopologicalSort()
{
for(int i=0;i<26;i++)
{
if(!visited[i]&&g[i].size()!=0)
{
dfs(i);
}
}
}
public static void dfs(int curr)
{
visited[curr]=true;
for(int x:g[curr])
{
if(!visited[x])
dfs(x);
}
stack.push(curr);
}
/*public static void dfs(int curr)
{
vis[curr]=true;
int trees=0;
for(int x:g[curr])
{
if(!vis[x]&&x!=1)
{
trees++;
if(!s.contains(curr+" "+x))
total+=cost[curr][x];
dfs(x);
}
}
if(trees==0)
{
if(!s.contains(curr+" "+1))
total+=cost[1][curr];
}
}
public static void dfs1(int curr,int parent)
{
val[curr]=a[curr];
for(int x:g[curr])
{
if(x!=parent)
{
dfs1(x,curr);
val[curr]+=val[x];
}
}
}
public static void dfs2(int curr,int parent)
{
f[curr]=val[curr];
for(int x:g[curr])
{
if(x!=parent)
{
dfs2(x,curr);
f[curr]+=f[x];
}
}
}
/* public static void dfs2(int curr)
{
if(st[col[curr]].isEmpty())
{
ans[curr]=-1;
}
else
{
ans[curr]=st[col[curr]].peek();
}
st[col[curr]].push(curr);
for(int x:g[curr])
{
dfs2(x);
}
st[col[curr]].pop();
}
public static void dfs1(int curr)
{
visited[curr]=true;
for(int next:g[curr])
{
edje++;
if(!visited[next])
dfs1(next);
}
}
public static void dfs(int curr,int prev)
{
val[curr]=1;
for(int x:g[curr])
{
if(x!=prev)
{
dfs(x,curr);
val[curr]+=val[x];
}
}
}*/
public static long power(long a,long b)
{
long result=1;
while(b>0)
{
if(b%2==1)
result*=a;
a=a*a;
b/=2;
}
return result;
}
public static long pow(long n,long p,long m)
{
long result = 1;
if(p==0)
return 1;
if (p==1)
return n;
while(p!=0)
{
if(p%2==1)
result *= n;
if(result>=m)
result%=m;
p >>=1;
n*=n;
if(n>=m)
n%=m;
}
return result;
}
static class Pair implements Comparable<Pair>{
int day1;
int day2;
int val;
Pair(int mr,int i){
day1=mr;
day2=i;
}
@Override
public int compareTo(Pair o) {
return 1;
}
}
public static long gcd(long a, long b) {
if (b == 0) return a;
return gcd(b, a%b);
}
static class InputReader
{
private InputStream stream;
private byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int snext() {
if (snumChars == -1)
throw new InputMismatchException();
if (curChar >= snumChars) {
curChar = 0;
try {
snumChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (snumChars <= 0)
return -1;
}
return buf[curChar++];
}
public int nextInt() {
int c = snext();
while (isSpaceChar(c))
c = snext();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = snext();
while (isSpaceChar(c))
c = snext();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public int[] nextIntArray(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public String readString() {
int c = snext();
while (isSpaceChar(c))
c = snext();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = snext();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
| 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 | /**
* Created by ankeet on 7/20/16.
*/
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class B103 {
static FastReader in = null;
static PrintWriter out = null;
static ArrayList<ArrayList<Integer>> ed = new ArrayList<>();
static boolean[] vis = new boolean[105];
static void dfs(int curr)
{
if(vis[curr]) return;
vis[curr] = true;
for(int i=0; i<ed.get(curr).size(); i++)
dfs(ed.get(curr).get(i));
}
public static void solve()
{
int n = in.nint();
int m = in.nint();
for(int i=0; i<=n; i++) ed.add(new ArrayList<>());
int val = 0;
for(int i=0; i<m; i++)
{
int a = in.nint(), b = in.nint();
if(val == 0) val = a;
ed.get(a).add(b);
ed.get(b).add(a);
}
dfs(val);
boolean allvis = true;
for(int i = 1; i<=n; i++)
{
if(!vis[i]) allvis = false;
}
out.println(n == m && allvis ? "FHTAGN!" : "NO");
}
public static void main(String[] args)
{
in = new FastReader(System.in);
out = new PrintWriter(System.out);
solve();
out.flush();
out.close();
}
static class FastReader {
BufferedReader read;
StringTokenizer tokenizer;
public FastReader(InputStream in)
{
read = new BufferedReader(new InputStreamReader(in));
}
public String next()
{
while(tokenizer == null || !tokenizer.hasMoreTokens())
{
try{
tokenizer = new StringTokenizer(read.readLine());
}catch(Exception e){
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nint()
{
return Integer.parseInt(next());
}
public long nlong()
{
return Long.parseLong(next());
}
public double ndouble()
{
return Double.parseDouble(next());
}
public int[] narr(int n)
{
int[] a = new int[n];
for(int i=0; i<n; ++i)
{
a[i] = nint();
}
return a;
}
public long[] nlarr(int n)
{
long[] a = new long[n];
for(int i=0; i<n; ++i)
{
a[i] = nlong();
}
return a;
}
}
}
| 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.*;
import java.text.*;
public class Main {
//SOLUTION BEGIN
//Into the Hardware Mode
void pre() throws Exception{}
void solve(int TC) throws Exception {
int N = ni(), M = ni();
int[] from = new int[M], to = new int[M];
for(int i = 0; i< M; i++){
from[i] = ni()-1;
to[i] = ni()-1;
}
int[][] G = make(N, from, to, M, true);
int[] p = new int[N], d = new int[N];
Arrays.fill(p, -1);
Arrays.fill(d, 2*N);
d[0] = 1;
int[] q = new int[N];int st = 0, en = 0;
q[en++] = 0;
int cnt = 0;
while(st < en){
int u = q[st++];
for(int v:G[u]){
if(v == p[u])continue;
if(d[v] == 2*N){
d[v] = d[u]+1;
p[v] = u;
q[en++] = v;
}else{
if(cnt <= 1)cnt++;
else{
pn("NO");
return;
}
}
}
}
if(cnt != 2){
pn("NO");return;
}
for(int i:d){
if(i == 2*N){
pn("NO");
return;
}
}
pn("FHTAGN!");
}
//SOLUTION END
void hold(boolean b)throws Exception{if(!b)throw new Exception("Hold right there, Sparky!");}
void exit(boolean b){if(!b)System.exit(0);}
static void debug(Object... o){System.out.println(Arrays.deepToString(o));}
final long IINF = (long)2e18;
final int INF = (int)1e9+2;
DecimalFormat df = new DecimalFormat("0.00000000000");
double PI = 3.141592653589793238462643383279502884197169399, eps = 1e-8;
static boolean multipleTC = false, memory = true, fileIO = false;
FastReader in;PrintWriter out;
void run() throws Exception{
long ct = System.currentTimeMillis();
if (fileIO) {
in = new FastReader("");
out = new PrintWriter("");
} else {
in = new FastReader();
out = new PrintWriter(System.out);
}
//Solution Credits: Taranpreet Singh
int T = multipleTC? ni():1;
pre();
for (int t = 1; t <= T; t++) solve(t);
out.flush();
out.close();
System.err.println(System.currentTimeMillis() - ct);
}
public static void main(String[] args) throws Exception{
if(memory)new Thread(null, new Runnable() {public void run(){try{new Main().run();}catch(Exception e){e.printStackTrace();}}}, "1", 1 << 28).start();
else new Main().run();
}
int[][] make(int n, int[] from, int[] to, int e, boolean f){
int[][] g = new int[n][];int[]cnt = new int[n];
for(int i = 0; i< e; i++){
cnt[from[i]]++;
if(f)cnt[to[i]]++;
}
for(int i = 0; i< n; i++)g[i] = new int[cnt[i]];
for(int i = 0; i< e; i++){
g[from[i]][--cnt[from[i]]] = to[i];
if(f)g[to[i]][--cnt[to[i]]] = from[i];
}
return g;
}
int[][][] makeS(int n, int[] from, int[] to, int e, boolean f){
int[][][] g = new int[n][][];int[]cnt = new int[n];
for(int i = 0; i< e; i++){
cnt[from[i]]++;
if(f)cnt[to[i]]++;
}
for(int i = 0; i< n; i++)g[i] = new int[cnt[i]][];
for(int i = 0; i< e; i++){
g[from[i]][--cnt[from[i]]] = new int[]{to[i], i};
if(f)g[to[i]][--cnt[to[i]]] = new int[]{from[i], i};
}
return g;
}
int find(int[] set, int u){return set[u] = (set[u] == u?u:find(set, set[u]));}
int digit(long s){int ans = 0;while(s>0){s/=10;ans++;}return ans;}
long gcd(long a, long b){return (b==0)?a:gcd(b,a%b);}
int gcd(int a, int b){return (b==0)?a:gcd(b,a%b);}
int bit(long n){return (n==0)?0:(1+bit(n&(n-1)));}
void p(Object o){out.print(o);}
void pn(Object o){out.println(o);}
void pni(Object o){out.println(o);out.flush();}
String n()throws Exception{return in.next();}
String nln()throws Exception{return in.nextLine();}
int ni()throws Exception{return Integer.parseInt(in.next());}
long nl()throws Exception{return Long.parseLong(in.next());}
double nd()throws Exception{return Double.parseDouble(in.next());}
class FastReader{
BufferedReader br;
StringTokenizer st;
public FastReader(){
br = new BufferedReader(new InputStreamReader(System.in));
}
public FastReader(String s) throws Exception{
br = new BufferedReader(new FileReader(s));
}
String next() throws Exception{
while (st == null || !st.hasMoreElements()){
try{
st = new StringTokenizer(br.readLine());
}catch (IOException e){
throw new Exception(e.toString());
}
}
return st.nextToken();
}
String nextLine() throws Exception{
String str;
try{
str = br.readLine();
}catch (IOException e){
throw new Exception(e.toString());
}
return str;
}
}
} | JAVA |
Subsets and Splits