Search is not available for this dataset
name
stringlengths 2
112
| description
stringlengths 29
13k
| source
int64 1
7
| difficulty
int64 0
25
| solution
stringlengths 7
983k
| language
stringclasses 4
values |
|---|---|---|---|---|---|
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Scanner;
public class cthulu {
static Scanner scan= new Scanner(System.in);
static int count = 0;
static void DFS(int x,boolean visited[],LinkedList<Integer> [] list){
visited[x]=true;
count++;
for(int i : list[x]){
if(!visited[i]){
DFS(i,visited,list);
}
}
}
public static void main(String[] args) {
int n = scan.nextInt();
int m = scan.nextInt();
if(n!=m){
System.out.println("NO");
}
else{
LinkedList<Integer> [] list = new LinkedList[n+1];
boolean visited [] = new boolean [n+1];
Arrays.fill(visited,false);
for(int i = 1 ;i<=n;i++){
LinkedList<Integer> neibours = new LinkedList<Integer>();
list[i]=neibours;
}
for(int j = 1 ;j<=m;j++){
int a = scan.nextInt();
int b = scan.nextInt();
list[a].add(b);
list[b].add(a);
}
DFS(1,visited,list);
if(count!=n){
System.out.println("NO");
}
else{
System.out.println("FHTAGN!");
}
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | from collections import defaultdict
# your code goes here
v=defaultdict(list)
n,m=map(int,input().split())
l=[0]*n
for i in range(m):
a,b=map(int,input().split())
v[a-1].append(b-1)
v[b-1].append(a-1)
vis=[0]*n
def dfs(node):
vis[node]=1
for j in v[node]:
if vis[j]==0:
dfs(j)
c=0
for i in range(n):
if vis[i]==0:
dfs(i)
c+=1
if c==1 and n==m:
print('FHTAGN!')
else:
print('NO')
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const long long int N = 105;
vector<long long int> gr[N];
long long int vis[N];
bool cycle, cycle2;
void dfs(long long int cur, long long int par) {
vis[cur] = 1;
bool fl = 0;
for (long long int x : gr[cur]) {
if (vis[x] == 0) dfs(x, cur);
if (vis[x] == 1 && x != par) {
if (cycle == 1) cycle2 = 1;
cycle = 1;
}
}
vis[cur] = 2;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{
long long int i, j, k, n, m, ans = 0, cnt = 0, sum = 0;
cin >> n >> m;
for (i = 0; i < m; i++) {
long long int x, y;
cin >> x >> y;
gr[x].emplace_back(y);
gr[y].emplace_back(x);
}
dfs(1, 0);
for (i = 1; i <= n; i++) {
if (vis[i] == 0) cycle = 0;
}
(cycle && !cycle2) ? puts("FHTAGN!") : 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 | class Node:
def __init__(self, n_name):
"""
String, list of edges -> node
"""
self.name = n_name
self.edges = []
self.incoming_edges = []
def __str__(self):
string = 'Name : ' + str(self.name) + ' \n'
string += 'outcoming edges : ' + '\n'
for edge in self.edges:
string += str(edge) + '\n'
return string
def add_edge(self, edge):
"""
edge -> None
"""
self.edges.append(edge)
class Edge:
def __init__(self, e_source, e_destination, weight = 1):
"""
Node, Node, number -> Edge
"""
self.source = e_source
self.destination = e_destination
self.weight = weight
def __str__(self):
string = 'source : ' + str(self.source.name) + ' \n'
string += 'destination : ' + str(self.destination.name) + ' \n'
string += 'weight : ' + str(self.weight) + '\n'
return string
def __lt__(self, other):
return self.weight < other.weight
class Graph:
def __init__(self):
self.node_list = []
self.edge_list = []
self.name_to_node = {}
def __str__(self):
output = ""
output += "Nodes : "
for node in self.node_list:
output += str(node.name) + " "
output += "\nEdges : "
for edge in self.edge_list:
output += str(edge.source.name) + "--(" + str(edge.weight) + ")--" + str(edge.destination.name) + " "
output += "\n"
return output
def add_node(self, node_name):
"""
(String or integer) -> Node
Adds a node to the graph
"""
new_node = Node(node_name)
self.node_list += [new_node]
self.name_to_node[node_name] = new_node
return new_node
def add_edge(self, source_name, dest_name, weight = 1):
"""
(String or number), (String or number) -> (Edge)
Adds an edge between two nodes
if the nodes are not there it will create then
"""
if source_name not in self.name_to_node :
self.add_node(source_name)
if dest_name not in self.name_to_node :
self.add_node(dest_name)
source_node = self.name_to_node[source_name]
dest_node = self.name_to_node[dest_name]
new_edge = Edge(source_node, dest_node, weight)
source_node.add_edge(new_edge)
dest_node.incoming_edges += [new_edge]
self.edge_list += [new_edge]
def get_cycles(source, level, levels, cycles):
# Mark source as explored
levels[source] = level
# DFS throught all of its neibour
for edge in source.edges:
next_vertex = edge.destination
# If it's not explored then DFs it else then it's a cycle
if next_vertex not in levels:
get_cycles(next_vertex, levels[source] + 1, levels, cycles)
else:
cycle_length = levels[next_vertex] - levels[source] + 1
if cycle_length > 2:
cycles.append(abs(cycle_length))
def get_all_nodes(source, explored_nodes):
explored_nodes.add(source)
for edge in source.edges:
next_vertex = edge.destination
if next_vertex not in explored_nodes:
get_all_nodes(next_vertex, explored_nodes)
def is_Cthulhu(cycles, m, all_reachable):
return all_reachable and m >= 3 and len(cycles) == 1 and cycles[0] >= 3
# Construct a graph
a = Graph()
first_line = input()
first_line = first_line.split()
n = int(first_line[0])
m = int(first_line[1])
for i in range(n):
a.add_node(i+1)
for i in range(m):
line = input()
line = line.split()
s = int(line[0])
t = int(line[1])
a.add_edge(s, t)
a.add_edge(t, s)
cycles = []
explored = {}
all_reachable_nodes = set()
if n >= 3:
get_all_nodes(a.node_list[0], all_reachable_nodes)
if len(all_reachable_nodes) == len(a.node_list):
for vertex in a.node_list:
if vertex not in explored:
get_cycles(vertex, 0, explored, cycles)
if is_Cthulhu(cycles, m, (len(all_reachable_nodes) == len(a.node_list))):
print("FHTAGN!")
else:
print("NO")
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Ktulhu {
public static BufferedReader openReader(String inputFile) throws IOException {
FileInputStream fis = new FileInputStream(inputFile);
return new BufferedReader(
new InputStreamReader(fis, "UTF-8")
);
}
public static BufferedWriter openWriter(String outputFile) throws IOException {
FileOutputStream fos = new FileOutputStream(outputFile);
return new BufferedWriter(
new OutputStreamWriter(fos, "UTF-8")
);
}
public static Scanner openScanner(BufferedReader reader) throws IOException {
return new Scanner(reader);
}
public void process() throws IOException {
try (
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
Scanner scanner = openScanner(reader)
) {
int n = scanner.nextInt();
int m = scanner.nextInt();
Graph graph = new Graph(n);
for (int i = 0; i < m; i++) {
int v = scanner.nextInt();
int u = scanner.nextInt();
graph.addEdge(v - 1, u - 1);
}
String result;
if (isKtulhu(graph)) {
result = "FHTAGN!";
} else {
result = "NO";
}
System.out.println(result);
}
}
/**
* Algorithm:
* <ul>
* <li>check connectivity</li>
* <li> compare edges and nodes count</li>
* </ul>
*
* @param graph Graph object with edges/nodes initialized
* @return true if graph is Ktulhu graph
*/
public boolean isKtulhu(Graph graph) {
graph.dfs(graph, 0);
return graph.isAllVertexVisited() && graph.getEdgesCount() == graph.getNodesCount();
}
public static void main(String[] args) throws IOException {
Ktulhu problem = new Ktulhu();
problem.process();
}
}
class Graph {
private int nodesCount;
private int edgesCount;
private Vertex[] nodes;
private VertexState visited[];
private int time;
Graph(int nodesCount) {
this.nodesCount = nodesCount;
nodes = new Vertex[nodesCount];
visited = new VertexState[nodesCount];
for (int i = 0; i < nodes.length; i++) {
nodes[i] = new Vertex();
visited[i] = new VertexState();
}
}
public int getNodesCount() {
return nodesCount;
}
public int getEdgesCount() {
return edgesCount;
}
public void addEdge(int u, int v) {
nodes[v].addEdge(u);
nodes[u].addEdge(v);
edgesCount++;
}
public void removeEdge(int u, int v) {
nodes[v].removeEdge(u);
nodes[u].removeEdge(v);
edgesCount--;
}
public List<Integer> getEdges(int id) {
return nodes[id].getEdges();
}
public boolean isAllVertexVisited() {
for (VertexState aVisited : visited) {
if (aVisited.getColor() != VertexState.Color.BLACK) {
// graph is not connected
return false;
}
}
return true;
}
public void clearVertexState() {
for (int i = 0; i < nodes.length; i++) {
visited[i] = new VertexState();
}
time = 0;
}
public VertexState[] getVertexStates() {
return visited;
}
public VertexState getVertexState(int i) {
return visited[i];
}
public void setColor(int i, VertexState.Color color) {
visited[i].setColor(color);
if (VertexState.Color.BLACK == color) {
visited[i].setFinishTime(time++);
} else if (VertexState.Color.GRAY == color) {
visited[i].setDiscoverTime(time++);
}
}
public VertexState.Color getColor(int i) {
return visited[i].getColor();
}
public int getDiscoveryTime(int i) {
return visited[i].getDiscoverTime();
}
public int getFinishTime(int i) {
return visited[i].getFinishTime();
}
public void dfs(Graph graph, Integer current) {
graph.setColor(current, VertexState.Color.GRAY);
for (Integer edge : graph.getEdges(current)) {
if (graph.getColor(edge) == VertexState.Color.WHITE) {
dfs(graph, edge);
}
}
graph.setColor(current, VertexState.Color.BLACK);
}
static class Edge {
private int vertex1;
private int vertex2;
Edge(int vertex1, int vertex2) {
this.vertex1 = vertex1;
this.vertex2 = vertex2;
}
public int getVertex1() {
return vertex1;
}
public int getVertex2() {
return vertex2;
}
}
static class VertexState {
public enum Color {
BLACK, GRAY, WHITE
}
private Color color;
private int discoverTime;
private int finishTime;
VertexState() {
color = Color.WHITE;
}
public Color getColor() {
return color;
}
public void setColor(Color color) {
this.color = color;
}
public int getDiscoverTime() {
return discoverTime;
}
public void setDiscoverTime(int discoverTime) {
this.discoverTime = discoverTime;
}
public int getFinishTime() {
return finishTime;
}
public void setFinishTime(int finishTime) {
this.finishTime = finishTime;
}
}
static class Vertex {
private List<Integer> list = new ArrayList<>();
public void addEdge(Integer edge) {
list.add(edge);
}
public void removeEdge(Integer edge) {
list.remove(edge);
}
public List<Integer> getEdges() {
return list;
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<long long> v[1005];
bool vis[1005];
void dfs(long long s) {
vis[s] = 1;
for (auto i : v[s]) {
if (vis[i]) continue;
dfs(i);
}
}
int main() {
long long n, m, flag = 1;
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
dfs(1);
if (n != m) flag = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) flag = 0;
if (flag)
cout << "FHTAGN!";
else
cout << "NO";
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (((a * b) / gcd(a, b))); }
long long phi(long long n) {
long long result = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) n /= i;
result -= result / i;
}
}
if (n > 1) result -= result / n;
return result;
}
long long binpow(long long a, long long n, long long c) {
long long res = 1;
while (n) {
if (n & 1) res *= a;
res %= c;
a *= a;
a %= c;
n >>= 1;
}
res = (res + c) % c;
return res;
}
void nxi(long long& n) {
bool min = 0;
char c;
n = 0;
while ((c = getc(stdin)) && c <= 32)
;
if (c == '-')
min = 1;
else
n = c - 48;
while ((c = getc(stdin)) && c > 32) n = (n << 3) + (n << 1) + c - 48;
if (min) n = -n;
}
void prl(long long n) {
if (n == 0) {
puts("0");
return;
}
if (n < 0) {
putchar('-');
n = -n;
}
static long long s[10];
long long top = 0;
while (n > 0) s[top++] = n % 10, n /= 10;
while (top--) putchar(s[top] + 48);
puts("");
}
using namespace std;
const int nmax = 1100;
long long n, a[nmax][nmax], m;
vector<int> g[nmax];
int cycle = -1, par[nmax], color[nmax];
bool ban[nmax];
int cnt = 0;
void outv(vector<int> v) {
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
}
void out() {
puts("NO");
exit(0);
}
void dfs(int v, int p = -1) {
par[v] = p;
color[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (color[to] == 1 && to != p)
cycle = v, cnt++;
else if (color[to] == 0)
dfs(to, v);
}
color[v] = 2;
}
bool check(vector<int> cc) {
cc.erase(cc.begin());
cc.erase(cc.begin() + cc.size() - 1);
for (int i = 0; i < cc.size(); i++)
for (int j = i + 2; j < cc.size(); j++) {
int v = cc[i], to = cc[j];
if (a[v][to]) return false;
}
return 1;
}
int main() {
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);
a[x][y] = a[y][x] = 1;
}
dfs(1);
for (int i = 1; i <= n; i++) {
if (color[i] == 0) out();
}
if (cycle == -1 || cnt > 1) out();
vector<int> cc;
while (cycle > 0) {
cc.push_back(cycle);
ban[cycle] = 1;
cycle = par[cycle];
}
int cntV = cc.size(), edges = cntV;
if (n - cntV + 1 == m - edges + 1 && n - cntV >= 3)
puts("FHTAGN!");
else if (check(cc))
puts("FHTAGN!");
else
out();
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.*;
import java.util.*;
public class Main implements Runnable
{
edge[] aux;
int m;
void solve() throws IOException
{
//while(sc.hasNext()){
int n = sc.nextInt();
int m = sc.nextInt();
if(n<3||m<3)
{
ps.println("NO");
return;
}
edge[] edges = new edge[m];
for(int i=0;i<m;i++)
{
edges[i] = new edge(sc.nextInt()-1,sc.nextInt()-1);
//System.out.println(edges[i]);
}
boolean[] used = dfs(-1,edges,n);
for(int i=0;i<n;i++)
if(!used[i])
{
ps.println("NO");
return;
}
edge e;
boolean inCycle;
ArrayList<edge> cycle = new ArrayList<edge>();
for(int i=0;i<m;i++)
{
e = edges[i];
used = dfs(i,edges,n);
inCycle = true;
for(int j=0;j<n;j++)
if(!used[j])
{
inCycle = false;
}
if(inCycle)
{
cycle.add(e);
//System.out.println(e);
}
}
if(cycle.size() < 3)
{
ps.println("NO");
return;
}
edge[] c = new edge[cycle.size()];
int[] d = new int[n];
cycle.toArray(c);
int k=0;
used = new boolean[n];
for(int i=0;i<c.length;i++)
{
e = c[i];
if(!used[e.u])
{
used[e.u] = true;
k++;
}
if(!used[e.v])
{
used[e.v] = true;
k++;
}
}
used = dfs(-1,c,n);
int cnt = 0;
for(int i=0;i<n;i++)
{
if(used[i])
{
cnt++;
}
}
//System.out.println(cnt+" "+k);
if(cnt!=k)
{
ps.println("NO");
return;
}
for(int i=0;i<c.length;i++)
{
d[c[i].u]++;
d[c[i].v]++;
}
for(int i=0;i<n;i++)
{
if(d[i]!=0&&d[i]!=2)
{
ps.println("NO");
return;
}
}
ps.println("FHTAGN!");
//}
}
private boolean[] dfs(int e,edge[] edges,int n)
{
boolean[] used = new boolean[n];
aux = edges;
m = aux.length;
explore(edges[0].u,used,e);
return used;
}
private void explore(int i, boolean[] used, int e)
{
used[i] = true;
for(int j=0;j<m;j++)
{
if(j==e) continue;
if(aux[j].u==i&&!used[aux[j].v])
explore(aux[j].v,used,e);
else if(aux[j].v==i&&!used[aux[j].u])
explore(aux[j].u,used,e);
}
}
Scanner sc;
PrintStream ps;
public void run()
{
try
{
sc = new Scanner(System.in);
// sc = new Scanner(new File("a.in"));
ps = new PrintStream(System.out);
solve();
sc.close();
ps.close();
}
catch (IOException e)
{
e.printStackTrace();
System.exit(0);
}
}
public static void main(String[] args)
{
new Thread(new Main()).start();
}
class edge
{
public int u,v;
public edge(int u,int v)
{
this.u = u;
this.v = v;
}
public boolean has(int a)
{
return (u==a)||(v==a);
}
public String toString()
{
return "("+u+","+v+")";
}
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
int t = 1;
while (t--) solve();
return 0;
}
int n, m;
vector<int> e[200];
bool be[200];
void dfs1(int v, int beg = -1, int end = -1) {
be[v] = true;
for (int i = 0; i < e[v].size(); i++)
if ((v != beg || e[v][i] != end) && (v != end || e[v][i] != beg))
if (!be[e[v][i]]) dfs1(e[v][i], beg, end);
}
vector<pair<int, int> > nemost;
void solve() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int q, w;
cin >> q >> w;
e[q - 1].push_back(w - 1);
e[w - 1].push_back(q - 1);
}
dfs1(0);
for (int i = 0; i < n; i++)
if (!be[i]) {
cout << "NO";
return;
}
memset(be, false, sizeof(be));
for (int i = 0; i < n; i++)
for (int j = 0; j < e[i].size(); j++)
if (i < e[i][j]) {
bool flag = true;
dfs1(0, i, e[i][j]);
for (int k = 0; k < n; k++)
if (!be[k]) {
flag = false;
break;
}
if (flag) nemost.push_back(make_pair(i, e[i][j]));
memset(be, false, sizeof(be));
}
int r = nemost.size();
int step[200];
memset(step, 0, sizeof(step));
for (int i = 0; i < r; i++) {
step[nemost[i].first]++;
step[nemost[i].second]++;
}
if (nemost.size() < 3) {
cout << "NO";
return;
}
for (int i = 0; i < n; i++)
if (step[i] != 0 && step[i] != 2) {
cout << "NO";
return;
}
cout << "FHTAGN!";
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.*;
import java.util.*;
public class B{
static boolean[] vis;
static void dfs(int i) {
if (vis[i]) return;
vis[i] =true;
for (int d = 0; d < adj[i].length; d++) {
if (adj[i][d]) dfs(d);
}
}
static boolean[][]adj;
public static Reader sc = new Reader();
//public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
public static void main(String[] args) throws IOException {
//BufferedReader br = new BufferedReader(new FileReader("input.in"));
int n = sc.nextInt();
int t = sc.nextInt();
int m = t;
vis = new boolean[n];
adj = new boolean[n][n];
while (t-- > 0) {
int a =sc.nextInt()-1;
int b = sc.nextInt()-1;
adj[a][b] = adj[b][a] = true;
//System.out.println(a + " " + b);
}
dfs(0);
int c = 0;
for (int i = 0; i < vis.length; i++) {
if (vis[i]) c++;
}
out.println(c==n&& n == m ? "FHTAGN!":"NO");
out.close();
}
static long ceil(long a, long b) {
return (a + b - 1) / b;
}
static long powMod(long base, long exp, long mod) {
if (base == 0 || base == 1)
return base;
if (exp == 0)
return 1;
if (exp == 1)
return base % mod;
long R = powMod(base, exp / 2, mod) % mod;
R *= R;
R %= mod;
if ((exp & 1) == 1) {
return base * R % mod;
} else
return R % mod;
}
static long pow(long base, long exp) {
if (base == 0 || base == 1)
return base;
if (exp == 0)
return 1;
if (exp == 1)
return base;
long R = pow(base, exp / 2);
if ((exp & 1) == 1) {
return R * R * base;
} else
return R * R;
}
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException {
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException {
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') {
break;
}
buf[cnt++] = (byte) c;
}
return new String(buf, 0, Integer.max(cnt - 1, 0));
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException {
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (din == null)
return;
din.close();
}
}
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
}
| 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 cdr;
import java.util.*;
import java.math.*;
import java.io.*;
public class Luck{
public static InputReader sc;
public static PrintWriter out;
public static final int MOD = (int) (1e9 + 7);
static TreeSet<Integer>[] adj;
static boolean[] visited;
public static void main(String[] args){
sc=new InputReader(System.in);
out=new PrintWriter(System.out);
int n=sc.nextInt();
int e=sc.nextInt();
adj=new TreeSet[n+1];
visited=new boolean[n+1];
for(int i=1;i<=n;i++){
adj[i]=new TreeSet<Integer>();
}
for(int i=0;i<e;i++){
int u=sc.nextInt();
int v=sc.nextInt();
adj[u].add(v);
adj[v].add(u);
}
if(e<=n-1 || e>n){
out.println("NO");
}
else{
DFS(1,1);
int flag=0;
for(int i=1;i<=n;i++){
if(visited[i]==false){
//out.println("i: "+i);
flag=1;
break;
}
}
if(flag==1){
out.println("NO");
}
else{
out.println("FHTAGN!");
}
}
out.close();
}
static void DFS(int src,int par){
if(visited[src]==true){
return;
}
visited[src]=true;
for(int nei:adj[src]){
if(nei==par){
continue;
}
DFS(nei,src);
}
}
static int gcd(int a,int b){
if(b==0){
return a;
}
return gcd(b,a%b);
}
static int lcm(int a,int b){
int g;
if(a<b){
g=gcd(b,a);
}
else{
g=gcd(a,b);
}
return (a*b)/g;
}
static boolean isPrime(int n){
if (n == 2)
return true;
for (long i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
static void shuffle(int[] A){
for(int i=A.length-1;i>0;i--){
int j=(int)(Math.random()*(i+1));
int temp=A[j];
A[j]=A[i];
A[i]=temp;
}
}
public static class Node implements Comparable<Node>{
int v;
int d;
public Node(){
;
}
public Node (int v, int d) {
this.d = d;
this.v = v;
}
public void print() {
out.println(v + " " + d + " ");
}
public int compareTo(Node n1){
return this.d-n1.d;
}
}
public static BigInteger pow(BigInteger base, BigInteger exp) {
if(exp.equals(new BigInteger(String.valueOf(0)))){
return new BigInteger(String.valueOf(1));
}
if(exp.equals(new BigInteger(String.valueOf(1))))
return base;
BigInteger temp=exp.divide(new BigInteger(String.valueOf(2)));
BigInteger val = pow(base, temp);
BigInteger result = val.multiply(val);
result=result.remainder(new BigInteger(String.valueOf(MOD)));
BigInteger AND=exp.and(new BigInteger(String.valueOf(1)));
if(AND.equals(new BigInteger(String.valueOf(1)))){
result = result.multiply(base);
result=result.remainder(new BigInteger(String.valueOf(MOD)));
}
return result;
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int snext() {
if (snumChars == -1)
throw new InputMismatchException();
if (curChar >= snumChars) {
curChar = 0;
try {
snumChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (snumChars <= 0)
return -1;
}
return buf[curChar++];
}
public int nextInt() {
int c = snext();
while (isSpaceChar(c))
c = snext();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = snext();
while (isSpaceChar(c))
c = snext();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public int[] nextIntArray(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public String readString() {
int c = snext();
while (isSpaceChar(c))
c = snext();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = snext();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #!/usr/bin/env python
import Queue
n,m=[int(i) for i in raw_input().split(' ')]
array = [[0 for i in range(n)] for j in range(n)]
for i in range(m):
x,y=[int(i)-1 for i in raw_input().split(' ')]
array[x][y]=array[y][x]=1
color=[0 for i in range(n)]
color[0] = 1
q = Queue.Queue()
q.put(0)
i=1
while(i<n and q.qsize()>0):
u = q.get()
for x in range(n):
if(array[x][u]==1):
if(color[x]==0):
color[x]=1
i+=1
q.put(x)
flag=0
for i in range(n):
if(color[i]==0):
flag=1
if flag==0 and n==m:
print "FHTAGN!"
else:
print "NO"
| PYTHON |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
bool visited[110];
bool a[110][110];
int color[110];
vector<int> v;
int n;
int cycle;
void dfs(int u) {
visited[u] = true;
color[u] = 1;
for (int(i) = 0; (i) < (n); (i)++)
if (a[u][i + 1]) {
a[u][i + 1] = a[i + 1][u] = false;
if (color[i + 1] == 1) {
cycle++;
for (int(j) = 0; (j) < (n); (j)++)
if (color[j + 1] == 1) v.push_back(j + 1);
}
if (!visited[i + 1]) dfs(i + 1);
}
color[u] = 2;
}
bool check() {
v.clear();
cycle = 0;
dfs(1);
if (cycle != 1) return false;
for (int(i) = 0; (i) < (n); (i)++)
if (!visited[i + 1]) return false;
if (v.size() < 3) return false;
return true;
}
int main() {
for (int(i) = 0; (i) < (110); (i)++)
for (int(j) = 0; (j) < (110); (j)++)
a[i][j] = visited[i] = color[i] = false;
int m;
cin >> n >> m;
for (int(i) = 0; (i) < (m); (i)++) {
int u, v;
cin >> u >> v;
a[u][v] = a[v][u] = true;
}
if (check())
cout << "FHTAGN!" << endl;
else
cout << "NO" << endl;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.Scanner;
public class Prob104C {
static int[][] adj;
static int[] seen;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int M = scanner.nextInt();
if (N != M){ System.out.println("NO");return;}
adj = new int[N][N];
seen = new int[N];
for (int i = 0; i < M; i++) {
int tmp1 = scanner.nextInt();
int tmp2 = scanner.nextInt();
adj[tmp1 - 1][tmp2 - 1] = 1;
adj[tmp2 - 1][tmp1 - 1] = 1;
}
DFS(0);
for (int i : seen)
if (i == 0) { System.out.println("NO"); return;}
System.out.println("FHTAGN!");
}
public static void DFS(int k) {
seen[k] = 1;
for (int i = 0; i < seen.length; i++) {
if (adj[k][i] != 0) {
if (seen[i] == 0) 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.*;
import java.util.*;
public class Cthulhu {
static boolean[][] graph;
static int n, m;
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(in.readLine());
n = Integer.parseInt(st.nextToken());
m = Integer.parseInt(st.nextToken());
graph = new boolean[n][n];
for (int i = 0; i < m; i++) {
st = new StringTokenizer(in.readLine());
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
a--; b--;
graph[a][b] = graph[b][a] = true;
}
boolean[] visited = new boolean[n];
boolean[][] used = new boolean[n][n];
LinkedList<Integer> q = new LinkedList<Integer>();
q.add(0);
int cycles = 0;
while (!q.isEmpty()) {
int v = q.poll();
if (visited[v]) {
cycles++;
continue;
}
visited[v] = true;
for (int i = 0; i < n; i++) {
if (graph[v][i] && !used[v][i]) {
q.add(i);
used[i][v] = used[v][i] = true;
}
}
}
boolean good = true;
for (int i = 0; i < n; i++) {
if (!visited[i]) {
good = false;
}
}
if (!good || cycles != 1) {
System.out.println("NO");
} else {
System.out.println("FHTAGN!");
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
def dfs (i):
stack = [i];
seen[i] = True
while (stack):
i = stack[len(stack)-1]
stack.pop()
seen[i] = True
for j in range (len(graph[i])):
v = graph[i][j]
if (seen[v]): continue
stack.append (v)
n, m = map (int, raw_input().split(' '))
graph = [[] for i in range (n)]
for i in range (m):
u, v = map (int, raw_input().split (' '))
u -= 1;
v -= 1;
graph[u].append (v)
graph[v].append (u)
seen = [False]*n
dfs (0)
if (not seen.count(False) and m == n):
print "FHTAGN!"
else:
print "NO"
| PYTHON |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | n, m = map(int, raw_input().split())
conn = [set([]) for i in range(n)]
for i in xrange(m):
a, b = map(int, raw_input().split())
a -= 1
b -= 1
conn[a].add(b)
conn[b].add(a)
ok = True
queue = set([])
for i in range(n):
if len(conn[i]) == 1:
queue.add(i)
if len(conn[i]) == 0:
ok = False
while queue:
frm = queue.pop()
if len(conn[frm]) != 1:
continue
to = conn[frm].pop()
conn[to].remove(frm)
if len(conn[to]) == 1:
queue.add(to)
# test whether the rest is simple circle
cnt = 0
for i in range(n):
if len(conn[i]) not in [0, 2]:
ok = False
if len(conn[i]):
cnt += 1
if cnt == 0:
ok = False
if ok:
for i in range(n):
if len(conn[i]):
start = i
break
seq = [start]
while True:
to1, to2 = list(conn[start])
if to1 in seq and to2 in seq:
break
if to1 in seq:
next = to2
else:
next = to1
seq.append(next)
start = next
if len(seq) != cnt:
ok = False
if ok:
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>
int g[110][110];
int v[110];
void dfs(int a, int n) {
v[a] = 1;
for (int i = 1; i <= n; i++) {
if (g[a][i] && !v[i]) dfs(i, n);
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) g[i][j] = 0;
memset(v, 0, sizeof(v));
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d %d", &a, &b);
g[a][b] = 1;
g[b][a] = 1;
}
if (n != m) {
printf("NO\n");
return 0;
}
dfs(1, n);
for (int i = 1; i <= n; i++) {
if (v[i] == 0) {
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 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* Created by IntelliJ IDEA.
* User: alexsen
* Date: 3/25/12
* Time: 9:49 PM
*/
public class Fhtagn {
protected static int n = 0;
protected static int m = 0;
public static void main(String[] args){
try{
CirclesFinder finder = new CirclesFinder();
Node[] all = readNodes();
if(!preCheck(all)){
System.out.println("NO");
return;
}
finder.fhtagn(all[0]);
if(!postCheck(all)){
System.out.println("NO");
return;
}
System.out.println("FHTAGN!");
}catch(IOException e){
e.printStackTrace();
}
}
protected static Node[] readNodes()throws IOException{
Reader reader = new Reader();
n = reader.next();
m = reader.next();
Node[] all = new Node[n];
for(int i = 0; i < n; ++i){
all[i] = new Node(i);
}
for(int i = 0; i<m; ++i){
int id1 = reader.next()-1;
int id2 = reader.next()-1;
all[id1].getNeighbors().add(all[id2]);
all[id2].getNeighbors().add(all[id1]);
}
return all;
}
protected static boolean preCheck(Node[] all){
if(all.length < 3) return false;
if(m!=n) return false;
for(int i = 0; i < all.length; ++i){
if(all[i].getNeighbors().size==0) return false;
}
return true;
}
protected static boolean postCheck(Node[] all){
for(Node n : all){
if(n.getColor().equals(Color.WHITE)) return false;
}
return true;
}
}
class CirclesFinder{
protected void fhtagn(Node start){
start.setVisits(1);
start.setColor(Color.GRAY);
dfs(start);
start.setColor(Color.BLACK);
}
protected void dfs(Node next){
for(int i = 0 ; i < next.getNeighbors().size() ; ++ i)
{
Node n = next.getNeighbors().get(i);
if(n.getColor()==Color.WHITE){
n.setVisits(1);
n.setColor(Color.GRAY);
n.setParent(next);
dfs(n);
n.setColor(Color.BLACK);
}
}
}
}
enum Color{WHITE,GRAY,BLACK};
class Node{
protected Array neighbors;
protected int id;
protected int visits;
protected Color color;
protected Node parent;
Node(int id) {
this.id = id;
neighbors = new Array();
visits = 0;
color = Color.WHITE;
}
public Node getParent() {
return parent;
}
public void setParent(Node parent) {
this.parent = parent;
}
public Color getColor() {
return color;
}
public void setColor(Color color) {
this.color = color;
}
public int getVisits() {
return visits;
}
public void setVisits(int visits) {
this.visits = visits;
}
public Array getNeighbors() {
return neighbors;
}
public int getId() {
return id;
}
}
class Array{
protected Node[] es;
protected int size = 0;
protected int sizeMax = 2;
Array() {
es = new Node[sizeMax];
}
void add(Node e){
if(size+1 == sizeMax){
sizeMax *= 2;
Node[] esNew = new Node[sizeMax];
for(int i = 0; i < size ; ++i){
esNew[i] = es[i];
}
es = esNew;
}
es[size] = e;
++size;
}
int size(){
return size;
}
Node get(int i){
return es[i];
}
}
class Reader{/*
protected int index = 0;
int next(){
return values[index++];
}
int[] values = {6, 6,4, 5,6, 1,3, 2,4, 3,1, 5,4, 6,2, 5};*/
Reader() {
InputStreamReader converter = new InputStreamReader(System.in);
reader = new BufferedReader(converter);
}
int next()throws IOException{
if(needToRead){
needToRead = false;
buffer = reader.readLine();
int iSep = buffer.indexOf(" ");
int result = Integer.parseInt(buffer.substring(0,iSep));
buffer = buffer.substring(iSep+1);
return result;
}
else{
needToRead = true;
return Integer.parseInt(buffer);
}
}
protected String buffer;
protected boolean needToRead=true;
BufferedReader reader;
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<vector<int> > G;
vector<int> was;
int cycle;
void pdfs(int node, int par) {
was[node]++;
for (int i = 0; i < G[node].size(); i++) {
int ch = G[node][i];
if (was[ch] && ch != par) cycle++;
if (!was[ch]) pdfs(ch, node);
}
}
int main() {
int N, M;
cin >> N >> M;
G.resize(N + 2);
was.resize(N + 2);
for (int i = 0; i < M; i++) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
pdfs(1, -1);
bool con = true;
for (int i = 1; i <= N; i++)
if (!was[i]) con = false;
if (cycle == 2 && con)
puts("FHTAGN!\n");
else
puts("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;
vector<vector<int> > ar(110, vector<int>(110, 0));
vector<vector<int> > te(110, vector<int>(110, 0));
int ar1[110];
int flag[110];
int n1;
bool f;
void dfs(int n) {
int i;
ar1[n] = 1;
flag[n] = 1;
for (i = 1; i <= n1; i++) {
if (ar[n][i] == 1 && flag[i] == 1) {
f = false;
} else if (ar[n][i] == 1) {
ar[i][n] = 0;
dfs(i);
}
}
flag[n] = 0;
}
int main() {
int n, m, cnt = 0;
vector<pair<int, int> > v;
cin >> n >> m;
n1 = n;
int i, j, a, b;
for (i = 0; i < m; i++) {
cin >> a >> b;
v.push_back(make_pair(a, b));
ar[a][b] = 1;
ar[b][a] = 1;
}
te = ar;
for (i = 0; i < m; i++) {
cnt = 0;
memset(ar1, 0, sizeof(ar1));
memset(flag, 0, sizeof(flag));
ar = te;
f = true;
a = v[i].first;
b = v[i].second;
ar[a][b] = ar[b][a] = 0;
dfs(1);
if (f == false)
continue;
else {
for (j = 1; j <= n; j++)
if (ar1[j] == 1) cnt++;
if (cnt == n) {
cout << "FHTAGN!"
<< "\n";
return 0;
}
}
}
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;
vector<int> adjList[110];
int state[110];
int parent[110];
int qtyCycles;
void dfs(int u) {
state[u] = 0;
for (int v : adjList[u]) {
if (state[v] == -1) {
parent[v] = u;
dfs(v);
} else if (state[v] == 0 && v != parent[u]) {
qtyCycles++;
}
}
state[u] = 1;
}
int main() {
int V, E;
cin >> V >> E;
memset(state, -1, sizeof state);
memset(parent, -1, sizeof parent);
qtyCycles = 0;
while (E--) {
int u, v;
cin >> u >> v;
u--;
v--;
adjList[u].push_back(v);
adjList[v].push_back(u);
}
int qtyCCs = 0;
for (int u = 0; u < V; u++)
if (state[u] == -1) {
dfs(u);
qtyCCs++;
}
cout << (qtyCycles == 1 && qtyCCs == 1 ? "FHTAGN!" : "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.Scanner;
public class Main{
static Scanner sc=new Scanner(System.in);
static int n=sc.nextInt();
static int m=sc.nextInt();
static int f[]=new int[n+1];//nδΈͺθηΉ ηζ°η»
public static void main(String[] args) {
int flag=0;
init();
flag=merge(flag);
// flag=check();
if(m!=n){
System.out.println("NO");
return;
}
if (flag==0||flag>1) {
System.out.println("NO");
}else {
System.out.println("FHTAGN!");
}
}
// private static int check() {
// for (int i = 0; i < n; i++) {
// f[i]=findFa(f[i]);
// }
// int temp=f[1];
// for (int i = 1; i <=n; i++) {
// if(f[i]!=temp){
// return 1;
// }
// }
// return 0;
// }
private static int merge(int flag) {
for (int i = 0; i < m; i++) {
int a=sc.nextInt();
int b=sc.nextInt();
int x=findFa(a);
int y=findFa(b);
if(x!=y){
f[y]=x;
}
if(x==y){
flag++;
}
}
return flag;
}
private static int findFa(int i) {
if(f[i]!=i){
f[i]=findFa(f[i]);
}
return f[i];
}
private static void init() {
for (int i = 1; i <=n; i++) {
f[i]=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 | #include <bits/stdc++.h>
using namespace std;
int vis[101];
vector<vector<int>> adj;
void dfs(int s) {
vis[s] = 1;
for (int i = 0; i < adj[s].size(); i++)
if (!vis[adj[s][i]]) dfs(adj[s][i]);
}
int main() {
int n, m;
cin >> n >> m;
if (m != n) {
cout << "NO\n";
return 0;
}
adj.resize(n + 1);
int f, t;
for (int i = 0; i < m; i++) {
cin >> f >> t;
adj[f].push_back(t);
adj[t].push_back(f);
}
bool flag = true;
vector<int> res1;
memset(vis, 0, sizeof(vis));
dfs(1);
for (int j = 1; j <= n; j++)
if (!vis[j]) {
flag = false;
break;
}
if (flag)
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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
FastReader in = new FastReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
BCthulhu solver = new BCthulhu();
solver.solve(1, in, out);
out.close();
}
static class BCthulhu {
private int[] p = new int[105];
private int[] sz = new int[105];
public void solve(int testNumber, FastReader in, OutputWriter out) {
int n = in.nextInt();
int m = in.nextInt();
for (int i = 1; i <= n; i++) p[i] = i;
boolean has = false;
int saikel = 0;
for (int i = 0; i < m; i++) {
int u, v;
u = in.nextInt();
v = in.nextInt();
has |= cycle(u, v);
if (cycle(u, v)) saikel++;
Union(u, v);
}
for (int i = 1; i <= n; i++) sz[p[Find(i)]]++;
int comp = 0;
for (int i = 1; i <= n; i++) if (sz[i] > 0) comp++;
if (comp == 1 && has && saikel == 1) out.println("FHTAGN!");
else out.println("NO");
}
int Find(int a) {
if (p[a] == a) return a;
return p[a] = Find(p[a]);
}
void Union(int a, int b) {
p[Find(b)] = Find(a);
}
boolean cycle(int a, int b) {
return p[Find(a)] == p[Find(b)];
}
}
static class FastReader {
InputStream is;
private byte[] inbuf = new byte[1024];
private int lenbuf = 0;
private int ptrbuf = 0;
public FastReader(InputStream is) {
this.is = is;
}
public int readByte() {
if (lenbuf == -1) throw new InputMismatchException();
if (ptrbuf >= lenbuf) {
ptrbuf = 0;
try {
lenbuf = is.read(inbuf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0) return -1;
}
return inbuf[ptrbuf++];
}
public int nextInt() {
int num = 0, b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = (num << 3) + (num << 1) + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(objects[i]);
}
}
public void println(Object... objects) {
print(objects);
writer.println();
}
public void close() {
writer.close();
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.Scanner;
public class B_Cthulhu {
static boolean[] vis;
static int cnt =0;
// do dfs and count number of reached nodes
static void isconnected (boolean[][] g,int i){
// mark as visited
vis[i] = true;
cnt++;
//for (int j=0;j<vis.length;j++) System.out.print(vis[j]);
//System.out.println();
for (int k=1;k<g.length;k++){
if (g[i][k] && !vis[k]) {
isconnected(g,k);
}
}
}
public static void main(String[] args) {
/* adjacency matrix*/
/* undirected graph */
Scanner s = new Scanner (System.in);
int n,m,v1=1,v2=1;
n=s.nextInt();
m=s.nextInt();
boolean[][] g = new boolean [n+1][n+1];
vis = new boolean[n+1];
for (int i=0;i<m;i++){
v1 = s.nextInt();
v2 = s.nextInt();
g[v1][v2]=true;
g[v2][v1]=true;
}
if (n!=m) System.out.println("NO");
else {
isconnected(g,v1);
if (cnt ==n) System.out.println("FHTAGN!");
else System.out.println("NO");
}
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int N = 101;
int n, m, c, par[N];
int get_par(int u) { return u == par[u] ? u : par[u] = get_par(par[u]); }
bool uni(int u, int v) {
u = get_par(u);
v = get_par(v);
if (u == v) return 0;
par[u] = v;
c--;
return 1;
}
int main() {
iota(par, par + N, 0);
cin >> n >> m;
bool ok = 0;
c = n;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
if (!uni(u, v)) ok = 1;
}
ok &= (c == 1);
ok &= (n == m);
cout << (ok ? "FHTAGN!" : "NO");
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m, i, x, y, s;
vector<int> a[105];
bool c[105];
void dfs(int i) {
c[i] = true;
s++;
for (int j = 0; j < a[i].size(); j++) {
if (!c[a[i][j]]) dfs(a[i][j]);
}
}
int main() {
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
if (n != m) {
cout << "NO";
return 0;
} else {
dfs(1);
if (s == n) {
cout << "FHTAGN!";
return 0;
} 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.InputStreamReader;
import java.io.PrintWriter;
import static java.lang.Math.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
/**
*
* @author pttrung
*/
public class C {
public static double Epsilon = 1e-6;
public static void main(String[] args) {
try {
Scanner in = new Scanner();
PrintWriter out = new PrintWriter(System.out);
int n = in.nextInt();
int m = in.nextInt();
// System.out.println("Size " + n);
boolean[][] data = new boolean[n][n];
for (int i = 0; i < m; i++) {
int a = in.nextInt() - 1;
int b = in.nextInt() - 1;
data[a][b] = true;
data[b][a] = true;
}
boolean[][] trace = new boolean[n][n];
boolean[] visit = new boolean[n];
dfs(0, data, visit, trace);
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
trace[i][j] = trace[i][j] || (trace[i][k] && trace[k][j]);
}
}
}
ArrayList<Integer> circle = new ArrayList();
boolean found = true;
for (int i = 0; i < n; i++) {
if (!visit[i]) {
found = false;
break;
}
if (trace[i][i]) {
circle.add(i);
// System.out.println("CIRCLE " + i );
}
}
for (int i = 0; i < circle.size() && found; i++) {
int count = 0;
for (int j = 0; j < circle.size(); j++) {
if (i != j) {
if (!(trace[circle.get(i)][circle.get(j)] && trace[circle.get(j)][circle.get(i)])) {
found = false;
break;
}
if (data[circle.get(i)][circle.get(j)]) {
// System.out.println(circle.get(i) + " " + circle.get(j));
count++;
}
}
}
if (count != 2) {
found = false;
}
}
if (found && circle.size() > 0) {
out.println("FHTAGN!");
} else {
out.println("NO");
}
out.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
static int dfs(int node, boolean[][] map, boolean[] visit, boolean[][] trace) {
visit[node] = true;
int result = 0;
for (int i = 0; i < map.length; i++) {
if (map[node][i]) {
if (!trace[i][node]) {
trace[node][i] = true;
}
if (!visit[i]) {
result += dfs(i, map, visit, trace) + 1;
}
}
}
return result;
}
static class P implements Comparable<P> {
int index, val;
public P(int index, int val) {
this.index = index;
this.val = val;
}
@Override
public int compareTo(P o) {
return val - o.val;
}
}
public static long pow(int a, int b) {
if (b == 0) {
return 1;
}
long val = pow(a, b / 2);
if (b % 2 == 0) {
return val * val;
} else {
return a * val * val;
}
}
public static long gcd(long a, long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
static class Line {
double a, b, c;
Line(double x1, double y1, double x2, double y2) {
if (Math.abs(x1 - x2) < Epsilon && Math.abs(y1 - y2) < Epsilon) {
throw new RuntimeException("Two point are the same");
}
a = y1 - y2;
b = x2 - x1;
c = -a * x1 - b * y1;
}
Line(Point x, Point y) {
this(x.x, x.y, y.x, y.y);
}
public Line perpendicular(Point p) {
return new Line(p, new Point(p.x + a, p.y + b));
}
public Point intersect(Line l) {
double d = a * l.b - b * l.a;
if (d == 0) {
throw new RuntimeException("Two lines are parallel");
}
return new Point((l.c * b - c * l.b) / d, (l.a * c - l.c * a) / d);
}
}
static void check(Point a, Point b, ArrayList<Point> p, Point[] rec, int index) {
for (int i = 0; i < 4; i++) {
int m = (i + index) % 4;
int j = (i + 1 + index) % 4;
Point k = intersect(minus(b, a), minus(rec[m], rec[j]), minus(rec[m], a));
if (k.x >= 0 && k.x <= 1 && k.y >= 0 && k.y <= 1) {
Point val = new Point(k.x * minus(b, a).x, k.x * minus(b, a).y);
p.add(add(val, a));
// System.out.println(a + " " + b + " " + rec[i] + " " + rec[j]);
// System.out.println(add(val, a));
}
}
}
static Point intersect(Point a, Point b, Point c) {
double D = cross(a, b);
if (D != 0) {
return new Point(cross(c, b) / D, cross(a, c) / D);
}
return null;
}
static Point convert(Point a, double angle) {
double x = a.x * cos(angle) - a.y * sin(angle);
double y = a.x * sin(angle) + a.y * cos(angle);
return new Point(x, y);
}
static Point minus(Point a, Point b) {
return new Point(a.x - b.x, a.y - b.y);
}
static Point add(Point a, Point b) {
return new Point(a.x + b.x, a.y + b.y);
}
static double cross(Point a, Point b) {
return a.x * b.y - a.y * b.x;
}
static class Point {
double x, y;
Point(double x, double y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "Point: " + x + " " + y;
}
}
static class Scanner {
BufferedReader br;
StringTokenizer st;
public Scanner() {
// System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
br = new BufferedReader(new InputStreamReader(System.in));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
throw new RuntimeException();
}
}
return st.nextToken();
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String nextLine() {
st = null;
try {
return br.readLine();
} catch (Exception e) {
throw new RuntimeException();
}
}
public boolean endLine() {
try {
String next = br.readLine();
while (next != null && next.trim().isEmpty()) {
next = br.readLine();
}
if (next == null) {
return true;
}
st = new StringTokenizer(next);
return st.hasMoreTokens();
} catch (Exception e) {
throw new RuntimeException();
}
}
}
}
| 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.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
/**
* @author Ivan Pryvalov ([email protected])
*/
public class Codeforces_Round80_Div2_C implements Runnable{
/*
* scanner.nextInt();
* new ByteScanner(scanner.nextLineAsArray()).nextInt();
*
*/
int n;
int[][] E;
int[][] A;
int[] cA;
int[][] from;
int[] cFrom;
private void solve() throws IOException {
n = scanner.nextInt(); // 100
int m = scanner.nextInt(); // 100^2/2
E = new int[n][n];
A = new int[n][n];
cA = new int[n];
Arrays.fill(cA, 0);
for (int i = 0; i < E.length; i++) {
Arrays.fill(E[i], 0);
}
for (int i = 0; i < m; i++) {
int x = scanner.nextInt()-1;
int y = scanner.nextInt()-1;
E[x][y] = 1;
E[y][x] = 1;
A[x][cA[x]]= y;
cA[x]++;
A[y][cA[y]]= x;
cA[y]++;
}
cFrom = new int[n];
Arrays.fill(cFrom, 0);
Queue<Integer> queue = new LinkedList<Integer>();
from = new int[n][n];
queue.add(0);
while (!queue.isEmpty()){
int u=queue.poll();
for (int v = 0; v < n; v++) {
if (E[u][v]!=0){
E[u][v]=0;
E[v][u]=0;
from[v][cFrom[v]] = u;
cFrom[v]++;
queue.add(v);
}
}
}
int cycle = -1;
for (int i = 1; i < n; i++) {
if (cFrom[i]==2){
if (cycle==-1){
cycle=i;
}else{
out.println("NO");
return;
}
}
if (cFrom[i]==0 || cFrom[i]>2){
out.println("NO");
return;
}
}
if (cycle==-1){
out.println("NO");
return;
}
int[] path1 = extractPath(cycle,0);
int[] path2 = extractPath(cycle,1);
int start=0;
for(; start<path1.length && start<path2.length; start++){
if (path1[start]!=path2[start]){
start--;
break;
}
}
int stop1 = start+1;
while (path1[stop1]!=0) stop1++;
int stop2 = start+1;
while (path2[stop2]!=0) stop2++;
int cycleLen = stop1 - start + stop2 - start;
if (cycleLen>=3){
out.println("FHTAGN!");
}else{
out.println("NO");
}
}
private int[] extractPath(int cycle, int start) {
int[] path1 = new int[n];
path1[0] = cycle;
int cur = from[cycle][start];
for (int i = 1; ; i++) {
path1[i] = cur;
if (cur!=0){
cur = from[cur][0];
}else{
break;
}
}
return path1;
}
/////////////////////////////////////////////////
final int BUF_SIZE = 1024 * 1024 * 8;//important to read long-string tokens properly
final int INPUT_BUFFER_SIZE = 1024 * 1024 * 8 ;
final int BUF_SIZE_INPUT = 1024;
final int BUF_SIZE_OUT = 1024;
boolean inputFromFile = false;
String filenamePrefix = "A-small-attempt0";
String inSuffix = ".in";
String outSuffix = ".out";
//InputStream bis;
//OutputStream bos;
PrintStream out;
ByteScanner scanner;
ByteWriter writer;
@Override
public void run() {
try{
InputStream bis = null;
OutputStream bos = null;
//PrintStream out = null;
if (inputFromFile){
File baseFile = new File(getClass().getResource("/").getFile());
bis = new BufferedInputStream(
new FileInputStream(new File(
baseFile, filenamePrefix+inSuffix)),
INPUT_BUFFER_SIZE);
bos = new BufferedOutputStream(
new FileOutputStream(
new File(baseFile, filenamePrefix+outSuffix)));
out = new PrintStream(bos);
}else{
bis = new BufferedInputStream(System.in, INPUT_BUFFER_SIZE);
bos = new BufferedOutputStream(System.out);
out = new PrintStream(bos);
}
scanner = new ByteScanner(bis, BUF_SIZE_INPUT, BUF_SIZE);
writer = new ByteWriter(bos, BUF_SIZE_OUT);
solve();
out.flush();
}catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
public interface Constants{
final static byte ZERO = '0';//48 or 0x30
final static byte NINE = '9';
final static byte SPACEBAR = ' '; //32 or 0x20
final static byte MINUS = '-'; //45 or 0x2d
final static char FLOAT_POINT = '.';
}
public static class EofException extends IOException{
}
public static class ByteWriter implements Constants {
int bufSize = 1024;
byte[] byteBuf = new byte[bufSize];
OutputStream os;
public ByteWriter(OutputStream os, int bufSize){
this.os = os;
this.bufSize = bufSize;
}
public void writeInt(int num) throws IOException{
int byteWriteOffset = byteBuf.length;
if (num==0){
byteBuf[--byteWriteOffset] = ZERO;
}else{
int numAbs = Math.abs(num);
while (numAbs>0){
byteBuf[--byteWriteOffset] = (byte)((numAbs % 10) + ZERO);
numAbs /= 10;
}
if (num<0)
byteBuf[--byteWriteOffset] = MINUS;
}
os.write(byteBuf, byteWriteOffset, byteBuf.length - byteWriteOffset);
}
/**
* Please ensure ar.length <= byteBuf.length!
*
* @param ar
* @throws IOException
*/
public void writeByteAr(byte[] ar) throws IOException{
for (int i = 0; i < ar.length; i++) {
byteBuf[i] = ar[i];
}
os.write(byteBuf,0,ar.length);
}
public void writeSpaceBar() throws IOException{
byteBuf[0] = SPACEBAR;
os.write(byteBuf,0,1);
}
}
public static class ByteScanner implements Constants{
InputStream is;
public ByteScanner(InputStream is, int bufSizeInput, int bufSize){
this.is = is;
this.bufSizeInput = bufSizeInput;
this.bufSize = bufSize;
byteBufInput = new byte[this.bufSizeInput];
byteBuf = new byte[this.bufSize];
}
public ByteScanner(byte[] data){
byteBufInput = data;
bufSizeInput = data.length;
bufSize = data.length;
byteBuf = new byte[bufSize];
byteRead = data.length;
bytePos = 0;
}
private int bufSizeInput;
private int bufSize;
byte[] byteBufInput;
byte by=-1;
int byteRead=-1;
int bytePos=-1;
static byte[] byteBuf;
int totalBytes;
boolean eofMet = false;
private byte nextByte() throws IOException{
if (bytePos<0 || bytePos>=byteRead){
byteRead = is==null? -1: is.read(byteBufInput);
bytePos=0;
if (byteRead<0){
byteBufInput[bytePos]=-1;//!!!
if (eofMet)
throw new EofException();
eofMet = true;
}
}
return byteBufInput[bytePos++];
}
/**
* Returns next meaningful character as a byte.<br>
*
* @return
* @throws IOException
*/
public byte nextChar() throws IOException{
while ((by=nextByte())<=0x20);
return by;
}
/**
* Returns next meaningful character OR space as a byte.<br>
*
* @return
* @throws IOException
*/
public byte nextCharOrSpacebar() throws IOException{
while ((by=nextByte())<0x20);
return by;
}
/**
* Reads line.
*
* @return
* @throws IOException
*/
public String nextLine() throws IOException {
readToken((byte)0x20);
return new String(byteBuf,0,totalBytes);
}
public byte[] nextLineAsArray() throws IOException {
readToken((byte)0x20);
byte[] out = new byte[totalBytes];
System.arraycopy(byteBuf, 0, out, 0, totalBytes);
return out;
}
/**
* Reads token. Spacebar is separator char.
*
* @return
* @throws IOException
*/
public String nextToken() throws IOException {
readToken((byte)0x21);
return new String(byteBuf,0,totalBytes);
}
/**
* Spacebar is included as separator char
*
* @throws IOException
*/
private void readToken() throws IOException {
readToken((byte)0x21);
}
private void readToken(byte acceptFrom) throws IOException {
totalBytes = 0;
while ((by=nextByte())<acceptFrom);
byteBuf[totalBytes++] = by;
while ((by=nextByte())>=acceptFrom){
byteBuf[totalBytes++] = by;
}
}
public int nextInt() throws IOException{
readToken();
int num=0, i=0;
boolean sign=false;
if (byteBuf[i]==MINUS){
sign = true;
i++;
}
for (; i<totalBytes; i++){
num*=10;
num+=byteBuf[i]-ZERO;
}
return sign?-num:num;
}
public long nextLong() throws IOException{
readToken();
long num=0;
int i=0;
boolean sign=false;
if (byteBuf[i]==MINUS){
sign = true;
i++;
}
for (; i<totalBytes; i++){
num*=10;
num+=byteBuf[i]-ZERO;
}
return sign?-num:num;
}
/*
//TODO test Unix/Windows formats
public void toNextLine() throws IOException{
while ((ch=nextChar())!='\n');
}
*/
public double nextDouble() throws IOException{
readToken();
char[] token = new char[totalBytes];
for (int i = 0; i < totalBytes; i++) {
token[i] = (char)byteBuf[i];
}
return Double.parseDouble(new String(token));
}
}
public static void main(String[] args) {
new Codeforces_Round80_Div2_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 | par,vis = [],[]
def dfs(u, prev):
if par[u]:
# print ' CCC', u+1
return 1
if vis[u]:
return 0
vis[u] = True
# print ' ', u + 1
r = 0
for v in adj[u]:
if v != prev:
par[u] = True
r += dfs(v, u)
par[u] = False
# print ' --', u+1
return r
n, m = (int(s) for s in raw_input().split())
vis = [False] * n
par = [False] * n
adj = []
for _ in xrange(n):
adj.append([])
for _ in xrange(m):
u, v = (int(s)-1 for s in raw_input().split())
adj[u].append(v)
adj[v].append(u)
x = dfs(0, -1)
for i in xrange(n):
if not vis[i]: x = 0
if x == 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;
int size[205];
int arr[205];
int root(int i) {
while (i != arr[i]) {
arr[i] = arr[arr[i]];
i = arr[i];
}
return i;
}
void unionn(int A, int B) {
int root_A = root(A);
int root_B = root(B);
if (size[root_A] < size[root_B]) {
arr[root_A] = arr[root_B];
size[root_B] += size[root_A];
} else {
arr[root_B] = arr[root_A];
size[root_A] += size[root_B];
}
}
int find(int a, int b) {
if (root(a) == root(b))
return 1;
else
return 0;
}
void initialize() {
for (int i = 0; i < 205; i++) {
arr[i] = i;
size[i] = 1;
}
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int m;
cin >> m;
int x, y;
initialize();
int cycle = 0;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
if (find(x, y)) cycle++;
unionn(x, y);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (root(i) == i) ans++;
}
if (ans > 1 || cycle != 1) {
cout << "NO" << endl;
return 0;
}
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.util.*;
import java.io.*;
public class Problems {
private static boolean marked[] ;
private static int left ,cycled ;
static class Graph {
private ArrayList<Integer> v[] ;
public Graph (int size ){
v = new ArrayList [size] ;
for(int i = 0 ; i < size ; ++i)
v[i] = new ArrayList<Integer>() ;
}
public void connect(int v1 , int v2){
v[v1].add(v2) ;
v[v2].add(v1) ;
}
public ArrayList<Integer> adj(int vIndex){
return v[vIndex] ;
}
}
public static void main(String[] args) throws IOException {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
/*
6 6
6 3
6 4
5 1
2 5
1 4
5 4
*/
int n = in.nextInt() ;
int m =in.nextInt() ;
Graph g = new Graph(n) ;
for(int i = 0 ; i < m ; ++i)
g.connect(in.nextInt()- 1 , in.nextInt()-1);
marked = new boolean[n] ;
left = n ;
detectCycle(g,0 , 0) ;
if(cycled/2.0 !=1)
out.println("NO") ;
else
if(left > 0 )
out.println("NO") ;
else
out.println("FHTAGN!") ;
out.close();
}
public static void detectCycle(Graph g , int workingV , int last) {
marked[workingV] = true ;
left-- ;
for(Integer v : g.adj(workingV)){
if(v == last )
continue ;
if(marked[v]){
cycled++ ;
continue ;
}
detectCycle(g , v , workingV) ;
}
}
}
class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 256000 * 4);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
int p[105], s[105];
int fnd(int a) { return a == p[a] ? a : p[a] = fnd(p[a]); }
void unn(int a, int b) {
a = fnd(a);
b = fnd(b);
if (s[a] < s[b]) swap(a, b);
s[a] += s[b];
p[b] = a;
}
int main() {
int n, m, u, v;
scanf("%d %d", &n, &m);
iota(p, p + n + 1, 0);
fill(s, s + n, 1);
int cc = 0;
for (int i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
if (fnd(u) != fnd(v))
unn(u, v);
else
++cc;
}
if (cc != 1)
puts("NO");
else {
bool c = 0;
for (int i = 1; i <= n; ++i) {
if (p[i] == i)
if (c)
return cout << "NO", 0;
else
c = 1;
}
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 Max = 110;
vector<int> adj[Max];
void init(int n) {
int i;
for (i = 1; i <= n; i++) adj[i].clear();
}
int vis[Max];
int ans;
int s;
void dfs(int i, int lev) {
vis[i] = 1;
int j, len = adj[i].size();
for (j = 0; j < len; j++) {
int v = adj[i][j];
if (v == s) {
if (ans < lev) ans = lev;
}
if (vis[v] == 0) {
dfs(v, lev + 1);
}
}
}
int solve(int n) {
int i;
ans = 0;
s = 1;
memset(vis, 0, sizeof(vis));
dfs(1, 1);
for (i = 1; i <= n; i++) {
if (vis[i] == 0) return 0;
}
if (ans >= 3) return 1;
for (i = 2; i <= n; i++) {
memset(vis, 0, sizeof(vis));
s = i;
dfs(i, 1);
if (ans >= 3) return 1;
}
return 0;
}
int main() {
int n, m;
int go;
while (scanf("%d %d", &n, &m) != EOF) {
init(n);
int a, b;
int tm = m;
while (tm--) {
scanf("%d %d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
if (m != n) {
printf("NO\n");
continue;
}
go = solve(n);
if (go)
printf("FHTAGN!\n");
else
printf("NO\n");
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.*;
import java.io.*;
public class Main {
public static void main(String args[]) throws Exception {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Task solver = new Task();
solver.main(in, out);
out.close();
}
}
class Task {
final int maxn = 411;
boolean[][] g = new boolean[maxn][maxn];
boolean[] vis = new boolean[maxn];
int cnt = 0;
void dfs(int u, int n) {
++cnt;
vis[u] = true;
for (int i = 1; i <= n; ++i) {
if (i != u && g[u][i] && !vis[i]) {
dfs(i, n);
}
}
}
boolean run(int n, int m) {
if (n != m)
return false;
cnt = 0;
dfs(1, n);
return cnt == n;
}
void main(InputReader in, PrintWriter out) throws Exception {
int i, n, m, u, v;
n = in.nextInt();
m = in.nextInt();
for (i = 0; i < m; ++i) {
u = in.nextInt();
v = in.nextInt();
g[u][v] = g[v][u] = true;
}
if (run(n, m))
out.println("FHTAGN!");
else
out.println("NO");
}
}
class InputReader {
BufferedReader reader;
StringTokenizer tokenizer;
InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
String next() {
if (!hasNext())
throw new RuntimeException();
return tokenizer.nextToken();
}
boolean hasNext() {
while (tokenizer == null || !tokenizer.hasMoreTokens())
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (Exception e) {
return false;
}
return true;
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
def unionSet(u,v):
up = findSet(u)
vp = findSet(v)
if up == vp:
return
else:
parent[up] = vp
# cnt[vp] += cnt[up]
def findSet(u):
if parent[u] != u:
parent[u] = findSet(parent[u])
return parent[u]
n,m = map(int,input().split())
if n != m:
print('NO')
exit()
parent = list(range(n+1))
for _ in range(m):
u , v = map(int,input().split())
unionSet(u,v) # O(n)
cnt = 0
for i in range(1,n+1):
if parent[i] == i:
cnt += 1
if cnt > 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 sys
def todos_visitados(list):
return len(list) == sum(list)
def um_componente(vertices, n):
vizinhos = [0]
visitado = [False] * n
while len(vizinhos) != 0:
v = vizinhos.pop()
visitado[v] = True
for u in vertices[v]:
if not visitado[u]:
vizinhos.append(u)
return todos_visitados(visitado)
def main():
n, m = [int(x) for x in input().split()]
vertices = [[] for _ in range(n)]
for _ in range(m):
v, u = [int(x) - 1 for x in input().split()]
vertices[v].append(u)
vertices[u].append(v)
somente_um_ciclo = n == m and um_componente(vertices, n)
print("FHTAGN!") if somente_um_ciclo else print("NO")
if __name__ == '__main__':
main()
def testin1(capsys):
sys.stdin = open("in1")
main()
out, err = capsys.readouterr()
sys.stin = sys.__stdin__
expected = open("in1_expeted").read()
assert out == expected
def testin2(capsys):
sys.stdin = open("in2")
main()
out, err = capsys.readouterr()
sys.stin = sys.__stdin__
expected = open("in2_expeted").read()
assert out == expected
def testin3(capsys):
sys.stdin = open("in3")
main()
out, err = capsys.readouterr()
sys.stin = sys.__stdin__
expected = open("in3_expeted").read()
assert out == expected
def testin4(capsys):
sys.stdin = open("in4")
main()
out, err = capsys.readouterr()
sys.stin = sys.__stdin__
expected = open("in4_expeted").read()
assert out == expected
def testin5(capsys):
sys.stdin = open("in5")
main()
out, err = capsys.readouterr()
sys.stin = sys.__stdin__
expected = open("in5_expeted").read()
assert out == expected
def testin6(capsys):
sys.stdin = open("in6")
main()
out, err = capsys.readouterr()
sys.stin = sys.__stdin__
expected = open("in6_expeted").read()
assert out == expected
#https://stackoverflow.com/questions/26561822/pytest-capsys-checking-output-and-getting-it-reported
#https://stackoverflow.com/questions/35851323/pytest-how-to-test-a-function-with-input-call | PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int g[102][102];
bool used[102];
int n, m, a, b;
bool cycle;
int dfs(int cur, int par = -1) {
used[cur] = true;
int ret = 1;
for (int i = 0; i < n; i++)
if (g[cur][i] && i != par) {
if (!used[i])
ret += dfs(i, cur);
else {
a = cur;
b = i;
cycle = true;
}
}
return ret;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
g[a][b] = g[b][a] = 1;
}
int cnt = dfs(0);
if (cnt != n || !cycle)
cout << "NO\n";
else {
memset(used, false, sizeof(used));
cycle = false;
g[a][b] = g[b][a] = 0;
dfs(0);
if (cycle)
cout << "NO\n";
else
cout << "FHTAGN!\n";
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | /*
The basic idea is to construct the graph
and using dfs to find a cycle in the graph
as at most two edges between two nodes, so
if there is a cycle, it must be equal or bigger than 3
modified
we first check if the nubmer of node equals the number of edges
if not, say no, we can find that if it is a cthulhu, the number of node must equal the number of edges
then choose a node, using dfs to check whether this graph is connected
*/
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
public class Cthulhu {
private static class CNode {
int id;
ArrayList<Integer> adj;
public CNode(int i) {
id = i;
adj = new ArrayList<Integer>();
}
}
static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
static PrintWriter printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
public static void main(String[] args) throws IOException{
String[] inputString = bufferedReader.readLine().split(" ");
int n = Integer.parseInt(inputString[0]);
int m = Integer.parseInt(inputString[1]);
if(n != m) {
printWriter.println("NO");
printWriter.flush();
printWriter.close();
return;
}
HashMap<Integer,CNode> map = new HashMap<Integer,CNode>();
for(int i = 0; i < m; i++) {
inputString = bufferedReader.readLine().split(" ");
int a = Integer.parseInt(inputString[0]);
int b = Integer.parseInt(inputString[1]);
if(!map.containsKey(a)) {
map.put(a,new CNode(a));
}
map.get(a).adj.add(b);
if(!map.containsKey(b)) {
map.put(b,new CNode(b));
}
map.get(b).adj.add(a);
}
HashSet<Integer> visited = new HashSet<Integer>();
findCycle(map, 1, visited);
if(visited.size() == n) {
printWriter.println("FHTAGN!");
} else {
printWriter.println("NO");
}
printWriter.flush();
printWriter.close();
}
public static void findCycle(HashMap<Integer, CNode> map, int root, HashSet<Integer> visited) {
visited.add(root);
CNode cur = map.get(root);
if(cur != null)
for(int i : cur.adj) {
if(!visited.contains(i)) findCycle(map,i,visited);
}
}
}
| 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 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 True
global count_p
count_p -= 1
if ranks[up] > ranks[vp]:
parents[vp] = up
elif ranks[up] < ranks[vp]:
parents[up] = vp
else:
parents[up] = vp
ranks[vp] += 1
return False
n, m = map(int, input().split())
parents = [i for i in range(n)]
ranks = [0 for i in range(n)]
result = False
count_p = n
num_cycle = 0
for i in range(m):
x, y = map(int, input().split())
x -= 1
y -= 1
has_cycle = unionSet(x, y)
if has_cycle:
result = True
num_cycle += 1
# print(num_cycle)
if count_p == 1 and result and num_cycle == 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 | n = raw_input()
ar = n.split()
arr = [ int(s) for s in ar ]
gr = range(arr[0])
pr = range(arr[0])
am = range(arr[0])
for i in range(0,arr[0]):
gr[i] = []
am[i] = 0
pr[i] = -1;
for i in range(0, arr[1]):
n = raw_input()
ar = n.split()
t = [ int(s)-1 for s in ar ]
gr[t[0]].append(t[1])
gr[t[1]].append(t[0])
def rec(now, frm, am, gr):
global pr
for i in gr[now]:
if i == pr[now]:
continue
if i == frm:
continue
am[i] += 1;
pr[i] = now
if am[i] >= 2:
continue
rec(i, now, am, gr)
pr[i] = now
am[0]=1
rec(0, -1, am, gr)
ans = False
meet = False
for s in am:
if s > 2:
ans = False
else:
if s == 2 and meet == False:
meet = True
ans = True
else:
if s == 2 and meet == True:
ans = False
if s == 0:
ans = False
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 | def f():
n, m = map(int, input().split())
t = [[] for i in range(n + 1)]
p = [0] * (n + 1)
for i in range(m):
a, b = map(int, input().split())
t[a].append(b)
t[b].append(a)
p = [a for a in range(1, n + 1) if len(t[a]) == 1]
if any(len(i) == 0 for i in t[1: ]): return 'NO'
while p:
r = []
for a in p:
b = t[a].pop()
t[b].remove(a)
if len(t[b]) == 1: r.append(b)
elif len(t[b]) == 0: return 'NO'
p = r
p = [a for a in range(1, n + 1) if len(t[a]) == 2]
if len(p) < 3: return 'NO'
if any(len(i) > 2 for i in t[1: ]): return 'NO'
s, a = 0, p[0]
while True:
b = t[a].pop()
t[b].remove(a)
a = b
s += 1
if a == p[0]: break
if s != len(p): return 'NO'
return 'FHTAGN!'
print(f()) | PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | def dfs(node):
cnt = 1
visited[node] = True
for adj in graph[node]:
if not visited[adj]:
cnt += dfs(adj)
return cnt
n, m = map(int, input().split())
graph = [[] for _ in range(n+1)]
visited = [False]*(n+1)
if m != n:
print("NO")
else:
for _ in range(m):
a, b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
print("NO" if dfs(1) != n else "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>
const int MaxSize = 1e2 + 5;
using namespace std;
int n, m;
bool Edge[MaxSize][MaxSize];
bool Node[MaxSize];
void DFS(int cur) {
if (Node[cur]) return;
Node[cur] = 1;
for (long long i = 1; i < n + 1; i++)
if (Edge[i][cur]) DFS(i);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
scanf("%d%d", &n, &m);
for (long long i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
Edge[x][y] = Edge[y][x] = 1;
}
DFS(1);
bool Connect = 1;
for (long long j = 2; j < n + 1; j++) Connect &= Node[j];
printf("%s", (Connect & m == n) ? "FHTAGN!" : "NO");
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
list<int> adj[101];
int m, n, x, y, cnt;
bool visited[101];
void dfs(int u) {
visited[u] = true;
++cnt;
for (list<int>::iterator it = adj[u].begin(); it != adj[u].end(); ++it)
if (!visited[*it]) dfs(*it);
}
int main() {
scanf("%d %d\n", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
if (n != m)
puts("NO");
else {
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 | #include <bits/stdc++.h>
using namespace std;
bool was[101];
vector<int> G[101];
void dfs(int u) {
was[u] = true;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (!was[v]) dfs(v);
}
}
int main() {
int n, m;
cin >> n >> m;
bool res = true;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
dfs(n);
for (int i = 1; i <= n; i++)
if (!was[i]) res = false;
if (res && 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 java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner r = new Scanner(System.in);
N = r.nextInt();
M = r.nextInt();
g = new ArrayList[N];
for(int i = 0; i < N; i++)
g[i] = new ArrayList<Integer>();
for(int k = 0; k < M; k++){
int i = r.nextInt() - 1;
int j = r.nextInt() - 1;
g[i].add(j);
g[j].add(i);
}
v = new boolean[N];
int cc = 0;
for(int i = 0; i < N; i++)if(!v[i]){
cc++;
dfs(i);
}
if(cc == 1 && M == N)System.out.println("FHTAGN!");
else System.out.println("NO");
}
private static void dfs(int i) {
v[i] = true;
for(int j : g[i]){
if(v[j])continue;
dfs(j);
}
}
static int N, M;
static ArrayList<Integer>[] g;
static boolean[] v;
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | n, m = [int(i) for i in input().split()]
g = [[] for i in range(n)]
mark = [False] * n
if n is not m:
print("NO")
else:
def dfs(node):
mark[node] = True
for u in g[node]:
if mark[u] is False:
dfs(u)
for i in range(m):
v, u = [int(x)-1 for x in input().split()]
g[v].append(u)
g[u].append(v)
dfs(0)
ans = True
for i in range(1, n):
if mark[i] is False:
ans = False
if ans is True:
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<vector<int> > arr(120);
bool vis[120] = {false};
void dfs(int node) {
if (vis[node]) {
return;
}
vis[node] = true;
for (int i = 0; i < arr[node].size(); i++) {
dfs(arr[node][i]);
}
return;
}
int main() {
int n, m;
cin >> n >> m;
if (n != m) {
cout << "NO";
return 0;
}
for (int i = 0; i < m; i++) {
int from, to;
cin >> from >> to;
arr[from].push_back(to);
arr[to].push_back(from);
}
dfs(1);
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
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 |
def dfs(u):
vis[u]=1
for v in adj[u]:
if vis[v]==0:
dfs(v)
n,m=map(int,input().split())
vis=[0]*n
adj=[[] for w in range(n)]
for i in range (m):
u,v = map(int,input().split())
u-=1
v-=1
adj[u].append(v)
adj[v].append(u)
cnt=0
for i in range(0,n-1):
if vis[i]==0:
dfs(i)
cnt+=1
if cnt==1 and n==m:
print('FHTAGN!')
else:
print('NO')
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m, vis[104];
vector<int> adj[104];
void dfs(int s) {
vis[s] = 1;
for (int v : adj[s]) {
if (!vis[v]) {
dfs(v);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1);
int f = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) f |= 1;
}
if (!f && n == m) {
puts("FHTAGN!");
} else {
puts("NO");
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | def dfs (num,av):
global res; b.add(num)
for v in g[num]:
if v!=av:
if v in b: res += 1; g[v].remove(num)
else:b.add(v); dfs(v,num)
n,m = map (int,input().split())
g,b,res = [[] for _ in range(n)], set(),0
for _ in range(m):
u,v = map(int,input().split())
g[u-1].append(v-1); g[v-1].append(u-1)
dfs(0,0)
if len(b) == n and res == 1: print("FHTAGN!")
else: print("NO") | PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m, cnt = 0;
int dat[105][105];
bool vis[105];
void dfs(int x) {
vis[x] = true;
cnt++;
for (int i = 1; i <= n; i++)
if (!vis[i] && dat[x][i] == 1) dfs(i);
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
dat[x][y] = 1;
dat[y][x] = 1;
}
dfs(1);
if (cnt == n && 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 int N = 110;
int n, m;
int fa[N];
bool ans, ansf = true;
int find(int x) {
if (fa[x] != x) fa[x] = find(fa[x]);
return fa[x];
}
void unionn(int x, int y) { fa[y] = x; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
if (x > y) swap(x, y);
int fx = find(x);
int fy = find(y);
if (fx == fy)
ans = true;
else
unionn(fx, fy);
}
int x = find(1);
for (int i = 2; i <= n; ++i)
if (find(i) != x) {
ansf = false;
break;
}
if (ans && ansf && 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 java.util.Scanner;
public class PrG {
public static void dfs(int k,boolean[]vis,int n,boolean[][]adjmatrix){
vis[k]=true;
for (int i = 1; i <=n; i++) {
if(adjmatrix[i][k]&&!vis[i]){
dfs(i,vis,n,adjmatrix);
}
}
}
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int n=input.nextInt();
int m=input.nextInt();
boolean[][] adjmatrix=new boolean[n+1][n+1];
for (int i = 0; i < m; i++) {
int k=input.nextInt();
int l=input.nextInt();
adjmatrix[k][l]=adjmatrix[l][k]=true;
}
boolean [] visited=new boolean[n+1];
dfs(1,visited,n,adjmatrix);
int found=0;
for (int i = 1; i <=n; i++) {
if(!visited[i]){
found=1;
}
}
if(found==1){
System.out.println("NO");
}
else if(m==n){
System.out.println("FHTAGN!");
}
else{
System.out.println("NO");
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
public class P103B {
public static void main(String[] args) {
Scanner inScanner = new Scanner(System.in);
int n = inScanner.nextInt();
int m = inScanner.nextInt();
Node[] nodes = new Node[n];
for (int i = 0; i < n; i++)
nodes[i] = new Node();
for (int i = 0; i < m; i++) {
Node first = nodes[inScanner.nextInt() - 1];
Node second = nodes[inScanner.nextInt() - 1];
first.neighbors.add(second);
second.neighbors.add(first);
}
Queue<Node> queue = new LinkedList<Node>();
queue.add(nodes[0]);
int cycles = 0;
int seen = 0;
while (!queue.isEmpty()) {
Node current = queue.remove();
if (current.visited)
continue;
seen++;
current.visited = true;
for (Node neighbor : current.neighbors) {
if (neighbor.visited && !neighbor.equals(current.visitedFrom)) {
cycles++;
} else {
neighbor.visitedFrom = current;
queue.add(neighbor);
}
}
}
if (seen != n || cycles != 1)
System.out.println("NO");
else
System.out.println("FHTAGN!");
}
private static class Node {
Set<Node> neighbors;
boolean visited;
Node visitedFrom;
Node() {
neighbors = new HashSet<Node>();
visited = false;
visitedFrom = null;
}
}
}
| 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 char letters[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
const int dx[] = {0, -1, 0, 1, -1, -1, 1, 1};
const int dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
long long inline max3(long long a, long long b, long long c) {
return max(a, max(b, c));
}
long long inline min3(long long a, long long b, long long c) {
return min(a, min(b, c));
}
long long power(long long x, long long p) {
if (p == 0)
return 1;
else if (p % 2 == 0)
return power(1LL * x * x, p / 2);
else
return 1LL * x * power(1LL * x * x, (p - 1) / 2);
}
long long GCD(long long a, long long b) {
if (b == 0) return a;
return GCD(b, a % b);
}
const int N = 150;
int n, m;
vector<vector<int> > G(N);
bool vis[N];
void dfs(int u, int p) {
vis[u] = 1;
for (int i = 0; i < ((int)G[u].size()); ++i) {
if (!vis[G[u][i]]) dfs(G[u][i], u);
}
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0, u, v; i < m; ++i) {
scanf("%d", &u);
scanf("%d", &v);
G[u].push_back(v), G[v].push_back(u);
}
int cnt = 0;
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
++cnt;
if (cnt > 1 || n != m)
return puts("NO");
else
dfs(i, i);
}
}
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 | def dfs(graph, start):
visited[start] = True
for i in graph[start]:
if not visited[i]:
dfs(graph, i)
a, b = list(map(int, input().split(' ')))
g = {}
for i in range(1, a+1):
g[i] = []
for i in range(b):
x, y = map(int, input().split(' '))
g[x].append(y)
g[y].append(x)
visited = [True] + [False] * a
dfs(g, 1)
if False in visited:
print("NO")
quit()
if a != b:
print("NO")
quit()
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;
int const N = 3112;
int const INF = 1e9 + 7;
int n, m;
vector<int> g[N];
int used[N];
int cnt;
void dfs(int v) {
used[v] = true;
for (int c = 0; c < g[v].size(); c++) {
if (!used[g[v][c]]) dfs(g[v][c]);
}
}
int main() {
int x, y;
cin >> n >> m;
if (n != m) {
cout << "NO";
return 0;
}
for (int c = 1; c <= m; c++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1);
for (int c = 1; c <= n; c++) {
if (!used[c]) {
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.util.ArrayList;
import java.util.Stack;
import java.util.StringTokenizer;
public class Solution
{
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = null;
private void solve() throws IOException
{
int n = nextInt();
int m = nextInt();
int a[][] = new int[n + 1][n + 1];
for(int i = 0; i < m; i++)
{
int tmp = nextInt();
int tmp2 = nextInt();
a[tmp][tmp2] = 1;
a[tmp2][tmp] = 1;
}
boolean isV[] = new boolean[n + 1];
int parent[] = new int[n + 1];
int level[] = new int[n + 1];
Stack<Integer> stack = new Stack<Integer>();
stack.push(1);
isV[1] = true;
parent[1] = -1;
level[1] = 1;
int counter = 0;
while(!stack.isEmpty())
{
int tmp = stack.pop();
for(int i = 1; i <= n; i++)
{
if(parent[tmp] != i && a[tmp][i] == 1)
{
if(isV[i])
{
counter++;
}
else
{
stack.push(i);
isV[i] = true;
parent[i] = tmp;
level[i] = level[tmp] + 1;
}
}
}
if(stack.isEmpty())
{
for(int i = 1; i <= n; i++)
{
if(!isV[i])
{
counter = 100;
break;
}
}
}
}
System.out.println(counter == 2 ? "FHTAGN!" : "NO");
}
String nextToken() throws IOException
{
if (st == null || !st.hasMoreTokens())
{
st = new StringTokenizer(bf.readLine());
}
return st.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());
}
public static void main(String args[]) throws IOException
{
new Solution().solve();
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.ArrayList;
import java.util.Scanner;
public class Main {
ArrayList<ArrayList<Integer>>graph ;
boolean[] v ;
int cycles ;
public static void main(String[] args) {
new Main().start();
}
private void start() {
Scanner r = new Scanner(System.in);
int n,m;
while(r.hasNext()){
n = r.nextInt();
m = r.nextInt();
graph = new ArrayList<ArrayList<Integer>>();
for(int i =0 ; i<=n ; i++)
graph.add(new ArrayList<Integer>());
int x,y;
boolean[] used = new boolean[n+1];
while(m--!=0){
x = r.nextInt();
y = r.nextInt();
graph.get( x ).add( y );
graph.get( y ).add( x );
used[x]=true; used[y]=true;
}
cycles = 0 ;
v = new boolean[n+1];
dfs(1,1);
for(int i=0 ; i<=n ; i++)
if(!v[i])
dfs(i,i);
int counter =0;
for(int i=1 ; i<=n ; i++)
if(!used[i])
counter++;
if(cycles==2 && counter==0)
System.out.println("FHTAGN!");
else
System.out.println("NO");
}
}
private void dfs(int index,int u) {
if(v[index]){
cycles++;
return;
}
ArrayList<Integer> a = graph.get(index);
v[index] = true ;
for(int i=0 ; i<a.size() ; i++){
int s = a.get(i);
if(s!=u)
dfs(s,index);
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Cthulhu_B103 {
static ArrayList<Integer>[] adjList;
static boolean[] visited;
static boolean[] recStack;
static void dfs(int u)
{
visited[u]=true;
for(int v:adjList[u])
if(!visited[v])
dfs(v);
}
public static void main(String[] args)throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
StringTokenizer tk = new StringTokenizer(br.readLine());
int n =Integer.parseInt(tk.nextToken());
visited=new boolean [n];
recStack=new boolean[n];
int m=Integer.parseInt(tk.nextToken());
int mm=m;
if(n<3)
{
out.println("NO");
out.flush();
out.close();
return;
}
adjList=new ArrayList[n+1];
for(int i=0;i<=n;i++)adjList[i]=new ArrayList<>();
while(mm-->0)
{
tk = new StringTokenizer(br.readLine());
int from=Integer.parseInt(tk.nextToken())-1;
int to =Integer.parseInt(tk.nextToken())-1;
adjList[from].add(to);
adjList[to].add(from);
}
dfs(0);
boolean flag=true;
for(int i=0;i<n;i++)
if(!visited[i])
flag=false;
if(n==m&&flag)
out.println("FHTAGN!");
else out.println("NO");
out.flush();
out.close();
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
int n, m;
List<List<Integer>> adjList = new ArrayList<>();
int[] visited;
int node1 = -1;
int node2 = -1;
int cnt = 0;
public void solve() throws IOException{
n = in.nextInt();
m = in.nextInt();
visited = new int[n + 1];
for(int i = 0; i <= n; i++){
adjList.add(new ArrayList<>());
}
for(int i = 0; i < m; i++){
int src = in.nextInt();
int dst = in.nextInt();
adjList.get(src).add(dst);
adjList.get(dst).add(src);
}
//for(int i = 1; i < adjList.size(); i++){
// out.print("Node " + i + " has Neighbors :");
// for(int j = 0; j < adjList.get(i).size(); j++){
// out.print(adjList.get(i).get(j) + " ");
// }
// out.println();
//}
findDelete(1, -1);
if(node1 == -1){
out.println("NO");
return;
}
adjList.get(node1).remove(new Integer(node2));
adjList.get(node2).remove(new Integer(node1));
//out.println(node1 + " node " + node2);
//for(int i = 1; i < adjList.size(); i++){
// out.print("Node " + i + " has Neighbors :");
// for(int j = 0; j < adjList.get(i).size(); j++){
// out.print(adjList.get(i).get(j) + " ");
// }
// out.println();
// }
Arrays.fill(visited, 0);
if(dfs(1, -1) && cnt == n){
out.println("FHTAGN!");
}else{
out.println("NO");
}
return;
}
public boolean dfs(int cur, int prev){
if(visited[cur] != 0){
return false;
}
visited[cur] = 1;
cnt++;
List<Integer> nbrs = adjList.get(cur);
boolean flag = true;
for(int nbr: nbrs){
if(nbr != prev){
flag &= dfs(nbr, cur);
}
}
return flag;
}
public void findDelete(int cur, int prev){
//out.println(cur + " " + prev);
if(visited[cur] == 1){
if(node1 == -1){
node1 = cur;
node2 = prev;
}
return;
}
visited[cur] = 1;
List<Integer> nbrs = adjList.get(cur);
for(int nbr: nbrs){
if(visited[nbr] != 2 && nbr != prev){
findDelete(nbr, cur);
}
}
visited[cur] = 2;
return;
}
public BigInteger gcdBigInt(BigInteger a, BigInteger b){
if(a.compareTo(BigInteger.valueOf(0L)) == 0){
return b;
}else{
return gcdBigInt(b.mod(a), a);
}
}
FastScanner in;
PrintWriter out;
static class FastScanner {
BufferedReader br;
StringTokenizer st;
FastScanner(InputStream in) {
br = new BufferedReader(new InputStreamReader(in));
st = null;
}
String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
String nextLine() throws IOException {
if (st == null || !st.hasMoreTokens())
return br.readLine();
StringBuilder result = new StringBuilder(st.nextToken());
while (st.hasMoreTokens()) {
result.append(" ");
result.append(st.nextToken());
}
return result.toString();
}
int nextInt() throws IOException {
return Integer.parseInt(next());
}
long nextLong() throws IOException {
return Long.parseLong(next());
}
double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
void run() throws IOException {
in = new FastScanner(System.in);
out = new PrintWriter(System.out, false);
solve();
out.close();
}
public static void main(String[] args) throws IOException{
new Main().run();
}
public void printArr(int[] arr){
for(int i = 0; i < arr.length; i++){
out.print(arr[i] + " ");
}
out.println();
}
public long gcd(long a, long b){
if(a == 0) return b;
return gcd(b % a, a);
}
public boolean isPrime(long num){
if(num == 0 || num == 1){
return false;
}
for(int i = 2; i * i <= num; i++){
if(num % i == 0){
return false;
}
}
return true;
}
public class Pair<A, B>{
public A x;
public B y;
Pair(A x, B y){
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Pair<?, ?> pair = (Pair<?, ?>) o;
if (!x.equals(pair.x)) return false;
return y.equals(pair.y);
}
@Override
public int hashCode() {
int result = x.hashCode();
result = 31 * result + y.hashCode();
return result;
}
}
class Tuple{
int x; int y; int z;
Tuple(int ix, int iy, int iz){
x = ix;
y = iy;
z = iz;
}
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int N = 511111;
int mm[105][105];
bool vis[1005];
int m, n;
void dfs(int u) {
vis[u] = 1;
for (int i = 1; i <= n; i++) {
if (vis[i] == 0 && mm[u][i] == 1) dfs(i);
}
}
int main() {
while (~scanf("%d%d", &n, &m)) {
int i;
for (i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
mm[u][v] = mm[v][u] = 1;
}
int flag = 0;
memset(vis, 0, sizeof(vis));
dfs(1);
for (int i = 1; i <= n; i++)
if (!vis[i]) flag = 1;
if (flag == 0 && m == n)
cout << "FHTAGN!" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
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 = 0) {
b[v] = 1;
for (int e = 0; e < g[v].size(); ++e) {
if (b[g[v][e]] == 0) {
dfs(g[v][e], v);
}
}
b[v] = 2;
}
bool isConnected(int n) {
dfs(1);
for (int i = 1; i <= n; ++i) {
if (b[i] != 2) return false;
}
return true;
}
int main() {
int n;
int m;
scanf("%d %d", &n, &m);
scanGraph(m);
if (n == m && n > 2 && isConnected(n)) {
printf("FHTAGN!");
} else {
printf("NO");
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.*;
import java.io.*;
public class special {
static int circle = 0;
static void dfs(int i , int[][] edges, int[] visited,int n)
{
if(visited[i]==1){
circle++;
return;
}
visited[i]=1;
for(int j=0;j<n;j++){
if(edges[j][i] == 1) {
edges[i][j]=0;
dfs(j,edges,visited,n);
}
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
if(n!=m)
{
System.out.println("NO");return;
}
int[] visited = new int[n];
int[][] edges = new int[n][n];
for(int i=0;i<m;i++) {
int k1 = sc.nextInt();
int k2 = sc.nextInt();
edges[k1-1][k2-1] = 1;
edges[k2-1][k1-1] = 1;
}
dfs(0,edges,visited,n);
for(int i=0;i<n;i++)
{
if(visited[i]==0)circle=0;
}
if(circle!=1){
System.out.println("NO");return;
}
System.out.println("FHTAGN!");
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class Main {
static int i, j, k, n, m, t, y, x, sum=0;
static long mod = 998244353;
static FastScanner fs = new FastScanner();
static PrintWriter out = new PrintWriter(System.out);
static String str;
static long ans;
static List<Integer>[] graph = new ArrayList[101];
static int[] vis = new int[101];
public static void dfs(int in){
vis[in]=1;
for(int i = 0; i<graph[in].size(); i++){
if(vis[graph[in].get(i)]==0){
dfs(graph[in].get(i));
}
}
}
public static void main(String[] args) {
t = 1;
while (t-- >0){
n = fs.nextInt();
m = fs.nextInt();
for(i=0;i<n+1;i++){
graph[i] = new ArrayList<>();
}
for(i=0;i<m;i++){
x = fs.nextInt();
y = fs.nextInt();
graph[x].add(y);
graph[y].add(x);
}
dfs(1);
int f = 0;
for(i=1;i<=n;i++) {
if (vis[i] == 0)
f = 1;
}
if(m!=n || f==1)
out.print("NO");
else
out.print("FHTAGN!");
}
out.close();
}
static class FastScanner {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
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());
}
}
static class Pair {
int first, second;
public Pair(int first, int second) {
this.first = first;
this.second = second;
}
}
static void ruffleSort(int[] a) {
//ruffle
int n=a.length;
Random r=new Random();
for (int i=0; i<a.length; i++) {
int oi=r.nextInt(n), temp=a[i];
a[i]=a[oi];
a[oi]=temp;
}
//then sort
Arrays.sort(a);
}
static void ruffleSort(long[] a) {
//ruffle
int n=a.length;
Random r=new Random();
for (int i=0; i<a.length; i++) {
int oi=r.nextInt(n); long temp=a[i];
a[i]=a[oi];
a[oi]=temp;
}
//then sort
Arrays.sort(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;
vector<vector<int>> g;
vector<bool> used;
vector<int> cycle;
vector<int> p;
bool find_cycle(int v, int pr) {
p[v] = pr;
used[v] = 1;
for (int i : g[v]) {
if (used[i] && i != pr) {
while (v != i) {
cycle.push_back(v);
if (v == -1) {
for (int i = 0; i < cycle.size(); i++) {
cout << cycle[i] << " ";
}
exit(0);
}
v = p[v];
}
cycle.push_back(i);
return 1;
}
if (!used[i] && find_cycle(i, v)) {
return 1;
}
}
return 0;
}
void dele(int v1, int v2) {
for (int i = 0; i < g[v1].size(); i++) {
if (g[v1][i] == v2) {
g[v1].erase(g[v1].begin() + i);
}
}
for (int i = 0; i < g[v2].size(); i++) {
if (g[v2][i] == v1) {
g[v2].erase(g[v2].begin() + i);
}
}
}
void dfs(int v) {
used[v] = 1;
for (int i : g[v]) {
if (!used[i]) {
dfs(i);
}
}
}
int main() {
int n, m;
cin >> n >> m;
g.resize(n);
p.resize(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
g[--x].push_back(--y);
g[y].push_back(x);
}
used.resize(n, 0);
if (!find_cycle(0, -1) || cycle.size() < 3) {
cout << "NO" << endl;
return 0;
} else {
for (int i = 0; i < cycle.size(); i++) {
dele(cycle[i], cycle[(i + 1) % cycle.size()]);
m--;
}
}
used.assign(n, 0);
bool flag = 0;
for (int i = 0; i < cycle.size(); i++) {
if (used[cycle[i]]) {
cout << "NO" << endl;
return 0;
}
if (find_cycle(cycle[i], -1)) {
cout << "NO" << endl;
return 0;
}
}
for (int i = 0; i < n; i++) {
if (!used[i]) {
cout << "NO" << endl;
return 0;
}
}
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 | #include <bits/stdc++.h>
using namespace std;
const int N = 110;
int p[N];
vector<int> adj[N], roots;
int n, m;
bool vis[N], root[N];
int S = 0, E = 0, cnt = 0;
void store(int u) {
while (1) {
root[u] = 1;
roots.push_back(u);
if (u == E) return;
u = p[u];
}
}
void dfs(int u) {
vis[u] = 1;
for (auto v : adj[u]) {
if (!vis[v]) {
p[v] = u;
dfs(v);
} else if (p[u] != v) {
if (v == S) continue;
S = u, E = v, cnt++;
}
}
}
int main() {
for (int i = 0; i < N; i++) p[i] = 1;
scanf("%d %d", &n, &m);
int u, v;
for (int i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
if (!S || cnt > 1) {
printf("NO\n");
return 0;
}
store(S);
for (int i = 0; i < N; i++) p[i] = 1;
memset(vis, 0, sizeof vis);
S = E = 0;
for (auto R : roots) {
vis[R] = 1;
for (auto v : adj[R]) {
if (root[v]) continue;
p[v] = R;
dfs(v);
if (S) {
printf("NO\n");
return 0;
}
}
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
printf("NO\n");
return 0;
}
printf("FHTAGN!\n");
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int MAX = 1e18, MIN = -1e18, MOD = 1000000007;
void dfs(int s, vector<int> adj[], vector<int>& vis) {
vis[s] = 1;
for (auto i : adj[s])
if (!vis[i]) dfs(i, adj, vis);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, i, u, v, k = 0;
cin >> n >> m;
vector<int> adj[n + 1];
vector<int> vis(n + 1, 0);
for (i = 1; i <= m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, adj, vis);
for (i = 1; i <= n; i++) {
if (!vis[i]) {
k = 1;
break;
}
}
if (k == 1 || n != m)
cout << "NO";
else
cout << "FHTAGN!";
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
void dfs(int v, vector<vector<int>>& g, vector<bool>& used) {
if (!used[v]) {
used[v] = true;
for (auto u : g[v]) dfs(u, g, used);
}
}
int cycle_vertex(int v, vector<vector<int>>& g, vector<bool>& used,
vector<int>& p) {
if (used[v])
return v;
else {
used[v] = true;
for (auto u : g[v])
if (u != p[v]) {
p[u] = v;
int t = cycle_vertex(u, g, used, p);
if (t) return t;
}
return 0;
}
}
bool is_tree(int v, pair<int, int> prev, vector<vector<int>>& g,
vector<bool>& used) {
if (used[v]) return false;
used[v] = true;
for (auto u : g[v])
if (u != prev.first && u != prev.second)
if (!is_tree(u, {v, 0}, g, used)) return false;
return true;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> p(n + 1), cycle;
vector<vector<int>> g(n + 1);
vector<bool> used(n + 1);
for (int i = 0; i < m; ++i) {
int x1, x2;
cin >> x1 >> x2;
g[x1].push_back(x2);
g[x2].push_back(x1);
}
int u = cycle_vertex(1, g, used, p);
used.clear();
used.resize(n + 1);
dfs(1, g, used);
int j = 1;
while (j <= n && used[j]) ++j;
if (j <= n || u == 0) {
cout << "NO";
return 0;
}
used.clear();
used.resize(n + 1);
cycle.push_back(u);
for (u = p[u]; u != cycle[0]; u = p[u]) cycle.push_back(u);
for (auto v : cycle) used[v] = true;
for (int i = 0; i < cycle.size(); ++i) {
used[cycle[i]] = false;
if (!is_tree(cycle[i],
{cycle[(i - 1 + cycle.size()) % cycle.size()],
cycle[(i + 1) % cycle.size()]},
g, used)) {
cout << "NO";
return 0;
}
}
cout << "FHTAGN!";
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
vector<int> a[101];
vector<int> vis(101);
void DFS(int s) {
vis[s] = 1;
for (int i = 0; i < a[s].size(); i++) {
int u = a[s][i];
if (!vis[u]) {
DFS(u);
}
}
}
int main() {
int n, m;
cin >> n >> m;
if (n != m) {
cout << "NO";
return 0;
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
DFS(1);
for (int i = 1; i < n; i++) {
if (!vis[i]) {
cout << "NO";
return 0;
}
}
cout << "FHTAGN!";
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | function trim(s) {
return s.replace(/^\s+|\s+$/gm, '');
}
function tokenize(s) {
return trim(s).split(/\s+/);
}
function tokenizeIntegers(s) {
var tokens = tokenize(s);
for (var i = 0; i < tokens.length; i += 1) {
tokens[i] = parseInt(tokens[i], 10);
};
return tokens;
}
function printValues() {
var parts = [];
for (var i = 0; i < arguments.length; i += 2) {
parts.push(arguments[i]+' = '+arguments[i+1]);
}
print(parts.join(', '));
}
function main() {
var data = tokenizeIntegers(readline()),
n = data[0], m = data[1],
v2v = {};
if (n != m) {
print('NO');
return;
}
function augment(u, v) {
if (v2v[u] === undefined) {
v2v[u] = [v];
} else {
v2v[u].push(v);
}
}
for (var i = 0; i < m; ++i) {
data = tokenizeIntegers(readline());
var x = data[0], y = data[1];
augment(x, y);
augment(y, x);
}
var count = 0,
seen = {};
function visit(u) {
if (seen[u]) {
return;
}
seen[u] = true;
count += 1;
var vs = v2v[u];
if (vs === undefined) {
return;
}
for (var i = 0; i < vs.length; ++i) {
visit(vs[i]);
}
}
visit(1);
print(count == n ? 'FHTAGN!' : 'NO');
}
main();
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.awt.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
public class C {
static LinkedList<Integer>[] edges;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int m = Integer.parseInt(st.nextToken());
int n = Integer.parseInt(st.nextToken());
if(m != n) {
System.out.println("NO");
return;
}
edges = new LinkedList[n];
for(int i = 0; i < n; i++)
edges[i] = new LinkedList<Integer>();
while(m-- > 0) {
st = new StringTokenizer(br.readLine());
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
a--;
b--;
edges[a].add(b);
edges[b].add(a);
}
LinkedList<Integer> q = new LinkedList<Integer>();
q.add(0);
boolean[] visit = new boolean[n];
visit[0] = true;
while(!q.isEmpty()) {
int curr = q.removeFirst();
for(int out: edges[curr]){
if(!visit[out]) {
visit[out] = true;
q.addLast(out);
}
}
}
boolean win = true;
for(boolean b: visit)
if(!b) {
win = false;
break;
}
System.out.println(win ? "FHTAGN!" : "NO");
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int inf = 100010;
const int MOD = 1000000007;
const double pi = acos(-1.0);
int gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
int lcm(int a, int b) { return (a * (b / gcd(a, b))); }
int fx[] = {0, 0, 1, -1};
int fy[] = {-1, 1, 0, 0};
int n, m;
int flg = 0;
int gr[105][105];
int vis[105], dis[105];
void dfs(int u) {
int i;
vis[u] = 1;
for (i = 0; i < n + 1; i++) {
if (gr[u][i] && !vis[i]) {
;
dfs(i);
}
}
}
int main() {
int i = 0, j;
int t, cnt = 0;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> t >> j;
gr[t][j] = gr[j][t] = 1;
}
if (n == m) {
for (i = 1; i < n + 1; i++) {
if (!vis[i]) {
cnt++;
if (cnt > 1) {
flg = 1;
;
break;
}
dfs(i);
}
}
} else {
flg = 1;
};
if (!flg) {
cout << "FHTAGN!";
} else {
cout << "NO";
}
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m;
const int mxN = 1e4;
vector<vector<int> > edges(mxN);
vector<vector<int> > cycles(mxN);
int cyclenumber;
vector<int> color(mxN);
vector<int> mark(mxN);
vector<int> par(mxN);
void dfs(int node, int p) {
if (color[node] == 2) {
return;
}
if (color[node] == 1) {
++cyclenumber;
int curr = p;
mark[curr] = cyclenumber;
while (curr != node) {
curr = par[curr];
mark[curr] = cyclenumber;
}
return;
}
par[node] = p;
color[node] = 1;
for (auto child : edges[node]) {
if (child != par[node]) {
dfs(child, node);
}
}
color[node] = 2;
return;
}
bool helper() {
if (cyclenumber != 1) {
return false;
}
return true;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
edges[u].push_back(v);
edges[v].push_back(u);
}
cyclenumber = 0;
dfs(1, 0);
bool ok = (cyclenumber == 1);
for (int i = 1; i <= n; i++) {
if (color[i] == 0) {
ok = false;
break;
}
}
if (ok) {
cout << "FHTAGN!\n";
return 0;
}
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.*;
public class Main extends PrintWriter {
private final InputStream stream = System.in;
private final byte[] bytes = new byte[IN_BUFF_SIZE];
private int pos = 0;
private int len = -1;
public Main() throws FileNotFoundException {
super(new BufferedOutputStream(System.out, OUT_BUFF_SIZE), false);
}
public static void main(String[] args) {
try {
Main main = new Main();
main.solve();
main.out.flush();
} catch (Exception ex) {
ex.printStackTrace();
}
}
public int read() {
if (pos > len) {
pos = 0;
len = -1;
do {
int c = -1;
try {
c = stream.read();
} catch (IOException ex) {
}
if (c == -1) {
break;
}
len++;
bytes[len] = (byte) c;
} while (len < bytes.length - 1);
}
return pos <= len ? bytes[pos++] : -1;
}
public int readInt() throws IOException {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
if (c == -1) {
throw new IOException("eof");
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
while (!isSpaceChar(c) && c != -1) {
if (c < '0' || c > '9') {
throw new IOException("Nu prea-i numar pe aici.");
}
res = (res << 3) + (res << 1);
res += c - '0';
c = read();
}
return res * sgn;
}
public long readLong() throws IOException {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
if (c == -1) {
throw new IOException("eof");
}
long sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
while (!isSpaceChar(c) && c != -1) {
if (c < '0' || c > '9') {
throw new IOException("Nu prea-i numar pe aici.");
}
res = (res << 3) + (res << 1);
res += c - '0';
c = read();
}
return res * sgn;
}
public String readString() throws IOException {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
while (!isSpaceChar(c) && c != -1) {
res.appendCodePoint(c);
c = read();
}
return res.toString();
}
public boolean isSpaceChar(int c) {
return c <= 32 && c >= 0;
}
/**
* ============================================================================
*/
public static final int IN_BUFF_SIZE = 1024 * 1024;// * 1024; // change accordingly
public static final int OUT_BUFF_SIZE = 1024;// * 1024; // change accordingly
void solve() throws Exception {
int n = readInt();
int m = readInt();
int[][] a = new int[n + 1][10000];
for (int i = 0; i < m; i++) {
int u = readInt();
int v = readInt();
a[u][++a[u][0]] = v;
a[v][++a[v][0]] = u;
}
boolean[] visit = new boolean[n + 1];
int cycles = dfs(a, visit, 1, -1);
for (int i = 1; i <= n; i++) {
if (!visit[i]) {
cycles = 100;
break;
}
}
// println(cycles);
println(cycles == 2 ? "FHTAGN!" : "NO");
}
private int dfs(int[][] a, boolean[] visit, int last, int prev) {
visit[last] = true;
int count = 0;
for (int i = 1; i <= a[last][0]; i++) {
if (a[last][i] == prev) {
continue;
}
if (!visit[a[last][i]]) {
// println(String.format("%d %d -", last, a[last][i]));
count += dfs(a, visit, a[last][i], last);
} else {
// println(String.format("%d %d +", last, a[last][i]));
count++;
}
}
return count;
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<int> v[105];
int vis[105], cunt = 0, par[105];
void graphcheck(int root) {
vis[root] = -1;
for (auto u : v[root]) {
if (!vis[u]) {
par[u] = root;
graphcheck(u);
} else if (vis[u] == -1) {
if (par[root] != u) ++cunt;
}
}
vis[root] = 1;
}
int main() {
ios::sync_with_stdio(0), ios_base::sync_with_stdio(0), cin.tie(0),
cout.tie(0);
;
int n, m, x, y;
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
memset(vis, 0, sizeof(vis));
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (!vis[i]) ++ans, graphcheck(i);
}
if (ans != 1 || cunt != 1)
cout << "NO\n";
else
cout << "FHTAGN!\n";
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.*;
import java.io.*;
public class Main {
// Graph modeled as list of edges
static int[][] graph;
static List<int[]> cycles = new ArrayList<int[]>();
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
int n, m, x, y;
st = new StringTokenizer(br.readLine());
n = Integer.parseInt(st.nextToken());
m = Integer.parseInt(st.nextToken());
graph = new int[2*m][2];
Graph g = new Graph(n);
for (int i = 0; i < m; i++) {
st = new StringTokenizer(br.readLine());
x = Integer.parseInt(st.nextToken());
y = Integer.parseInt(st.nextToken());
graph[i] = new int[]{x,y};
graph[i+m] = new int[]{y,x};
g.addEdge(x-1,y-1);
g.addEdge(y-1,x-1);
}
g.DFS(0);
boolean[] v = g.visited;
if (todosVisitados(v,n) && n == m) {
System.out.println("FHTAGN!");
} else {
System.out.println("NO");
}
}
static boolean todosVisitados(boolean visited[], int n) {
for (int i = 0; i < n; i++) {
if (!visited[i]) return false;
}
return true;
}
}
class Graph
{
private int V; // No. of vertices
// Array of lists for Adjacency List Representation
private LinkedList<Integer> adj[];
public boolean[] visited;
private boolean[] visited2;
public int cycles;
// Constructor
Graph(int v)
{
V = v;
adj = new LinkedList[v];
for (int i=0; i<v; ++i)
adj[i] = new LinkedList();
visited = new boolean[v];
visited2 = new boolean[v];
cycles = 0;
}
//Function to add an edge into the graph
void addEdge(int v, int w)
{
adj[v].add(w); // Add w to v's list.
}
// A function used by DFS
void DFSUtil(int v,boolean visited[])
{
// Mark the current node as visited and print it
visited[v] = true;
// Recur for all the vertices adjacent to this vertex
Iterator<Integer> i = adj[v].listIterator();
while (i.hasNext())
{
int n = i.next();
if (!visited[n])
DFSUtil(n, visited);
}
}
// The function to do DFS traversal. It uses recursive DFSUtil()
void DFS(int v)
{
// Call the recursive helper function to print DFS traversal
DFSUtil(v, visited);
}
/*int isCyclicUtil(int v, boolean visited[], int parent, int cycles)
{
// Mark the current node as visited
visited[v] = true;
Integer i;
//System.out.println(v);
//System.out.println(cycles);
// Recur for all the vertices adjacent to this vertex
Iterator<Integer> it = adj[v].iterator();
while (it.hasNext())
{
i = it.next();
// If an adjacent is not visited, then recur for that
// adjacent
if (!visited[i])
{
cycles += isCyclicUtil(i, visited, v, cycles);
}
// If an adjacent is visited and not parent of current
// vertex, then there is a cycle.
else if (i != parent)
cycles += 1;
}
return cycles;
}
int DFS()
{
for (int i = 0; i < V; i++)
visited[i] = false;
int cycles = 0;
// Call the recursive helper function to detect cycle in
// different DFS trees
for (int u = 0; u < V; u++)
if (!visited[u]) // Don't recur for u if already visited
cycles += isCyclicUtil(u, visited, -1, cycles);
return cycles;
}*/
}
// 1500590502231
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | n, m = map(int, input().split())
if n < 3 or n != m: # minimo 3 vertices para un circulo
print("NO") # todo vertice debe tener un edge
else:
V = []
S = []
for i in range(n+1): #Armado de lista para conexiones de vertices
V.append([])
for j in range(m):
x, y = map(int, input().split())
V[x].append(y) #conexion de x con y
V[y].append(x) #conexion de y con x
def DFS(a):
S.append(a)
for v in V[a]:
if not v in S:
DFS(v)
DFS(1) #hay que comenzar en algun punto
if len(S) == n:
print("FHTAGN!")
else:
print("NO") | PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
public class Contest80_2 {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String[] s = in.readLine().split(" ");
int n = Integer.parseInt(s[0]);
int m = Integer.parseInt(s[1]);
boolean[][] edges = new boolean[n][n];
for (int i = 0; i < m; i++) {
s = in.readLine().split(" ");
int a = Integer.parseInt(s[0]) - 1;
int b = Integer.parseInt(s[1]) - 1;
edges[a][b] = true;
edges[b][a] = true;
}
if (n != m) {
System.out.println("NO");
return;
}
int cycles = 0;
boolean[] vis = new boolean[n];
LinkedList<p> list = new LinkedList<p>();
list.offer(new p(0, 0 , -1));
while (!list.isEmpty()) {
p curr = list.remove();
vis[curr.x] = true;
for (int j = 0; j < n; j++) {
if (edges[curr.x][j]){
if(j!=curr.z && vis[j])
cycles++;
else if(!vis[j])
list.add(new p(j, curr.y + 1 , curr.x));
}
}
}
for (int j = 0; j < vis.length; j++) {
if (!vis[j]) {
System.out.println("NO");
return;
}
}
if (cycles != 2) {
System.out.println("NO");
return;
} else {
System.out.println("FHTAGN!");
}
}
}
class p{
int x;
int y;
int z;
public p(int xx,int yy,int zz){
x=xx;
y=yy;
z=zz;
}
} | JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 |
class UnionFind:
def __init__(self, n):
self.parent = [i for i in range(n)]
self.rank = [0 for i in range(n)]
def union(self, u, v):
up = self.find(u)
vp = self.find(v)
if up == vp:
return
if self.rank[up] == self.rank[vp]:
self.parent[up] = vp
self.rank[vp] += 1
elif self.rank[up] < self.rank[vp]:
self.parent[up] = vp
else:
self.parent[vp] = up
def find(self, u):
if u != self.parent[u]:
self.parent[u] = self.find(self.parent[u])
return self.parent[u]
def main():
n, m = map(int, input().split())
if m != n:
print('NO')
return
uf = UnionFind(n)
for i in range(m):
u, v = map(lambda x: int(x) - 1, input().split())
uf.union(u, v)
counter = 0
for i in range(n):
if i == uf.find(i):
counter += 1
print('FHTAGN!' if counter == 1 else '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 | import java.io.*;
import java.util.*;
public class Cthulhu {
static class Pair<E> {
final E first, second;
Pair(E first, E second) {
this.first = first;
this.second = second;
}
}
static List<Integer> cycle(int size, Map<Integer, List<Integer>> edges) {
Stack<Pair<Integer>> stack = new Stack<>();
stack.push(new Pair<>(1, null));
Map<Integer, Integer> nextNodes = new HashMap<>();
int cycleCount = 0;
int last = -1;
while (!stack.empty()) {
Pair<Integer> pair = stack.pop();
Integer previous = pair.second;
Integer current = pair.first;
if (nextNodes.keySet().contains(current)) {
cycleCount++;
last = current;
} else {
List<Integer> neighbors = edges.get(current);
if (neighbors != null) {
for (Integer neighbor : neighbors) {
if (!neighbor.equals(previous)) {
stack.push(new Pair<>(neighbor, current));
}
}
}
nextNodes.put(current, previous);
}
}
if (nextNodes.keySet().size() < size || cycleCount != 2) {
return Collections.emptyList();
} else {
ArrayList<Integer> result = new ArrayList<>();
Integer current = last;
while (current != null) {
result.add(current);
current = nextNodes.get(current);
}
return result;
}
}
static Map<Integer, List<Integer>> asMap(ArrayList<Pair<Integer>> edges) {
Map<Integer, List<Integer>> result = new HashMap<>();
for (Pair<Integer> edge : edges) {
addEdge(result, edge);
addEdge(result, new Pair<>(edge.second, edge.first));
}
return result;
}
private static void addEdge(Map<Integer, List<Integer>> result, Pair<Integer> edge) {
List<Integer> toNodes = result.get(edge.first);
if (toNodes == null) {
ArrayList<Integer> nodes = new ArrayList<>();
nodes.add(edge.second);
result.put(edge.first, nodes);
} else {
toNodes.add(edge.second);
}
}
static Pair<Integer> readPair(String line) {
String[] strs = line.split(" ");
return new Pair<>(Integer.parseInt(strs[0]), Integer.parseInt(strs[1]));
}
public static void main(String[] args) throws IOException {
InputStream input = System.in; // new FileInputStream("test-data/input.txt");
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
Pair<Integer> pair = readPair(reader.readLine());
int n = pair.first;
int m = pair.second;
ArrayList<Pair<Integer>> edgesAsPairs = new ArrayList<>();
for (int i = 0; i < m; i++) {
edgesAsPairs.add(readPair(reader.readLine()));
}
reader.close();
Map<Integer, List<Integer>> edges = asMap(edgesAsPairs);
List<Integer> cycle = cycle(n, edges);
System.out.println(cycle.size() >= 3 ? "FHTAGN!" : "NO");
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.ArrayList;
import java.util.List;
import java.util.Collections;
import java.util.InputMismatchException;
import java.math.BigInteger;
import java.io.*;
/**
* Generated by Contest helper plug-in
* Actual solution is at the bottom
*/
public class Main {
public static void main(String[] args) {
InputReader in = new StreamInputReader(System.in);
PrintWriter out = new PrintWriter(System.out);
run(in, out);
}
public static void run(InputReader in, PrintWriter out) {
Solver solver = new TaskB();
solver.solve(1, in, out);
Exit.exit(in, out);
}
}
abstract class InputReader {
private boolean finished = false;
public abstract int read();
public int readInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String readString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuffer res = new StringBuffer();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public void setFinished(boolean finished) {
this.finished = finished;
}
public abstract void close();
}
class StreamInputReader extends InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar, numChars;
public StreamInputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public void close() {
try {
stream.close();
} catch (IOException ignored) {
}
}
}
class Exit {
private Exit() {
}
public static void exit(InputReader in, PrintWriter out) {
in.setFinished(true);
in.close();
out.close();
}
}
interface Solver {
public void solve(int testNumber, InputReader in, PrintWriter out);
}
interface IndependentSetSystem {
public boolean join(int first, int second);
public int getSetCount();
public static interface Listener {
public void joined(int joinedRoot, int root);
}
}
class RecursiveIndependentSetSystem implements IndependentSetSystem {
private final int[] color;
private int setCount;
private Listener listener;
public RecursiveIndependentSetSystem(int size) {
color = new int[size];
for (int i = 0; i < size; i++)
color[i] = i;
setCount = size;
}
public RecursiveIndependentSetSystem(RecursiveIndependentSetSystem other) {
color = other.color.clone();
setCount = other.setCount;
}
public boolean join(int first, int second) {
first = get(first);
second = get(second);
if (first == second)
return false;
setCount--;
color[second] = first;
if (listener != null)
listener.joined(second, first);
return true;
}
public int get(int index) {
if (color[index] == index)
return index;
return color[index] = get(color[index]);
}
public int getSetCount() {
return setCount;
}
}
class TaskB implements Solver {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int vertexCount = in.readInt();
int edgeCount = in.readInt();
if (vertexCount != edgeCount) {
out.println("NO");
return;
}
IndependentSetSystem setSystem = new RecursiveIndependentSetSystem(vertexCount);
for (int i = 0; i < edgeCount; i++)
setSystem.join(in.readInt() - 1, in.readInt() - 1);
if (setSystem.getSetCount() == 1)
out.println("FHTAGN!");
else
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 | n , m = map(int,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)
#print(lst)
a = [0]*(n+1)
b = [0]*(n+1)
c = 0
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
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.util.Scanner;
/**
* Created by user on 2017-03-31.
* cycle μ°ΎκΈ°
*/
public class CodeForce103B {
static boolean[][] table = new boolean[101][101];
static boolean[] visit = new boolean[101];
static int n, m, x, y, count = 0;
public static void main(String [] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
for (int i = 0; i < m; i++) {
x = sc.nextInt();
y = sc.nextInt();
table[x][y] = true;
table[y][x] = true;
}
dfs(1);
if ((n == m) && (count == n)) {
System.out.print("FHTAGN!");
}else {
System.out.print("NO");
}
}
public static void dfs(int v) {
visit[v] = true;
count++;
for (int i = 1; i < n + 1; i++) {
if (table[v][i] && !(visit[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.*;
import java.util.*;
public class B {
BufferedReader br;
PrintWriter out;
StringTokenizer st;
boolean eof;
int fnd(int v, int[] p) {
return (v == p[v]) ? v : (p[v] = fnd(p[v], p));
}
boolean uni(int v1, int v2, int[] p) {
v1 = fnd(v1, p);
v2 = fnd(v2, p);
if (v1 != v2) {
p[v1] = v2;
return true;
}
return false;
}
void solve() throws IOException {
int n = nextInt();
int m = nextInt();
if (n < 3 || n != m) {
out.println("NO");
return;
}
int[] p = new int[n];
for (int i = 0; i < n; i++)
p[i] = i;
int cnt = n;
for (int i = 0; i < m; i++) {
int v1 = nextInt() - 1;
int v2 = nextInt() - 1;
if (uni(v1, v2, p))
cnt--;
}
out.println(cnt == 1 ? "FHTAGN!" : "NO");
}
void inp() throws IOException {
br = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
out.close();
}
public static void main(String[] args) throws IOException {
new B().inp();
}
String nextToken() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
eof = true;
return "0";
}
}
return st.nextToken();
}
String nextString() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
eof = true;
return "0";
}
}
return st.nextToken("\n");
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(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;
int cycle = 0;
bool single = true;
struct graph {
vector<int> adj;
bool isBlack;
graph(void) { isBlack = false; }
};
void dfs(graph G[], int index, int CB);
int main(void) {
int n, m;
graph G[106];
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
G[u].adj.push_back(v);
G[v].adj.push_back(u);
}
dfs(G, 1, 0);
for (int i = 1; i <= n; i++) {
if (!G[i].isBlack) {
single = false;
}
}
string ans;
if (cycle == 2 && single)
ans = string("FHTAGN!\n");
else
ans = string("NO\n");
cout << ans;
return 0;
}
void dfs(graph G[], int index, int CB) {
vector<int>& adj = G[index].adj;
int size = adj.size();
G[index].isBlack = true;
for (int i = 0; i < size; i++) {
if (!G[adj[i]].isBlack) {
dfs(G, adj[i], index);
} else if (G[adj[i]].isBlack && adj[i] != CB) {
cycle++;
}
}
return;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.Scanner;
public class Problem80C {
static boolean[][] match;
static boolean[] visited;
static int n;
public static void dfs(int v) {
visited[v] = true;
for (int i = 0; i < n; i++) {
if(match[v][i] && !visited[i]) {
dfs(i);
}
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
int m = sc.nextInt();
if(n!=m) {
System.out.println("NO");
return;
}
visited = new boolean[n];
match = new boolean[n][n];
int x;
int y;
for (int i = 0; i < m; i++) {
x = sc.nextInt()-1;
y = sc.nextInt()-1;
match[x][y] = true;
match[y][x] = true;
}
dfs(0);
for (int i = 0; i < n; i++) {
if(!visited[i]) {
System.out.println("NO");
return;
}
}
System.out.println("FHTAGN!");
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int nro_ciclos = 0;
void DFS(vector<pair<int, vector<int>>> &graph, int a, int b) {
if (graph[a].first == 0) {
graph[a].first = 1;
for (int i = 0; i < graph[a].second.size(); ++i) {
if (graph[graph[a].second[i]].first == 1 && graph[a].second[i] != b)
++nro_ciclos;
DFS(graph, graph[a].second[i], a);
}
graph[a].first = 2;
}
}
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, vector<int>>> graph(n);
int a, b;
for (int i = 0; i < m; ++i) {
cin >> a >> b;
graph[a - 1].first = 0;
graph[a - 1].second.push_back(b - 1);
graph[b - 1].first = 0;
graph[b - 1].second.push_back(a - 1);
}
DFS(graph, 0, -1);
bool tmp = 1;
for (int i = 0; i < n; ++i)
if (graph[i].first != 2) {
tmp = 0;
break;
}
if (nro_ciclos == 1 && tmp)
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.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class Smile {
static Scanner in;
static PrintWriter out;
static int[] used;
static ArrayList<Integer>[] list;
static int count1;
static int count2;
static void dfs(int v, int pr) {
if (used[v] == 2) {
return;
}
if (used[v] == 1) {
count1++;
return;
}
used[v] = 1;
for (int i = 0; i < list[v].size(); i++) {
if (list[v].get(i) != pr)
dfs(list[v].get(i), v);
}
used[v] = 2;
count2++;
return;
}
public static void main(String[] args) {
in = new Scanner(System.in);
out = new PrintWriter(System.out);
int n = in.nextInt();
int m = in.nextInt();
used = new int[n];
Arrays.fill(used, 0);
list = new ArrayList[n];
for (int i = 0; i < n; i++) {
list[i] = new ArrayList();
}
for (int i = 0; i < m; i++) {
int x = in.nextInt() - 1;
int y = in.nextInt() - 1;
list[x].add(y);
list[y].add(x);
}
count1 = 0;
count2 = 0;
dfs(0, 0);
// out.println(count);
if (count1 != 1 || count2 < n) {
out.println("NO");
} else {
out.println("FHTAGN!");
}
out.close();
}
}
| JAVA |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | from __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())
version=2
if version==1:
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!")
else:
n,m=read_int_line()
if n<3 or m!=n:
print("NO")
exit()
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)
vis=set()
def dfs(x):
vis.add(x)
for y in adjs[x]:
if y not in vis:
dfs(y)
dfs(0)
if len(vis)==n:
print("FHTAGN!")
else:
print("NO")
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
using namespace std;
bool color[50000];
int par[50000];
int find(int a) {
if (par[a] == a) return a;
return par[a] = find(par[a]);
}
void Union(int a, int b) {
if (find(a) != find(b)) par[find(b)] = find(a);
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i <= n; i++) par[i] = i;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
Union(x, y);
}
if (n != m) {
cout << "NO" << endl;
return 0;
}
m = find(1);
for (int i = 2; i <= n; i++)
if (find(i) != m) {
cout << "NO" << endl;
return 0;
}
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 | n,m=map(int,input().split())
a=[[] for _ in range(n+1)]
vis=[]
for _ in range(m):
x,y=map(int,input().split())
a[x].append(y)
a[y].append(x)
def dfs(x):
vis.append(x)
for z in a[x]:
if not(z in vis):
dfs(z)
dfs(1)
if n<3 or n!=m or len(vis)!=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;
int maxi = 102;
vector<vector<int>> mat(maxi, vector<int>(maxi, 0));
vector<int> vis(maxi, 0);
int visitados = 0;
void dfs(int v, int n) {
vis[v] = 1;
visitados++;
for (int i = 1; i < n + 1; i++) {
if (vis[i]) {
continue;
} else {
if (mat[v][i]) {
dfs(i, n);
}
}
}
}
int main() {
int n, m;
int a, b;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
mat[a][b] = 1;
mat[b][a] = 1;
}
dfs(1, n);
if (n == m) {
if (n == visitados) {
cout << "FHTAGN!";
} else {
cout << "NO";
}
} else {
cout << "NO";
}
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<vector<int>> adjList;
bool visited[100];
void dfs(int node) {
if (visited[node]) return;
visited[node] = true;
for (int i = 0; i < adjList[node].size(); i++) dfs(adjList[node][i]);
}
int main() {
int nodes, vertices;
cin >> nodes >> vertices;
adjList = vector<vector<int>>(nodes);
for (int i = 0; i < vertices; i++) {
int from, to;
cin >> from >> to;
adjList[from - 1].push_back(to - 1);
adjList[to - 1].push_back(from - 1);
}
if (vertices < nodes) {
cout << "NO";
return 0;
}
dfs(0);
bool found = false;
for (int i = 0; i < nodes; i++)
if (!visited[i]) found = true;
if (!found && nodes == vertices)
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 | from collections import defaultdict
from typing import List, Tuple
def solve(n: int, m: int, adj: List[Tuple[int, int]]) -> str:
visited = [0] * n
graph = defaultdict(list) # type: Dict[int, List[int]]
for u, v in adj:
graph[u - 1].append(v - 1)
graph[v - 1].append(u - 1)
stack = [0]
while stack:
curr_node = stack.pop()
visited[curr_node] = 1
for adj_node in graph[curr_node]:
if not visited[adj_node]:
stack.append(adj_node)
if sum(visited) != n:
return 'NO'
elif n == m:
return 'FHTAGN!'
else:
return 'NO'
n, m = list(map(int, input().split()))
adj = [list(map(int, input().split())) for _ in range(m)]
print(solve(n, m, adj))
| PYTHON3 |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 100;
int n, m;
struct vertex {
int parent;
bool mark;
vector<int> adj;
} v[MAXN];
inline void INPUT() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
v[a].adj.push_back(b);
v[b].adj.push_back(a);
}
}
inline int DFS_VISIT(int u) {
for (int i = 0; i < v[u].adj.size(); i++) {
int x = v[u].adj[i];
if (v[x].mark == 0) {
v[x].mark = 1;
v[x].parent = u;
DFS_VISIT(x);
}
}
}
int main() {
INPUT();
if (n != m) {
cout << "NO" << endl;
return 0;
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (v[i].mark == 0) {
v[i].mark = 1;
v[i].parent = -1;
DFS_VISIT(i);
cnt++;
}
}
if (cnt > 1) {
cout << "NO" << endl;
return 0;
}
cout << "FHTAGN!" << endl;
return 0;
}
| CPP |
103_B. Cthulhu | ...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root. | 2 | 8 | import java.util.LinkedList;
import java.util.Scanner;
public class p103b {
static boolean [] visit;
static LinkedList<Integer>[]q;
public static void dfs(int now) {
if(visit[now])
return;
visit[now] = true;
while(!q[now].isEmpty()) {
dfs(q[now].remove());
}
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
visit = new boolean[n];
q = new LinkedList[n];
for (int i = 0; i < q.length; i++) {
q[i] = new LinkedList<Integer>();
}
for (int i = 0; i < m; i++) {
int a = in.nextInt()-1;
int b = in.nextInt()-1;
q[a].add(b);
q[b].add(a);
}
dfs(0);
for (int i = 0; i < visit.length; i++) {
if(!visit[i]) {
System.out.println("NO");
return;
}
}
if(n == m) {
System.out.println("FHTAGN!");
} else System.out.println("NO");
}
}
| JAVA |
Subsets and Splits