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 sys
import queue
sys.setrecursionlimit(100000)
# global constant
INF = int(1e7+1)
MAX = 100005
# For testing
#sys.stdin = open("INP.txt", 'r')
#sys.stdout = open("OUT.txt", 'w')
# global variables
parents = []
ranks = []
size = []
n = 0
# classes
class Pair:
def __init__(self, a, b):
self.first = a
self.second = b
# functions
def init():
global parents, ranks, size
parents = [i for i in range(n)]
ranks = [0 for i in range(n)]
size = [1 for i in range(n)]
def findSet(u):
if(parents[u] != u):
parents[u] = findSet(parents[u])
return parents[u]
def unionSet(u, v):
up = findSet(u)
vp = findSet(v)
if up == vp:
return
if ranks[up] < ranks[vp]:
parents[up] = vp
elif ranks[vp] < ranks[up]:
parents[vp] = up
else:
ranks[vp] += 1
parents[up] = vp
# main function
def main():
global n
n, m = map(int, input().split())
init()
flag = False
firstLoop = False
for i in range(m):
u, v = map(int, input().split())
u -= 1
v -= 1
if findSet(u) == findSet(v):
flag = True
if not firstLoop:
firstLoop = True
else:
flag = False
break
unionSet(u, v)
S = set()
if flag:
for i in range(n):
S.add(findSet(i))
if flag and len(S) > 1:
flag = False
if flag:
print("FHTAGN!")
else:
print("NO")
main()
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long long visited[100010];
vector<long long> g[100010];
void dfs(long long u) {
visited[u] = true;
for (auto x : g[u]) {
if (!visited[x]) {
dfs(x);
}
}
}
void solve() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; ++i) {
long long a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
long long c = 0;
for (long long i = 1; i <= n; i++)
if (!visited[i]) c++, dfs(i);
if (n == m and c == 1)
cout << "FHTAGN!" << '\n';
else
cout << "NO" << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long 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 | import java.io.*;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.function.BiFunction;
public class Graph {
static Scanner sc = new Scanner(System.in);
static PrintWriter pw = new PrintWriter(System.out), pw2 = new PrintWriter(System.out);
public static void main(String[] args) throws IOException {
int n = sc.nextInt(), m = sc.nextInt();
if(n!=m)System.out.println("NO");
else {
graph g = new graph(m);
for (int i = 0; i < m; i++) g.addEdge(sc.nextInt(), sc.nextInt());
g.BFS(1);
if(g.c==n)System.out.println("FHTAGN!");
else System.out.println("NO");
}
}
public static <E> void print2D(E[][] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
pw2.println(arr[i][j]);
}
}
pw2.flush();
}
public static int digitSum(String s) {
int toReturn = 0;
for (int i = 0; i < s.length(); i++) toReturn += Integer.parseInt(s.charAt(i) + " ");
return toReturn;
}
public static boolean isPrime(long n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
public static long pow(long a, long pow) {
return pow == 0 ? 1 : pow % 2 == 0 ? pow(a * a, pow >> 1) : a * pow(a, pow >> 1);
}
public static long sumNum(long a) {
return a * (a + 1) / 2;
}
public static int gcd(int n1, int n2) {
return n2 == 0 ? n1 : gcd(n2, n1 % n2);
}
public static long factorial(long a) {
return a == 0 || a == 1 ? 1 : a * factorial(a - 1);
}
public static Double[] solveQuadratic(double a, double b, double c) {
double result = (b * b) - 4.0 * a * c;
double r1;
if (result > 0.0) {
r1 = ((double) (-b) + Math.pow(result, 0.5)) / (2.0 * a);
double r2 = ((double) (-b) - Math.pow(result, 0.5)) / (2.0 * a);
return new Double[]{r1, r2};
} else if (result == 0.0) {
r1 = (double) (-b) / (2.0 * a);
return new Double[]{r1, r1};
} else {
return new Double[]{null, null};
}
}
public static BigDecimal[] solveQuadraticBigDicimal(double aa, double bb, double cc) {
BigDecimal a = BigDecimal.valueOf(aa), b = BigDecimal.valueOf(bb), c = BigDecimal.valueOf(cc);
BigDecimal result = (b.multiply(b)).multiply(BigDecimal.valueOf(4).multiply(a.multiply(c)));
BigDecimal r1;
if (result.compareTo(BigDecimal.ZERO) > 0) {
r1 = (b.negate().add(bigSqrt(result)).divide(a.multiply(BigDecimal.valueOf(2))));
BigDecimal r2 = (b.negate().subtract(bigSqrt(result)).divide(a.multiply(BigDecimal.valueOf(2))));
return new BigDecimal[]{r1, r2};
} else if (result.compareTo(BigDecimal.ZERO) == 0) {
r1 = b.negate().divide(a.multiply(BigDecimal.valueOf(2)));
return new BigDecimal[]{r1, r1};
} else {
return new BigDecimal[]{null, null};
}
}
private static BigDecimal sqrtNewtonRaphson(BigDecimal c, BigDecimal xn, BigDecimal precision) {
BigDecimal fx = xn.pow(2).add(c.negate());
BigDecimal fpx = xn.multiply(new BigDecimal(2));
BigDecimal xn1 = fx.divide(fpx, 2 * BigDecimal.valueOf(16).intValue(), RoundingMode.HALF_DOWN);
xn1 = xn.add(xn1.negate());
BigDecimal currentSquare = xn1.pow(2);
BigDecimal currentPrecision = currentSquare.subtract(c);
currentPrecision = currentPrecision.abs();
if (currentPrecision.compareTo(precision) <= -1) {
return xn1;
}
return sqrtNewtonRaphson(c, xn1, precision);
}
public static BigDecimal bigSqrt(BigDecimal c) {
return sqrtNewtonRaphson(c, new BigDecimal(1), new BigDecimal(1).divide(BigDecimal.valueOf(10).pow(16)));
}
static class graph {
static int c=0;
int V;
ArrayList<Integer> list[];
boolean vis[];
public graph(int V) {
this.V = V;
list = new ArrayList[V + 1];
vis=new boolean[V+1];
for (int i = 0; i < V + 1; i++) list[i] = new ArrayList<>();
}
public void addEdge(int v1, int v2) {
this.list[v1].add(v2);
this.list[v2].add(v1);
}
public void BFS(int n) {
c++;
Queue<Integer> q = new LinkedList<>();
q.add(n);
while (!q.isEmpty()) {
int a = q.poll();
vis[a] = true;
for (int x : list[a]) {
if (!vis[x]) {
vis[x]=true;
q.add(x);
c++;
}
}
}
}
}
static class pair<E1, E2> implements Comparable<pair> {
E1 x;
E2 y;
pair(E1 x, E2 y) {
this.x = x;
this.y = y;
}
@Override
public int compareTo(pair o) {
return x.equals(o.x) ? (Integer) y - (Integer) o.y : (Integer) x - (Integer) o.x;
}
@Override
public String toString() {
return x + " " + y;
}
public double pointDis(pair p1) {
return Math.sqrt(((Integer) y - (Integer) p1.y) * ((Integer) y - (Integer) p1.y) + ((Integer) x - (Integer) p1.x) * ((Integer) x - (Integer) p1.x));
}
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(FileReader r) {
br = new BufferedReader(r);
}
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;
bool connected[100];
void dfs(const vector<vector<int>>& a, int node) {
connected[node] = true;
for (int child : a[node]) {
if (connected[child] == false) {
dfs(a, child);
}
}
}
int main() {
memset(connected, false, sizeof(connected));
int n, m, a, b;
cin >> n >> m;
vector<vector<int>> adjlist(n);
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
adjlist[a].push_back(b);
adjlist[b].push_back(a);
}
dfs(adjlist, 0);
for (int i = 0; i < n; i++) {
if (connected[i] == false) {
cout << "NO";
return 0;
}
}
if (n == m) {
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 sys
import copy
n, m = map(int, sys.stdin.readline().split())
g = [[] for i in xrange(105)]
visited = [0 for i in xrange(105)]
path = [1]
for i in xrange(m):
a, b = map(int, sys.stdin.readline().split())
g[a].append(b)
g[b].append(a)
cycles = 0
def dfs():
global path
u = path[len(path)-1]
visited[u] = 1
for i in xrange(len(g[u])):
v = g[u][i]
if visited[v] == 0:
path.append(v)
dfs()
path = path[:-1]
elif visited[v] == 1:
l = len(path)
if l > 2 and path[l-2] != v:
global cycles
cycles += 1
visited[u] = 2
#path = [1]
dfs()
vAll = True;
#print cycles
for i in xrange(1, n+1):
vAll &= visited[i] == 2
if vAll and cycles == 1:
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.*;
import java.util.*;
public class A implements Runnable {
private static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
private BufferedReader in;
private PrintWriter out;
private StringTokenizer tok = new StringTokenizer("");
private void init() throws FileNotFoundException {
Locale.setDefault(Locale.US);
String fileName = "";
if (ONLINE_JUDGE && fileName.isEmpty()) {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
} else {
if (fileName.isEmpty()) {
in = new BufferedReader(new FileReader("input.txt"));
out = new PrintWriter("output.txt");
} else {
in = new BufferedReader(new FileReader(fileName + ".in"));
out = new PrintWriter(fileName + ".out");
}
}
}
String readString() {
while (!tok.hasMoreTokens()) {
try {
tok = new StringTokenizer(in.readLine());
} catch (Exception e) {
return null;
}
}
return tok.nextToken();
}
int readInt() {
return Integer.parseInt(readString());
}
long readLong() {
return Long.parseLong(readString());
}
double readDouble() {
return Double.parseDouble(readString());
}
int[] readIntArray(int size) {
int[] a = new int[size];
for (int i = 0; i < size; i++) {
a[i] = readInt();
}
return a;
}
public static void main(String[] args) {
//new Thread(null, new A(), "", 128 * (1L << 20)).start();
new A().run();
}
long timeBegin, timeEnd;
void time() {
timeEnd = System.currentTimeMillis();
System.err.println("Time = " + (timeEnd - timeBegin));
}
@Override
public void run() {
try {
timeBegin = System.currentTimeMillis();
init();
solve();
out.close();
time();
} catch (Exception e) {
e.printStackTrace();
System.exit(-1);
}
}
private int aiverson(boolean good) {
return good ? 1 : 0;
}
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 o) {
if (Integer.compare(x, o.x) == 0) {
return Integer.compare(y, o.y);
}
return Integer.compare(x, o.x);
}
}
List<Integer>[] graph;
private void solve() throws IOException {
int n = readInt();
int m = readInt();
graph = new List[n];
for (int i = 0; i < n; i++) {
graph[i] = new ArrayList<>();
}
int[] q = new int[n];
for (int i = 0; i < m; i++) {
int u = readInt() - 1;
int v = readInt() - 1;
graph[u].add(v);
graph[v].add(u);
q[u]++;
q[v]++;
}
int degrees = 0;
for (int i = 0; i < n; i++) {
degrees += aiverson(q[i] >= 3);
}
if (n != m) {
out.println("NO");
return;
}
vis = new boolean[n];
dfs(0);
for (int i = 0; i < n; i++) {
if (!vis[i]) {
out.println("NO");
return;
}
}
out.println("FHTAGN!");
}
private void dfs(int v) {
vis[v] = true;
for (int to : graph[v]) {
if (!vis[to]) {
dfs(to);
}
}
}
boolean[] vis;
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | def solve():
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
edges = []
link = [i for i in range(n+1)]
size = [1 for _ in range(n+1)]
def find_link(x):
while x != link[x]:
x = link[x]
return x
def same(x, y):
return find_link(x) == find_link(y)
def unite(x, y):
if same(x, y):
return
small_set, big_set = find_link(x), find_link(y)
if size[small_set] > size[big_set]:
small_set, big_set = big_set, small_set
link[small_set] = big_set
size[big_set] += size[small_set]
for _ in range(m):
u, v = map(int, input().split())
unite(u, v)
if max(size) == n and n == m:
print('FHTAGN!')
else:
print('NO')
solve()
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
def rd(): return map(int, raw_input().split())
n, m = rd()
g = [[] for _ in xrange(n)]
for _ in xrange(m):
x, y = rd()
g[x-1].append(y-1)
g[y-1].append(x-1)
color = [0]*n
used = [False]*n
parent = [None]*n
cc = []
def dfs(x):
used[x] = True
color[x] = 1
for y in g[x]:
if color[y] == 1 and parent[x] != y:
lc = [y]
u = x
while u != y:
lc.append(u)
u = parent[u]
cc.append(lc)
if not used[y]:
parent[y] = x
dfs(y)
color[x] = 2
dfs(0)
print 'FHTAGN!' if len(cc) == 1 and sum(used) == n else '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;
vector<long long> arr[101];
long long vis[101];
void dfs(long long node) {
vis[node] = 1;
for (auto x : arr[node]) {
if (vis[x]) continue;
dfs(x);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
long long u, v;
for (long long i = 0; i < m; i++)
cin >> u >> v, arr[u].push_back(v), arr[v].push_back(u);
if (n != m)
cout << "NO";
else {
long long count = 0;
for (long long i = 1; i <= n; i++) {
if (vis[i]) continue;
dfs(i);
count++;
}
if (count > 1)
cout << "NO"
<< "\n";
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;
const bool testcase = 0;
const long long int mod1 = 1000000007;
const long long int mod2 = 998244353;
const long long int N = 1e5 + 5;
std::vector<long long int> adj[N];
std::vector<long long int> vis(N, false);
bool hasLoop(long long int i, long long int p) {
vis[i] = true;
bool ans = false;
for (auto it : adj[i]) {
if (!vis[it]) {
ans |= hasLoop(it, i);
} else if (it != p) {
ans |= true;
}
}
return ans;
}
void dfs(long long int i) {
vis[i] = true;
for (auto it : adj[i]) {
if (!vis[it]) {
dfs(it);
}
}
}
void solve() {
long long int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
long long int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
bool ok = true;
dfs(1);
for (int i = 1; i <= n; ++i) {
ok &= (vis[i] == 1);
}
if (ok && n == m) {
cout << "FHTAGN!\n";
} else {
cout << "NO\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int T_T = 1;
if (testcase) {
cin >> T_T;
}
while (T_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 | #include <bits/stdc++.h>
using namespace std;
long long power(long long x, unsigned long long y) {
long long temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
long long modpow(long long x, unsigned int y, long long p) {
long long res = 1;
x = x % p;
if (y == 0) return 1;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long exponentMod(long long A, long long B, long long C) {
if (B == 0) return 1;
if (A == 0) return 0;
long long y;
if (B % 2 == 0) {
y = exponentMod(A, B / 2, C);
y = (y * y) % C;
} else {
y = A % C;
y = (y * exponentMod(A, B - 1, C) % C) % C;
}
return (long long)((y + C) % C);
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int gcdExtended(int a, int b, int *x, int *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
void modInverse(int a, int m) {
int x, y;
int g = gcdExtended(a, m, &x, &y);
if (g != 1)
cout << "Inverse doesn't exist";
else {
int res = (x % m + m) % m;
cout << "Modular multiplicative inverse is " << res;
}
}
void SieveOfEratosthenes(int n) {
bool sieve[n + 1];
long long cnt = 0;
memset(sieve, 0, sizeof(sieve));
for (int p = 2; p * p <= n; p++) {
if (!sieve[p]) {
for (int i = 2 * p; i <= n; i += p) sieve[i] = p;
}
}
for (int p = 2; p <= n; p++) {
if (sieve[p]) cnt++;
}
cout << cnt;
}
int phi(unsigned int n) {
float result = n;
for (int p = 2; p * p <= n; ++p) {
if (n % p == 0) {
while (n % p == 0) n /= p;
result *= (1.0 - (1.0 / (float)p));
}
}
if (n > 1) result *= (1.0 - (1.0 / (float)n));
return (int)result;
}
long long floorSqrt(long long x) {
if (x == 0 || x == 1) return x;
unsigned long long start = 1, end = x, ans;
while (start <= end) {
unsigned long long mid = start + (end - start) / 2;
if (mid * mid == x) return mid;
if (mid * mid < x) {
start = mid + 1;
ans = mid;
} else
end = mid - 1;
}
return ans;
}
void start() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int main() {
start();
long long n, m;
cin >> n >> m;
vector<long long> adj[n + 1];
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
queue<long long> q;
bool vis[n + 1];
memset(vis, false, sizeof(vis));
long long cnt = 0;
for (long long i = 1; i < n + 1; i++) {
if (!vis[i]) {
q.push(i);
cnt++;
vis[i] = true;
while (!q.empty()) {
long long curr = q.front();
q.pop();
for (auto x : adj[curr]) {
if (!vis[x]) {
vis[x] = true;
q.push(x);
}
}
}
}
}
if (cnt == 1 && n == m) {
cout << "FHTAGN!";
} else
cout << "NO";
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.LinkedList;
import java.util.Scanner;
/**
* Created with IntelliJ IDEA.
* Author : Dylan
* Date : 2013-08-03
* Time : 13:56
* Project : Cthulhu
*/
public class Main {
static LinkedList<Integer>[] graph;
static boolean[] visited;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
graph = new LinkedList[n + 1];
for(int i = 1; i <= n; i++)
graph[i] = new LinkedList<Integer>();
for(int i = 0; i < m; i++) {
int x = in.nextInt();
int y = in.nextInt();
graph[x].add(y);
graph[y].add(x);
}
visited = new boolean[n + 1];
dfs(1);
boolean connected = true;
for(int i = 1; i <= n; i++) {
if(!visited[i]) {
connected = false;
break;
}
}
if(n == m && n >= 3 && connected) {
System.out.println("FHTAGN!");
} else {
System.out.println("NO");
}
}
static void dfs(int x) {
visited[x] = true;
for(int i : graph[x]) {
if(!visited[i]) {
dfs(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.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class B103_Cthulhu {
static int n;
static boolean[] vis, adjMatrix[];
static void dfs(int node) {
vis[node] = true;
for (int i = 0; i < n; i++)
if (adjMatrix[node][i] && !vis[i])
dfs(i);
}
public static void main(String[] args) throws IOException {
Scanner in = new Scanner(System.in);
n = in.nextInt();
int m = in.nextInt();
adjMatrix = new boolean[n][n];
int m1 = m;
while (m-- > 0) {
int u = in.nextInt() - 1;
int v = in.nextInt() - 1;
adjMatrix[u][v] = true;
adjMatrix[v][u] = true;
}
vis = new boolean[n];
dfs(0);
if (m1 != n) {
System.out.println("NO");
return;
}
boolean flag = true;
for (int i = 0; i < n; i++)
if (!vis[i])
flag = false;
if(flag)
System.out.println("FHTAGN!");
else
System.out.println("NO");
}
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();
}
}
}
| 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 | /** https://codeforces.com/problemset/problem/103/B
* idea: DSU
*/
import java.util.Scanner;
public class Cthulhu {
public static void makeSet(int[] parent, int[] size) {
int sz = parent.length;
for (int i=0; i < sz; i++) {
parent[i] = i;
size[i] = 1;
}
}
public static int findSet(int u, int[] parent) {
if (parent[u] != u) {
parent[u] = findSet(parent[u], parent);
}
return parent[u];
}
public static boolean unionSet(int[] parent, int[] size, int u, int v, int[] cycle) {
int up = findSet(u, parent);
int vp = findSet(v, parent);
if (up == vp) {
return false;
}
if (size[up] > size[vp]) {
parent[vp] = up;
size[up] += size[vp];
} else if (size[up] < size[vp]) {
parent[up] = vp;
size[vp] += size[up];
} else {
parent[up] = vp;
size[vp] += size[up];
}
return true;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int sz = n+1;
int[] parent = new int[sz];
int[] size = new int[sz];
int[] cycle = new int[sz];
makeSet(parent, size);
// N == M
// > 1 -> 1
// N-1
if (n != m ) {
System.out.println("NO");
return;
}
int a, b, ans = n;
for (int i=0; i < m; i++) {
a = sc.nextInt();
b = sc.nextInt();
if (unionSet(parent, size, a, b, cycle)) {
ans -= 1;
}
}
System.out.println(ans == 1 ? "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.io.*;
import java.util.*;
public class Task103b{
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Task solver = new Task();
solver.solve(1, in, out);
out.close();
}
}
class Task{
private List<Integer>[] g;
private int par[], rootedAt[];
private boolean vis[], inLoop[];
private ArrayList<Integer> loop;
private int start, end, res;
private void dfs(int root, int p){
if (vis[root]){
start = p; end = root;
return;
}
vis[root] = true;
for (int v : g[root]){
if (v != p){
if (!vis[v])
par[v] = root;
dfs(v, root);
}
}
}
void makeCycle(int r){
loop.add(r);
inLoop[r] = true;
if (par[r] != r && r != start)
makeCycle(par[r]);
}
private void dfs2(int root, int p){
if (vis[root]) return ;
vis[root] = true;
for (int v : g[root]){
if (inLoop[v] == false && v != p){
rootedAt[v]++;
dfs2(v, root);
}
}
}
public void solve(int testNumber, InputReader in, PrintWriter out) {
int n = in.nextInt();
int m = in.nextInt();
g = new List[n + 1];
par = new int[n + 1];
rootedAt = new int[n+1];
vis = new boolean[n+1];
inLoop = new boolean[n+1];
loop = new ArrayList<>();
for (int i = 0; i<=n; i++){
g[i] = new ArrayList<>();
par[i] = i;
}
for (int i = 0; i<m; i++){
int u = in.nextInt();
int v = in.nextInt();
g[u].add(v);
g[v].add(u);
}
dfs(1, 1);
makeCycle(end);
boolean ok = true;
if (loop.size() < 3) ok = false;
for (int v : loop){
Arrays.fill(vis, false);
rootedAt[v] = 1;
dfs2(v, v);
}
for (int i = 1; i<=n ;i++){
if (rootedAt[i] != 1){
ok = false;
}
}
out.println(ok ? "FHTAGN!" : "NO");
}
}
class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
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 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 | r=lambda:map(int,raw_input().split())
n,m=r()
g=[[] for i in range(n+1)]
for i in range(m):
a,b=r()
g[a]+=[b]
g[b]+=[a]
v=set()
def d(i):
if i in v: return
v.add(i)
for j in g[i]:
d(j)
d(1)
if len(v) ==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 | #include <bits/stdc++.h>
using namespace std;
int n, m;
bool use[105];
vector<int> a[105];
void dfs(int f) {
use[f] = 1;
for (int i = 0; i < a[f].size(); i++)
if (!use[a[f][i]]) dfs(a[f][i]);
}
int main() {
cin >> n >> m;
int i, j, x, y;
if (n != m) {
cout << "NO" << endl;
return 0;
}
for (i = 0; i < n; i++) {
cin >> x >> y;
a[x - 1].push_back(y - 1);
a[y - 1].push_back(x - 1);
}
dfs(0);
for (i = 0; i < n; i++)
if (!use[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.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Scanner;
public class B {
static ArrayList<ArrayList<Integer>> graph;
static LinkedList<Integer> cycle;
static int[] vis, parent;
public static void dfs(int cur, int pnt) {
if (cycle.size() > 0)
return;
if (vis[cur] != 0) {
while (pnt != cur) {
cycle.add(pnt);
pnt = parent[pnt];
}
cycle.add(cur);
return;
}
vis[cur] = 1;
parent[cur] = pnt;
for (Integer Int : graph.get(cur)) {
if (Int == pnt)
continue;
dfs(Int, cur);
}
}
public static boolean isTreeRoot(int cur, int parent) {
if (vis[cur] > 1||vis[cur]==1&&parent!=-1&&vis[parent]==2) {
return false;
} else if (vis[cur] == 1 &&parent!=-1) {
return true;
}
if(vis[cur]==0)
vis[cur] = 2;
boolean can = true;
for (Integer Int : graph.get(cur)) {
if (Int == parent)
continue;
can = can & isTreeRoot(Int, cur);
}
return can;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int nodes = sc.nextInt();
int edges = sc.nextInt();
graph = new ArrayList<ArrayList<Integer>>();
for (int i = 0; i < nodes; i++) {
graph.add(new ArrayList<Integer>());
}
for (int i = 0; i < edges; i++) {
int source = sc.nextInt() - 1;
int dest = sc.nextInt() - 1;
graph.get(source).add(dest);
graph.get(dest).add(source);
}
cycle = new LinkedList<Integer>();
vis = new int[nodes];
parent = new int[nodes];
dfs(0, -1);
if (cycle.size() < 3) {
System.out.println("NO");
return;
}
vis = new int[nodes];
Arrays.fill(parent, -1);
for (Integer e : cycle) {
vis[e] = 1;
}
boolean valid = true;
while (!cycle.isEmpty()) {
if (!isTreeRoot(cycle.remove(), -1)) {
valid = false;
break;
}
}
for(int i=0;i<nodes;i++){
if(vis[i]==0) valid=false;
}
if (valid) {
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 | s=raw_input().split()
n=int(s[0])
m=int(s[1])
C= [[0 for col in range(n)] for row in range(n)]
for i in range(m):
s=raw_input().split()
x=int(s[0])
y=int(s[1])
C[x-1][y-1]=1
C[y-1][x-1]=1
e= [0 for i in range(n)]
def dfs(u):
ver=1;
ed=0;
e[u]=1
for v in range(n):
if C[u][v]==1:
C[v][u]=0
C[u][v]=0
ed+=1;
if e[v]==0:
x,y=dfs(v)
ver+=x
ed+=y
return (ver,ed)
res=0
count=0
for i in range(n):
if e[i]==0:
count+=1
ver,ed=dfs(i)
#print ver, ed
res+=(ed-ver+1)
if (res==1 and count==1): 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;
vector<int> g[100010];
int visited[100010];
int parent[100010];
int flag;
void explore(int u) {
visited[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
if (!visited[g[u][i]]) {
parent[g[u][i]] = u;
explore(g[u][i]);
} else if (g[u][i] == parent[u])
;
else
flag++;
}
}
int n;
int dfs() {
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (visited[i])
continue;
else {
explore(i);
cnt++;
if (cnt > 1) return 0;
}
}
if (flag == 2) return 1;
}
int main() {
int m;
int e = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
e++;
}
if (m != n) {
cout << "NO" << endl;
return 0;
}
int k = dfs();
if (k)
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.util.LinkedList;
import java.util.ListIterator;
import java.util.Scanner;
public class Cthulhu {
public static void main(String args[]){
Graphe g = new Graphe();
if(g.n_m){
g.dfs(0);
if(g.all_marked())
System.out.println("FHTAGN!");
else
System.out.println("NO");
} else
System.out.println("NO");
}
}
class Graphe{
private int V;
private LinkedList<Integer>[] adj;
private boolean marked[];
boolean n_m = false;
public Graphe(){
int edges, i;
Scanner input = new Scanner(System.in);
V = input.nextInt();
edges = input.nextInt();
if(V == edges){
n_m = true;
adj = new LinkedList[V];
marked = new boolean[V];
for(i = 0; i < V; i++){
adj[i] = new LinkedList<Integer>();
}
i = 0;
while (i< edges){
AddEdge(input.nextInt() - 1, input.nextInt() - 1);
i++;
}
input.close();
}
}
private void AddEdge(int a, int b){
adj[a].add(b);
adj[b].add(a);
}
public void dfs(int start){
marked[start] = true;
for(int w : adj[start]){
if(!marked[w]){
dfs(w);
}
}
}
public boolean all_marked(){
boolean all_marked = true;
for(int i = 0; i < V && all_marked; i++){
if(!marked[i])
all_marked = false;
}
return all_marked;
}
}
| 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 CF_Cthulu_104C{
public static void main(String[] args)throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String[] input;
input = in.readLine().split(" ");
int n = Integer.parseInt(input[0]);
int m = Integer.parseInt(input[1]);
int[] parent = new int[n];
for(int i=0;i<n;i++)
parent[i]=i;
int count=0;
for(int i=0;i<m;i++){
input = in.readLine().split(" ");
int a = Integer.parseInt(input[0]);
int b = Integer.parseInt(input[1]);
int pi = find(parent,a-1);
int pj = find(parent,b-1);
if(pi==pj){
// circle
count++;
if(count>1)
break;
}
else{
parent[pj] = pi;
}
}
int p = find(parent,0);
for(int i=1;i<n;i++){
if(find(parent,i)!=p){
count=0;
break;
}
}
// tentacles also must be attached!
if(count>1 || count==0)
System.out.println("NO");
else
System.out.println("FHTAGN!");
}
public static int find(int[] parent,int i){
if(parent[i]==i)
return i;
parent[i] = find(parent,parent[i]);
return parent[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.util.Scanner;
public class C {
int n, m;
boolean[][] e;
boolean[] u;
boolean[] cycle;
int[] trace;
int cycleN;
void f(int x, int from, int k){
if(cycleN>1)return;
for(int i=0;i<n;i++){
if(i==from)continue;
if(e[x][i]){
if(u[i]){
if(cycle[i])continue;
cycleN++;
if(cycleN>1)return;
int j = k-1;
cycle[i] = true;
while(trace[j]!=i){
cycle[trace[j]] = true;
j--;
}
}
else{
u[i] = true;
trace[k] = i;
f(i, x, k+1);
}
}
}
}
void g(int x){
if(u[x])return;
u[x] = true;
for(int i=0;i<n;i++)if(e[x][i])g(i);
}
void run(){
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
e = new boolean[n][n];
for(int i=0;i<m;i++){
int s = sc.nextInt()-1;
int t = sc.nextInt()-1;
e[s][t] = e[t][s] = true;
}
// cycleN = 0;
u = new boolean[n];
g(0);
boolean c = true;
for(int i=0;i<n;i++)if(!u[i])c=false;
System.out.println(c&&n==m&&n>=3?"FHTAGN!":"NO");
// trace = new int[n];
// cycle = new boolean[n];
// trace[0] = 0;
// u[0] = true;
// f(0, -1, 1);
// int rt = 0;
// boolean ok = true;
// for(int i=0;i<n;i++)if(!u[i])ok = false;
// for(int i=0;i<n;i++)if(!cycle[i])rt++;
// if(cycleN!=1||rt<3||!ok)System.out.println("NO");
// else System.out.println("FHTAGN!");
}
public static void main(String[] args) {
new C().run();
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
import java.util.*;
import java.io.*;
public class Main implements Runnable {
int N;
List<Integer>[] edges;
boolean[] visited;
public void dfs(int at){
visited[at] = true;
for(int c : edges[at]){
if(!visited[c])
dfs(c);
}
}
public void solve() throws IOException {
N = nextInt();
int e = nextInt();
edges = new ArrayList[N];
visited = new boolean[N];
for(int i = 0; i < N; i++) edges[i] = new ArrayList<Integer>();
for(int i = 0; i < e; i++){
int from = nextInt() - 1;
int to = nextInt() - 1;
edges[from].add(to);
edges[to].add(from);
}
dfs(0);
boolean isConnected = true;
for(int i = 0; i < N; i++) if(!visited[i]) isConnected = false;
boolean isCircle = (N == e ? true : false);
if(isConnected && isCircle)System.out.println("FHTAGN!");
else System.out.println("NO");
}
//-----------------------------------------------------------
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 | #include <bits/stdc++.h>
using namespace std;
const int INFint = 2e9;
const long long INF = 1e18;
const long long MOD = 1000000007ll;
int g[100][100];
vector<int> used;
set<int> roots;
int n, m;
void dfs(int v, int p) {
used[v] = 1;
for (int i = 0; i < n; i++) {
if (i == p || !g[v][i]) continue;
if (used[i] || roots.count(i)) {
cout << "NO";
exit(0);
}
dfs(i, v);
}
used[v] = 1;
}
vector<int> anc;
void addCycle(int st, int en) {
int v = en;
while (v != st) {
roots.insert(v);
v = anc[v];
}
roots.insert(st);
}
bool cycle(int v, int p = -1) {
used[v] = 1;
for (int i = 0; i < n; i++) {
if (i == p || !g[v][i]) continue;
if (used[i]) {
addCycle(i, v);
return 1;
}
anc[i] = v;
if (cycle(i, v)) return 1;
}
used[v] = 1;
return 0;
}
vector<int> p;
int get(int v) { return p[v] == v ? v : p[v] = get(p[v]); }
void unite(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return;
if (rand() & 1) swap(a, b);
p[a] = b;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
used.resize(n);
p.resize(n);
for (int i = 0; i < n; i++) p[i] = i;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
unite(a, b);
g[a][b] = g[b][a] = 1;
}
int cnt = 0;
for (int i = 0; i < n; i++)
if (p[i] == i) cnt++;
if (cnt != 1) {
cout << "NO";
return 0;
}
anc.resize(n);
for (int i = 0; i < n; i++) {
if (!used[i]) {
if (cycle(i)) break;
}
}
if (roots.size() < 3) {
cout << "NO";
return 0;
}
used.assign(n, 0);
for (auto v : roots) {
for (int i = 0; i < n; i++) {
if (g[v][i] && !roots.count(i)) {
dfs(i, v);
}
}
}
cout << "FHTAGN!";
fprintf(stderr, "\nTIME = %lf\n", 1.0 * clock() / CLOCKS_PER_SEC);
;
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 B {
int n, m;
ArrayList<Integer>[] g;
int k;
int[] s;
boolean[] used;
void dfs(int v) {
used[v] = true;
for (int j : g[v]) {
if (!used[j]) {
dfs(j);
}
}
}
void solve() throws Exception {
n = nextInt();
m = nextInt();
if (n != m) {
out.println("NO");
out.close();
System.exit(0);
}
k = 0;
s = new int[n];
used = new boolean[n];
g = new ArrayList[n];
for (int i = 0; i < n; i++)
g[i] = new ArrayList<Integer>();
for (int i = 0; i < m; i++) {
int x = nextInt() - 1;
int y = nextInt() - 1;
g[x].add(y);
g[y].add(x);
}
dfs(0);
for (int i = 0; i < n; i++)
if (!used[i]) {
out.println("NO");
out.close();
System.exit(0);
};
out.println("FHTAGN!");
}
void run() {
try {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
// in = new BufferedReader(new FileReader(filename + ".in"));
// out = new PrintWriter(filename + ".out");
solve();
out.close();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
BufferedReader in;
StringTokenizer st;
PrintWriter out;
final String filename = new String("B").toLowerCase();
String nextToken() throws Exception {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(in.readLine());
return st.nextToken();
}
int nextInt() throws Exception {
return Integer.parseInt(nextToken());
}
long nextLong() throws Exception {
return Long.parseLong(nextToken());
}
double nextDouble() throws Exception {
return Double.parseDouble(nextToken());
}
public static void main(String[] args) {
new B().run();
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | //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 words, a graph is Cthulhu when we can make the graph acyclic by removing one edge
//Let's use DSU for implementation
//Mistake made-Graph is not Cthulhu, if the graph has more than 1 connected componenet.
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 | # Bosdiwale code chap kr kya milega
# Motherfuckers Don't copy code for the sake of doing it
# ..............
# ╭━┳━╭━╭━╮╮
# ┃┈┈┈┣▅╋▅┫┃
# ┃┈┃┈╰━╰━━━━━━╮
# ╰┳╯┈┈┈┈┈┈┈┈┈◢▉◣
# ╲┃┈┈┈┈┈┈┈┈┈┈▉▉▉
# ╲┃┈┈┈┈┈┈┈┈┈┈◥▉◤
# ╲┃┈┈┈┈╭━┳━━━━╯
# ╲┣━━━━━━┫
# ……….
# .……. /´¯/)………….(\¯`\
# …………/….//……….. …\\….\
# ………/….//……………....\\….\
# …./´¯/…./´¯\……/¯ `\…..\¯`\
# ././…/…/…./|_…|.\….\….\…\.\
# (.(….(….(…./.)..)...(.\.).).)
# .\…………….\/../…....\….\/…………/
# ..\…………….. /……...\………………../
# …..\…………… (………....)……………./
from collections import defaultdict
graph = defaultdict(list)
n,m = list(map(int,input().split()))
for i in range(m):
u,v = list(map(int,input().split()))
graph[u-1].append(v-1)
graph[v-1].append(u-1)
visited = [False for i in range(n)]
parent = [-1 for i in range(n)]
q = []
visited[0] = True
q+=[0]
f = 0
while q!=[]:
u = q[0]
q.pop(0)
for i in graph[u]:
if visited[i]==False:
visited[i]=True
q.append(i)
parent[i] = u
elif parent[u]!=i:
f = 1
cnt = visited.count(True)
if f==0 or cnt!=n or n!=m:
print("NO")
else:
print("FHTAGN!") | PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | inp = input().split()
n = int(inp[0])
m = int(inp[1])
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 | #include <bits/stdc++.h>
using namespace std;
vector<int> g[111];
bool u[111];
int n, m, x, y, z;
void dfs(int i) {
u[i] = true;
z++;
for (int j = 0; j < g[i].size(); j++) {
if (u[g[i][j]] == false) dfs(g[i][j]);
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) u[i] = false;
for (int i = 0; i < m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
if (n != m) {
cout << "NO";
return 0;
}
dfs(1);
if (n != z) {
cout << "NO";
return 0;
}
cout << "FHTAGN!";
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | from sys import stdin, exit
buf = []
for line in stdin:
buf.append(line.strip())
buf.reverse()
def getints():
return [int(e) for e in buf.pop().split()]
d = getints()
if d[0] != d[1]:
print 'NO'
exit()
v = d[0]
UF = [i for i in range(v)]
def find(i):
p = UF[i]
if p == i:
return i
UF[i] = find(p)
return UF[i]
def union(i, j):
i, j = find(i), find(j)
if i == j:
return
UF[j] = i
for (i, j) in [tuple(int(k) for k in e.split()) for e in buf]:
union(i-1, j-1)
root = set(find(i) for i in range(v))
print ['NO', 'FHTAGN!'][len(root) == 1]
| 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;
void build(long long v, long long tl, long long tr, long long st[],
long long lz[], bool f[], long long a[]) {
if (tl == tr) {
st[v] = a[tl];
lz[v] = 0LL;
f[v] = false;
return;
}
build((v << 1), tl, ((tl + tr) >> 1), st, lz, f, a);
build((v << 1) | 1, ((tl + tr) >> 1) + 1, tr, st, lz, f, a);
st[v] = st[(v << 1)] + st[(v << 1) | 1];
lz[v] = 0LL;
f[v] = false;
return;
}
void push(long long v, long long tl, long long tr, long long st[],
long long lz[], bool f[]) {
if (f[v]) {
st[(v << 1)] = lz[(v << 1)] = st[(v << 1) | 1] = lz[(v << 1) | 1] = 0LL;
f[(v << 1)] = f[(v << 1) | 1] = true;
f[v] = false;
}
st[(v << 1)] += lz[v] * (((tl + tr) >> 1) - tl + 1);
lz[(v << 1)] += lz[v];
st[(v << 1) | 1] += lz[v] * (tr - ((tl + tr) >> 1));
lz[(v << 1) | 1] += lz[v];
lz[v] = 0LL;
return;
}
void update(long long v, long long tl, long long tr, long long l, long long r,
long long val, bool set, long long st[], long long lz[], bool f[]) {
if (l > r) {
return;
}
if (l == tl && tr == r) {
if (set) {
st[v] = lz[v] = 0LL;
f[v] = true;
}
st[v] += val * (tr - tl + 1);
lz[v] += val;
return;
}
push(v, tl, tr, st, lz, f);
update((v << 1), tl, ((tl + tr) >> 1), l, min(r, ((tl + tr) >> 1)), val, set,
st, lz, f);
update((v << 1) | 1, ((tl + tr) >> 1) + 1, tr, max(l, ((tl + tr) >> 1) + 1),
r, val, set, st, lz, f);
st[v] = st[(v << 1)] + st[(v << 1) | 1];
return;
}
long long query(long long v, long long tl, long long tr, long long l,
long long r, long long st[], long long lz[], bool f[]) {
if (l > r) {
return 0LL;
}
if (l == tl && tr == r) {
return st[v];
}
push(v, tl, tr, st, lz, f);
return query((v << 1), tl, ((tl + tr) >> 1), l, min(r, ((tl + tr) >> 1)), st,
lz, f) +
query((v << 1) | 1, ((tl + tr) >> 1) + 1, tr,
max(l, ((tl + tr) >> 1) + 1), r, st, lz, f);
}
void build(int v, int tl, int tr, int a[], long long st[]) {
if (tl == tr) {
st[v] = a[tl];
return;
}
int tm = ((tl + tr) / 2);
build(2 * v, tl, tm, a, st);
build(2 * v + 1, tm + 1, tr, a, st);
st[v] = st[v * 2] + st[v * 2 + 1];
return;
}
void update(int v, int tl, int tr, int pos, int val, long long st[]) {
if (tl == tr && tl == pos) {
st[v] = val;
return;
}
if (tl > pos || tr < pos) {
return;
}
int tm = ((tl + tr) / 2);
update(2 * v, tl, tm, pos, val, st);
update(2 * v + 1, tm + 1, tr, pos, val, st);
st[v] = st[v * 2] + st[v * 2 + 1];
return;
}
long long query(int v, int tl, int tr, int l, int r, long long st[]) {
if (tl == l && tr == r) {
return st[v];
}
if (l > r) {
return 0LL;
}
int tm = ((tl + tr) / 2);
return query(v * 2, tl, tm, l, std::min(tm, r), st) +
query(v * 2 + 1, tm + 1, tr, std::max(tm + 1, l), r, st);
}
long long fn(long long x, long long rn[]) {
if (x == rn[x])
return x;
else
return rn[x] = fn(rn[x], rn);
}
bool un(long long x, long long y, long long rn[], long long sz[]) {
x = fn(x, rn);
y = fn(y, rn);
if (x == y) return false;
if (sz[x] < sz[y]) swap(x, y);
sz[x] += sz[y];
rn[y] = x;
return true;
}
long long power(long long k) {
long long temp = 1;
for (long long i = 0; i <= k - 1; i++) {
temp = temp * 2;
}
return temp;
}
bool compare(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.second < b.second;
}
pair<int, int> mostFrequent(long long arr[], long long n) {
unordered_map<long long, long long> hash;
for (long long i = 0; i < n; i++) hash[arr[i]]++;
long long max_count = 0, res = -1;
for (auto i : hash) {
if (max_count < i.second) {
res = i.first;
max_count = i.second;
}
}
pair<long long, long long> temp;
temp.first = res;
temp.second = max_count;
return temp;
}
string findSum(string str1, string str2) {
if (str1.length() > str2.length()) swap(str1, str2);
string str = "";
int n1 = str1.length(), n2 = str2.length();
reverse(str1.begin(), str1.end());
reverse(str2.begin(), str2.end());
int carry = 0;
for (int i = 0; i < n1; i++) {
int sum = ((str1[i] - '0') + (str2[i] - '0') + carry);
str.push_back(sum % 10 + '0');
carry = sum / 10;
}
for (int i = n1; i < n2; i++) {
int sum = ((str2[i] - '0') + carry);
str.push_back(sum % 10 + '0');
carry = sum / 10;
}
if (carry) str.push_back(carry + '0');
reverse(str.begin(), str.end());
return str;
}
long long div(long long n) {
if (n % 2 == 0) return 2;
for (long long i = 3; i * i <= n; i += 2) {
if (n % i == 0) return i;
}
return n;
}
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
bool sec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first > b.first);
}
bool sec1(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second > b.second);
}
vector<long long> v[4001];
vector<bool> vis(100005, 0);
long long vert;
long long ed;
long long flag = 0;
void dfs(long long t) {
vis[t] = 1;
vert++;
ed = ed + v[t].size();
for (auto u : v[t]) {
if (vis[u] == 0) {
dfs(u);
}
}
}
long long msum(long long a[], long long size) {
long long max_so_far = a[0];
long long curr_max = a[0];
for (long long i = 1; i < size; i++) {
curr_max = max(a[i], curr_max + a[i]);
max_so_far = max(max_so_far, curr_max);
}
return max_so_far;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i <= m - 1; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
long long cnt = 0;
long long flag = 0;
for (long long i = 1; i <= n; i++) {
if (vis[i] == 0) {
vert = 0;
ed = 0;
dfs(i);
if (ed / 2 != vert) {
cout << "NO";
flag = 1;
break;
}
cnt++;
}
}
if (cnt > 1 and flag == 0) {
cout << "NO";
flag = 1;
}
if (flag == 0) {
cout << "FHTAGN!";
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.*;
import java.util.*;
import java.math.*;
public class Main implements Runnable {
int n, m;
boolean[][] a;
boolean[] f;
int[] p, d;
int ck = 0;
boolean ok = true;
void dfs(int v) {
f[v] = true;
for (int i=0; i<n; i++)
if (a[v][i])
if (!f[i]) { p[i] = v; dfs(i); } else {
if (i!=p[v]) {
// ck++;
// int j = v;
// do {
// ok &= (d[j]>2);
// j = p[j];
//
// } while (j>=0 && j!=i);
}
}
}
void solve() throws IOException {
n = nextInt();
m = nextInt();
a = new boolean[n][n];
d = new int[n];
for (int i=0; i<m; i++) {
int x = nextInt()-1;
int y = nextInt()-1;
a[x][y] = a[y][x] = true;
d[x]++; d[y]++;
}
if (n==m) {
f = new boolean[n];
p = new int[n]; p[0] = -1;
dfs(0);
for (int i=0; i<n; i++) ok &= f[i];
if (ok) {
out.println("FHTAGN!");
return;
}
}
out.println("NO");
}
BufferedReader br;
StringTokenizer st;
PrintWriter out;
public void run() {
try {
br = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
// br = new BufferedReader(new FileReader("input.txt"));
// out = new PrintWriter("output.txt");
solve();
br.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
System.exit(123);
}
}
String next() throws IOException {
while (st == null || !st.hasMoreTokens()) {
String s = br.readLine();
if (s == null)
return null;
st = new StringTokenizer(s,", \t");
}
return st.nextToken();
}
double nextDouble() throws IOException {
return Double.parseDouble(next());
}
int nextInt() throws IOException {
return Integer.parseInt(next());
}
long nextLong() throws IOException {
return Long.parseLong(next());
}
public static void main(String[] args) {
new Thread(new Main()).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;
struct edge {
long long u, v;
} e[5005 << 1] = {0};
long long n, m, cnt = 0, tot = 0, v[5005] = {0}, h[5005] = {0};
inline void add(long long u, long long v) {
e[++tot] = (edge){h[u], v}, h[u] = tot;
}
void dfs(long long x) {
v[x] = 1, cnt++;
for (register long long i = h[x]; i; i = e[i].u)
if (!v[e[i].v]) dfs(e[i].v);
}
signed main() {
scanf("%lld%lld", &n, &m);
for (register long long i = 1, x, y; i <= m; i++)
scanf("%lld%lld", &x, &y), add(x, y), add(y, x);
if (n ^ m) {
puts("NO");
return 0;
}
dfs(1);
if (cnt ^ n)
puts("NO");
else
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 | import java.util.*;
import java.io.*;
public class cthulu {
public static void main(String[] args) throws IOException{
Scanner s = new Scanner(System.in);
int n = s.nextInt();
int m = s.nextInt();
if (n == m) {
boolean[] seen = new boolean[n];
ArrayDeque<Integer>[] edges = new ArrayDeque[n];
for (int i=0; i<n; i++) {
edges[i] = new ArrayDeque<Integer>();
}
for (int i=0; i<m; i++) {
int a = s.nextInt()-1;
int b = s.nextInt()-1;
edges[a].add(b);
edges[b].add(a);
}
ArrayDeque<Integer> q = new ArrayDeque<Integer>();
q.add(0);
seen[0] = true;
while (!q.isEmpty()) {
int curr = q.poll();
for (int e : edges[curr]) {
if (!seen[e]) {
seen[e] = true;
q.add(e);
}
}
}
for (int i=0; i<n; i++) {
if (!seen[i]) {
System.out.println("NO");
break;
} else if (i == n-1) {
System.out.println("FHTAGN!");
}
}
} else {
System.out.println("NO");
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const long maxn = 105;
long cht;
vector<long> edges[maxn];
long n, m;
long mark[maxn];
void dfs(long u, long pred) {
mark[u] = 1;
if (edges[u].size() != 0) {
for (long choice = 0; choice < edges[u].size(); choice++) {
long next = edges[u][choice];
if ((mark[next] == 1) && (next != pred)) cht++;
if (mark[next] == 0) dfs(next, u);
}
}
}
int main() {
scanf("%ld%ld", &n, &m);
long q;
for (q = 1; q <= n; q++) edges[q].resize(0);
for (q = 1; q <= m; q++) {
long t1, t2;
scanf("%ld%ld", &t1, &t2);
edges[t1].push_back(t2);
edges[t2].push_back(t1);
}
cht = 0;
for (q = 1; q <= n; q++) mark[q] = 0;
long count = 0;
for (q = 1; q <= n; q++)
if (mark[q] == 0) {
dfs(q, -1);
count++;
}
cht = cht / 2;
if ((cht != 1) || (count > 1))
printf("NO");
else
printf("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 int N = 101;
int mat[N][N];
bool chk[N];
int cnt;
int n, m;
void dfs(int now) {
if (chk[now]) return;
chk[now] = true;
cnt++;
for (int i = 1; i <= n; i++) {
if (mat[now][i]) {
dfs(i);
}
}
}
int main() {
while (scanf("%d %d", &n, &m) == 2) {
memset(mat, 0, sizeof(mat));
memset(chk, 0, sizeof(chk));
cnt = 0;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
mat[u][v] = mat[v][u] = 1;
}
if (n != m) {
printf("NO\n");
continue;
}
dfs(1);
cnt == n ? printf("FHTAGN!\n") : 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.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class test {
static int[] parents;
static int[] ranks;
static int[] count;
static class pair {
int x, y;
public pair (int x, int y){
this.x = x;
this.y = y;
}
public boolean canMove(pair other){
return this.x == other.x || this.y == other.y;
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader(InputStream in) {
br = new BufferedReader(new InputStreamReader(in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
static void makeSet() {
for (int i = 0; i < parents.length; i++) {
parents[i] = i;
ranks[i] = 0;
}
}
static int findSet(int u) {
if (u != parents[u]) {
parents[u] = findSet(parents[u]);
}
return parents[u];
}
static void unionSet(int u, int v) {
int up = findSet(u);
int vp = findSet(v);
if (up == vp)
return;
if (ranks[up] < ranks[vp]) {
parents[up] = vp;
count[vp] += count[up];
} else if (ranks[up] > ranks[vp]) {
parents[vp] = up;
count[up] += count[vp];
} else {
parents[up] = vp;
count[vp] += count[up];
ranks[vp]++;
}
}
static boolean detectCycle(ArrayList<Integer>[] graph, boolean[] visited, int start, int parent, ArrayList<Integer> path){
visited[start] = true;
path.add(start);
for (int i = 0; i < graph[start].size(); i++) {
int adj = graph[start].get(i);
if (!visited[adj]) {
if (detectCycle(graph, visited, adj, start, path))
return true;
}
else if (adj != parent)
return true;
}
path.remove(path.size() - 1);
return false;
}
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
int n = reader.nextInt();
int m = reader.nextInt();
parents = new int[n];
ranks = new int[n];
count = new int[n];
Arrays.fill(count, 1);
ArrayList<Integer>[] graph = new ArrayList[n];
for (int i = 0; i < n; i++) {
graph[i] = new ArrayList<>();
}
makeSet();
pair[] arr = new pair[m];
int u, v;
for (int i = 0; i < m; i++) {
u = reader.nextInt() - 1;
v = reader.nextInt() - 1;
arr[i] = new pair(u, v);
graph[u].add(v);
graph[v].add(u);
}
boolean[] visited = new boolean[n];
ArrayList<Integer> path = new ArrayList<>();
if (detectCycle(graph, visited, 0, -1, path)){
if (path.size() < 3){
System.out.println("NO");
System.exit(0);
}
visited = new boolean[n];
for (int vetex : path){
visited[vetex] = true;
}
int up, vp;
for (int i = 0; i < m; i++) {
if (visited[arr[i].x] && visited[arr[i].y]){
continue;
}
up = findSet(arr[i].x);
vp = findSet(arr[i].y);
if (up == vp){
System.out.println("NO");
System.exit(0);
}
unionSet(up, vp);
}
int sum = 0;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (parents[i] == i) {
sum += count[i];
cnt++;
}
}
for (int i = 0; i < n; i++) {
if (visited[i]){
for (int j = i + 1; j < n; j++) {
if (visited[j] && findSet(i) == findSet(j)){
System.out.println("NO");
System.exit(0);
}
}
}
}
if (sum == n && cnt == path.size()){
System.out.println("FHTAGN!");
}
else {
System.out.println("NO");
}
}
else {
System.out.println("NO");
}
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int find_parent(int a, int *parent) {
if (parent[a] == a) return a;
return find_parent(parent[a], parent);
}
int dfs(int u, int v, vector<vector<int>> &adj, bool *visited) {
visited[u] = true;
if (u == v) return 0;
int myres = INT_MIN;
for (int i = 0; i < adj[u].size(); i++) {
int s = adj[u][i];
if (!visited[s]) myres = max(myres, 1 + dfs(s, v, adj, visited));
}
return myres;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> adj(n + 1);
int *parent = new int[n + 1];
for (int i = 1; i <= n; i++) parent[i] = i;
bool temp = false;
bool *visited = new bool[n + 1];
for (int i = 0; i <= n; i++) visited[i] = false;
int ln;
int myx = -1;
int myy = -1;
int cnt = 0;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
ln = a;
int g = find_parent(a, parent);
int e = find_parent(b, parent);
parent[g] = e;
if (g == e) {
cnt++;
temp = true;
myx = a;
myy = b;
}
}
if (!temp || cnt > 1 || n == m + 1)
cout << "NO" << endl;
else {
int k = dfs(myx, myy, adj, visited);
if (k >= 2)
cout << "FHTAGN!" << endl;
else
cout << "-1" << 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 | import java.io.InputStream;
import java.io.PrintStream;
import java.util.*;
public class Ktulhu implements Runnable {
public void run() {
int n = in.nextInt();
int m = in.nextInt();
if(n != m) {
out.println("NO");
return;
}
Node[] nodes = new Node[n];
for(int i = 0; i < n; ++i) {
nodes[i] = new Node(i);
}
for(int i = 0; i < m; ++i) {
int x = in.nextInt() - 1, y = in.nextInt() - 1;
nodes[x].edges.add(nodes[y]);
nodes[y].edges.add(nodes[x]);
}
Queue<Node> queue = new LinkedList<Node>();
queue.offer(nodes[0]);
nodes[0].visited = true;
while(!queue.isEmpty()) {
Node from = queue.poll();
for(Node to: from.edges) {
if(!to.visited) {
to.visited = true;
queue.offer(to);
}
}
}
for(int i = 0; i < n; ++i) {
if(!nodes[i].visited) {
out.println("NO");
return;
}
}
out.println("FHTAGN!");
}
private class Node implements Comparable<Node> {
List<Node> edges;
boolean visited;
final int index;
private Node(int index) {
this.index = index;
edges = new ArrayList<Node>();
}
public int compareTo(Node node) {
return index - node.index;
}
}
private Scanner in;
private PrintStream out;
public Ktulhu(InputStream in, PrintStream out) {
this.in = new Scanner(in);
this.out = out;
}
public static void main(String[] args) {
new Ktulhu(System.in, System.out).run();
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
bool a[maxn][maxn];
int u[maxn];
vector<int> st;
int n, m;
void dfs0(int x) {
u[x] = 1;
for (int i = 0; i < n; i++) {
if (a[x][i] && !u[i]) dfs0(i);
}
}
int dfs(int x, int p = -1) {
u[x] = 1;
st.push_back(x);
for (int i = 0; i < n; i++)
if (a[x][i] && i != p) {
if (u[i] == 2) continue;
if (u[i] == 1) {
int t = 0;
while (st[i] != i) ++t;
int s = st.size() - t;
a[st[t]][x] = 0;
a[x][st[t]] = 0;
while (t < st.size() - 1) {
a[st[t]][st[t + 1]] = 0;
a[st[t + 1]][st[t]] = 0;
++t;
}
return s;
}
}
}
int main() {
cin >> n >> m;
memset(a, 0, sizeof(a));
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
--x, --y;
a[x][y] = a[y][x] = 1;
}
memset(u, 0, sizeof(u));
dfs0(0);
for (int i = 0; i < n; i++) {
if (!u[i]) {
printf("NO\n");
return 0;
}
}
printf("%s\n", m == n ? "FHTAGN!" : "NO");
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int g[128][128];
vector<bool> visited;
int n, m;
void dfs(int v = 0) {
for (int i = 0; i < n; i++)
if (!visited[i] && g[v][i]) visited[i] = true, dfs(i);
}
int main() {
cin >> n >> m;
if (n != m) {
cout << "NO" << endl;
return 0;
}
visited.resize(n, false);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
g[x - 1][y - 1] = g[y - 1][x - 1] = 1;
}
dfs();
if (find(visited.begin(), visited.end(), false) != visited.end()) {
cout << "NO" << endl;
} else {
cout << "FHTAGN!" << 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 | import java.io.*;
import java.util.*;
public class B103 {
static int n, m;
static ArrayList<Integer> adjList[];
static boolean visited[];
@SuppressWarnings("unchecked")
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
n = in.nextInt();
m = in.nextInt();
adjList = new ArrayList[n];
visited = new boolean[n];
for (int i = 0; i < n; i++) adjList[i] = new ArrayList<Integer>();
for (int i = 0; i < m; i++) {
int a = in.nextInt() - 1, b = in.nextInt() - 1;
adjList[a].add(b);
adjList[b].add(a);
}
if (n != m) {
System.out.println("NO");
return;
}
int comp = 0;
for (int i = 0; i < n; i++) {
if (!visited[i]) comp++;
dfs(i);
}
System.out.println((comp == 1) ? "FHTAGN!":"NO");
}
static void dfs(int v) {
if (visited[v]) return;
visited[v] = true;
for (int a : adjList[v])
dfs(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 | #include <bits/stdc++.h>
using namespace std;
template <class T>
inline T Get_Max(const T& a, const T& b) {
return a < b ? b : a;
}
template <class T>
inline T Get_Min(const T& a, const T& b) {
return a < b ? a : b;
}
const int maxn = 110;
vector<int> G[maxn];
int mark[maxn];
int dfs(int u) {
int cnt = 0;
if (mark[u])
return 0;
else {
mark[u] = 1;
cnt++;
for (int i = 0; i < G[u].size(); i++) {
cnt += dfs(G[u][i]);
}
}
return cnt;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
memset(mark, 0, sizeof mark);
if (n == m && dfs(1) == 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 | # Team ASML
MAX_EDGES = 10000
def nr_edges(n):
if (n != None):
return len(n)
else:
return MAX_EDGES
if __name__=='__main__':
l = map(int,raw_input().split())
n, m = l[0], l[1]
nodes = [[] for i in xrange(n)]
nodes_left = n
for i in xrange(m):
l = map(int,raw_input().split())
nodes[l[0]-1].append(l[1]-1)
nodes[l[1]-1].append(l[0]-1)
lengths = [nr_edges(n) for n in nodes]
min_length = min(lengths)
while min_length == 1:
idx = lengths.index(min_length)
for n in nodes[idx]:
nodes[n].remove(idx)
nodes[idx] = None
nodes_left -= 1
lengths = [nr_edges(n) for n in nodes]
min_length = min(lengths)
if (min_length != 2):
print "NO"
else:
# Not necessarily a loop
idx = lengths.index(min_length)
visited = [idx]
error = False
while (not error):
if len(nodes[idx]) > 2:
# Intersection, jump out of the loop
error = True
else:
# Select next idx
candidates = set(nodes[idx]).difference(set(visited))
if len(candidates) > 0:
# Move the next node
idx = list(candidates)[0]
visited.append(idx)
else:
error = True
if (len(visited) == nodes_left) and (len(visited) >= 3):
print "FHTAGN!"
else:
print "NO"
| PYTHON |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.*;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
/*``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````*/
/*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ CONTROLLER CLASS ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````*/
public class Main {
public static void main(String[] args) throws Exception {
InputReader in = new InputReader(System.in);
PrintWriter out = new PrintWriter(System.out);
TaskA solver = new TaskA();
solver.solve(1, in, out);
out.close();
}
static class TaskA {
/*``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````*/
/*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ OTHER USEFULL METHODS ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````*/
// GCD && LCM
long gcd(long a, long b) {
return b == 0 ? a : gcd(b, a % b);
}
long lcm(long a, long b) {
return a * (b / gcd(a, b));
}
// REverse a String
String rev(String s) {
return new StringBuilder(s).reverse().toString();
}
/*``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````*/
/*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ SOLUTION IS RIGHT HERE^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````*/
public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
// BufferedReader br = new BufferedReader(new
// InputStreamReader(System.in));
// Scanner sc = new Scanner(System.in);
//final long mod = (long)1e9+7;
int n = in.nextInt() , m = in.nextInt();
dsu u = new dsu(n);
for(int i = 0; i < m; i++)
u.union(in.nextInt(), in.nextInt());
if(u.cnt() == 1 && n == m)
out.println("FHTAGN!");
else out.println("NO");
}
}
/*``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````*/
/*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ OTHER USEFULL CLASSES ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````*/
//union
static class dsu{
int[] union , size;
int count;
public dsu(int n){
count = n;
union = new int[n+1];
size = new int[n+1];
for(int i = 0; i <= n; i++){
union[i] = i;
size[i] = 1;
}
}
public int root(int s){
while(s != union[s])
s = union[s];
return s;
}
public boolean connected(int a , int b){
return root(a) == root(b);
}
public void union(int a, int b){
int ea = root(a);
int eb = root(b);
if(ea == eb);
else if(size[ea] > size[eb]){
union[eb] = ea;
size[ea] += size[eb];
count--;
}else{
union[ea] = eb;
size[eb] += size[ea];
count--;
}
//System.out.println(count);
}
public int cnt(){
//System.out.println(count);
return count;
}
}
/*``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````*/
/*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ INPUT READER CLASS ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````*/
static class InputReader {
private byte[] buf = new byte[8000];
private int index;
private int total;
private InputStream in;
//BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
public InputReader(InputStream stream) {
in = stream;
}
public int scan() {
if (total == -1)
throw new InputMismatchException();
if (index >= total) {
index = 0;
try {
total = in.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (total <= 0)
return -1;
}
return buf[index++];
}
public long scanlong() {
long integer = 0;
int n = scan();
while (isWhiteSpace(n))
n = scan();
int neg = 1;
if (n == '-') {
neg = -1;
n = scan();
}
while (!isWhiteSpace(n)) {
if (n >= '0' && n <= '9') {
integer *= 10;
integer += n - '0';
n = scan();
} else
throw new InputMismatchException();
}
return neg * integer;
}
private int scanInt() {
int integer = 0;
int n = scan();
while (isWhiteSpace(n))
n = scan();
int neg = 1;
if (n == '-') {
neg = -1;
n = scan();
}
while (!isWhiteSpace(n)) {
if (n >= '0' && n <= '9') {
integer *= 10;
integer += n - '0';
n = scan();
} else
throw new InputMismatchException();
}
return neg * integer;
}
public double scandouble() {
double doubll = 0;
int n = scan();
int neg = 1;
while (isWhiteSpace(n))
n = scan();
if (n == '-') {
neg = -1;
n = scan();
}
while (!isWhiteSpace(n) && n != '.') {
if (n >= '0' && n <= '9') {
doubll *= 10;
doubll += n - '0';
n = scan();
}
}
if (n == '.') {
n = scan();
double temp = 1;
while (!isWhiteSpace(n)) {
if (n >= '0' && n <= '9') {
temp /= 10;
doubll += (n - '0') * temp;
n = scan();
}
}
}
return neg * doubll;
}
private float scanfloat() {
float doubll = 0;
int n = scan();
int neg = 1;
while (isWhiteSpace(n))
n = scan();
if (n == '-') {
neg = -1;
n = scan();
}
while (!isWhiteSpace(n) && n != '.') {
if (n >= '0' && n <= '9') {
doubll *= 10;
doubll += n - '0';
n = scan();
}
}
if (n == '.') {
n = scan();
double temp = 1;
while (!isWhiteSpace(n)) {
if (n >= '0' && n <= '9') {
temp /= 10;
doubll += (n - '0') * temp;
n = scan();
}
}
}
return neg * doubll;
}
public String scanstring() {
StringBuilder sb = new StringBuilder();
int n = scan();
while (isWhiteSpace(n))
n = scan();
while (!isWhiteSpace(n)) {
sb.append((char) n);
n = scan();
}
return sb.toString();
}
public String scan_nextLine() {
int n = scan();
while (isWhiteSpace(n))
n = scan();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(n);
n = scan();
} while (!isEndOfLine(n));
return res.toString();
}
public boolean isWhiteSpace(int n) {
if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1)
return true;
return false;
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
/// Input module
public int nextInt() {
return scanInt();
}
public long nextLong() {
return scanlong();
}
public double nextDouble() {
return scandouble();
}
public float nextFloat() {
return scanfloat();
}
public String next() {
return scanstring();
}
public String nextLine() throws IOException {
return scan_nextLine();
}
public int[] readIntArray(int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++) {
array[i] = nextInt();
}
return array;
}
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | //package solvingProblems;
import java.util.LinkedList;
import java.util.Scanner;
public class Cthulhu {
static boolean visited[];
static LinkedList<Integer>[] g;
static int count;
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");
} else {
visited = new boolean[n];
g = new LinkedList[n];
for (int i = 0; i < n; i++) {
g[i] = new LinkedList<Integer>();
}
for (int i = 0; i < n; i++) {
int a = scan.nextInt();
int b = scan.nextInt();
g[a - 1].add(b - 1);
g[b - 1].add(a - 1);
}
DFS(0);
if (count == n) {
System.out.println("FHTAGN!");
} else {
System.out.println("NO");
}
}
}
public static void DFS(int i) {
if (visited[i]){
return;
}
visited[i] = true;
count++;
LinkedList<Integer> adj = g[i];
for (int j = 0; j < adj.size(); j++) {
DFS(adj.get(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 | import java.io.*;
import java.util.*;
public class B103 {
static int n, m;
static int[] parent, size;
public static void main(String[] args) throws IOException {
PrintWriter w = new PrintWriter(System.out);
InputReader in = new InputReader(System.in);
n = in.nextInt(); m = in.nextInt();
if (n != m) {
w.println("NO");
} else {
parent = new int[n+1];
size = new int[n+1];
for (int i=1; i<=n; i++) {
parent[i] = i;
size[i] = 0;
}
for (int i=0; i<m; i++) {
int a = in.nextInt();
int b = in.nextInt();
union(a, b);
}
boolean flag = true;
int val = find(1);
for (int i=2; i<=n; i++) {
if (find(i) != val) {
flag = false; break;
}
}
w.println(flag ? "FHTAGN!" : "NO");
}
w.close();
}
static void union(int a, int b) {
a = find(a);
b = find(b);
if (a != b) {
if (size[a] < size[b]) {
int temp = a; a = b; b = temp;
}
size[a] += size[b];
parent[b] = a;
}
}
static int find(int a) {
if (a == parent[a]) return a;
return parent[a] = find(parent[a]);
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String nextString() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
if (Character.isValidCodePoint(c)) {
res.appendCodePoint(c);
}
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
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 | 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.StringTokenizer;
public class CF103B {
static class UndirectedGraph {
ArrayList<Integer>[] adjList;
int n;
UndirectedGraph(int n) {
this.n = n;
adjList = new ArrayList[n];
Arrays.setAll(adjList, i -> new ArrayList<Integer>());
}
void addEdge(int v, int u) {
adjList[v].add(u);
adjList[u].add(v);
}
int cyclesCnt() {
int[] visited = new int[n];
int cnt = dfs(0, -1, visited);
for (int i = 0; i < n; i++)
if (visited[i] == 0) // disconnected graph
return -1;
return cnt;
}
int dfs(int v, int parent, int[] visited) {
int cnt = 0;
visited[v] = 1;
for (int u : adjList[v])
if (visited[u] == 0)
cnt += dfs(u, v, visited);
else if (visited[u] == 1 && u != parent)
cnt++;
visited[v] = 2;
return cnt;
}
}
public static void main(String[] args) throws IOException {
FastScanner sc = new FastScanner();
PrintWriter pw = new PrintWriter(System.out);
int n = sc.nextInt(), m = sc.nextInt();
UndirectedGraph g = new UndirectedGraph(n);
while (m-- > 0) {
g.addEdge(sc.nextInt() - 1, sc.nextInt() - 1);
}
if (g.cyclesCnt() != 1)
pw.println("NO");
else
pw.println("FHTAGN!");
sc.close();
pw.close();
}
static class FastScanner {
BufferedReader in;
StringTokenizer st;
public FastScanner() {
this.in = new BufferedReader(new InputStreamReader(System.in));
}
public String nextToken() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(in.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(nextToken());
}
public long nextLong() {
return Long.parseLong(nextToken());
}
public double nextDouble() {
return Double.parseDouble(nextToken());
}
public void close() throws IOException {
in.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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.List;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
/**
* Built using CHelper plug-in Actual solution is at the top
*
* @author MaxHeap
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
BCthulhu solver = new BCthulhu();
solver.solve(1, in, out);
out.close();
}
static class BCthulhu {
List<Integer>[] g;
int n;
int m;
int visited = 0;
int[] cc;
void dfs(int u, int pt) {
cc[u] = pt;
for (int v : g[u]) {
if (cc[v] == -1) {
dfs(v, pt);
++visited;
}
}
}
public void solve(int testNumber, InputReader in, PrintWriter out) {
n = in.nextInt();
m = in.nextInt();
g = GraphUtils.generateGraph(n + 1);
cc = ArrayUtils.createArray(n + 1, -1);
for (int i = 0; i < m; ++i) {
int u = in.nextInt();
int v = in.nextInt();
g[u].add(v);
g[v].add(u);
}
int pt = 0;
for (int i = 1; i <= n; ++i) {
if (cc[i] == -1) {
dfs(i, pt++);
}
}
if (pt > 1) {
out.println("NO");
return;
}
if (visited + 1 == n && m == n) {
out.println("FHTAGN!");
} else {
out.println("NO");
}
}
}
static interface FastIO {
}
static class InputReader implements FastIO {
private InputStream stream;
private static final int DEFAULT_BUFFER_SIZE = 1 << 16;
private static final int EOF = -1;
private byte[] buf = new byte[DEFAULT_BUFFER_SIZE];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (this.numChars == EOF) {
throw new UnknownError();
} else {
if (this.curChar >= this.numChars) {
this.curChar = 0;
try {
this.numChars = this.stream.read(this.buf);
} catch (IOException ex) {
throw new InputMismatchException();
}
if (this.numChars <= 0) {
return EOF;
}
}
return this.buf[this.curChar++];
}
}
public int nextInt() {
int c;
for (c = this.read(); isSpaceChar(c); c = this.read()) {
}
byte sgn = 1;
if (c == 45) {
sgn = -1;
c = this.read();
}
int res = 0;
while (c >= 48 && c <= 57) {
res *= 10;
res += c - 48;
c = this.read();
if (isSpaceChar(c)) {
return res * sgn;
}
}
throw new InputMismatchException();
}
public static boolean isSpaceChar(int c) {
return c == 32 || c == 10 || c == 13 || c == 9 || c == EOF;
}
}
static class GraphUtils {
private GraphUtils() {
}
public static <T> List<T>[] generateGraph(int n) {
List<T>[] graph = new ArrayList[n];
for (int i = 0; i < n; i++) {
graph[i] = new ArrayList<>();
}
return graph;
}
}
static class ArrayUtils {
public static int[] createArray(int count, int value) {
int[] array = new int[count];
Arrays.fill(array, value);
return array;
}
}
}
| 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 | //thnks learn Ds
import java.io.*;
import java.util.*;
public class CNew
{
public static void main(String args[])throws IOException
{
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer(in.readLine());
int n=Integer.parseInt(st.nextToken());
int m=Integer.parseInt(st.nextToken());
if(n!=m)//tree cant have cycle as tree with n nodes has n-1 edges add 1 edge 1 cycle is sure
{
System.out.println("NO");
return;
}
DisjointSet ds=new DisjointSet(m);
for(int i=1;i<=m;i++)
{
st=new StringTokenizer(in.readLine());
int x=Integer.parseInt(st.nextToken());
int y=Integer.parseInt(st.nextToken());
ds.union(x-1,y-1);
}
if(ds.count()==1) {
System.out.println("FHTAGN!");
return;
}
else {
System.out.println("NO");
return;
}
}
}
class DisjointSet
{
public int upper[];
public DisjointSet(int n)
{
upper=new int[n];
Arrays.fill(upper,-1);
}
int root(int x)
{
return upper[x]<0 ? x : (upper[x]=root(upper[x]));
}
public void union(int x,int y)
{
x=root(x);
y=root(y);
if(x!=y)
{
if(upper[y]<upper[x]){
int temp=x;x=y;y=temp;
}
upper[x]+=upper[y];
upper[y]=x;
}
}
public int count()
{
int cnt=0;
for(int i : upper) {
if(i<0)
cnt++;
}
return cnt;
}
}
| 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.math.BigInteger;
import static java.lang.Math.*;
public class Sol implements Runnable {
int [] par;
int parent(int u) {
return par[u] == u ? u : (par[u] = parent(par[u]));
}
void unite(int u, int v) {
int pu = parent(u);
int pv = parent(v);
par[pu] = pv;
}
void solve() throws Exception {
int n = nextInt(), m = nextInt();
if (m != n) {
out.println("NO");
return;
}
par = new int[n];
for (int i = 0; i < n; i++) {
par[i] = i;
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
unite(u, v);
}
int comp = parent(0);
for (int i = 1; i < n; i++) {
if (parent(i) != comp) {
out.println("NO");
return;
}
}
out.println("FHTAGN!");
}
public static void main(String[] args) {
new Thread(new Sol()).start();
}
public void run() {
try {
Locale.setDefault(Locale.US);
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
sTime();
solve();
debug("Time consumed: " + gTime());
gMemory();
out.close();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
StringTokenizer tokenizer = new StringTokenizer("");
BufferedReader in;
PrintWriter out;
long time;
void sTime() {
time = System.currentTimeMillis();
}
long gTime() {
return System.currentTimeMillis() - time;
}
void gMemory() {
debug("Memory: " + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / 1000 + " kb");
}
public void debug(Object o) {
System.err.println(o);
}
boolean seekForToken() {
while (!tokenizer.hasMoreTokens()) {
String s = null;
try {
s = in.readLine();
} catch (Exception e) {
e.printStackTrace();
}
if (s == null)
return false;
tokenizer = new StringTokenizer(s);
}
return true;
}
String nextToken() {
return seekForToken() ? tokenizer.nextToken() : null;
}
int nextInt() {
return Integer.parseInt(nextToken());
}
long nextLong() {
return Long.parseLong(nextToken());
}
double nextDouble() {
return Double.parseDouble(nextToken());
}
BigInteger nextBig() {
return new BigInteger(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 MAX_N = 1000;
vector<int> g[MAX_N + 10];
vector<int> dfs_trace;
bool is_circle[MAX_N + 10] = {0};
int circles_finded = 0;
int b[MAX_N + 10] = {0};
void scanGraph(int m) {
int x;
int y;
for (int i = 0; i < m; ++i) {
scanf("%d %d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
}
void dfs(int v, int prev) {
b[v] = 1;
dfs_trace.push_back(v);
for (int e = 0; e < g[v].size(); ++e) {
if (b[g[v][e]] == 1 && prev != g[v][e]) {
circles_finded++;
for (int i = dfs_trace.size() - 1; dfs_trace[i] != g[v][e];
is_circle[dfs_trace[i]] = true, --i)
;
is_circle[g[v][e]] = true;
}
if (b[g[v][e]] == 0) {
dfs(g[v][e], v);
}
}
while (dfs_trace[dfs_trace.size() - 1] != v) {
dfs_trace.pop_back();
}
dfs_trace.pop_back();
b[v] = 2;
}
bool find1Cilrclre(int n) {
dfs(1, 0);
for (int i = 1; i <= n; ++i) {
if (b[i] != 2) return false;
}
return (circles_finded == 1);
}
int countTreesOnCircle(int n) {
int count = 0;
for (int i = 1; i <= n; ++i) {
if (is_circle[i]) {
count++;
}
}
return count;
}
int main() {
int n;
int m;
scanf("%d %d", &n, &m);
scanGraph(m);
if (!find1Cilrclre(n)) {
printf("NO");
return 0;
}
if (countTreesOnCircle(n) < 3) {
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<int> x[101];
int vis[101] = {0}, flag = 0;
void dfs(int i, int parent) {
if (vis[i]) {
if (vis[i] != parent) flag++;
return;
}
vis[i] = parent;
for (int j = 0; j < x[i].size(); ++j) {
if (x[i][j] == parent) continue;
dfs(x[i][j], i);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int t, t1;
cin >> t >> t1;
x[t].push_back(t1);
x[t1].push_back(t);
}
int z = 0;
if (n != m) {
cout << "NO";
return 0;
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) {
dfs(1, 0);
++z;
}
if (flag >= 1 && z == 1)
cout << "FHTAGN!";
else
cout << "NO";
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
public class B103 {
public static class V{
int ind;
int vis;
List<V> roadsTo = new ArrayList<>();
public V(int ind)
{
this.ind = ind;
}
}
public static int counter = 0;
public static void go(V cur)
{
cur.vis = 1;
counter++;
for (V kid : cur.roadsTo)
{
if (kid.vis == 0){go(kid);}
}
return;
}
public static void main(String... xxx) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
int m = Integer.parseInt(st.nextToken());
if (n != m){System.out.println("NO");return;}
V[] a = new V[n];
for (int i = 0; i < n; i++) {
a[i] = new V(i);
}
for (int i = 0; i < m; i++) {
st = new StringTokenizer(br.readLine());
int x = Integer.parseInt(st.nextToken()) - 1;
int y = Integer.parseInt(st.nextToken()) - 1;
a[x].roadsTo.add(a[y]);
a[y].roadsTo.add(a[x]);
}
go(a[0]);
if (counter == n)
{
System.out.println("FHTAGN!");
return;
}
System.out.println("NO");
return;
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m;
int i;
int x, y;
vector<int> a[100];
int color[100];
int c_count;
bool isCyclic(int node, int prev) {
int i;
color[node] = 1;
for (i = 0; i < a[node].size(); i++) {
int k = a[node][i];
if (k == prev) continue;
if (color[k] == 1) return true;
if (color[k] == 0)
if (isCyclic(k, node)) return true;
}
color[node] = 2;
return false;
}
void dfs(int node) {
color[node] = 1;
int i;
for (i = 0; i < a[node].size(); i++) {
int k = a[node][i];
if (color[k] == 0) dfs(k);
}
return;
}
void Cnt(int node, int prev) {
int i;
color[node] = 1;
for (i = 0; i < a[node].size(); i++) {
int k = a[node][i];
if (k == prev) continue;
if (color[k] == 1) c_count++;
if (color[k] == 0) Cnt(k, node);
}
color[node] = 2;
return;
}
int main() {
scanf("%d %d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
x--;
y--;
a[x].push_back(y);
a[y].push_back(x);
}
if (n <= 2) {
printf("NO\n");
return 0;
}
for (i = 0; i < n; i++) color[i] = 0;
dfs(0);
for (i = 0; i < n; i++)
if (color[i] == 0) {
printf("NO\n");
return 0;
}
for (i = 0; i < n; i++) color[i] = 0;
if (!isCyclic(0, -1)) {
printf("NO\n");
return 0;
}
for (i = 0; i < n; i++) color[i] = 0;
Cnt(0, -1);
if (c_count > 1) {
printf("NO\n");
return 0;
}
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 |
def func(n):
global a, b, c, lst
a[n] = 1
for j in lst[n]:
if a[j] == 1 and b[n] != j:
c += 1
if(not a[j]):
b[j] = n
func(j)
a[n] = 2
n , m = [int(x) for x in input().split()]
lst = [[] for i in range(n +1)]
for i in range(m):
x , y = map(int, input().split())
lst[x].append(y)
lst[y].append(x)
a = [0]*(n+1)
b = [0]*(n+1)
c = 0
func(1)
if c -1 or 0 in a[1: ]:
print("NO")
else:
print("FHTAGN!")
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;
public class ProblemC_80 {
final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE")!=null;
BufferedReader in;
PrintWriter out;
StringTokenizer tok = new StringTokenizer("");
void init() throws FileNotFoundException{
if (ONLINE_JUDGE){
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
}else{
in = new BufferedReader(new FileReader("input.txt"));
out = new PrintWriter("output.txt");
}
}
String readString() throws IOException{
while(!tok.hasMoreTokens()){
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
int readInt() throws IOException{
return Integer.parseInt(readString());
}
long readLong() throws IOException{
return Long.parseLong(readString());
}
double readDouble() throws IOException{
return Double.parseDouble(readString());
}
public static void main(String[] args){
new ProblemC_80().run();
}
public void run(){
try{
long t1 = System.currentTimeMillis();
init();
solve();
out.close();
long t2 = System.currentTimeMillis();
System.err.println("Time = "+(t2-t1));
}catch (Exception e){
e.printStackTrace(System.err);
System.exit(-1);
}
}
ArrayList<Integer>[] graph;
int[] color;
int[] p;
boolean cycle;
int begin, end;
ArrayList<Integer> list;
void solve() throws IOException{
int n = readInt();
int m = readInt();
graph = new ArrayList[n];
for (int i = 0; i < n; i++){
graph[i] = new ArrayList<Integer>();
}
color = new int[n];
p = new int[n];
Arrays.fill(p, -1);
for (int i = 0; i < m; i++){
int from = readInt() - 1;
int to = readInt() - 1;
graph[from].add(to);
graph[to].add(from);
}
cycle = false;
begin = -1;
end = -1;
if (!dfs(0)){
out.print("NO");
return;
}
list = new ArrayList<Integer>();
list.add(begin);
for (; end != begin; end = p[end]){
list.add(end);
}
Arrays.fill(color, 0);
Arrays.fill(p, -1);
for (int from: list){
for (int to: list){
if (from == to) continue;
graph[from].remove((Integer)to);
graph[to].remove((Integer)from);
}
}
for (int from: list){
if (color[from] != 0 || dfs(from)){
out.print("NO");
return;
}
}
for (int i = 0; i < n; i++){
if (color[i] < 2){
out.print("NO");
return;
}
}
out.print("FHTAGN!");
}
boolean dfs(int from){
color[from] = 1;
for (int to: graph[from]){
if (color[to] == 2 || to == p[from]) continue;
if (color[to] == 0){
p[to] = from;
if (dfs(to)) return true;
continue;
}
begin = to;
end = from;
return true;
}
color[from] = 2;
return false;
}
static int[][] step8 = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}, {-1, -1}, {1, -1}, {-1, 1}, {1, 1}};
static int[][] stepKnight = {{-2, -1}, {-2, 1}, {-1, -2}, {-1, 2}, {1, -2}, {1, 2}, {2, -1}, {2, 1}};
static long gcd(long a, long b){
if (a == 0) return b;
return gcd(b % a, a);
}
static long lcm(long a, long b){
return a / gcd(a, b)*b;
}
static long[] gcdPlus(long a, long b){
long[] d = new long[3];
if (a == 0){
d[0] = b;
d[1] = 0;
d[2] = 1;
}else{
d = gcdPlus(b % a, a);
long r = d[1];
d[1] = d[2] - b/a*d[1];
d[2] = r;
}
return d;
}
static long binpow(long a, int n){
if (n == 0) return 1;
if ((n & 1) == 0){
long b = binpow(a, n/2);
return b*b;
}else return binpow(a, n - 1)*a;
}
static long binpowmod(long a, int n, long m){
if (m == 1) return 0;
if (n == 0) return 1;
if ((n & 1) == 0){
long b = binpowmod(a, n/2, m);
return (b*b) % m;
}else return binpowmod(a, n - 1, m)*a % m;
}
static long phi(long n){
int[] p = Sieve((int)ceil(sqrt(n)) + 2);
long phi = 1;
for (int i = 0; i < p.length; i++){
long x = 1;
while (n % p[i] == 0){
n /= p[i];
x *= p[i];
}
phi *= x - x/p[i];
}
if (n != 1) phi *= n - 1;
return phi;
}
static long f(long n, int x, int k){ //���-�� ���������� ����� (������� 0), ���������� � ���� ����� �� 0 �� k-1
if (n == 0) return 1;
long b = binpow(10, x - 1);
long c = n / b;
return (c < k? c: k)*binpow(k, x - 1) + (c < k? 1: 0)*f(n % b, x - 1, k);
}
static long fib(int n){
if (n == 0) return 0;
if ((n & 1) == 0){
long f1 = fib(n/2 - 1);
long f2 = fib(n/2 + 1);
return f2*f2 - f1*f1;
}else{
long f1 = fib(n/2);
long f2 = fib(n/2 + 1);
return f1*f1 + f2*f2;
}
}
static BigInteger BigFib(int n){
if (n == 0) return BigInteger.ZERO;
if ((n & 1) == 0){
BigInteger f1 = BigFib(n/2 - 1);
f1 = f1.multiply(f1);
BigInteger f2 = BigFib(n/2 + 1);
f2 = f2.multiply(f2);
return f2.subtract(f1);
}else{
BigInteger f1 = BigFib(n/2);
f1 = f1.multiply(f1);
BigInteger f2 = BigFib(n/2 + 1);
f2 = f2.multiply(f2);
return f2.add(f1);
}
}
static public class PointD{
double x, y;
public PointD(double x, double y){
this.x = x;
this.y = y;
}
}
static double d(Point p1, Point p2){
return sqrt(d2(p1, p2));
}
static public double d(PointD p1, PointD p2){
return sqrt(d2(p1, p2));
}
static double d2(Point p1, Point p2){
return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
}
static public double d2(PointD p1, PointD p2){
return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
}
static boolean IsProbablyPrime(long n){
if (n == 1) return false;
if ((n & 1) == 0) return false;
for (int j = 3; j < sqrt(n) + 1; j += 2){
if (n % j == 0) return false;
}
return true;
}
static int[] Sieve(int n){
boolean[] b = new boolean[n+1];
Arrays.fill(b, true);
b[0] = false;
b[1] = false;
long nLong = n;
int j=0;
for (int i = 1; i <= n; i++) {
if (b[i]){
j++;
if (((long)i)*i <= nLong) {
for (int k = i*i; k <= n; k += i) {
b[k] = false;
}
}
}
}
int[] p = new int[j];
Arrays.fill(p, 0);
j=0;
for (int i = 2; i <= n; i++) {
if (b[i]){
p[j]=i;
j++;
}
}
return p;
}
static int[][] Palindromes(String s){
char[] c = s.toCharArray();
int n = c.length;
int[][] d = new int[2][n];
int l = 0, r = -1;
for (int i = 0; i < n; i++){
int j = (i > r? 0: min(d[0][l+r-i+1], r-i+1)) + 1;
for (; i - j >= 0 && i + j - 1< n && c[i-j] == c[i+j-1]; j++);
d[0][i] = --j;
if (i + d[0][i] - 1 > r){
r = i + d[0][i] - 1;
l = i - d[0][i];
}
}
l = 0;
r = -1;
for (int i = 0; i < n; i++){
int j = (i > r? 0: min(d[1][l+r-i], r-i)) + 1;
for (; i - j >= 0 && i + j < n && c[i-j] == c[i+j]; j++);
d[1][i] = --j;
if (i + d[1][i] > r){
r = i + d[1][i];
l = i - d[1][i];
}
}
return d;
}
static public class Permutation {
int[] a;
int n;
public Permutation(int n){
this.n=n;
a=new int[n];
for (int i=0; i<n; i++){
a[i]=i;
}
}
public boolean nextPermutation(){ //������� � do{}while(nextPermutation(a));
int i=n-1;
for (i=n-2; i>=0; i--){
if (a[i]<a[i+1]){
break;
}
}
if (i==-1){
return false;
}
int jMin=i+1;
for (int j=n-1; j>i; j--){
if (a[i]<a[j]&&a[j]<a[jMin]){
jMin=j;
}
}
swap(i, jMin);
for (int j=1; j<=(n-i)/2; j++){
swap(i+j, n-j);
}
return true;
}
public int get(int i){
return a[i];
}
void swap(int i, int j){
int r=a[i];
a[i]=a[j];
a[j]=r;
}
}
static public class Fraction implements Comparable<Fraction>, Cloneable{
public final Fraction FRACTION_ZERO = new Fraction();
public final Fraction FRACTION_ONE = new Fraction(1);
public long numerator = 0;
public long denominator = 1;
public Fraction(){
numerator = 0;
denominator = 1;
}
public Fraction(long numerator){
this.numerator = numerator;
denominator = 1;
}
public Fraction(long numerator, long denominator){
this.numerator = numerator;
this.denominator = denominator;
Cancellation();
}
public Fraction(double numerator, double denominator, int accuracy){
this.numerator = (long)(numerator*pow(10,accuracy));
this.denominator = (long)(denominator*pow(10,accuracy));
Cancellation();
}
public Fraction(String s){
if (s.charAt(0) == '-'){
denominator = -1;
s = s.substring(1);
}
if (s.indexOf("/") != -1){
denominator *= Integer.parseInt(s.substring(s.indexOf("/") + 1));
}
if (s.indexOf(" ") != -1){
numerator = Integer.parseInt(s.substring(0, s.indexOf(" "))) * abs(denominator) + Integer.parseInt(s.substring(s.indexOf(" ") + 1, s.indexOf("/")));
}else{
if (s.indexOf("/") != -1){
numerator = Integer.parseInt(s.substring(0, s.indexOf("/")));
}else{
numerator = Integer.parseInt(s)*abs(denominator);
}
}
this.Cancellation();
}
void Cancellation(){
long g = gcd(abs(numerator), abs(denominator));
numerator /= g;
denominator /= g;
if (denominator < 0){
numerator *= -1;
denominator *= -1;
}
}
public String toString(){
String s = "";
if (numerator == 0){
return "0";
}
if (numerator < 0){
s += "-";
}
if (abs(numerator) >= denominator){
s += Long.toString(abs(numerator) / denominator) + " ";
}
if (abs(numerator) % denominator != 0){
s += Long.toString(abs(numerator) % denominator);
}else{
s = s.substring(0, s.length()-1);
}
if (denominator != 1){
s += "/" + Long.toString(denominator);
}
return s;
}
public Fraction add(Fraction f){
Fraction fResult = new Fraction();
fResult.denominator = lcm(denominator, f.denominator);
fResult.numerator = numerator * fResult.denominator / denominator + f.numerator * fResult.denominator / f.denominator;
fResult.Cancellation();
return fResult;
}
public Fraction subtract(Fraction f){
Fraction fResult = new Fraction();
fResult.denominator = lcm(denominator, f.denominator);
fResult.numerator = numerator * fResult.denominator / denominator - f.numerator * fResult.denominator / f.denominator;
fResult.Cancellation();
return fResult;
}
public Fraction multiply(Fraction f){
Fraction fResult = new Fraction();
fResult.numerator = numerator * f.numerator;
fResult.denominator = denominator * f.denominator;
fResult.Cancellation();
return fResult;
}
public Fraction divide(Fraction f){
Fraction fResult = new Fraction();
fResult.numerator = numerator * f.denominator;
fResult.denominator = denominator * f.numerator;
fResult.Cancellation();
return fResult;
}
@Override
public int compareTo(Fraction f){
long g = gcd(denominator, f.denominator);
long res = numerator * (f.denominator / g) - f.numerator * (denominator / g);
if (res < 0){
return -1;
}
if (res > 0){
return 1;
}
return 0;
}
public Fraction clone(){
Fraction fResult = new Fraction(numerator, denominator);
return fResult;
}
public Fraction floor(){
Fraction fResult = this.clone();
fResult.numerator = (fResult.numerator / fResult.denominator) * fResult.denominator;
return fResult;
}
public Fraction ceil(){
Fraction fResult = this.clone();
fResult.numerator = (fResult.numerator/fResult.denominator + 1) * fResult.denominator;
return fResult;
}
public Fraction binpow(int n){
if (n==0) return FRACTION_ONE;
if ((n&1)==0){
Fraction f=this.binpow(n/2);
return f.multiply(f);
}else return binpow(n-1).multiply(this);
}
}
static public class FenwickTree_1{ //One-dimensional array
int n;
long[] t;
public FenwickTree_1(int n){
this.n = n;
t = new long[n];
}
public long sum(int xl, int xr){
return sum(xr) - sum(xl);
}
public long sum(int x){
long result = 0;
for (int i = x; i >= 0; i = (i & (i + 1)) - 1){
result += t[i];
}
return result;
}
public void update(int x, long delta){
for (int i = x; i < n; i = (i | (i + 1))){
t[i] += delta;
}
}
}
static public class FenwickTree_2{ //Two-dimensional array
int n, m;
long[][] t;
public FenwickTree_2(int n, int m){
this.n = n;
this.m = m;
t = new long[n][m];
}
public long sum(int xl, int yl, int xr, int yr){
return sum(xr, yr) - sum(xl - 1, yr) - sum(xr, yl - 1) + sum(xl - 1, yl - 1);
}
public long sum(int x, int y){
long result = 0;
for (int i = x; i >= 0; i = (i & (i + 1)) - 1){
for (int j = y; j >= 0; j = (j & (j + 1)) - 1){
result+=t[i][j];
}
}
return result;
}
public void update(int x, int y, long delta){
for (int i = x; i < n; i = (i | (i + 1))){
for (int j = y; j < m; j = (j | (j + 1))){
t[i][j] += delta;
}
}
}
}
static public class FenwickTree_3{ //Three-dimensional array
int n, m, l;
long[][][] t;
public FenwickTree_3(int n, int m, int l){
this.n = n;
this.m = m;
this.l = l;
t = new long[n][m][l];
}
public long sum(int xl, int yl, int zl, int xr, int yr, int zr){
return sum(xr, yr, zr) - sum(xl - 1, yr, zr)
+ sum(xl - 1, yr, zl - 1) - sum(xr, yr, zl - 1)
- sum(xr, yl - 1, zr) + sum(xl - 1, yl - 1, zr)
- sum(xl - 1, yl - 1, zl - 1) + sum(xr, yl - 1, zl - 1);
}
public long sum(int x, int y, int z){
long result = 0;
for (int i = x; i >= 0; i = (i & (i + 1)) - 1){
for (int j = y; j >= 0; j = (j & (j + 1)) - 1){
for (int k = z; k >= 0; k = (k & (k + 1)) - 1){
result += t[i][j][k];
}
}
}
return result;
}
public void update(int x, int y, int z, long delta){
for (int i = x; i < n; i = (i | (i + 1))){
for (int j = y; j < n; j = (j | (j + 1))){
for (int k = z; k < n; k = (k | (k + 1))){
t[i][j][k] += delta;
}
}
}
}
}
}
| 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 ans = 0;
int a = 0;
vector<int> v[101];
int visited[101];
int parent[101];
void dsf(int s) {
visited[s] = 1;
for (int n = 0; n < v[s].size(); n++) {
int d = v[s][n];
if (parent[s] != d && visited[d] != 2) {
if (visited[d] == 1) {
ans++;
} else {
visited[d] = 1;
parent[d] = s;
dsf(d);
}
}
}
visited[s] = 2;
}
int main() {
int n, e;
cin >> n >> e;
int s, d;
for (int m = 0; m < e; m++) {
cin >> s >> d;
v[s].push_back(d);
v[d].push_back(s);
}
for (int m = 1; m <= n; m++) {
if (visited[m] == 0) {
parent[m] = m;
dsf(m);
a++;
}
}
if (a == 1 && ans == 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 |
N, M = map(int, input().split())
g = [[] for i in range(N)]
for i in range(M):
a, b = map(int, input().split())
g[a-1].append(b-1)
g[b-1].append(a-1)
visn = 0
visited = [0] * N
def dfs(n):
global visn
visn += 1
visited[n] = 1
for i in g[n]:
if not visited[i]:
dfs(i)
if N != M:
print("NO")
exit()
dfs(0)
if visn != N:
print("NO")
else:
print("FHTAGN!")
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const long long INF64 = 3e18;
const int mod = (int)1e9 + 7;
const int MAX_N = 100000 + 5;
long long binp(long long a, long long b) {
if (b == 0) return 1;
long long ans = binp(a, b / 2);
long long tmp = (ans * ans);
if (b % 2) return ((tmp * a));
return ((tmp));
}
void display(vector<long long> v) {
for (auto x : v) cout << x << " ";
cout << "\n";
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void qr(long long i, long long j) {
cout << "? " << i << " " << j << '\n';
cout.flush();
}
void here(long long a) { cout << "here " << a << '\n'; }
const long long nmax = 150005;
long long par[nmax];
long long siize[nmax];
long long find(long long x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
void merge(long long a, long long b) {
long long x = find(a);
long long y = find(b);
if (x == y) return;
long long sizex = siize[x];
long long sizey = siize[y];
if (sizex < sizey) {
par[x] = par[y];
siize[y] += siize[x];
} else {
par[y] = par[x];
siize[x] += siize[y];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
par[i] = i;
siize[i] = 1;
}
for (long long j = 0; j < m; j++) {
long long a, b;
cin >> a >> b;
merge(a - 1, b - 1);
}
if (n == m && siize[find(0)] == n)
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 | """
https://codeforces.com/problemset/problem/103/B
"""
parent = []
ranks = []
edge = []
cycle = 0
def makeSet(n):
global parent, ranks
parent = [i for i in range(n)]
ranks = [0 for _ in range(n)]
def findSet(u):
global parent
if parent[u] != u:
parent[u] = findSet(parent[u])
return parent[u]
def unionSet(u, v):
global parent, ranks, cycle
up = findSet(u)
vp = findSet(v)
if up == vp:
cycle += 1
return
if ranks[up] > ranks[vp]:
parent[vp] = up
elif ranks[up] < ranks[vp]:
parent[up] = vp
else:
ranks[up] += 1
parent[vp] = up
def Kruskal():
for i in range(len(edge)):
u = edge[i][0]
v = edge[i][1]
if u != v:
unionSet(u, v)
def main():
n, m = map(int, input().split())
makeSet(n + 1)
for _ in range(m):
edge.append(list(map(int, input().split())))
Kruskal()
for i in range(1, n + 1):
findSet(i)
parent.pop(0)
cnt = len(set(parent))
if cnt == 1 and cycle == 1:
print('FHTAGN!')
else:
print('NO')
if __name__ == "__main__":
main()
| 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.*;
import java.io.*;
public class a {
static long mod = 1000000007;
public static void main(String[] args) throws IOException
{
input.init(System.in);
PrintWriter out = new PrintWriter(new PrintStream(System.out));
//Scanner input = new Scanner(new File("input.txt"));
//PrintWriter out = new PrintWriter(new File("output.txt"));
int n = input.nextInt(), m = input.nextInt();
boolean[][] adj = new boolean[n][n];
for(int i = 0; i<m; i++)
{
int a = input.nextInt()-1, b = input.nextInt()-1;
adj[a][b] = adj[b][a] = true;
}
for(int k = 0; k<n; k++)
for(int i = 0; i<n; i++)
for(int j = 0; j<n; j++)
adj[i][j] |= (adj[i][k] && adj[k][j]);
boolean good = n==m;
for(int i = 0; i<n; i++) good &= adj[0][i];
out.println(good?"FHTAGN!":"NO");
out.close();
}
static long pow(long a, long p)
{
if(p==0) return 1;
if((p&1) == 0)
{
long sqrt = pow(a, p/2);
return (sqrt*sqrt)%mod;
}
else
return (a*pow(a,p-1))%mod;
}
static class input {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(
new InputStreamReader(input) );
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while ( ! tokenizer.hasMoreTokens() ) {
//TODO add check for eof if necessary
tokenizer = new StringTokenizer(
reader.readLine() );
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt( next() );
}
static long nextLong() throws IOException {
return Long.parseLong( next() );
}
static double nextDouble() throws IOException {
return Double.parseDouble( next() );
}
static String nextLine() throws IOException {
return reader.readLine();
}
}
} | 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())
g = []
for i in range(n):
g.append([0] * n)
for i in range(m):
x, y = map(int, raw_input().split())
x -= 1
y -= 1
g[x][y] = 1
g[y][x] = 1
v = [0] * n
x = 0
def dfs(i, d):
global x
if v[i] == 1:
if d > 0:
x += 1
else:
v[i] = 1
for j in range(n):
if i != j and g[i][j] == 1:
g[i][j] = 0
g[j][i] = 0
dfs(j, d + 1)
for i in range(n):
if v[i] != 1:
dfs(i, 0)
break
if x == 1 and min(v) == 1:
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 Cthulhu {
int[] parents;
int numOfLoops=0;
public static void main(String[] args) {
Cthulhu obj=new Cthulhu();
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int m = input.nextInt();
obj.parents = new int[n + 1];
int x,y,numOfSets=0;
obj.createSets();
for (int i=0;i<m;i++){
x=input.nextInt();
y=input.nextInt();
obj.union(x, y);
}
if (obj.numOfLoops!=1){
System.out.println("NO");
}else{
boolean[] visited=new boolean[n+1];
for (int i=1;i<n+1;i++){
visited[obj.parents[i]]=true;
}
for (int i=1;i<n+1;i++){
if (visited[i]){
numOfSets++;
}
}
if (numOfSets==1){
System.out.println("FHTAGN!");
}else{
System.out.println("NO");
}
}
}
private void createSets(){
for (int i=1;i<parents.length;i++){
parents[i]=i;
}
}
private int getRoot(int x) {
return parents[x];
}
private void union(int x, int y) {
int parentX = getRoot(x);
int parentY = getRoot(y);
if (parentY != parentX) {
for (int i = 0; i < parents.length; i++) {
if (parents[i] == parentY) {
parents[i] = parentX;
}
}
}else{
numOfLoops++;
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long long n, m, x, y;
void dfs(int s, vector<bool>& visited, vector<vector<long long> >& g) {
visited[s] = true;
for (int i = 0; i < g[s].size(); i++) {
if (visited[g[s][i]] == false) dfs(g[s][i], visited, g);
}
}
int main() {
cin >> n >> m;
vector<vector<long long> > g(n + 1);
vector<bool> visited(n + 1);
for (long long i = 0; i < m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
if (n != m) {
cout << "NO";
return 0;
}
dfs(x, visited, g);
for (long long i = 1; i <= n; i++)
if (visited[i] == false) {
cout << "NO";
return 0;
}
cout << "FHTAGN!";
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Main
{
int nodes;
int edges;
int count;
boolean graph[][];
boolean visited[];
int parent[];
int rank[];
FastScanner in;
PrintWriter out;
public void solve() throws IOException
{
count = nodes = in.nextInt();
edges = in.nextInt();
parent = new int[nodes];
rank = new int[nodes];
for (int i = 0; i < parent.length; i++)
{
parent[i] = i;
rank[i] = 0;
}
for (int i = 0; i < edges; i++)
{
int from = in.nextInt() - 1;
int to = in.nextInt() - 1;
unionSet(from, to);
}
if (count == 1 && nodes == edges)
{
System.out.println("FHTAGN!");
return;
}
System.out.println("NO");
}
public int findSet(int i)
{
return parent[i] == i ? i : (parent[i] = findSet(parent[i]));
}
public boolean isSameSet(int i, int j)
{
return findSet(i) == findSet(j);
}
public void unionSet(int i, int j)
{
if (!isSameSet(i, j))
{
count--;
int x = findSet(i);
int y = findSet(j);
if (rank[x] > rank[y])
{
parent[y] = x;
}
else
{
parent[x] = y;
if (rank[x] == rank[y])
{
rank[y]++;
}
}
}
}
public void run()
{
try
{
in = new FastScanner();
out = new PrintWriter(System.out);
solve();
out.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
class FastScanner
{
BufferedReader br;
StringTokenizer st;
FastScanner()
{
br = new BufferedReader(new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreTokens())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
}
public static void main(String[] arg)
{
new Main().run();
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import sys
from array import array
if len(sys.argv) > 1:
infile = open(sys.argv[1],'rU')
else:
infile = sys.stdin
def rd():
return infile.readline()
n,m = map(int, rd().split())
adjl = {} # the adjoint list
for i in range(1,n+1):
adjl[i] = []
for i in range(m):
v1,v2 = map(int, rd().split())
adjl[v1].append(v2)
adjl[v2].append(v1)
deg = array('i',[0]*(n+1)) # deg[i]: the degree of node i
BLUE = 0
RED = 1
GREEN = 2
col = array('i',[BLUE]*(n+1))
delque = [] # the delete que
for i in range(1,n+1):
deg[i] = len(adjl[i])
if deg[i] == 1:
delque.append(i)
ans = True
# if the following occur, then ans = False
# 0) if the map is not connected
# 1) after delete v1, deg[v2] = 0
# 2) exist i, deg[i] = 0
# 3) not a simple loop at last
def dfs(v1,vis):
vis[v1] = True
for v2 in adjl[v1]:
if not vis[v2]:
dfs(v2,vis)
if m == 0:
ans = False
else:
for v1 in range(1,n+1):
vis = [False]*(n+1)
dfs(v1,vis)
for v2 in range(1,n+1):
if not vis[v2]:
ans = False
break
if not ans:
break
if ans:
while len(delque) > 0:
v1 = delque[0]
for v2 in adjl[v1]:
adjl[v2].remove(v1)
deg[v2] -= 1
col[v2] = RED
if deg[v2] == 0:
ans = False
break
elif deg[v2] == 1:
delque.append(v2)
if not ans: break
adjl[v1] = []
deg[v1] = 0
col[v1] = GREEN
delque.pop(0)
if ans:
for i in range(1,n+1):
if deg[i] != 0 and deg[i] != 2:
ans = False
break
if ans:
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.Arrays;
import java.util.StringTokenizer;
public class Main {
static int n,m;
static boolean visi[],mat[][];
public static void dfs(int j)
{
visi[j]=true;
for(int i=0;i<n;i++)
{
if(mat[j][i] && !visi[i])
{
dfs(i);
}
}
}
public static void main(String args[])throws Exception
{
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());
visi=new boolean[n];
mat=new boolean[n][n];
for(int i=0;i<m;i++)
{
st=new StringTokenizer(br.readLine());
int t1=Integer.parseInt(st.nextToken())-1;
int t2=Integer.parseInt(st.nextToken())-1;
mat[t1][t2]=true;
mat[t2][t1]=true;
}
if(n!=m)
{
System.out.print("NO");
return ;
}
int count=0;
for(int i=0;i<n;i++)
{
if(!visi[i])
{
count++;
if(count>1)
{
System.out.print("NO");
return ;
}
dfs(i);
}
}
System.out.print("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;
int fa[1005];
int n, m;
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void merge(int u, int v) {
int ru = find(u);
int rv = find(v);
if (ru != rv) {
fa[ru] = rv;
}
}
int main() {
int u, v;
int flag = 0, fail = 0, r = 0;
cin >> n >> m;
int temp = m;
for (int i = 0; i < n; i++) {
fa[i] = i;
}
while (temp--) {
cin >> u >> v;
if (fail) continue;
int ru = find(u);
int rv = find(v);
if (ru != rv) {
r++;
fa[ru] = rv;
} else {
if (!flag) {
r++;
flag = 1;
} else {
fail = 1;
}
}
}
if (fail || !flag || n != m) {
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 | /**
* Created by IntelliJ IDEA.
* User: mac
* Date: 11-11-25
* Time: 下午8:20
* To change this template use File | Settings | File Templates.
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class C {
BufferedReader reader;
StringTokenizer tokenizer;
PrintWriter writer;
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);
}
}
String nextToken() throws IOException {
while (tokenizer == null || !tokenizer.hasMoreTokens())
tokenizer = new StringTokenizer(reader.readLine());
return tokenizer.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
int nV, nE;
class V extends ArrayList<V> {
boolean visited = false;
void dfs() {
if (visited)
return;
visited = true;
nV++;
for (V v : this) {
nE++;
v.dfs();
}
}
}
void solve() throws IOException {
int n = nextInt(), m = nextInt();
V[] vs = new V[n];
for (int i = 0; i < vs.length; i++) {
vs[i] = new V();
}
for (int i = 0; i < m; i++) {
int a = nextInt() - 1, b = nextInt() - 1;
vs[a].add(vs[b]);
vs[b].add(vs[a]);
}
nV = 0;
nE = 0;
vs[0].dfs();
nE /= 2;
if (nV != nE || nV != n) {
writer.println("NO");
return;
}
writer.println("FHTAGN!");
}
static public void main(String[] args) {
new C().run();
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int hits = 0;
vector<int> edges[101];
void print_vector2d(vector<vector<int>>& a, string name) {
cout << name << " is\n";
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < a[0].size(); j++) {
cout << a[i][j] << " ";
}
cout << "\n";
}
cout << "\n";
}
void print_vector(vector<int>& a, string name) {
cout << name << " is\n";
for (int i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
cout << "\n";
}
void dfs(int n, vector<int>& visited) {
visited[n] = 1;
for (int i = 0; i < edges[n].size(); i++) {
if (visited[edges[n][i]] == 1)
hits += 1;
else {
dfs(edges[n][i], visited);
}
}
}
int main() {
int n, m;
cin >> n >> m;
vector<int> visited(n + 1, 0);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
edges[a].push_back(b);
edges[b].push_back(a);
}
dfs(1, visited);
bool all_visited = true;
for (int i = 1; i <= n; i++) {
if (visited[i] != 1) {
all_visited = false;
break;
}
}
if (all_visited && m == n) {
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;
const long long OO = (long long)1e15 + 1;
const int MAX = 1e5 + 5;
vector<vector<int> > adjLst;
int n, m, vis[101], countt = 0, x, y;
void dfs(int cur = 1) {
if (vis[cur]) return;
vis[cur] = 1;
for (int i = 0; i < adjLst[cur].size(); i++) {
int child = adjLst[cur][i];
if (!vis[child]) {
countt++;
dfs(child);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
adjLst.resize(n + 1);
for (int i = 0; i < m; i++) {
cin >> x >> y;
adjLst[x].push_back(y);
adjLst[y].push_back(x);
}
dfs();
if (countt != m - 1) return cout << "NO\n", 0;
for (int i = 1; i < n + 1; i++)
if (!vis[i]) return cout << "NO\n", 0;
cout << "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 | #include <bits/stdc++.h>
using namespace std;
vector<int> mp[105];
int vis[105];
struct node {
int fa;
int kid;
node(int fa, int b) {
this->fa = fa;
kid = b;
}
};
bool bfs(int rt, int n) {
queue<node> q;
q.push(node(-1, rt));
vis[rt] = 1;
while (!q.empty()) {
int now = q.front().kid;
int fa = q.front().fa;
q.pop();
for (int i = 0; i < mp[now].size(); i++) {
int v = mp[now][i];
if (vis[v] && v != fa) {
vis[v]++;
continue;
}
if (vis[v] || v == fa) continue;
vis[v] = 1;
q.push(node(now, v));
}
}
int f = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] > 2) return false;
if (vis[i] == 2) f = 1;
}
if (f) return true;
return false;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
mp[u].push_back(v);
mp[v].push_back(u);
}
int yes = 0;
int no = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
if (bfs(i, n)) {
yes++;
} else {
no = 1;
}
}
}
if (yes == 1 && no == 0)
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 | #include <bits/stdc++.h>
using namespace std;
int a, b, n, m, ok, passou[1 << 20];
vector<int> grafo[1 << 20];
void dfs(int u) {
passou[u] = 1;
for (int i = 0; i < grafo[u].size(); i++) {
int v = grafo[u][i];
if (!passou[v]) dfs(v);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
if (n != m) ok = 1;
while (m--) {
cin >> a >> b;
grafo[a].push_back(b);
grafo[b].push_back(a);
}
dfs(1);
for (int i = 1; i <= n; i++) {
if (!passou[i]) ok = 1;
}
cout << (!ok ? "FHTAGN!" : "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;
vector<int> gr[1000];
int vis[1000];
int ans = 0;
void dfs(int a) {
vis[a] = 1;
ans++;
for (int i = 0; i < gr[a].size(); i++)
if (vis[gr[a][i]] == 0) dfs(gr[a][i]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
memset(vis, 0, sizeof(vis));
int n, m, a, b;
cin >> n >> m;
set<int> st;
int h;
for (int i = 0; i < m; i++) {
cin >> a >> b;
gr[a].push_back(b);
gr[b].push_back(a);
st.insert(a);
st.insert(b);
h = a;
}
if (m > 0) dfs(h);
if (ans == m && m > 0 && m == n)
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 | import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
PrintWriter stdout = new PrintWriter(new BufferedOutputStream(System.out));
kernel("stdin", stdout);
}
public static void kernel(String source, PrintWriter out) {
MyScanner sc = new MyScanner(source);
// Start writing your solution here. -------------------------------------
/*
int n = sc.nextInt(); // read input as integer
long k = sc.nextLong(); // read input as long
double d = sc.nextDouble(); // read input as double
String str = sc.next(); // read input as String
String s = sc.nextLine(); // read whole line as String
*/
int n = sc.nextInt();
int m = sc.nextInt();
int a, b;
Vertex[] v = new Vertex[n+1];
for (int i=1;i<=n;++i) {
v[i] = new Vertex(i);
}
for (int i=0;i<m;++i) {
a = sc.nextInt();
b = sc.nextInt();
v[a].edges.add(v[b]);
v[b].edges.add(v[a]);
}
if (n != m || !connected(v)) {
out.println("NO");
} else {
out.println("FHTAGN!");
}
// Stop writing your solution here. -------------------------------------
out.close();
}
private static boolean connected(Vertex[] v) {
dfs(v[1]);
for (int i=1;i<v.length;++i) {
if (!v[i].visited) {
return false;
}
}
return true;
}
private static void dfs(Vertex v) {
v.visited = true;
for(Vertex to : v.edges) {
if (!to.visited) {
dfs(to);
}
}
}
//-----------MyScanner class for faster input----------
public static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner(String source) {
if (source.equals("stdin")) {
br = new BufferedReader(new InputStreamReader(System.in));
} else {
try {
br = new BufferedReader(new FileReader(source));
} catch (Exception e) {
System.out.println("Error reading file");
}
}
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine(){
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
//--------------------------------------------------------
}
class Vertex {
ArrayList<Vertex> edges;
boolean visited;
int id;
Vertex(int id) {
this.edges = new ArrayList<Vertex>();
this.visited = false;
this.id = id;
}
}
| 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 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author Saransh
*/
import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;
public class Main {
/**
* @param args the command line arguments
*/
static Stack<Integer>cycle;
static boolean adj[][];
static boolean marked[];
public static void main(String[] args) {
// TODO code application logic here
try
{
Parserdoubt pd=new Parserdoubt(System.in);
cycle=new Stack<Integer>();
int n=pd.nextInt();
int ed=pd.nextInt();
adj=new boolean[n][n];
marked=new boolean[n];
for(int i=0;i<ed;i++)
{
int a=pd.nextInt()-1;
int b=pd.nextInt()-1;
adj[a][b]=true;
adj[b][a]=true;
}
count=0;
dfs(0);
if(count==n)
{
if(tot-1==n)
{
System.out.println("FHTAGN!");
return;
}
}
System.out.println("NO");
}
catch(Exception e)
{}
}
static int count=0;
static int tot=0;
public static void dfs(int start)
{
if(marked[start])
{
tot++;
return;
}
count++;
marked[start]=true;
for(int i=0;i<adj.length;i++)
if(adj[i][start])dfs(i);
}
}
class Parserdoubt
{
final private int BUFFER_SIZE = 1 << 17;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Parserdoubt(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 | #include <bits/stdc++.h>
using namespace std;
int eD[150][150], mark[150], delx, dely, flag, n, m;
int dfs(int x, int rem) {
mark[x] = 1;
for (int i = 1; i <= n; i++) {
if (!eD[x][i] || i == rem) continue;
if (mark[i]) {
delx = x;
dely = i;
flag = 1;
return 1;
} else
dfs(i, x);
if (flag) return 1;
}
return 0;
}
int main() {
int x, y;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
eD[x][y] = eD[y][x] = 1;
}
if (!dfs(1, -1)) {
puts("NO");
return 0;
}
flag = eD[delx][dely] = eD[dely][delx] = 0;
memset(mark, 0, sizeof(mark));
flag = dfs(1, -1);
for (int i = 1; i <= n; i++)
if (!mark[i]) {
flag = 1;
break;
}
if (flag)
puts("NO");
else
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>
using namespace std;
const int MX = (1 << 20);
class Disjoint_Set {
public:
int sz[MX], P[MX];
int find_(int x) {
if (x != P[x]) P[x] = find_(P[x]);
return P[x];
}
int comp;
void init(int N) {
for (int j = 1; j <= N; j++) sz[j] = 1, P[j] = j;
comp = N;
}
bool same(int x, int y) { return find_(x) == find_(y); }
int compsize(int node) { return sz[find_(node)]; }
bool merge_(int x, int y) {
int px = find_(x), py = find_(y);
if (px == py) return false;
if (sz[px] < sz[py]) swap(px, py);
P[py] = px;
comp--;
sz[px] += sz[py];
return true;
}
} G;
int n, m;
int main() {
scanf("%d %d", &n, &m);
if (n != m) {
puts("NO");
return 0;
}
G.init(n);
int tt = 0;
while (m--) {
int a, b;
scanf("%d %d", &a, &b);
if (!G.merge_(a, b)) tt++;
}
if (tt == 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 | #include <bits/stdc++.h>
using namespace std;
int n, m;
int x, y;
vector<int> ga[200];
bool vis[200];
void dfs(int u) {
vis[u] = true;
for (int i = 0; i < ga[u].size(); i++) {
int v = ga[u][i];
if (!vis[v]) dfs(v);
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
ga[y].push_back(x);
ga[x].push_back(y);
}
dfs(1);
if (n != m) {
cout << "NO" << endl;
return 0;
} else {
if (n < 3) {
cout << "NO" << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
if (!vis[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 | #include <bits/stdc++.h>
using namespace std;
int n, m;
int P[102];
int p(int x) {
if (P[x] == x)
return x;
else
return p(P[x]);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= 100; i++) {
P[i] = i;
}
for (int i = 1; i <= m; i++) {
int k, l;
scanf("%d%d", &k, &l);
int u = p(k);
int v = p(l);
P[u] = v;
}
if (n != m) {
printf("NO");
return 0;
}
for (int i = 1; i < n; i++) {
if (p(i) != p(i + 1)) {
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;
const int N = 110;
vector<int> adj[N];
int n, m, cnt = 0;
bool vis[N];
void dfs(int u) {
cnt++;
vis[u] = 1;
for (auto v : adj[u])
if (!vis[v]) dfs(v);
}
int main() {
scanf("%d %d", &n, &m);
if (n != m) {
printf("NO\n");
return 0;
}
int u, v;
for (int i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1);
if (cnt == n)
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;
const int MAX_N = (100 + 10);
int N, M, cnt, mark[MAX_N];
vector<int> g[MAX_N];
void dfs(int u) {
mark[u] = 1;
++cnt;
for (int i = (0); i < ((int)g[u].size()); ++i) {
int v = g[u][i];
if (!mark[v]) dfs(v);
}
}
int main() {
while (cin >> N >> M) {
for (int i = (1); i <= (N); ++i) g[i].clear();
memset(mark, 0, sizeof(mark));
for (int i = (1); i <= (M); ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
if (N == M) {
cnt = 0;
dfs(1);
cnt == N ? puts("FHTAGN!") : puts("NO");
} else
puts("NO");
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
int mp[101][101], in[101], out[101], m, n;
bool vis[101];
bool sch(int k) {
vis[k] = 1;
for (int j = 0; j < n; j++)
if (mp[k][j] && !vis[j]) {
in[k]--;
in[j]--;
if (in[j] == 1)
return sch(j);
else if (in[j] == 0)
return false;
else
return true;
}
}
void sch2(int k) {
vis[k] = 1;
for (int i = 0; i < n; i++)
if (mp[k][i] && !vis[i]) sch2(i);
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
mp[u][v] = 1;
in[u]++;
swap(u, v);
mp[u][v] = 1;
in[u]++;
}
for (int i = 0; i < n; i++) {
if (in[i] == 0) {
printf("NO\n");
return 0;
}
}
for (int i = 0; i < n; i++) {
if (in[i] == 1) {
if (!sch(i)) {
printf("NO\n");
return 0;
}
}
}
int tmp = 0;
for (int i = 0; i < n; i++) {
if (!vis[i] && in[i] != 2) {
printf("NO\n");
return 0;
}
if (in[i] == 2) tmp++;
}
if (tmp < 3) {
printf("NO\n");
return 0;
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
sch2(i);
break;
}
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
printf("NO\n");
return 0;
}
}
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 | from __future__ import print_function
import sys
from collections import *
from heapq import *
from functools import *
import re
from itertools import *
INF=float("inf")
NINF=float("-inf")
try:
input=raw_input
except:
pass
def read_string():
return input()
def read_string_line():
return [x for x in input().split(" ")]
def read_int_line():
return [int(x) for x in input().split(" ")]
def read_int():
return int(input())
n,m=read_int_line()
adjs=[[] for _ in range(n)]
for _ in range(m):
a,b=read_int_line()
adjs[a-1].append(b-1)
adjs[b-1].append(a-1)
degs=[-1]*n
st=[]
circle=[]
def dfs(x, pre,deg):
degs[x]=deg
st.append(x)
for to in adjs[x]:
if to==pre:continue
if degs[to]==-1:
if dfs(to,x,deg+1):
st.pop()
return True
else:
i=st.index(to)
assert not circle
circle.extend(st[i:])
st.pop()
return True
st.pop()
return False
edges=set()
def dfs2(x,pre,deg):
#print("dfs2 %d, from %d, deg:%d, degs:%s"%(x,pre,deg,degs))
degs[x]=deg
for to in adjs[x]:
if to==pre:continue
if (x,to) in edges:continue
if degs[to] != -1:
return False
if not dfs2(to,x,deg+1):
return False
return True
dfs(0,-1,0)
if not circle:
print("NO")
else:
#print("circle:%s"%(circle,))
degs[:]=[-1]*n
for i, a in enumerate(circle):
b=circle[(i+1)%len(circle)]
edges.add((a,b))
edges.add((b,a))
for a in circle:
if degs[a]!=-1:
print("NO")
break
if not dfs2(a,-1,0):
print("NO")
break
else:
if -1 in degs:
print("NO")
else:
print("FHTAGN!")
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import sys
sys.setrecursionlimit(10 ** 6)
class Edge:
def __init__(self, u, v, w=0):
self.frm = u
self.to = v
self.weight = w
def __repr__(self):
return "{frm} - {to}: {weight}".format(frm=self.frm, to=self.to, weight=self.weight)
def __eq__(self, other):
return self.frm == other.frm and self.to == other.to \
or self.frm == other.to and self.to == other.frm
class Graph:
def __init__(self, num_vertex):
self.num_vertex = num_vertex
self.adj_list = [[] for _ in range(num_vertex)]
def add_edge(self, u, v, w=0):
self.adj_list[u].append(Edge(u, v, w))
self.adj_list[v].append(Edge(v, u, w))
def adj(self, v):
return self.adj_list[v]
def edges(self):
all_edges = []
for v in range(self.num_vertex):
for e in self.adj_list[v]:
if e not in all_edges:
all_edges.append(e)
return all_edges
class DisjointSetUnion:
def __init__(self, num_nodes):
self.id = [i for i in range(num_nodes)]
self.parent = [i for i in range(num_nodes)]
self.size = [1 for _ in range(num_nodes)]
self.cnt = num_nodes
def find(self, p):
while p != self.parent[p]:
p = self.parent[p]
return p
def count(self):
return self.cnt
def connected(self, p, q):
return self.find(p) == self.find(q)
def union(self, p, q):
root_p = self.find(p)
root_q = self.find(q)
if root_p == root_q: return
if self.size[root_p] < self.size[root_q]:
self.parent[root_p] = root_q
self.size[root_q] += self.size[root_p]
else:
self.parent[root_q] = root_p
self.size[root_p] += self.size[root_q]
self.cnt -= 1
dsu = None
graph = None
def main():
sc = sys.stdin
line = sc.readline().strip()
n, m = map(int, line.split())
global graph, dsu
cnt_cycle = 0
graph = Graph(n)
dsu = DisjointSetUnion(n)
for i in range(m):
line = sc.readline().strip()
x, y = map(int, line.split())
x, y = x-1, y-1
graph.add_edge(x, y)
# cycle count
if dsu.connected(x, y):
cnt_cycle += 1
else:
dsu.union(x, y)
detected = False
if cnt_cycle == 1 and dsu.count() == 1:
detected = True
print("FHTAGN!" if detected else "NO")
if __name__ == '__main__':
main()
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long long int visited[100000];
long long int len[100000];
long long int cycle = 0;
void dfs(long long int second, vector<long long int> v[]) {
visited[second] = 1;
long long int vp;
for (long long int i = 0; i < v[second].size(); i++) {
vp = v[second][i];
if (visited[vp] == 0) {
len[vp] = len[second] + 1;
dfs(vp, v);
} else if (visited[vp] == true && len[second] - len[vp] > 1) {
cycle++;
}
}
}
int main() {
long long int n, m, x, y;
cin >> n >> m;
vector<long long int> v[n + 1];
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, v);
if (cycle != 1)
cout << "NO";
else if (cycle == 1) {
if (n == m) {
for (int i = 1; i < n; i++) {
if (visited[i] == false) {
cout << "NO";
return 0;
}
}
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.*;
import java.util.*;
import java.util.function.*;
import java.lang.*;
public class Main {
final static String fileName = "";
final static boolean useFiles = false;
public static void main(String[] args) throws FileNotFoundException {
InputStream inputStream;
OutputStream outputStream;
if (useFiles) {
inputStream = new FileInputStream(fileName + ".in");
outputStream = new FileOutputStream(fileName + ".out");
} else {
inputStream = System.in;
outputStream = System.out;
}
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Task solver = new Task(in, out);
Debug.out = out;
solver.solve();
out.close();
}
}
class Dsu {
private int n;
int[] size, parent;
Dsu(int n) {
this.n = n;
size = new int[n];
Arrays.fill(size, 1);
parent = new int[n];
for (int i = 0; i < n; i++)
parent[i] = i;
}
int findSet(int x) {
if (parent[x] == x)
return x;
return parent[x] = findSet(parent[x]);
}
void union(int x, int y) {
if (size[x] > size[y]) {
int t = x;
x = y;
y = t;
}
size[y] += size[x];
parent[x] = y;
}
void normalize() {
for (int i = 0; i < n; i++)
findSet(i);
}
@Override
public String toString(){
normalize();
return Arrays.toString(parent);
}
}
class Task {
public void solve() {
int n = in.nextInt(), m = in.nextInt();
Dsu d = new Dsu(n);
int count = 0;
for (int i = 0; i < m; i++){
int x = in.nextInt() - 1, y = in.nextInt() - 1;
x = d.findSet(x);
y = d.findSet(y);
if (x == y)
count++;
else
d.union(x, y);
}
d.normalize();
boolean linked = true;
for (int i = 1; i < n; i++){
if (d.parent[i] != d.parent[0])
linked = false;
}
if (count == 1 && linked){
out.print("FHTAGN!");
}
else
out.print("NO");
}
private InputReader in;
private PrintWriter out;
Task(InputReader in, PrintWriter out) {
this.in = in;
this.out = out;
}
}
class Debug {
public static PrintWriter out;
public static void printObjects(Object... objects) {
out.println(Arrays.deepToString(objects));
out.flush();
}
}
class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
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 double nextDouble(){
return Double.parseDouble(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong(){
return Long.parseLong(next());
}
public byte nextByte(){
return Byte.parseByte(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.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class B103 {
static BufferedReader br;
static StringTokenizer st;
static PrintWriter pw;
static String nextToken() {
try {
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(br.readLine());
}
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
static int nextInt() {
return Integer.parseInt(nextToken());
}
static long nextLong() {
return Long.parseLong(nextToken());
}
static double nextDouble() {
return Double.parseDouble(nextToken());
}
public static void main(String[] args) {
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(System.out);
run();
pw.close();
}
static int[] head;
static int[] next;
static int[] edges;
static int edgesId = 0;
private static void run() {
int n = nextInt();
int m = nextInt();
if (m == n) {
head = new int[n];
Arrays.fill(head, -1);
next = new int[m * 2];
edges = new int[m * 2];
for (int i = 0; i < m; i++) {
int x = nextInt() - 1;
int y = nextInt() - 1;
addEdge(x, y);
addEdge(y, x);
}
used = new boolean[n];
dfs(0, -1);
if (ans) {
for (int i = 0; i < n; i++) {
if(!used[i]){
pw.println("NO");
return;
}
}
pw.println("FHTAGN!");
} else {
pw.println("NO");
}
} else {
pw.println("NO");
}
}
static boolean used[];
static boolean ans = false;
private static void dfs(int v, int parent) {
used[v] = true;
for (int i = head[v]; i != -1; i = next[i]) {
int vv = edges[i];
if (!used[vv]) {
dfs(vv, v);
} else if (vv != parent) {
ans = true;
}
}
}
private static void addEdge(int x, int y) {
edges[edgesId] = y;
next[edgesId] = head[x];
head[x] = edgesId++;
}
}
| 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 os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
##########################################################
def prime_factors(x):
s=set()
n=x
i=2
while i*i<=n:
if n%i==0:
while n%i==0:
n//=i
s.add(i)
i+=1
if n>1:
s.add(n)
return s
from collections import Counter
# c=sorted((i,int(val))for i,val in enumerate(input().split()))
import heapq
# c=sorted((i,int(val))for i,val in enumerate(input().split()))
# n = int(input())
# ls = list(map(int, input().split()))
# n, k = map(int, input().split())
# n =int(input())
#arr=[(i,x) for i,x in enum]
#arr.sort(key=lambda x:x[0])
#print(arr)
#import math
# e=list(map(int, input().split()))
from collections import Counter
#print("\n".join(ls))
#print(os.path.commonprefix(ls[0:2]))
#n=int(input())
from bisect import bisect_right
#d=sorted(d,key=lambda x:(len(d[x]),-x)) d=dictionary d={x:set() for x in arr}
#n=int(input())
#n,m,k= map(int, input().split())
import heapq
#for _ in range(int(input())):
#n,k=map(int, input().split())
#input=sys.stdin.buffer.readline
#for _ in range(int(input())):
#arr = list(map(int, input().split()))import bisect
def par(x):
if root[x]!=x:
return par(root[x])
else:
return x
def max_edge(n):
return n*(n-1)//2
def union(u,v):
x=par(u)
y=par(v)
if x!=y:
if rank[x]>=rank[y]:
root[y]=root[x]
rank[x]+=rank[y]
elif rank[y]>rank[x]:
root[x]=root[y]
rank[y]+=rank[x]
n,m= map(int, input().split())
root=[i for i in range(n+1)]
rank=[1]*(n+1)
#g=[[] for i in range(n+1)]
#special = list(map(int, input().split()))
cnt=0
for i in range(m):
u,v=map(int, input().split())
if par(u)!=par(v):
union(u,v)
else:
cnt+=1
s=set()
for i in range(n):
s.add(par(i+1))
if n==m and 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;
vector<int> edges[5001];
int n, m;
bool vis1[110];
bool flag = false;
int ans = 0;
void dfs(int u, int parent) {
vis1[u] = true;
for (int i = 0; i < edges[u].size(); i++) {
int v = edges[u][i];
if (!vis1[v]) {
dfs(v, u);
} else if (v != parent) {
ans++;
}
}
return;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
edges[x].push_back(y);
edges[y].push_back(x);
}
if (n == m) {
memset(vis1, false, sizeof(vis1));
dfs(1, -1);
for (int i = 1; i <= n; i++) {
if (!vis1[i]) {
flag = true;
break;
}
}
if (!flag && ans == 2)
printf("FHTAGN!\n");
else
printf("NO\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;
const int N = 1e5 + 5;
const int inf = 1e9 + 1;
const double eps = 1e-15;
const double EPS = 1e-9;
const double PI = acos(-1.0);
vector<int> edge[200];
int vis[200];
int n, m, u, v;
void dfs(int id) {
vis[id] = 1;
for (int i = 0; i < edge[id].size(); i++) {
int x = edge[id][i];
if (!vis[x]) {
dfs(x);
}
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cnt++;
dfs(i);
}
}
(cnt > 1 || n != m) ? cout << "NO\n" : cout << "FHTAGN!\n";
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
bool v[105], f[105][105];
int n, m, s = 0;
void dfs(int x) {
v[x] = 1;
s++;
for (int i = 1; i <= n; i++)
if (!v[i] && f[x][i]) dfs(i);
}
int main() {
scanf("%d%d", &n, &m);
if (n != m) {
puts("NO");
return 0;
}
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
f[a][b] = f[b][a] = true;
}
memset(v, 0, sizeof(v));
dfs(1);
if (s == n)
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.util.*;
public class B103 {
HashSet<Integer> visited;
List<Integer> edges[];
public static void main(String[] args) {
new B103().solve();
}
@SuppressWarnings("unchecked")
public void solve() {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
edges = new List[n];
for (int i = 0; i < n; i++)
edges[i] = new ArrayList<Integer>();
for (int i = 0; i < m; i++) {
int x = in.nextInt() - 1;
int y = in.nextInt() - 1;
edges[x].add(y);
edges[y].add(x);
}
visited = new HashSet<Integer>();
dfs(0);
System.out.println(visited.size() == n && n == m ? "FHTAGN!" : "NO");
}
public void dfs(int curr) {
visited.add(curr);
for (int e : edges[curr]) {
if (!visited.contains(e))
dfs(e);
}
}
}
| 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 parent[1005];
bool visited[1005];
int f = 0;
int findParent(int node) {
if (parent[node] == node) return node;
return parent[node] = findParent(parent[node]);
}
set<int> Connected[1005];
void dfs(int node) {
if (visited[node]) return;
f++;
visited[node] = true;
for (set<int>::iterator it = Connected[node].begin();
it != Connected[node].end(); it++)
dfs(*it);
}
bool tree[1005];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) parent[i] = i;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
Connected[v].insert(u);
Connected[u].insert(v);
}
dfs(1);
if (f == n && n == m) {
cout << "FHTAGN!";
return 0;
}
cout << "NO";
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class Cthulhu
{
/*
* Look at the formal part of statement.
* Cthulhu is a simple cycle with length of 3 or more and every vertix of the cycle should be a root of some tree.
* Notice this two important facts:
* a) Cthulhu is a connected graph
* b) Cthulhu is a graph with only one cycle
* If we add only one edge to tree (not a multiedge nor loop) then we will get a graph that has
* both a) and b) properties.
* There is a simple solution:
* let's check graph for connectivity (we can do it by one DFS only) and check n = m restriction.
* Because trees has n vertices and n-1 edges so when m = n we add a new edge to make the required cycle
* also n must be >= 3
* If all are ok then graph is Cthulhu.
*/
private static ArrayList<Integer> adjList[];
private static boolean visited[];
public static void main(String[] args)
{
BufferedTokenizer io = new BufferedTokenizer(System.in);
int n,m,x,y;
n = io.nextInt();
m = io.nextInt();
adjList = new ArrayList[n];
for (int i = 0; i < n; i++) adjList[i] = new ArrayList<Integer>();
for (int i = 0; i < m; i++)
{
x = io.nextInt()-1;
y = io.nextInt()-1;
if(!adjList[x].contains(y)) adjList[x].add(y);
if(!adjList[y].contains(x)) adjList[y].add(x);
}
if(n<3) io.println("NO");
else
{
visited = new boolean[n];
if(DFS() && n==m) io.println("FHTAGN!");
else io.println("NO");
}
}
private static boolean DFS()
{
boolean first = true;
for (int i = 0; i < adjList.length; i++)
{
if(!visited[i])
{
if(first)
{
visit(i);
first=false;
}
else return false;
}
}
return true;
}
private static void visit(int s)
{
visited[s] = true;
for (int x : adjList[s])
{
if(!visited[x]) visit(x);
}
}
public static class BufferedTokenizer
{
private BufferedReader reader;
private StringTokenizer tokenizer;
private PrintWriter writer;
public BufferedTokenizer(InputStream stream)
{
reader = new BufferedReader(new InputStreamReader(stream));
writer = new PrintWriter(System.out);
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 int nextInt()
{
return Integer.parseInt(next());
}
public void println(String x)
{
writer.println(x);
writer.flush();
}
public void print(String x)
{
writer.print(x);
writer.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;
int v, e, a, b, x, y, cyc, found, head, chk[105];
vector<int> par, deg;
int findr(int a) {
if (par[a] != a) par[a] = findr(par[a]);
return par[a];
}
int main() {
scanf("%d %d", &v, &e);
for (int i = 0; i <= v; ++i) par.push_back(i);
deg.resize(v + 1);
while (e--) {
scanf("%d %d", &a, &b);
deg[a]++;
deg[b]++;
x = findr(a);
y = findr(b);
if (x == y)
cyc++;
else
par[y] = x;
}
for (int i = 1; i <= v; ++i) findr(i);
for (int i = 1; i <= v; ++i) {
if (chk[par[i]] == 0) {
chk[par[i]] = 1;
head++;
}
}
if (cyc == 1 && head == 1)
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 | #include <bits/stdc++.h>
using namespace std;
int n, d[111], fa[111];
bool bo[111][111];
bool vis[111], flag, pd;
int getfa(int x) {
if (fa[x] == x)
return x;
else
return fa[x] = getfa(fa[x]);
}
void round() {
int i, j;
while (1) {
flag = true;
for (i = 1; i <= n; i++)
if (d[i] <= 1 && !vis[i]) {
flag = false;
vis[i] = true;
for (j = 1; j <= n; j++)
if (bo[i][j]) {
bo[i][j] = bo[j][i] = false;
d[i]--;
d[j]--;
}
}
if (flag) return;
}
}
int main() {
int i, j, k, t, m, T, x, y, ans, now, xx, yy;
while (scanf("%d%d", &n, &m) != EOF) {
for (i = 1; i <= n; i++) fa[i] = i;
memset(d, 0, sizeof(d));
memset(bo, 0, sizeof(bo));
memset(vis, 0, sizeof(vis));
for (i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
d[x]++;
d[y]++;
bo[x][y] = bo[y][x] = true;
xx = getfa(x);
yy = getfa(y);
if (xx != yy) fa[xx] = yy;
}
pd = true;
for (i = 2; i <= n; i++)
if (getfa(i) != getfa(i - 1)) pd = false;
round();
flag = false;
for (i = 1; i <= n; i++)
if (!vis[i]) {
flag = true;
break;
}
if (!flag) pd = false;
if (flag) {
for (j = 1; j <= n; j++)
if (bo[i][j]) {
bo[i][j] = bo[j][i] = false;
d[i]--;
d[j]--;
break;
}
round();
for (i = 1; i <= n; i++)
if (!vis[i]) flag = false;
}
if (flag && pd)
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 | #include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[100000];
bool used[100000];
void dfs(int v) {
used[v] = true;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (used[to] == false) {
dfs(to);
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
g[l].push_back(r);
g[r].push_back(l);
}
dfs(1);
for (int i = 1; i <= n; i++) {
if (used[i] == false) {
cout << "NO";
return 0;
}
}
if (n == m) {
cout << "FHTAGN!";
return 0;
}
cout << "NO";
}
| CPP |
Subsets and Splits