text
stringlengths 291
465k
|
|---|
### Prompt
Please provide a Python3 coded solution to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
import os, sys
from io import BytesIO, IOBase
def main():
n, m, q = rints()
s, t, cum = rstr(), rstr(), [0] * (n + 1)
for i in range(m - 1, n):
ix, cum[i] = m - 1, cum[i] + cum[i - 1]
for j in range(i, i - m, -1):
if s[j] != t[ix]:
break
ix -= 1
else:
cum[i] += 1
for i in range(q):
l, r = rints()
if r - l + 1 >= m:
print(cum[r - 1] - cum[l + m - 3])
else:
print(0)
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
BUFSIZE = 8192
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
rstr = lambda: input().strip()
rstrs = lambda: [str(x) for x in input().split()]
rstr_2d = lambda n: [rstr() for _ in range(n)]
rint = lambda: int(input())
rints = lambda: [int(x) for x in input().split()]
rint_2d = lambda n: [rint() for _ in range(n)]
rints_2d = lambda n: [rints() for _ in range(n)]
ceil1 = lambda a, b: (a + b - 1) // b
if __name__ == '__main__':
main()
``` |
### Prompt
Generate a Python solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python
n,m,q = map(int,raw_input().split())
s=raw_input()
t=raw_input()
"""
#n,m,q = 10,3,1
#s='codeforfor'
#t='for'
n,m,q=15,2, 1
s='abacabadabacaba'
t='ba'
"""
ct=[[0 for i in range(n+m)] for j in range(n+m)]
for i in range(n):
if t==s[i:i+m]:
ct[i][i]=1
for k in range(1,n):
for i in range(n-k):
j=i+k
ct[i][j]=ct[i][j-1]+ct[j][j]
#print ct
for _ in range(q):
x,y = map(int,raw_input().split())
ctx=ct[x-1][y-m]
print ctx
exit()
``` |
### Prompt
Your challenge is to write a python3 solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
#!/usr/bin/env python3
from sys import stdin, stdout
def rint():
return map(int, stdin.readline().split())
#lines = stdin.readlines()
n, m, q = rint()
s = input()
t = input()
occur_in_s =[0]*(n+1)
for i in range(n-1, -1, -1):
if i + m > n:
occur_in_s[i] = occur_in_s[i+1]
continue
if s[i:i+m] == t:
occur_in_s[i] = occur_in_s[i+1] + 1
else:
occur_in_s[i] = occur_in_s[i+1]
for i in range(q):
l, r = rint()
l -= 1
r -= 1
if r - l + 1 < m:
print(0)
else:
print(occur_in_s[l] - occur_in_s[r-m+2])
``` |
### Prompt
In cpp, your task is to solve the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
int pi[1002];
void pi_function(char temp[], int len) {
int k = 0;
for (int q = 2; q < len + 1; q++) {
while (k > 0 && temp[k] != temp[q - 1]) k = pi[k];
if (temp[k] == temp[q - 1]) k++;
pi[q] = k;
}
return;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
char s[n + 2];
scanf("%s", s);
char t[m + 2];
scanf("%s", t);
pi_function(t, m);
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d%d", &l, &r);
int k = 0, ans = 0;
for (int j = l - 1; j < r; j++) {
if (s[j] != t[k]) {
if (k != 0) j--;
k = pi[k];
} else
k++;
if (k == m) ans++;
}
printf("%d\n", ans);
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
string s, t;
cin >> s >> t;
vector<int> v(n);
for (int i = 0; i <= n - m; i++) {
bool flag = 0;
for (int j = 0; j < m; j++) {
if (t[j] != s[i + j]) {
flag = 1;
}
}
if (!flag) {
v[i] = 1;
}
}
for (int i = 1; i < n; i++) {
v[i] += v[i - 1];
}
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
if (r - l + 1 < m) {
cout << 0 << endl;
} else {
if (l == 1) {
cout << v[r - m] << endl;
} else {
cout << v[r - m] - v[l - 2] << endl;
}
}
}
}
``` |
### Prompt
Your challenge is to write a PYTHON3 solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
n,m,q=list(map(int,input().split()))
s=input()
t=input()
ans=[]
counter=0
dec=[]
for i in range(0,n-m+1):
type(i)
if s[i:i+m]==t:
ans.append(1)
else:ans.append(0)
for i in range(q):
start,stop=list(map(int,input().split()))
slice=ans[start-1:stop-m+1]
if stop-start+1<m:
dec.append(0)
continue
dec.append(slice.count(1))
print('\n'.join(map(str,dec)))
``` |
### Prompt
Develop a solution in Python3 to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
def main():
n, m, q = map(int, input().split())
s = input()
t = input()
matrix = [[0 for i in range(n)] for i in range(n)]
for l in range(n):
for r in range(l + m - 1, n):
if s[r - m + 1:r + 1] == t:
matrix[l][r] = matrix[l][r - 1] + 1
else:
matrix[l][r] = matrix[l][r - 1]
for i in range(q):
l, r = map(int, input().split())
print(matrix[l - 1][r - 1])
main()
``` |
### Prompt
Please formulate a java solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
//codeforces_1016_B
//dp version: O(n)
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
import java.math.*;
public class acm {
public static void main(String[] args) throws IOException {
BufferedReader gi = new BufferedReader(new InputStreamReader(System.in));
PrintWriter go = new PrintWriter(System.out);
int[] line = parseArray(gi);
int q = line[2];
int n = line[0];
String s = gi.readLine();
String t = gi.readLine();
int[] occ = new int[n];
int last = s.indexOf(t);
while (last!=-1){
occ[last] = 1;
last = s.indexOf(t,last+1);
}
long ans;
int dp[] = new int[n];
dp[0] = occ[0];
for (int j = 1; j<n;j++){
dp[j] = dp[j-1] + occ[j];
}
for (int i = 0; i < q; i++) {
line = parseArray(gi);
ans = 0;
if (line[1] - line[0]>=t.length()-1){
ans = dp[line[1]-t.length()]-(line[0]-2<0?0:dp[line[0]-2]);
}
go.println(ans);
}
go.close();
}
static int[] parseArray(BufferedReader gi) throws IOException{
String[] line = gi.readLine().split(" ");
int[] ans = new int[line.length];
for (int i = 0; i < line.length; i++) {
ans[i] = Integer.parseInt(line[i]);
}
return ans;
}
}
``` |
### Prompt
Generate a Python3 solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
from bisect import bisect_left, bisect_right
def main():
n, m, q = map(int, input().split(' '))
s = input()
t = input()
ps = []
for i in range(n-m+1):
if t == s[i:i+m]:
ps.append(i)
ans = []
for _ in range(q):
l, r = map(int, input().split(' '))
l, r = l - 1, r - 1
i = bisect_left(ps, l)
j = bisect_right(ps, r - m + 1)
ans.append(max(j - i, 0))
for x in ans:
print(x)
if __name__ == '__main__':
main()
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c = getchar();
int x = 0, f = 1;
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 1e5 + 5;
char s[MAXN], t[MAXN];
int nxt[MAXN], sum[MAXN];
int N, M, Q;
int main() {
N = read();
M = read();
Q = read();
scanf("%s", s + 1);
scanf("%s", t + 1);
int j = 0;
for (int i = 2; i <= M; i++) {
while (j && t[i] != t[j + 1]) j = nxt[j];
if (t[i] == t[j + 1]) j++;
nxt[i] = j;
}
j = 0;
for (int i = 1; i <= N; i++) {
while (j && s[i] != t[j + 1]) j = nxt[j];
if (s[i] == t[j + 1]) j++;
if (j == M) sum[i]++, j = nxt[j];
}
for (int i = 1; i <= N; i++) sum[i] += sum[i - 1];
while (Q--) {
int l = read(), r = read();
l += M - 1;
if (l > r)
puts("0");
else
printf("%d\n", sum[r] - sum[l - 1]);
}
return 0;
}
``` |
### Prompt
Please provide a java coded solution to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.io.*;
import java.util.*;
public class CFB {
BufferedReader br;
PrintWriter out;
StringTokenizer st;
boolean eof;
private static final long MOD = 1000L * 1000L * 1000L + 7;
private static final int[] dx = {0, -1, 0, 1};
private static final int[] dy = {1, 0, -1, 0};
private static final String yes = "Yes";
private static final String no = "No";
void solve() throws IOException {
int n = nextInt();
int m = nextInt();
int q = nextInt();
char[] s = nextString().toCharArray();
char[] t = nextString().toCharArray();
int limit = 100000;
int[] pref = new int[limit];
for (int i = 0; i < n; i++) {
if (i + m - 1 < n) {
boolean flag = true;
for (int j = 0; j < m; j++) {
if (t[j] != s[i + j]) {
flag = false;
break;
}
}
if (flag) {
pref[i + 1] = 1;
}
}
}
for (int i = 1; i < limit; i++) {
pref[i] += pref[i - 1];
}
for (int i = 0; i < q; i++) {
int l = nextInt() - 1;
int r = nextInt() - 1;
//[l, r - (m - 1)]
if (l > r - (m - 1)) {
outln(0);
continue;
}
int cnt = pref[r - (m - 1) + 1] - pref[l];
outln(cnt);
}
}
void shuffle(int[] a) {
int n = a.length;
for(int i = 0; i < n; i++) {
int r = i + (int) (Math.random() * (n - i));
int tmp = a[i];
a[i] = a[r];
a[r] = tmp;
}
}
private void outln(Object o) {
out.println(o);
}
private void out(Object o) {
out.print(o);
}
private void formatPrint(double val) {
outln(String.format("%.9f%n", val));
}
public CFB() 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 CFB();
}
public long[] nextLongArr(int n) throws IOException{
long[] res = new long[n];
for(int i = 0; i < n; i++)
res[i] = nextLong();
return res;
}
public int[] nextIntArr(int n) throws IOException {
int[] res = new int[n];
for(int i = 0; i < n; i++)
res[i] = nextInt();
return res;
}
public String nextToken() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
eof = true;
return null;
}
}
return st.nextToken();
}
public String nextString() {
try {
return br.readLine();
} catch (IOException e) {
eof = true;
return null;
}
}
public int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
public long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
public double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
}
``` |
### Prompt
Please formulate a python3 solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
def coun(s, t):
d = 0
for i in range(len(s) - len(t) + 1):
if s[i:i + len(t)] == t:
d += 1
return(d)
n, m, q = list(map(int, input().split()))
s = input()
t = input()
x = [0]
for j in range(n):
x.append(coun(s[:j + 1], t))
for i in range(q):
l, r = map(int, input().split())
r += 1
if m <= r - l:
print(x[r - 1] - x[max(0, l + m - 2)])
else:
print(0)
``` |
### Prompt
Your task is to create a PYTHON3 solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
M = 10000000007
b = 29
a = ord('a') - 1
n, m, q = map(int, input().split())
s = list(input())
t = list(input())
hs = [0] * (n + 1)
ps = [1] * (n + 1)
for i in range(n):
hs[i + 1] = (hs[i] * b + ord(s[i]) - a) % M
ps[i + 1] = (ps[i] * b) % M
h = 0
for i in range(m):
h = (h * b + ord(t[i]) - a) % M
ans = [0] * (n + 1)
for i in range(n - m + 1):
u = (hs[i + m] - hs[i] * ps[m]) % M
if u == h:
ans[i] = 1
for i in range(1, n):
ans[i] += ans[i - 1]
for i in range(q):
l, r = map(int, input().split())
l -= 1
r -= 1
r -= m - 1
if l > r:
print(0)
else:
print(max(ans[max(r, 0)] - ans[l - 1], 0))
``` |
### Prompt
Please formulate a Python3 solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
n,m,q=map(int,input().split())
s,t,l=input(),input(),[0]*(n+5)
for i in range(n-m+1):
if t==s[i:i+m]:l[i+1]=1
for i in range(1,n + 3):l[i]+=l[i-1]
for i in range(q):
a,b=map(int,input().split())
print(0if int(b-a+1<m)else l[b-m+1]-l[a-1])
``` |
### Prompt
Please create a solution in python3 to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
n,m,q=map(int,input().split())
s=input()
t=input()
check=''
for i in range(n):
if s[i:i+m]==t:
check+='1'
else:
check+='0'
#print(check)
for xx in range(q):
l,r=map(int,input().split())
print(check[l-1:r-m+1].count('1') if (r-l+1)>=m else 0)
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 9;
int n, m, q;
string s, t;
int a[N], b[N];
void check(int i) {
for (int j = 1; j <= m; ++j)
if (t[j] != s[j + i - 1]) return;
a[i + m - 1] = 1;
return;
}
int main() {
cin >> n >> m >> q;
cin >> s;
s = "#" + s;
cin >> t;
t = "@" + t;
for (int i = 1; i <= n - m + 1; ++i) check(i);
for (int i = 1; i <= q; ++i) {
int x, y;
cin >> x >> y;
int res = 0;
for (int j = x + m - 1; j <= y; ++j) res += a[j];
cout << res << '\n';
}
}
``` |
### Prompt
Develop a solution in java to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
public class B {
public static void main(String args[])throws Exception{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer(br.readLine());
StringBuilder sb=new StringBuilder();
int n=Integer.parseInt(st.nextToken());
int m=Integer.parseInt(st.nextToken());
int q=Integer.parseInt(st.nextToken());
String str=br.readLine();
String pattern=br.readLine();
int reset[]=new int[pattern.length()];
int j=-1;
int i=0;
reset[0]=-1;
while(i<reset.length){
while(j>=0 && pattern.charAt(i)!=pattern.charAt(j)){
j=reset[j];
}
j++;
i++;
if(i<reset.length)
reset[i]=j;
}
int Que[][]=new int[q][2];
for( i=0;i<q;i++){
st=new StringTokenizer(br.readLine());
Que[i][0]=Integer.parseInt(st.nextToken());
Que[i][1]=Integer.parseInt(st.nextToken());
}
/*for(int k=0;k<q;k++){
int count=0;
if((Que[k][1]-Que[k][0]+1)<pattern.length()){
sb.append(count+"\n");
//System.out.println(77);
}
else{
i=Que[k][0]-1;
j=0;
int ini=i;
int h=Que[k][1];
while(i<h){
int len=0;
while(i<h && j<pattern.length() && str.charAt(i)==pattern.charAt(j)){
i++;
j++;
len++;
}
if(len==pattern.length()){
if(reset[j-1]>ini)
i=i-1-reset[j-1];
else
i++;
j=0;
count++;
}
else
{
if(reset[j]>ini)
i=i-reset[j];
else
i++;
j=0;
}
}
sb.append(count+"\n");
}
}*/
ArrayList<Integer> lsts=new ArrayList<>();
ArrayList<Integer> lste=new ArrayList<>();
i=0;
j=0;
while(i<str.length()){
int len=0;
int ini=i;
while(i<str.length() && j<pattern.length() && str.charAt(i)==pattern.charAt(j)){
i++;
j++;
len++;
}
if(len==pattern.length()){
lsts.add(ini);
lste.add(ini+pattern.length()-1);
if(reset[j-1]>0)
i=i-1-reset[j-1];
else if(len!=1 && pattern.length()!=1)
i--;
j=0;
}
else
{
if(reset[j]>0 && len>0)
i=i-reset[j];
else if(len==0)
i++;
j=0;
}
}
//System.out.println(lsts);
// System.out.println(lste);
//System.out.println(Collections.binarySearch(lste,15));
for(int k=0;k<q;k++){
int a=Que[k][0]-1;
int b=Que[k][1]-1;
int ind= Collections.binarySearch(lsts,a);
if(ind<0){
ind=Math.abs(ind)-1;
}
int count=0;
for(int h=0;h<lsts.size();h++){
if(lsts.get(h)>=a && lste.get(h)<=b)
count++;
}
sb.append(count+"\n");
}
System.out.println(sb);
}
}
// This algorithm is partially O(N) where we are everytime Computing the the number of occurances So
// the complexity of algorithm will be O( q*N )
// ie More t the NUmber
``` |
### Prompt
Your task is to create a Java solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException{
BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
String[] ss=sc.readLine().split(" ");
int n=Integer.parseInt(ss[0]);
int m=Integer.parseInt(ss[1]);
int q=Integer.parseInt(ss[2]);
char[] s=sc.readLine().toCharArray();
char[] t=sc.readLine().toCharArray();
int[] data=new int[s.length+1];
for(int j=0;j<=s.length-t.length;j++) {
int k;
for(k=0;k<t.length;k++) {
if(t[k]!=s[j+k])
break;
}
if(k==t.length) {
data[j+1]=data[j]+1;
}
else {
data[j+1]=data[j];
}
}
try {
for(int j=s.length-t.length+2;j<s.length+1;j++)
data[j]=data[j-1];
}
catch(ArrayIndexOutOfBoundsException e) {
}
StringBuilder sb=new StringBuilder();
for(int i=0;i<q;i++) {
ss=sc.readLine().split(" ");
int l=Integer.parseInt(ss[0]);
int r=Integer.parseInt(ss[1]);
int res=0;
try{res=data[r-t.length+1]-data[l-1];}
catch(ArrayIndexOutOfBoundsException e) {
}
if(res<0)
res=0;
sb.append(res+"\n");
}
System.out.print(sb);
sc.close();
}
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, t;
cin >> n >> m >> t;
string a, b;
cin >> a >> b;
std::vector<int> v(n, 0);
int cnt = 0;
int p = 1, index = 0, flag = 0;
for (int i = 0; i <= n - m; ++i) v[i + 1] = v[i] + (a.substr(i, m) == b);
while (t--) {
int l, r;
cin >> l >> r;
if (r - l + 1 < m)
cout << "0\n";
else
cout << v[r - m + 1] - v[l - 1] << endl;
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> v[1003];
string text, pat;
vector<int> vv;
int main() {
int n, m, q;
cin >> n >> m >> q;
cin >> text >> pat;
for (int i = 0; i < n; i++) {
int x = 0;
for (int j = 0; j < m; j++) {
if ((j + i) < n && text[j + i] == pat[j]) {
x++;
} else
break;
}
if (x == m) {
vv.push_back(i + 1);
}
}
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
int res = 0;
for (int i = 0; i < vv.size(); i++) {
int st = vv[i];
int en = vv[i] + m - 1;
if (st >= l && en <= r) res++;
}
printf("%d\n", res);
}
return 0;
}
``` |
### Prompt
Your task is to create a Python3 solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
import sys
def get_array(): return list(map(int, sys.stdin.readline().split()))
def get_ints(): return map(int, sys.stdin.readline().split())
def input(): return sys.stdin.readline().strip('\n')
n , m , q = get_ints()
s = input()
p = input()
ans = []
i = 0
count = 0
while True:
si = s.find(p,i)
if si != -1:
ans += [count]*(si-i+1)
count += 1
i = si+1
else:
ans += [count]*(n-i+2)
break
out = []
for i in range(q):
a , b = get_ints()
a -= 1
b -= m-1
out.append(ans[b]-ans[a] if b >= a else 0)
print(*out,sep='\n')
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string a, b;
int n, m, q;
int pos[1005];
int main() {
cin >> n >> m >> q;
cin >> a;
cin >> b;
for (int i = 0; i <= n - m; i++) {
if (a.substr(i, m) == b) {
pos[i] = 1;
}
}
while (q--) {
int x, y, ans = 0;
cin >> x >> y;
for (int i = x - 1; i <= y - m; i++) {
if (pos[i] == 1) ans++;
}
cout << ans << endl;
}
}
``` |
### Prompt
Develop a solution in python3 to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
n,m,q=map(int,input().split())
s=input()
t=input()
st=[]
en=[]
def check(i):
if i>(n-m):
return False
for j in range(i,i+m):
if(s[j]!=t[j-i]):
return False
return True
for i in range(n):
st.append(0)
en.append(0)
for i in range(n):
if(check(i)):
st[i]=1
en[i+m-1]=1
if(i>0):
st[i]+=st[i-1]
en[i]+=en[i-1]
st.insert(0,0)
for i in range(q):
l,r=map(int,input().split())
l-=1
r-=1
#print(st[l])
#print(en[r])
print(max(0,en[r]-st[l]))
``` |
### Prompt
Construct a Java code solution to the problem outlined:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class SegmentOccurences {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] str = sc.nextLine().split(" ");
int n = Integer.parseInt(str[0]);
int m = Integer.parseInt(str[1]);
int q = Integer.parseInt(str[2]);
String s = sc.nextLine();
String t = sc.nextLine();
int[][] qu = new int[q][2];
for (int i = 0; i < q; i++) {
str = sc.nextLine().split(" ");
qu[i][0] = Integer.parseInt(str[0]);
qu[i][1] = Integer.parseInt(str[1]);
}
List<int[]> xx = new ArrayList<>();
int k = 0;
for (int i = 0; i + m <= s.length(); i++) {
String temp = s.substring(i, i + m);
if (temp.equalsIgnoreCase(t)) {
int[] range = new int[2];
range[0] = i + 1;
range[1] = i + t.length();
xx.add(range);
}
}
for (int i = 0; i < q; i++) {
int count = 0;
if (xx.size() == s.length()) {
count = qu[i][1] - qu[i][0] + 1;
} else {
for (int j = 0; j < xx.size(); j++) {
if (xx.get(j)[0] >= qu[i][0] && xx.get(j)[1] <= qu[i][1]) {
count++;
}
if (xx.get(j)[1] > qu[i][1]) {
break;
}
}
}
System.out.println(count);
}
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int n, m, q, l, r, pr[maxn];
bool ok[maxn], flag;
string s, t;
int main() {
cin >> n >> m >> q;
cin >> s >> t;
pr[0] = 0;
for (int i = 0; i < n - m + 1; i++) {
flag = true;
for (int j = 0; j < m; j++)
if (s[i + j] != t[j]) {
flag = false;
break;
}
ok[i] = flag;
pr[i + 1] = pr[i] + ok[i];
}
for (int i = max(0, n - m + 1); i < n; i++) {
pr[i + 1] = pr[i];
}
while (q--) {
cin >> l >> r;
l--, r -= m - 1;
cout << (r >= l ? (pr[r] - pr[l]) : 0) << '\n';
}
return 0;
}
``` |
### Prompt
Please create a solution in python3 to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
import sys
line1 = sys.stdin.readline().strip('\n')
line2 = sys.stdin.readline().strip('\n')
line3 = sys.stdin.readline().strip('\n')
a,b,n = list(map(int, line1.split()))
sum = [0]*(len(line3))
for i in range(len(line2)):
if line2[i:i+len(line3)] == line3:
sum.append(1)
else:
sum.append(0)
for i in range(len(sum)):
if i > 0:
sum[i] = sum[i-1]+sum[i]
for i in range(n):
line2 = sys.stdin.readline().strip('\n')
a,b = list(map(int, line2.split()))
if b-a+1<len(line3):
print(0)
else:
print(sum[b]-sum[a+len(line3)-2])
``` |
### Prompt
Generate a PYTHON3 solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
n, m, q = map(int, input().split())
s = input()
t = input()
flag = [0]*(1007)
prefix = [0]*(1007)
for i in range(n-m+1):
f = 1
for j in range(m):
if s[i+j] != t[j]:
f = 0
flag[i]= f
prefix[i+1]= prefix[i]+flag[i]
for i in range(max(0,n-m+1), n):
prefix[i+1] = prefix[i]
for _ in range(q):
l, r = map(int, input().split())
l -= 1
r -= (m - 1)
print(prefix[r] - prefix[l]) if r >= l else print(0)
``` |
### Prompt
Construct a Python3 code solution to the problem outlined:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
"""
Author : thekushalghosh
Team : CodeDiggers
"""
import sys,math
input = sys.stdin.readline
############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(s[:len(s) - 1])
def invr():
return(map(int,input().split()))
################################################################
############ ---- THE ACTUAL CODE STARTS BELOW ---- ############
t = 1
for tt in range(t):
n,m,qq = invr()
a = insr()
b = insr()
q = [[0] * len(a) for i in range(len(a))]
for i in range(len(a)):
w = [j for j in range(len(a[i:])) if a[i:].startswith(b,j)]
for j in range(len(w)):
w[j] = w[j] + m - 1 + i
w.reverse()
c = 0
for j in range(len(a)):
if w and j == w[-1]:
c = c + 1
w.pop()
q[i][j] = c
for i in range(qq):
l,r = invr()
print(q[l - 1][r - 1])
``` |
### Prompt
Please create a solution in JAVA to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;
/**
* 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;
Scanner in = new Scanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
static class TaskB {
public void solve(int testNumber, Scanner in, PrintWriter out) {
// int n = in.nextInt();
// int m = in.nextInt();
// int q = in.nextInt();
// in.nextLine();
// String s = in.nextLine();
// String t = in.nextLine();
// while (q-- > 0) {
// int li = in.nextInt();
// int ri = in.nextInt();
// int c = 0;
// int idx = 0;
// final String ssub = s.substring(li - 1, ri);
// while ((idx = ssub.indexOf(t, idx)) != -1) {
// ++c;
// idx += t.length();
// }
// out.println(c);
// }
int n = Integer.parseInt(in.next());
int m = Integer.parseInt(in.next());
int q = Integer.parseInt(in.next());
String s = in.next();
String t = in.next();
int[] pr = new int[n + 1];
boolean[] ok = new boolean[n + 1];
pr[0] = 0;
for (int i = 0; i < n - m + 1; i++) {
boolean fl = true;
for (int j = 0; j < m; j++) {
if (s.charAt(i + j) != t.charAt(j)) {
fl = false;
}
}
ok[i] = fl;
pr[i + 1] = pr[i] + (ok[i] ? 1 : 0);
}
for (int i = Math.max(0, n - m + 1); i < n - 1; i++) {
pr[i + 1] = pr[i];
}
for (int i = 0; i < q; i++) {
int l = Integer.parseInt(in.next());
int r = Integer.parseInt(in.next());
--l;
r -= m - 1;
out.println(r >= l ? pr[r] - pr[l] : 0);
}
}
}
}
``` |
### Prompt
Generate a JAVA solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class EducationalRound48B {
public static void main(String[] args) {
// TODO Auto-generated method stub
out=new PrintWriter(new BufferedOutputStream(System.out));
FastReader s=new FastReader();
int n=s.nextInt();
int m=s.nextInt();
int q=s.nextInt();
String main=s.next();
String a=s.next();
boolean[] arr=new boolean[main.length()];
for(int i=0;i<=main.length()-a.length();i++) {
String cstring=main.substring(i, i+a.length());
if(compare(cstring,a)) {
arr[i]=true;
}
}
while(q>0) {
int start =s.nextInt();
int end=s.nextInt();
int count=0;
for(int i=start-1;i<=end-a.length();i++) {
if(arr[i]) {
count++;
}
}
out.println(count);
q--;
}
out.close();
}
public static boolean compare(String s1,String s2) {
for(int i=0;i<s1.length();i++) {
if(s1.charAt(i)!=s2.charAt(i)) {
return false;
}
}
return true;
}
public static PrintWriter out;
public static class FastReader {
BufferedReader br;
StringTokenizer st;
//it reads the data about the specified point and divide the data about it ,it is quite fast
//than using direct
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());//converts string to integer
}
double nextDouble() {
return Double.parseDouble(next());
}
long nextLong() {
return Long.parseLong(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (Exception e) {
e.printStackTrace();
}
return str;
}
}
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
string str1, str2;
int ans[1005];
int main() {
scanf("%d %d %d", &n, &m, &q);
cin >> str1 >> str2;
int f[1005];
str1 = " " + str1;
str2 = " " + str2;
for (int i = 1; i <= n - m + 1; i++) {
f[i] = 1;
for (int j = 0; j < m; j++) {
if (str1[i + j] != str2[j + 1]) {
f[i] = 0;
break;
}
}
ans[i] = ans[i - 1] + f[i];
}
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d %d", &l, &r);
r = r - m + 1;
if (r < l) {
printf("0\n");
continue;
}
printf("%d\n", ans[r] - ans[l - 1]);
}
return 0;
}
``` |
### Prompt
In Java, your task is to solve the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.util.*;
import java.io.*;
public class Main
{
public static void main(String[] args)
{
FastReader reader = new FastReader();
PrintWriter writer = new PrintWriter(System.out);
int n = reader.nextInt();
int m = reader.nextInt();
int q = reader.nextInt();
//sample
char[] s = reader.nextLine().toCharArray();
char[] t = reader.nextLine().toCharArray();
int[] count = new int[n];
for (int i=0; i+m-1<n; i++)
{
boolean check = true;
for (int j=0; j<m; j++)
{
if (s[j+i] != t[j])
check = false;
}
if (check)
count[i]++;
}
for (int i=1; i<n; i++)
count[i] += count[i-1];
while (q > 0)
{
int l = reader.nextInt()-1;
int r = reader.nextInt()-1;
int ans = 0;
if (r-m+1 >= 0)
ans += count[r-m+1];
if (l-1 >= 0)
ans -= count[l-1];
writer.println(Math.max(ans,0));
q--;
}
writer.close();
}
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int desll[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const long long mod = 1e9 + 7;
const int maxn = 1e6 + 7;
const int maxm = 1e8 + 7;
const double eps = 1e-4;
int m, n;
int ar[maxn];
char ch1[maxn], ch2[maxn];
int main() {
scanf("%d", &n);
scanf("%d", &m);
int q;
scanf("%d", &q);
scanf("%s", ch1 + 1);
scanf("%s", ch2 + 1);
memset(ar, 0, sizeof(ar));
for (int i = 1; i <= (n - m + 1); i++) {
int ins = 1;
for (int j = 1; j <= m; j++) {
if (ch1[i + j - 1] != ch2[j]) {
ins = 0;
break;
}
}
ar[i] = ar[i - 1] + ins;
}
for (int i = n - m + 2; i <= n; i++) {
ar[i] = ar[i - 1];
}
while (q--) {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
int ins = ar[b - m + 1] - ar[a - 1];
if (ins < 0) ins = 0;
printf("%d\n", ins);
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
const double EPS = 0.00000001;
const long long mod = 1000000000 + 7;
using namespace std;
string s, t;
int a[2000], sum[2000];
int main() {
cout.sync_with_stdio(0);
int n, m, q;
cin >> n >> m >> q >> s >> t;
for (int i = 0; i < n; i++) {
int is = 1;
for (int j = 0; j < m; j++) {
if (i + j == n || s[i + j] != t[j]) {
is = 0;
break;
}
}
if (is) a[i] = 1;
}
sum[0] = a[0];
for (int i = 1; i < n; i++) sum[i] = a[i] + sum[i - 1];
while (q--) {
int i, j;
cin >> i >> j;
if (j - i + 1 < m) {
cout << 0 << endl;
continue;
}
i--, j--;
cout << max(sum[j - m + 1] - sum[i] + a[i], 0) << endl;
}
return 0;
}
``` |
### Prompt
In JAVA, your task is to solve the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.io.*;
import java.util.*;
public class Mainn {
FastReader scn;
PrintWriter out;
String INPUT = "";
void solve() {
int n = scn.nextInt(), m = scn.nextInt(), q = scn.nextInt(), ind = 0;
String str = scn.next(), s = scn.next();
int[] arr = new int[n], bit = new int[n + 1];
while(str.indexOf(s, ind) != -1) {
ind = str.indexOf(s, ind);
arr[ind++]++;
update(bit, 1, ind);
}
while(q-- > 0) {
int l = scn.nextInt(), r = scn.nextInt();
out.println(Math.max(query(bit, r - m + 1) - query(bit, l - 1), 0));
}
}
void update(int[] bit, int val, int ind) {
while (ind < bit.length) {
bit[ind] += val;
int x = ind & (-ind);
ind += x;
}
}
int query(int[] bit, int ind) {
int rv = 0;
while (ind > 0) {
rv += bit[ind];
ind -= ind & (-ind);
}
return rv;
}
void run() throws Exception {
long time = System.currentTimeMillis();
boolean oj = System.getProperty("ONLINE_JUDGE") != null;
out = new PrintWriter(System.out);
scn = new FastReader(oj);
solve();
out.flush();
if (!oj) {
System.out.println(Arrays.deepToString(new Object[] { System.currentTimeMillis() - time + " ms" }));
}
}
public static void main(String[] args) throws Exception {
new Mainn().run();
}
class FastReader {
InputStream is;
public FastReader(boolean onlineJudge) {
is = onlineJudge ? System.in : new ByteArrayInputStream(INPUT.getBytes());
}
byte[] inbuf = new byte[1024];
public int lenbuf = 0, ptrbuf = 0;
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++];
}
boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
int skip() {
int b;
while ((b = readByte()) != -1 && isSpaceChar(b))
;
return b;
}
double nextDouble() {
return Double.parseDouble(next());
}
char nextChar() {
return (char) skip();
}
String next() {
int b = skip();
StringBuilder sb = new StringBuilder();
while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
char[] next(int n) {
char[] buf = new char[n];
int b = skip(), p = 0;
while (p < n && !(isSpaceChar(b))) {
buf[p++] = (char) b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
char[][] nextMatrix(int n, int m) {
char[][] map = new char[n][];
for (int i = 0; i < n; i++)
map[i] = next(m);
return map;
}
int[] nextArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
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 * 10 + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
long nextLong() {
long num = 0;
int 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 * 10 + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
int[] shuffle(int[] arr) {
Random r = new Random();
for (int i = 1, j; i < arr.length; i++) {
j = r.nextInt(i);
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
}
return arr;
}
}
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
char s1[maxn], s2[maxn];
int nxt[maxn];
int n, m, q;
void getFail(char *P, int *f) {
f[0] = 0;
f[1] = 0;
for (int i = 1; i < m; i++) {
int j = f[i];
while (j && P[i] != P[j]) j = f[j];
f[i + 1] = P[i] == P[j] ? j + 1 : 0;
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
scanf("%s", s1);
scanf("%s", s2);
getFail(s2, nxt);
int l, r;
while (q--) {
scanf("%d%d", &l, &r);
l--;
r--;
int j = 0, cnt = 0;
for (int i = l; i <= r; i++) {
while (j && s2[j] != s1[i]) j = nxt[j];
if (s2[j] == s1[i]) j++;
if (j == m) {
cnt++;
}
}
printf("%d\n", cnt);
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string st, subSt;
int lenSt, lenSubSt, queries;
vector<int> positions;
int main() {
ios::sync_with_stdio(0);
cin >> lenSt >> lenSubSt >> queries;
cin >> st;
cin >> subSt;
bool found;
for (int i = 0; i < lenSt - (lenSubSt - 1); i++) {
found = true;
for (int j = 0; j < lenSubSt; j++) {
if (st[i + j] != subSt[j]) {
found = false;
break;
}
}
if (found) {
positions.push_back(i);
}
}
int l, k;
for (int i = 0; i < queries; i++) {
cin >> l >> k;
auto firstIndex = lower_bound(positions.begin(), positions.end(), l - 1);
auto secondIndex =
upper_bound(positions.begin(), positions.end(), k - lenSubSt);
if (secondIndex - firstIndex < 0) {
cout << 0 << endl;
} else {
cout << secondIndex - firstIndex << endl;
}
}
return 0;
}
``` |
### Prompt
Please provide a python3 coded solution to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
def read():
return int(input())
def readlist():
return list(map(int, input().split()))
def readmap():
return map(int, input().split())
n, m, q = readmap()
S = input()
T = input()
L = []
R = []
for _ in range(q):
l, r = readmap()
L.append(l)
R.append(r)
left = [0] * n
right = [0] * n
for i in range(n-m+1):
if S[i:i+m] == T:
for j in range(i+1, n):
left[j] += 1
for j in range(i+m-1, n):
right[j] += 1
for i in range(q):
l, r = L[i], R[i]
print(max(0, right[r-1] - left[l-1]))
``` |
### Prompt
Generate a Cpp solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int match[1000 + 1];
int psum[1000 + 1];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
string s, t;
cin >> s >> t;
memset(match, false, sizeof match);
for (int i = 0; i + m - 1 < n; i++) {
match[i + 1] = true;
for (int j = 0; j < m; j++) {
match[i + 1] &= s[i + j] == t[j];
}
}
partial_sum(match, match + n + 1, psum);
while (q--) {
int L, R;
cin >> L >> R;
R -= m - 1;
cout << (R >= L ? psum[R] - psum[L - 1] : 0) << '\n';
}
return 0;
}
``` |
### Prompt
Your task is to create a PYTHON3 solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
tmp=input().split()
n=int(tmp[0])
m=int(tmp[1])
q=int(tmp[2])
arr1=[]
arr2=[]
tmp=input()
for i in tmp:
arr1.append(i)
tmp=input()
for i in tmp:
arr2.append(i)
hash=[0 for i in range(n+10)]
for i in range(n-m+1):
if(arr2==arr1[i:i+m:1]):
hash[i+1]=1
for i in range(1,n+2,1):
hash[i]+=hash[i-1]
for i in range(q):
tmp=input().split()
l=int(tmp[0])
r=int(tmp[1])
if(r-l+1<m or m>n):
ans=0
else:
ans=hash[r-m+1]-hash[l-1]
print(ans)
``` |
### Prompt
Please provide a Java coded solution to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.util.*;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Scanner;
import java.util.StringTokenizer;
public class temp {
int lower(ArrayList<Integer> a,int x)
{
int l = 0,r = a.size()-1;
int ans = -1;
while(l<=r)
{
int mid = (l+r)/2;
if(a.get(mid) >= x)
{
ans = mid;
r = mid-1;
}
else
l = mid+1;
}
return ans;
}
int upper(ArrayList<Integer> a,int x)
{
int l=0,r=a.size()-1;
int ans = -1;
while(l<=r)
{
int mid = (l+r)/2;
if(a.get(mid) <= x)
{
ans = mid;
l = mid+1;
}
else
r = mid-1;
}
return ans;
}
void solve() throws IOException
{
FastReader sc=new FastReader();
int n = sc.nextInt();
int m = sc.nextInt();
int q = sc.nextInt();
String s = sc.next();
String p = sc.next();
ArrayList<Integer> a = new ArrayList<>();
for(int i=0;i<=s.length()-p.length();i++)
{
String x = s.substring(i,i+p.length());
if(x.equals(p))
a.add(i);
}
while(q-->0)
{
int l = sc.nextInt()-1;
int r = sc.nextInt()-1;
int idx1 = lower(a,l);
int idx2 = upper(a,r-p.length()+1);
if(idx1!=-1 && idx2!=-1 && idx1 <= idx2)
System.out.println(idx2-idx1+1);
else
System.out.println("0");
}
}
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
new temp().solve();
}
class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
}
``` |
### Prompt
Please formulate a Python3 solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
n, m, q = map(int, input().split())
s = input(); t = input()
dictworks = [0]*n
for start in range(n-m+1):
works = True
for i in range(m):
if s[start+i] != t[i]:
works = False
dictworks[start] = works^0
#print(dictworks)
for tc in range(q):
l, r = map(int, input().split())
if r-m+1 < l:
print(0)
continue
print(sum(dictworks[l-1:r-m+1]))
``` |
### Prompt
Develop a solution in Java to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.FilterInputStream;
import java.io.BufferedInputStream;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Jenish
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
ScanReader in = new ScanReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
BSegmentOccurrences solver = new BSegmentOccurrences();
solver.solve(1, in, out);
out.close();
}
static class BSegmentOccurrences {
public void solve(int testNumber, ScanReader in, PrintWriter out) {
int n = in.scanInt();
int m = in.scanInt();
int q = in.scanInt();
String s = in.scanString();
String t = in.scanString();
int ans[] = new int[n + 1];
for (int i = 0; i < s.length(); i++) {
int u = 0;
while ((u + i) < s.length() && u < t.length()) {
if (t.charAt(u) != s.charAt(u + i)) {
break;
} else {
u++;
}
}
if (u == t.length()) {
ans[i + 1] += 1;
}
}
while (q-- > 0) {
int h = in.scanInt();
int j = in.scanInt();
int an = 0;
for (int i = h; i <= j; i++) {
if ((j - i + 1) >= t.length()) {
an += ans[i];
} else {
break;
}
}
out.println(an);
}
}
}
static class ScanReader {
private byte[] buf = new byte[4 * 1024];
private int INDEX;
private BufferedInputStream in;
private int TOTAL;
public ScanReader(InputStream inputStream) {
in = new BufferedInputStream(inputStream);
}
private int scan() {
if (INDEX >= TOTAL) {
INDEX = 0;
try {
TOTAL = in.read(buf);
} catch (Exception e) {
e.printStackTrace();
}
if (TOTAL <= 0) return -1;
}
return buf[INDEX++];
}
public int scanInt() {
int I = 0;
int n = scan();
while (isWhiteSpace(n)) n = scan();
int neg = 1;
if (n == '-') {
neg = -1;
n = scan();
}
while (!isWhiteSpace(n)) {
if (n >= '0' && n <= '9') {
I *= 10;
I += n - '0';
n = scan();
}
}
return neg * I;
}
public String scanString() {
int c = scan();
while (isWhiteSpace(c)) c = scan();
StringBuilder RESULT = new StringBuilder();
do {
RESULT.appendCodePoint(c);
c = scan();
} while (!isWhiteSpace(c));
return RESULT.toString();
}
private boolean isWhiteSpace(int n) {
if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
else return false;
}
}
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
const int inf = 1000000005;
const long long INF = 3e18;
const double pi = 2 * acos(0.0);
using namespace std;
int gcd(int a, int b) {
a = abs(a);
b = abs(b);
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
int modInverse(int a, int m) {
int m0 = m;
int y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
int q = a / m;
int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
int lcm(int a, int b) {
int temp = gcd(a, b);
return temp ? (a / temp * b) : 0;
}
const int maxn = 1e3 + 10;
int n, m, q;
int tree[4 * maxn], arr[maxn];
void build(int node, int b, int e) {
if (b == e) {
tree[node] = arr[b];
return;
}
int mid = (b + e) / 2;
build(2 * node, b, mid);
build((2 * node) + 1, mid + 1, e);
tree[node] = tree[2 * node] + tree[(2 * node) + 1];
}
int query(int node, int b, int e, int i, int j) {
if (i > e or j < b) return 0;
if (b >= i and j >= e) return tree[node] / m;
int mid = (b + e) / 2;
int p1 = query(2 * node, b, mid, i, j);
int p2 = query((2 * node) + 1, mid + 1, e, i, j);
return p1 + p2;
}
int main() {
cin >> n >> m >> q;
string s, t;
cin >> s >> t;
vector<int> pos;
for (int i = 0; i < s.size(); i++) {
bool check = true;
for (int j = 0; j < t.size(); j++) {
if (s[i + j] != t[j]) {
check = false;
break;
}
}
if (check == true) {
pos.push_back(i + 1);
}
}
build(1, 1, n);
while (q--) {
int x, y;
cin >> x >> y;
int ans = 0;
for (int i = 0; i < pos.size(); i++) {
if (pos[i] >= x and pos[i] + m - 1 <= y) {
ans++;
}
}
cout << ans << endl;
}
}
``` |
### Prompt
In Python, your task is to solve the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python
n,m,q=map(int,raw_input().split())
s=raw_input()
t=raw_input()
lps=[0]*m
i,l=1,0
while(i<m):
if t[i]==t[l]:
l+=1
lps[i]=l
i+=1
else:
if l==0:
lps[i]=0
i+=1
else: l=lps[l-1]
j=0
ans=[0]*n
pre=[0]*(n+1)
i=0
while i<n:
if t[j]==s[i]:
j+=1
i+=1
if j==m:
ans[i-1]=1
j=lps[j-1]
else:
if j==0:
i+=1
else: j=lps[j-1]
pre[0]=0
for i in xrange(1,n+1):
pre[i]=pre[i-1]+ans[i-1]
for i in xrange(q):
l,r=map(int,raw_input().split())
if l+m-1>r:print 0
else: print pre[r]-pre[l+m-2]
``` |
### Prompt
Develop a solution in Java to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.util.*;
public class test
{
/*
private static class IntegerPair implements Comparable
{
public Integer first;
public Integer second;
public IntegerPair(Integer f, Integer s) {
first = f;
second = s;
}
public int compareTo(Object obj)
{
if (!this.first.equals( ((IntegerPair)obj).first) )
{
return first - ((IntegerPair)obj).first;
}
else
{
return second - ((IntegerPair)obj).second;
}
}
}
*/
/*
//Arrays.sort(data, new MyComparator());
//if a<b return -1
//if a>b return 1
//if a==b return 0
private static class MyComparator implements Comparator<Long>
{
@Override
public int compare(Long a, Long b)
{
int a3 = 0;
int b3 = 0;
while(a%3==0)
{
a/=3;
a3++;
}
while(b%3==0)
{
b/=3;
b3++;
}
if(a3>b3)
{
return -1;
}
else if(a3 == b3 && a<b)
{
return -1;
}
return 1;
}
}
*/
private static Scanner sc = new Scanner(System.in);
public static void main(String[] args)
{
int n = sc.nextInt();
int m = sc.nextInt();
int q = sc.nextInt();
sc.nextLine();
String s = sc.nextLine();
String t = sc.nextLine();
int[] answer = new int[1234];
for(int i=0;i<n;i++)
{
if(i+m > n)
{
break;
}
int flag = 1;
for(int j = 0;j<m;j++)
{
if(s.charAt(i+j) != t.charAt(j))flag = 0;
}
if(flag == 1)answer[i]=1;
}
while(q-- > 0)
{
int left = sc.nextInt();
int right = sc.nextInt();
left--;
right--;
right -= (m-1);
int qwe = 0;
for(int i=left;i<=right;i++)qwe+=answer[i];
System.out.println(qwe);
}
}
}
/*
done 1
9 14
10 15
*/
``` |
### Prompt
Develop a solution in JAVA to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
//Author: Patel Rag
//Java version "1.8.0_211"
import java.util.*;
import java.io.*;
public class Main
{
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader(){ br = new BufferedReader(new InputStreamReader(System.in)); }
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong(){ return Long.parseLong(next()); }
double nextDouble(){ return Double.parseDouble(next()); }
float nextFloat() { return Float.parseFloat(next()); }
boolean nextBoolean() { return Boolean.parseBoolean(next()); }
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
static long modExp(long x, long n, long mod) //binary Modular exponentiation
{
long result = 1;
while(n > 0)
{
if(n % 2 == 1)
result = (result%mod * x%mod)%mod;
x = (x%mod * x%mod)%mod;
n=n/2;
}
return result;
}
static long gcd(long a, long b)
{
if(a==0) return b;
return gcd(b%a,a);
}
public static void main(String[] args)
throws IOException
{
FastReader fr = new FastReader();
int n = fr.nextInt();
int m = fr.nextInt();
int q = fr.nextInt();
char[] s = fr.nextLine().toCharArray();
char[] t = fr.nextLine().toCharArray();
int[] pre = new int[n+1];
Arrays.fill(pre,0);
for(int i = 0; i < n - m + 1; i++)
{
int flag = 1;
for(int j = 0; j < m; j++)
{
if(s[i + j] != t[j])
{
flag = 0;
break;
}
}
if(i > 0) pre[i + 1] = pre[i] + flag;
else pre[i + 1] = flag;
}
for(int i = Integer.max(n - m + 1,0); i < n; i++)
{
pre[i + 1] = pre[i];
}
for(int i = 0; i < q; i++)
{
int l = fr.nextInt() - 1;
int r = fr.nextInt() - m + 1;
int ans = 0;
if(r > l)
{
ans = pre[r] - pre[l];
}
System.out.println(ans);
}
}
}
class Pair<U, V> // Pair class
{
public final U first; // first field of a Pair
public final V second; // second field of a Pair
private Pair(U first, V second)
{
this.first = first;
this.second = second;
}
@Override
public boolean equals(Object o)
{
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Pair<?, ?> pair = (Pair<?, ?>) o;
if (!first.equals(pair.first)) return false;
return second.equals(pair.second);
}
@Override
public int hashCode()
{
return 31 * first.hashCode() + second.hashCode();
}
public static <U, V> Pair <U, V> of(U a, V b)
{
return new Pair<>(a, b);
}
}
class myComp implements Comparator<Pair>
{
public int compare(Pair a,Pair b)
{
if(a.first != b.first) return ((int)a.first - (int)b.first);
if(a.second != b.second) return ((int)a.second - (int)b.second);
return 0;
}
}
class BIT //Binary Indexed Tree aka Fenwick Tree
{
public long[] m_array;
public BIT(long[] dat)
{
m_array = new long[dat.length + 1];
Arrays.fill(m_array,0);
for(int i = 0; i < dat.length; i++)
{
m_array[i + 1] = dat[i];
}
for(int i = 1; i < m_array.length; i++)
{
int j = i + (i & -i);
if(j < m_array.length)
{
m_array[j] = m_array[j] + m_array[i];
}
}
}
public final long prefix_query(int i)
{
long result = 0;
for(++i; i > 0; i = i - (i & -i))
{
result = result + m_array[i];
}
return result;
}
public final long range_query(int fro, int to)
{
if(fro == 0)
{
return prefix_query(to);
}
else
{
return (prefix_query(to) - prefix_query(fro - 1));
}
}
public void update(int i, long add)
{
for(++i; i < m_array.length; i = i + (i & -i))
{
m_array[i] = m_array[i] + add;
}
}
}
``` |
### Prompt
Your challenge is to write a Python3 solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
# n=int(input())
# ns=[int(x) for x in input().split()]
# dp=[None]*n
# def greater(i,num):
# return ns[i]+ns[i+1]>=num
# def biSearch(t,l,r):
# if r-l<=1:
# return l
# m=(l+r)//2
# if greater(m,t)
#
#
# def update(t):
# l=ns[t]
n,m,q=[int(x)for x in input().split()]
sn=input()
sm=input()
def eq(i):
for j in range(m):
if sn[i+j]!=sm[j]:
return False
return True
re=[0]*n
for i in range(n-m+1):
if eq(i):
re[i]=1
for i in range(1,n):
re[i]+=re[i-1]
for i in range(q):
l,r=[int(x)-1 for x in input().split()]
if r-l+1<m:
print(0)
continue
if l==0:
print(re[r-m+1])
else:
print(re[r-m+1]-re[l-1])
``` |
### Prompt
Please create a solution in java to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
public class b{
static void solve(){
int n = ni(), m=ni(), q=ni();
String s = ns(), t=ns();
int[] cnt = new int[n];
for(int i=0;i+m<=n;++i){
for(int j=i;j<i+m;++j){
if(s.charAt(j)!=t.charAt(j-i))break;
if(j==i+m-1)cnt[i]++;
}
}
for(int i=1;i<n;++i)cnt[i]+=cnt[i-1];
while(q-->0){
int l=ni()-1, r=ni()-1;
if(r-l+1<m)out.println(0);
else out.println((r-m+1>=0 ? cnt[r-m+1]:0) - (l-1>=0 ? cnt[l-1]:0));
}
}
public static void main(String[] args){
solve();
out.flush();
}
private static InputStream in = System.in;
private static PrintWriter out = new PrintWriter(System.out);
private static final byte[] buffer = new byte[1<<15];
private static int ptr = 0;
private static int buflen = 0;
private static boolean hasNextByte(){
if(ptr<buflen)return true;
ptr = 0;
try{
buflen = in.read(buffer);
} catch (IOException e){
e.printStackTrace();
}
return buflen>0;
}
private static int readByte(){ if(hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isSpaceChar(int c){ return !(33<=c && c<=126);}
private static int skip(){int res; while((res=readByte())!=-1 && isSpaceChar(res)); return res;}
private static double nd(){ return Double.parseDouble(ns()); }
private static char nc(){ return (char)skip(); }
private static String ns(){
StringBuilder sb = new StringBuilder();
for(int b=skip();!isSpaceChar(b);b=readByte())sb.append((char)b);
return sb.toString();
}
private static int[] nia(int n){
int[] res = new int[n];
for(int i=0;i<n;++i)res[i]=ni();
return res;
}
private static long[] nla(int n){
long[] res = new long[n];
for(int i=0;i<n;++i)res[i]=nl();
return res;
}
private static int ni(){
int res=0,b;
boolean minus=false;
while((b=readByte())!=-1 && !((b>='0'&&b<='9') || b=='-'));
if(b=='-'){
minus=true;
b=readByte();
}
for(;'0'<=b&&b<='9';b=readByte())res=res*10+(b-'0');
return minus ? -res:res;
}
private static long nl(){
long res=0,b;
boolean minus=false;
while((b=readByte())!=-1 && !((b>='0'&&b<='9') || b=='-'));
if(b=='-'){
minus=true;
b=readByte();
}
for(;'0'<=b&&b<='9';b=readByte())res=res*10+(b-'0');
return minus ? -res:res;
}
}
``` |
### Prompt
Create a solution in CPP for the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
int n, m, q, l, r, f[1010] = {0};
cin >> n >> m >> q;
cin >> s >> t;
for (int i = 0; i < n; i++) {
if (s.substr(i, m) == t) f[i] = 1;
}
for (int T = 0; T < q; T++) {
cin >> l >> r;
int c = 0;
for (int i = l - 1; i <= (r - m); i++) {
if (f[i] == 1) {
c++;
}
}
cout << c << endl;
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int precision = 16;
const int modulo = 1000000007;
using ll = long long;
const double EPS = 1e-9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(precision);
cout.setf(ios_base::fixed);
int n, m, q;
cin >> n >> m >> q;
string s, t;
cin >> s >> t;
vector<int> ocurr(n, 0);
for (auto i = 0; i < n; ++i) {
ocurr[i] = (i - 1) >= 0 ? ocurr[i - 1] : 0;
if ((i - m + 1) < 0) continue;
if (s.substr(i - m + 1, m) == t) {
ocurr[i]++;
}
}
while (q--) {
int l, r;
cin >> l >> r;
l--;
r--;
if (l > r or l < 0 or r < 0) {
cout << 0 << "\n";
continue;
}
if ((r - l + 1) < m) {
cout << 0 << "\n";
continue;
}
int ret = ocurr[r];
if ((l + m - 2) < n and (l + m - 2) >= 0) ret -= ocurr[l + m - 2];
cout << ret << "\n";
}
return 0;
}
``` |
### Prompt
Your task is to create a java solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.util.Scanner;
public class B {
public static void main(String args[])
{
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int m=scan.nextInt();
int q=scan.nextInt();
String s=scan.next();
String t=scan.next();
boolean sad[]=new boolean[n];
int dp[]=new int[n+1];
for(int i=0;i<(n-m+1);i++){
boolean lul=true;
for(int j=0;j<m;j++)
{
if(s.charAt(i+j)!=t.charAt(j))lul=false;
sad[i]=lul;
if(sad[i]){
dp[i+1]=dp[i]+1;
}else{
dp[i+1]=dp[i];
}
}
}
for(int i=Math.max(0,(n-m+1));i<n;i++)
{
dp[i+1]=dp[i];
}
for(int i=0;i<q;i++)
{
int x=scan.nextInt();
int l=scan.nextInt();
--x;l-=m-1;
System.out.println((l>=x)?dp[l]-dp[x]:0);
}
}
}
``` |
### Prompt
Please create a solution in java to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
//package codeforces.div2;
import java.util.Scanner;
public class SegmentOccurrences {
int dp[];
public void compute(String s, String y) {
dp = new int[s.length() + 1];
for(int i = 1; i <=s.length(); i++) {
String sub = "";
if((i-y.length())>=0) {
sub = s.substring(i-y.length(),i);
}
if (sub.equals(y)) {
dp[i] = dp[i-1] + 1;
} else {
dp[i] = dp[i-1];
}
}
}
public void print(int x, int y, String p) {
int a = x;
int b = y;
if((y-x+1) < p.length()) {
System.out.println(0);
} else {
System.out.println(dp[b] - dp[a]);
}
}
public static void main(String []args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m=sc.nextInt();
int q=sc.nextInt();
int counter=0;
int index=0;
boolean match=true;
String s1=sc.next();
String s2=sc.next();
int[] occ=new int[n+1];
for(int i=0;i<n-m+1;i++){
if(s1.charAt(i)==s2.charAt(0)){
index=i+1;
for(int j=1;j<m;j++){
if(s1.charAt(index)!=s2.charAt(j)){
match=false;
break;
}
index++;
}
if(match){
occ[index]=1;
}
match=true;
}
}
for( int i = 1; i < n+1; ++i ){
occ[i] = occ[i-1] + occ[i];
}
for(int i=0;i<q;i++){
int first=sc.nextInt();
int second=sc.nextInt();
first=first+s2.length()-1;
int left=first-1;
if(left<0||left>s1.length()||s2.length()>s1.length()){
System.out.println(0);
}
else{
System.out.println(Math.max(0, occ[second]-occ[first-1]));
}
}
}
}
``` |
### Prompt
Develop a solution in java to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.util.*;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int q=sc.nextInt();
int flag[]=new int[1050];
String str1=sc.next();
String str2=sc.next();
for(int i=0; i<=n-m; i++) {
if(str1.substring(i, i+m).equals(str2)) {
flag[i]=1;
}
}
while(q-->0) {
int a=sc.nextInt();
int b=sc.nextInt();
int count=0;
for(int j=a-1;j<=b-m;j++) {
if(flag[j]==1) {
count++;
}
}
System.out.println(count);
}
}
}
``` |
### Prompt
Please provide a Python3 coded solution to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
from collections import defaultdict
from math import sqrt,factorial,gcd,log2,inf,ceil
# map(int,input().split())
n,m,q = map(int,input().split())
pref = [0]*(n+1)
s = input()
s1 = input()
for i in range(n):
z = s[i:i+m]
if z == s1:
pref[i+1] = 1
# print(pref)
for i in range(q):
a,b = map(int,input().split())
b-=m
b+=1
if a<=b:
print(sum(pref[a:b+1]))
else:
print(0)
``` |
### Prompt
Please formulate a PYTHON3 solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
from sys import stdin, stdout
n,m,q=map(int,input().split())
s=input()
t=input()
x=0
dp1=[]
while x<n:
if s[x-m+1:x+1]==t:
dp1.append(1)
else:
dp1.append(0)
x+=1
dp=[[0 for i in range(n)] for j in range(n)]
for i in range(n):
acum=0
for j in range(i,n):
if dp1[j]!=0 and j-m+1>=i:
acum+=dp1[j]
dp[i][j]=acum
ans=""
for i in range(q):
l,r=map(int,input().split())
ans+=str(dp[l-1][r-1])+chr(10)
stdout.write(ans)
``` |
### Prompt
Your task is to create a Java solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.util.*;
public class Main {
static int n, m, q, a, b;
static char[] uno, dos;
static int sum[];
static String buffer;
public static void main(String[] args) {
Scanner l = new Scanner(System.in);
n = l.nextInt();
m = l.nextInt();
q = l.nextInt();
buffer = l.next();
uno = new char[100005];
for (int i = 1; i <= n; i++) {
uno[i] = buffer.charAt(i - 1);
}
dos = new char[100005];
buffer = l.next();
for (int i = 1; i <= m; i++) {
dos[i] = buffer.charAt(i - 1);
}
sum = new int[100005];
for (int i = 1; i <= n; i++) {
int good = 1;
for (int j = 1; j <= m; j++) {
if (uno[i + j - 1] != dos[j]) {
good = 0;
}
}
sum[i] = sum[i - 1] + good;
}
while (q-- > 0) {
a = l.nextInt();
b = l.nextInt();
b = Math.max(a - 1, b - m + 1);
System.out.println(sum[b] - sum[a - 1]);
}
}
}
``` |
### Prompt
Develop a solution in Python3 to the problem described below:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
n,m,q = map(int,input().split())
s = input()
t = input()
len_t = len(t)
len_s = len(s)
ans = ''
for i in range(len_s):
if(s[i:len_t+i] == t):
ans += '1'
else:
ans += '0'
for i in range(q):
l,r = map(int,input().split())
r-=len_t
l-=1
r+=1
r=max(0,r)
l = max(0,l)
if(r>l):
print(ans[l:r].count('1'))
else:
print(0)
``` |
### Prompt
Your task is to create a PYTHON3 solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```python3
import sys
import itertools
input = sys.stdin.readline
def main():
N, M, Q = [int(x) for x in input().split()]
S = input().strip()
T = input().strip()
LR = [[int(x) for x in input().split()] for _ in range(Q)]
ans = [0] * (N + 1)
for i in range(N):
if S[i:i + M] == T:
ans[i + M] = 1
ansaccu = list(itertools.accumulate(ans))
for l, r in LR:
if r - l + 1 < M:
print(0)
else:
if M == 1:
print(ansaccu[r] - ansaccu[l - 1])
else:
print(ansaccu[r] - ansaccu[max(0, l + M - 2)])
if __name__ == '__main__':
main()
``` |
### Prompt
Your task is to create a java solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```java
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
public class Main {
static int[] z_function (String s) {
int n = (int) s.length();
int[] z = new int[n];
for (int i=1, l=0, r=0; i<n; ++i) {
if (i <= r)
z[i] = Math.min(r-i+1, z[i-l]);
while (i+z[i] < n && s.charAt(z[i]) == s.charAt(i+z[i]))
++z[i];
if (i+z[i]-1 > r) {
l = i;
r = i + z[i] - 1;
}
}
return z;
}
public static void main(String[] args) throws IOException {
FastScanner in = new FastScanner(System.in);
FastPrinter out = new FastPrinter(System.out);
//FastScanner in = new FastScanner(new InputStreamReader(new FileInputStream(new File("mars.in"))));
//FastPrinter out = new FastPrinter(new OutputStreamWriter(new FileOutputStream(new File("mars.out"))));
int n = in.nextInt(), m = in.nextInt(), q = in.nextInt();
String s1 = in.next();
String s2 = in.next();
int[] zF = z_function(s2 + "^" + s1);
for(int i = 0; i < q; i++){
int a = in.nextInt(), b = in.nextInt();
int ans = 0;
for(int j = a; j <= b; j++){
if (zF[s2.length() + j] <= (b - j + 1) && zF[s2.length() + j] != 0 && zF[s2.length() + j] >= s2.length()){
ans++;
}
}
System.out.println(ans);
}
System.out.close();
}
}
class FastPrinter {
private final PrintWriter writer;
public FastPrinter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public FastPrinter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void close() {
writer.close();
}
public void println(long i) {
writer.println(i);
}
public void println(double d) {
writer.println(d);
}
public void println(String s) {
writer.println(s);
}
public void println(String format, Object... args) {
println(String.format(format, args));
}
public void println() {
writer.println();
}
public void print(long i) {
writer.print(i);
}
public void print(char c) {
writer.print(c);
}
public void print(double d) {
writer.print(d);
}
public void print(String s) {
writer.print(s);
}
public void print(String format, Object... args) {
print(String.format(format, args));
}
public void flush() {
writer.flush();
}
}
class FastScanner {
private BufferedReader reader;
private StringTokenizer st;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public FastScanner(InputStream stream) {
this.reader = new BufferedReader(new InputStreamReader(stream));
this.st = new StringTokenizer("");
}
public FastScanner(InputStreamReader stream) {
this.reader = new BufferedReader(stream);
this.st = new StringTokenizer("");
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String next() {
while (!st.hasMoreTokens()) {
st = new StringTokenizer(readLine());
}
return st.nextToken();
}
public String nextLine() {
st = new StringTokenizer("");
return readLine();
}
public String tryNextLine() {
st = new StringTokenizer("");
return tryReadLine();
}
private String readLine() {
String line = tryReadLine();
if (line == null) throw new InputMismatchException();
return line;
}
private String tryReadLine() {
try {
return reader.readLine();
} catch (IOException e) {
throw new InputMismatchException();
}
}
public int[] nextIntArray(int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++)
array[i] = nextInt();
return array;
}
public int[][] nextIntTable(int rowCount, int columnCount) {
int[][] table = new int[rowCount][];
for (int i = 0; i < rowCount; i++)
table[i] = nextIntArray(columnCount);
return table;
}
public long[] nextLongArray(int size) {
long[] array = new long[size];
for (int i = 0; i < size; i++)
array[i] = nextLong();
return array;
}
public long[][] nextLongTable(int rowCount, int columnCount) {
long[][] table = new long[rowCount][];
for (int i = 0; i < rowCount; i++)
table[i] = nextLongArray(columnCount);
return table;
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\t' || isEOL(c);
}
public static boolean isEOL(int c) {
return c == '\n' || c == '\r' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> v[102];
bool par[102][102];
bool vis[102];
int cyc = 0;
void dfs(int nd, int p) {
vis[nd] = true;
int z = v[nd].size();
int nx;
for (int i = 0; i < z; i++) {
nx = v[nd][i];
if (vis[nx]) {
if (nx != p && p != 0) {
if (par[nx][nd] || par[nd][nx]) continue;
par[nx][nd] = par[nd][nx] = true;
cyc++;
}
} else
dfs(nx, nd);
}
return;
}
int main() {
int n, m;
cin >> n >> m;
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, 0);
bool complete = true;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
complete = false;
}
}
if (cyc == 1 && complete) {
cout << "FHTAGN!";
} else
cout << "NO";
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long maxx = 1e6 + 5;
bool dd[maxx], check, d1[maxx];
long long tr[maxx], val[maxx];
long long b, n, m, k, q, a[maxx], c, f[maxx], x, y, tong = 0;
long long bs(long long v) {
long long l1 = 1, h1 = n, m1;
while (l1 <= h1) {
m1 = (l1 + h1) / 2;
if (a[m1] <= v)
l1 = m1 + 1;
else
h1 = m1 - 1;
}
return h1;
}
vector<long long> st[maxx];
void dfs(long long v) {
dd[v] = false;
for (long long u : st[v]) {
if (dd[u]) {
++k;
dfs(u);
}
}
}
void cf() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
st[x].push_back(y);
st[y].push_back(x);
}
fill_n(dd, maxx, true);
k = 1;
dfs(1);
if (k != n || m != n)
cout << "NO";
else
cout << "FHTAGN!";
}
long long uoc(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
bool prime(long long v) {
if (v < 2) return false;
for (int i = 2; i <= v / i; i++) {
if (v % i == 0) return false;
}
return true;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cf();
}
``` |
### Prompt
Please provide a java coded solution to the problem described below:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```java
//package algoEx;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Stack;
public class Cthulhu {
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
// int t = sc.nextInt();
// for(int tc=0;tc<t;tc++)
// {
int n = sc.nextInt();
int m = sc.nextInt();
int a[][] = new int[n][n];
for(int i=0;i<m;i++)
{
int from = sc.nextInt()-1;
int to = sc.nextInt()-1;
a[from][to] = 1;
a[to][from] = 1;
}
boolean b[] = new boolean[n];
dfs(a,b,0);
boolean vis=true;
for(int i=0;i<n;i++)
if(!b[i])
vis = false;
if(n==m && vis)
System.out.println("FHTAGN!");
else
System.out.println("NO");
// }
sc.close();
}
private static void dfs(int[][] a, boolean[] b, int from)
{
for(int i=0;i<b.length;i++)
{
if(a[from][i]==1 && !b[i])
{
b[i] = true;
dfs(a,b,i);
}
}
}
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int P[100001];
void CreateSet(int x) { P[x] = x; }
int FindSet(int x) {
if (x != P[x]) P[x] = FindSet(P[x]);
return P[x];
}
int MergeSets(int x, int y) {
int PX = FindSet(x);
int PY = FindSet(y);
if (PX == PY) return 0;
P[PX] = PY;
return 1;
}
int main() {
int n, m;
int i, j, u, v;
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) P[i] = i;
int kq = 0;
for (i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
u = FindSet(u);
v = FindSet(v);
if (u == v)
kq++;
else
P[u] = v;
}
if (kq == 1) {
u = FindSet(1);
for (i = 2; i <= n; i++)
if (FindSet(i) != u) {
printf("NO");
return 0;
}
printf("FHTAGN!");
} else
printf("NO");
return 0;
}
``` |
### Prompt
Your challenge is to write a python3 solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```python3
inp = input().split()
n = int(inp[0])
m = int(inp[1])
def dfs(x):
visited.add(x)
for y in e[x]:
if not y in visited:
dfs(y)
if n >= 3 and n == m:
visited = set()
e = [[] for i in range(n + 1)]
for i in range(m):
x, y = map(int, input().split())
e[x].append(y)
e[y].append(x)
dfs(1)
print('FHTAGN!' if len(visited) == n else 'NO')
else:
print('NO')
``` |
### Prompt
In JAVA, your task is to solve the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```java
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
static ArrayList<ArrayList<Integer> > g = null;
static boolean[] was = null;
static void dfs(int u, int p) {
was[u] = true;
for (Integer v : g.get(u))
if (v != p && !was[v])
dfs(v, u);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
if (n != m) {
System.out.println("NO");
return;
}
g = new ArrayList<ArrayList<Integer>>(n);
was = new boolean[n];
Arrays.fill(was, false);
for (int i = 0; i < n; ++i)
g.add(i, new ArrayList<Integer>());
for (int i = 0; i < m; ++i) {
int u = in.nextInt(), v = in.nextInt();
--u; --v;
if (g.get(u) == null)
g.set(u, new ArrayList<Integer>());
if (g.get(v) == null)
g.set(v, new ArrayList<Integer>());
g.get(u).add(v);
g.get(v).add(u);
}
dfs(0, -1);
for (int i = 0; i < n; ++i)
if (!was[i]) {
System.out.println("NO");
return;
}
System.out.println("FHTAGN!");
}
}
``` |
### Prompt
Please create a solution in Java to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```java
import java.io.*;
import java.util.*;
public class C {
String s = null;
String[] ss = null;
String F = "FHTAGN!";
String N = "NO";
int n;
int m;
List<Integer>[] edges = null;
public void run() throws Exception{
BufferedReader br = null;
File file = new File("input.txt");
if(file.exists()){
br = new BufferedReader(new FileReader("input.txt"));
}
else{
br = new BufferedReader(new InputStreamReader(System.in));
}
s = br.readLine();
ss = s.split(" ");
n = Integer.parseInt(ss[0]);
m = Integer.parseInt(ss[1]);
edges = new List[n+1];
Set<Integer>[] modos = new HashSet[n+1];
for(int i = 0; i <= n; i++){
edges[i] = new ArrayList<Integer>();
modos[i] = new HashSet<Integer>();
}
for(int i = 0; i < m; i++){
s = br.readLine();
ss = s.split(" ");
int f = Integer.parseInt(ss[0]);
int t = Integer.parseInt(ss[1]);
edges[f].add(t);
edges[t].add(f);
}
boolean[] f = new boolean[n+1];
int[] nx = new int[2];
nx[0] = 1;
nx[1] = -1;
List<int[]> next = new ArrayList<int[]>();
next.add(nx);
while(next.size() > 0){
nx = next.get(0);
next.remove(0);
f[nx[0]] = true;
List<Integer> tl = edges[nx[0]];
for(int i = 0; i < tl.size(); i++){
int to = tl.get(i);
if(to == nx[1]){
continue;
}
if(f[to]){
modos[to].add(nx[0]);
}
else{
int[] nnx = new int[2];
nnx[0] = to;
nnx[1] = nx[0];
next.add(nnx);
}
}
}
boolean check = true;
for(int i = 1; i <= n; i++){
if(!f[i]){
check = false;
}
}
boolean found = false;
for(int i = 1; i <= n; i++){
if(modos[i].size() > 1){
check = false;
}
if(modos[i].size() == 1){
found = true;
}
}
if(check && found){
System.out.println(F);
return;
}
System.out.println(N);
return;
}
/**
* @param args
*/
public static void main(String[] args) throws Exception{
C t = new C();
t.run();
}
}
``` |
### Prompt
Develop a solution in JAVA to the problem described below:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```java
//package codeforcesnew;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
//prob 103B
public class Cthhulhu {
int n;
int m;
int[] visited;
boolean[][] graph;
ArrayList<Integer> list;
Scanner input;
boolean flag;
public Cthhulhu(){
list = new ArrayList<>();
input = new Scanner(System.in);
n = input.nextInt();
m = input.nextInt();
visited = new int[n+1];
graph = new boolean[n+1][n+1];
Arrays.fill(visited,-1);
int a=0;
int b=0;
for(int i=0;i<m;i++){
a =input.nextInt();
b =input.nextInt();
graph[a][b]=true;
graph[b][a]=true;
}
flag =true;
traverse(1,0);
if(flag==true)
{ for(int i=1;i<=n;i++)
{
if(visited[i]==-1) {
flag=false;
break;
}
}
}
if(flag==true&&n==m) System.out.println("FHTAGN!");
else System.out.println("NO");
}
public boolean dfs(int vertex,int parent){
traverse(vertex,parent);
boolean quit=false;
if(visited[vertex]!=-1){
if(list.size()-1-visited[vertex]+1>2) {
traverse(vertex,parent);
quit=flag=true;
return quit;
}
}
visited[vertex]=list.size();
list.add(vertex);
for(int i=1;i<=n;i++){
if(graph[vertex][i]==true&&i!=parent)
{
quit=dfs(i,vertex);
list.remove(list.size()-1);
if(quit==true) return quit;
else continue;
}
}
return quit;
}
public void traverse(int vertex,int parent){
visited[vertex]=1;
for(int i=1;i<=n;i++){
if(graph[vertex][i]==true)
{ graph[vertex][i]=false;
if(i!=parent) traverse(i,vertex);
}
}
}
public static void main(String[] args){
new Cthhulhu();
}
}
``` |
### Prompt
Construct a java code solution to the problem outlined:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```java
/*
ID: govind.3, GhpS, govindpatel
LANG: JAVA
TASK: Main
*/
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
/**
* Min segment Tree takes the minimum number at the root
*/
class MinSegmentTree {
/**
* root: Tree root, balance: input array, rl,rr:
* rl=0,rr=inputArray.length-1 minTree:segment Tree
*/
private void initMinTree(int root, int rl, int rr, int[] balance, int[] minTree) {
if (rl == rr) {
minTree[root] = balance[rl];
return;
}
int rm = (rl + rr) / 2;
initMinTree(root * 2 + 1, rl, rm, balance, minTree);
initMinTree(root * 2 + 2, rm + 1, rr, balance, minTree);
minTree[root] = Math.min(minTree[root * 2 + 1], minTree[root * 2 + 2]);
}
/**
* minTree:segment tree root:0 rl:0,rr:inputarray.length-1
* l=queryleft-1(If 1 based index),r = queryright(1-based)
*/
private int getMin(int[] minTree, int root, int rl, int rr, int l, int r) {
//l = query left-1, r = query right
if (l > r) {
return Integer.MAX_VALUE;
}
if (l == rl && r == rr) {
return minTree[root];
}
int rm = (rl + rr) / 2;
return Math.min(getMin(minTree, root * 2 + 1, rl, rm, l, Math.min(r, rm)),
getMin(minTree, root * 2 + 2, rm + 1, rr, Math.max(rm + 1, l), r));
}
}
//dsu next operation
int[] next;
private int next(int i) {
if (next[i] == i) {
return i;
}
return next[i] = next(next[i]);
}
//segment tree...
private void set(int[] t, int ind, int val) {
ind += (t.length / 2);
t[ind] = val;
int curr = 0;
while (ind > 1) {
ind >>= 1;
if (curr == 0) {
t[ind] = t[ind * 2] | t[ind * 2 + 1];
} else {
t[ind] = t[ind * 2] ^ t[2 * ind + 1];
}
curr ^= 1;
}
}
//Binary Index tree
class FenwickTree {
int[] ft;
int N;
FenwickTree(int n) {
this.N = n;
ft = new int[N];
}
private int lowbit(int x) {
return x & (-x);
}
void update(int pos, int val) {
while (pos < N) {
ft[pos] += val;
pos |= pos + 1;//0-index
}
}
int sum(int pos) {
int sum = 0;
while (pos >= 0) {
sum += ft[pos];
pos = (pos & (pos + 1)) - 1;
}
return sum;
}
int rangeSum(int left, int right) {
return sum(right) - sum(left - 1);
}
}
/**
* BINARY SEARCH IN FENWICK TREE: l=1, r=N(length), at=sumRequired,
* letter=TreeIndex(if there are many ft), ft=arrays of FT
*/
private int binarySearch(int l, int r, int at, int letter, FenwickTree[] ft) {
while (r - l > 0) {
int mid = (l + r) / 2;
int sum = ft[letter].sum(mid);
if (sum < at) {
l = mid + 1;
} else {
r = mid;
}
}
return l;
}
private int[] compress(int[] a) {
int[] b = new int[a.length];
for (int i = 0; i < a.length; i++) {
b[i] = a[i];
}
Arrays.sort(b);
int m = 0;
for (int i = 0; i < b.length;) {
int j = i;
while (j < b.length && b[j] == b[i]) {
j++;
}
b[m++] = b[i];
i = j;
}
for (int i = 0; i < a.length; i++) {
a[i] = Arrays.binarySearch(b, 0, m, a[i]);
}
return a;
}
private void solve() throws IOException {
int N = nextInt();
int M = nextInt();
ArrayList<Integer>[] edge = new ArrayList[N];
boolean[] visited = new boolean[N];
if (M != N) {
out.println("NO");
return;
}
for (int i = 0; i < N; i++) {
edge[i] = new ArrayList<Integer>();
}
for (int i = 0; i < M; i++) {
int t = nextInt() - 1;
int f = nextInt() - 1;
edge[t].add(f);
edge[f].add(t);
}
LinkedList<Integer> list = new LinkedList<Integer>();
list.addLast(0);
visited[0] = true;
while (!list.isEmpty()) {
int ind = list.removeFirst();
for (int i : edge[ind]) {
if (!visited[i]) {
visited[i] = true;
list.addLast(i);
}
}
}
for (int i = 0; i < N; i++) {
if (!visited[i]) {
out.println("NO");
return;
}
}
out.println("FHTAGN!");
}
boolean isSorted(ArrayList<Integer> al) {
int size = al.size();
for (int i = 1; i < size - 2; i++) {
if (al.get(i) > al.get(i + 1)) {
return false;
}
}
return true;
}
/**
* SHUFFLE: shuffle the array 'a' of size 'N'
*/
private void shuffle(int[] a, int N) {
for (int i = 0; i < N; i++) {
int r = i + (int) ((N - i) * Math.random());
int t = a[i];
a[i] = a[r];
a[r] = t;
}
}
/**
* TEMPLATE-STUFF: main method, run method - ( fileIO and stdIO ) and
* various methods for input like nextInt, nextLong, nextToken and
* nextDouble with some declarations.
*/
/**
* For solution to the problem ... see the solve method
*/
public static void main(String[] args) {
new Main().run();
}
public void run() {
try {
in = new BufferedReader(new FileReader("D-large.in"));
out = new PrintWriter(new BufferedWriter(new FileWriter("Main.out")));
tok = null;
solve();
in.close();
out.close();
System.exit(0);
} catch (IOException e) {//(FileNotFoundException e) {
try {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(new OutputStreamWriter(System.out));
tok = null;
solve();
in.close();
out.close();
System.exit(0);
} catch (IOException ex) {
System.out.println(ex.getMessage());
System.exit(0);
}
}
}
private String nextToken() throws IOException {
while (tok == null || !tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
private int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
private long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
private double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
BufferedReader in;
StringTokenizer tok;
PrintWriter out;
}
``` |
### Prompt
Your challenge is to write a PYTHON3 solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```python3
from collections import *
from sys import stdin
def arr_inp(n):
if n == 1:
return [int(x) for x in stdin.readline().split()]
elif n == 2:
return [float(x) for x in stdin.readline().split()]
else:
return list(stdin.readline()[:-1])
class disjointset:
def __init__(self, n):
self.rank, self.parent, self.n, self.nsets, self.edges, self.gdict = [0] * (n + 1), [0] * (n + 1), n, [1] * (
n + 1), [], defaultdict(list)
self.add_nodes(n)
def add_nodes(self, n):
for i in range(1, n + 1):
self.parent[i], self.nsets[i] = i, 1
def add_edge(self, node1, node2, w=None):
self.gdict[node1].append(node2)
self.gdict[node2].append(node1)
self.edges.append([node1, node2])
def dfsUtil(self, v, c):
stack = [v]
while (stack):
s = stack.pop()
for i in self.gdict[s]:
if not self.visit[i]:
stack.append(i)
self.visit[i] = 1
self.color[i] = c
# dfs for graph
def dfs(self):
self.cnt, self.visit, self.color = 0, defaultdict(int), defaultdict(int)
for i in range(1, n + 1):
if self.visit[i] == 0:
self.dfsUtil(i, self.cnt)
self.cnt += 1
def find(self, x):
result, stack = self.parent[x], [x]
while result != x:
x = result
result = self.parent[x]
stack.append(x)
while stack:
self.parent[stack.pop()] = result
return result
def union(self, x, y):
xpar, ypar = self.find(x), self.find(y)
# already union
if xpar == ypar:
return
# perform union by rank
par, child = 0, 0
if self.rank[xpar] < self.rank[ypar]:
par, child = ypar, xpar
elif self.rank[xpar] > self.rank[ypar]:
par, child = xpar, ypar
else:
par, child = xpar, ypar
self.rank[xpar] += 1
self.parent[child] = par
self.nsets[par] += self.nsets[child]
self.n -= 1
def kruskal(self):
result, edges, self.cycle = [], self.edges, defaultdict(int)
# loop over v-1
for i in range(len(edges)):
u, v = edges[i]
upar, vpar = self.find(u), self.find(v)
# no cycle
if upar != vpar:
result.append(edges[i])
self.union(upar, vpar)
else:
if self.cycle[self.color[upar]] == 0:
self.cycle[self.color[upar]] += 1
else:
exit(print('NO'))
n, m = arr_inp(1)
dis, ans = disjointset(n), 0
for i in range(m):
u, v = arr_inp(1)
dis.add_edge(u, v)
dis.dfs()
dis.kruskal()
# print(dis.cycle, dis.n)
print('FHTAGN!' if dis.n == 1 and sum(dis.cycle.values()) == dis.n else 'NO')
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 1e18;
const int INF = 1e9;
const long double EPS = 1e-9;
const int MOD = 1e9 + 7;
const int N = 105;
vector<int> adj[N];
bitset<N> vis;
int cycle;
void dfs(int v) {
vis[v] = 1;
for (int& u : adj[v]) {
if (vis[u] == 0) dfs(u);
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
int a, b;
for (int i = 0; i < (m); ++i) {
scanf("%d %d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
int comp = 0;
if (n != m) {
printf("NO\n");
} else {
bool flag = true;
dfs(1);
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
flag = false;
break;
}
}
if (flag)
printf("FHTAGN!\n");
else
printf("NO\n");
}
return 0;
}
``` |
### Prompt
Please provide a Java coded solution to the problem described below:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```java
import java.io.*;
import java.util.*;
public class Graph
{
static Graph graph[];
long cost;
int vis;
int val;
ArrayList<Graph> adj;
static long cos=Long.MAX_VALUE;
Graph(int v)
{
vis=0;
val=v;
cost=0;
adj=new ArrayList<>();
}
public static void add_edge(int u,int v)
{
graph[u].adj.add(graph[v]);
graph[v].adj.add(graph[u]);
}
public static void dfs(int index)
{
Graph z=graph[index];
z.vis=1;
cos=Math.min(cos,z.cost);
for( int i=0;i<z.adj.size();i++)
{
if(z.adj.get(i).vis==0)
{
dfs(z.adj.get(i).val);
}
}
}
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
graph=new Graph[n+1];
int m=sc.nextInt();
for( int i=1;i<=n;i++)
{
graph[i]=new Graph(i);
}
for( int i=0;i<m;i++)
{
int x=sc.nextInt();
int y=sc.nextInt();
add_edge(x,y);
}
int c=0;
for( int i=1;i<=n;i++)
{
if(graph[i].vis==0)
{
dfs(i);
c++;
}
}
if(c==1&&n==m)
{
System.out.println("FHTAGN!");
}
else
System.out.println("NO");
}
}
``` |
### Prompt
Your task is to create a python3 solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```python3
# #include <iostream>
# #include <vector>
# #define N 101
# using namespace std;
# int n, m;
# vector<int> g[N];
# bool vst[N];
# bool dfs(int node){
# if(vst[node]){
# return false;
# }
# }
# int main(){
# ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
# cin >> n >> m;
# int a,b;
# for(int i=0;i<m;i++){
# cin >> a >> b;
# g[a].push_back(b);
# g[b].push_back(a);
# }
# cout << dfs(0);
# }
class Graph:
def __init__(self):
self.edges = []
self.vertices = set()
def addEdge(self, a, b):
self.edges.append([a, b])
self.vertices.add(a)
self.vertices.add(b)
def kruskal_mst(self):
def getSet(v):
for s in sets:
if v in s: return s
return None
def sameset(v1, v2):
for s in sets:
if v1 in s and v2 in s: return True
return False
sets = [set([vertex]) for vertex in self.vertices]
edges = 0
nodes = set()
for edge in self.edges:
v0, v1 = edge
if not sameset(v0, v1):
edges += 1
nodes.add(v0)
nodes.add(v1)
v0_s = getSet(v0)
v1_s = getSet(v1)
v1_s |= v0_s
sets.remove(v0_s)
return edges, len(nodes)
n, m = [int(x) for x in input().split()]
g = Graph()
for i in range(m):
g.addEdge(*[int(x) for x in input().split()])
edges,nodes = g.kruskal_mst()
print("FHTAGN!" if edges + 1 == m and nodes == n else "NO")
``` |
### Prompt
Your task is to create a PYTHON solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```python
[n, m] = map(lambda x: int(x), raw_input().split())
verts = []
vertss = {}
count = 0
for i in range(n):
verts.append([])
vertss[i] = 1
#creating adjacency list
for i in range(m):
[a,b] = map(lambda x: int(x) - 1, raw_input().split())
verts[a].append(b)
verts[b].append(a)
arr = [0]
par = [0]
ind = 0
del vertss[0]
while ind < len(arr):
#print "i am at index " + str(ind)
for node in verts[arr[ind]]:
#print "i am node " + str(node)
if node == par[ind]:
continue
if node in arr:
#print "count + 1 here"
count += 1
else:
#print "nop, not seen b4"
arr.append(node)
par.append(arr[ind])
del vertss[node]
ind += 1
if count > 2:
#print 'break here'
count = 0
break
if len(vertss) > 0:
count = 0
if count == 0:
print 'NO'
else: print 'FHTAGN!'
``` |
### Prompt
Create a solution in cpp for the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0.0);
const int inf = 0x3f3f3f3f;
const double infd = 1.0 / 0.0;
long long power(long long x, long long y, long long MOD) {
long long res = 1;
x = x % MOD;
while (y > 0) {
if (y & 1) res = (res * x) % MOD;
y = y >> 1;
x = (x * x) % MOD;
}
return res;
}
long long mul(long long a, long long b, long long MOD) {
if (b == 1) {
return a;
}
if (b % 2 == 0) {
return 2 * (mul(a, b / 2, MOD) % MOD);
} else {
return (a + (2 * (mul(a, b / 2, MOD)) % MOD)) % MOD;
}
}
bool ispow2(long long n) {
if (((n & (n - 1)) == 0) && n != 0) {
return true;
}
return false;
}
bool prime(int x) {
if (x == 1) {
return false;
}
if (x == 2) {
return true;
}
if (x % 2 == 0) {
return false;
}
for (int i = 3; i * i <= x; i += 2) {
if (x % i == 0) {
return false;
}
}
return true;
}
int __gcd(int a, int b) {
if (b == 0) return a;
return __gcd(b, a % b);
}
int coprime(int a, int b) {
if (a == b) return 0;
if (prime(a) && prime(b)) return 1;
if ((a == 2 && b % 2 != 0) || (b == 2 && a % 2 != 0)) return 1;
if ((a % 2 != 0 && prime(b) && a < b) || (b % 2 != 0 && prime(a) && a > b))
return 1;
if (abs(a - b) == 1) return 1;
if (a == 1 || b == 1) return 1;
return __gcd(a, b);
}
unsigned long long lcm(unsigned a, unsigned b) {
return ((unsigned long long)a) * (b / __gcd(a, b));
}
int n, m, x, y;
vector<int> g[101];
int vis[101];
int cnt = 0;
void dfs(int u) {
vis[u] = 1;
cnt++;
for (int i = 0; i < g[u].size(); i++) {
if (!vis[g[u][i]]) {
dfs(g[u][i]);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(vis, 0, sizeof(vis));
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
if (n == m) {
dfs(1);
(cnt == n) ? cout << "FHTAGN!" << endl : cout << "NO" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a Java solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```java
import java.util.*;
public class cycledfs
{
public static void main(String ar[])
{
Scanner in=new Scanner(System.in);
int V=in.nextInt();
GraphDFS obj=new GraphDFS(V);
int E = in.nextInt();
for (int i = 0; i < E; i++)
{
int v = in.nextInt();
int w = in.nextInt();
obj.addEdge(v-1, w-1);
}
obj.dfs(0);
if(V==E&&obj.count()==0)
System.out.println("FHTAGN!");
else
System.out.println("NO");
}
}
class GraphDFS
{
public int V;
public int E;
public int count=0;
public boolean[] marked;
ArrayList<Integer>[] adj;
GraphDFS(int V)
{
this.V = V; this.E = 0;
marked=new boolean[V];
Arrays.fill(marked,false);
adj =(ArrayList<Integer>[]) new ArrayList[V];
for (int v = 0; v < V; v++)
adj[v] = new ArrayList<Integer>();
}
public int V() { return V; }
public int E() { return E; }
public void addEdge(int v, int w)
{
adj[v].add(w);
adj[w].add(v);
E++;
}
public Iterable<Integer> adj(int v)
{ return adj[v]; }
public void dfs(int v)
{
marked[v] = true;
for (int w : adj(v)){
if (!marked[w])
dfs( w);
}
}
public int count(){
int count=0;
for (int i = 0; i < V; i++) {
if (!marked[i])
count+=1;
}
return count;
}
}
``` |
### Prompt
Create a solution in cpp for the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int fp(int abc, int parent[]) {
if (parent[abc] == abc) return abc;
int def = fp(parent[abc], parent);
parent[abc] = def;
return def;
}
void cycledmerge(vector<int> hub[], int n, int parent[]) {
stack<int> urutan;
for (int i = 0; i < n; i++) parent[i] = i;
stack<pair<int, int> > ngurut;
vector<int> sudah(n, 0);
vector<int> adadiurutan(n, 0);
vector<int> dari(n, -1);
for (int i = 0; i < n; i++) {
if (sudah[i]) continue;
urutan.push(i);
ngurut.push(make_pair(i, 0));
adadiurutan[i] = 1;
sudah[i] = 1;
while (!ngurut.empty()) {
int id = ngurut.top().first;
int val = ngurut.top().second;
ngurut.pop();
if (val == (int)hub[id].size()) {
while (!urutan.empty() && urutan.top() == id) urutan.pop();
adadiurutan[id] = 0;
continue;
}
ngurut.push(make_pair(id, val + 1));
int next = hub[id][val];
if (dari[id] == next) continue;
if (sudah[next] && !adadiurutan[fp(next, parent)]) continue;
if (!sudah[next]) {
sudah[next] = 1;
urutan.push(next);
ngurut.push(make_pair(next, 0));
adadiurutan[next] = 1;
dari[next] = id;
continue;
}
if (parent[fp(id, parent)] == fp(next, parent)) continue;
parent[fp(id, parent)] = fp(next, parent);
while (!urutan.empty() && urutan.top() != fp(next, parent)) {
parent[fp(urutan.top(), parent)] = fp(next, parent);
urutan.pop();
}
}
}
return;
}
int main() {
int p[200];
vector<int> hub[200];
int n, m;
cin >> n >> m;
for (int(i) = 0; (i) < (m); ++(i)) {
int a, b;
cin >> a >> b;
--a;
--b;
hub[a].push_back(b);
hub[b].push_back(a);
}
cycledmerge(hub, n, p);
vector<int> ukuran(n, 0);
for (int(i) = 0; (i) < (n); ++(i)) ukuran[p[i]]++;
int numcyc = 0;
for (int(i) = 0; (i) < (n); ++(i))
if (ukuran[i] >= 3) ++numcyc;
if (numcyc != 1) {
cout << "NO" << endl;
return 0;
}
int besar = 0;
for (int(i) = 0; (i) < (n); ++(i))
if (ukuran[i] >= 3) besar = ukuran[i];
int yesadj = 0;
int noadj = 0;
for (int(i) = 0; (i) < (n); ++(i))
for (int(j) = 0; (j) < (((int)hub[i].size())); ++(j)) {
int k = hub[i][j];
if (k < i) continue;
if (p[i] != p[k])
++noadj;
else
++yesadj;
}
if (yesadj != besar || noadj != (n - besar + 1) - 1) {
cout << "NO" << endl;
} else {
cout << "FHTAGN!" << endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
vector<int> G[N];
int vis[N];
void DFS(int cur) {
vis[cur]++;
int sz = G[cur].size();
int v;
for (int i = 0; i < sz; i++) {
v = G[cur][i];
if (!vis[v]) DFS(v);
}
}
int main() {
int n, m, u, v;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
DFS(1);
for (int i = 1; i <= n; i++)
if (!vis[i]) {
cout << "NO";
return 0;
}
if (n == m)
cout << "FHTAGN!";
else
cout << "NO";
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, ciclos, vertice_visited;
int pai[110], vis[110];
vector<int> adj[110];
void dfs(int v) {
vis[v] = 1;
vertice_visited++;
for (int i = 0; i < adj[v].size(); i++) {
int x = adj[v][i];
if (vis[x]) {
if (pai[v] != x) ciclos++;
continue;
}
pai[x] = v;
vis[x] = 1;
dfs(x);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
while (m--) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(1);
cout << (ciclos == 2 && vertice_visited == n ? "FHTAGN!" : "NO") << endl;
return 0;
}
``` |
### Prompt
Generate a python3 solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```python3
n,m=map(int,input().split())
t=[]
l=[]
l.append(1)
def hambandi(q):
for k in t[q]:
if(not(k in l)):
l.append(k)
hambandi(k)
if(n!=m):
print('NO')
else:
for i in range(n+1):
t.append([])
for kl in range(m):
a,b=map(int,input().split())
t[a].append(b)
t[b].append(a)
hambandi(1)
if(len(l)==n):
print('FHTAGN!')
else:
print('NO')
``` |
### Prompt
Please formulate a PYTHON3 solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```python3
from collections import defaultdict
d=defaultdict(list)
n,m=map(int,input().split())
for i in range(m):
a,b=map(int,input().split())
a-=1
b-=1
d[a].append(b)
d[b].append(a)
vis=[0]*n
q=[0]
vis[0]=1
while q:
t=q.pop(0)
for i in d[t]:
if not vis[i]:
vis[i]=1
q.append(i)
if sum(vis)==n and m==n:
print('FHTAGN!')
else:
print('NO')
``` |
### Prompt
In Cpp, your task is to solve the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, unsigned long long y) {
long long temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
long long modpow(long long x, unsigned int y, long long p) {
long long res = 1;
x = x % p;
if (y == 0) return 1;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long exponentMod(long long A, long long B, long long C) {
if (B == 0) return 1;
if (A == 0) return 0;
long long y;
if (B % 2 == 0) {
y = exponentMod(A, B / 2, C);
y = (y * y) % C;
} else {
y = A % C;
y = (y * exponentMod(A, B - 1, C) % C) % C;
}
return (long long)((y + C) % C);
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int gcdExtended(int a, int b, int *x, int *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
void modInverse(int a, int m) {
int x, y;
int g = gcdExtended(a, m, &x, &y);
if (g != 1)
cout << "Inverse doesn't exist";
else {
int res = (x % m + m) % m;
cout << "Modular multiplicative inverse is " << res;
}
}
void SieveOfEratosthenes(int n) {
bool sieve[n + 1];
long long cnt = 0;
memset(sieve, 0, sizeof(sieve));
for (int p = 2; p * p <= n; p++) {
if (!sieve[p]) {
for (int i = 2 * p; i <= n; i += p) sieve[i] = p;
}
}
for (int p = 2; p <= n; p++) {
if (sieve[p]) cnt++;
}
cout << cnt;
}
int phi(unsigned int n) {
float result = n;
for (int p = 2; p * p <= n; ++p) {
if (n % p == 0) {
while (n % p == 0) n /= p;
result *= (1.0 - (1.0 / (float)p));
}
}
if (n > 1) result *= (1.0 - (1.0 / (float)n));
return (int)result;
}
long long floorSqrt(long long x) {
if (x == 0 || x == 1) return x;
unsigned long long start = 1, end = x, ans;
while (start <= end) {
unsigned long long mid = start + (end - start) / 2;
if (mid * mid == x) return mid;
if (mid * mid < x) {
start = mid + 1;
ans = mid;
} else
end = mid - 1;
}
return ans;
}
void start() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
vector<long long> adj[105];
bool vis[105];
void dfs(long long k) {
if (!vis[k]) {
vis[k] = true;
for (auto x : adj[k]) {
if (!vis[x]) {
dfs(x);
vis[x] = true;
}
}
}
}
int main() {
start();
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
long long cnt = 0;
for (long long i = 1; i < n + 1; i++) {
if (!vis[i]) {
dfs(i);
cnt++;
}
}
if (cnt == 1 && n == m) {
cout << "FHTAGN!";
} else
cout << "NO";
}
``` |
### Prompt
Generate a Python3 solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```python3
inp = input().split()
n = int(inp[0])
m = int(inp[1])
def dfs(x):
visited.add(x)
for y in e[x]:
if not y in visited:
dfs(y)
if n >= 3 and n == m:
e, visited = [[] for i in range(n + 1)], set()
for j in range(m):
x, y = map(int, input().split())
e[x].append(y)
e[y].append(x)
dfs(1)
print('FHTAGN!' if len(visited) == n else 'NO')
else:
print('NO')
``` |
### Prompt
Please formulate a CPP solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> v[105];
int visit[105];
int c;
void dfs(int i) {
visit[i] = 1;
vector<int>::iterator it;
for (it = v[i].begin(); it != v[i].end(); it++) {
if (visit[(*it)] == 0) {
c++;
dfs((*it));
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, a, b, i;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
c++;
dfs(1);
if (c == n && m == n)
cout << "FHTAGN!";
else
cout << "NO";
return 0;
}
``` |
### Prompt
Please create a solution in Java to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```java
import java.util.Scanner;
public class main {
public static final int MAX = 100;
public static Scanner input = new Scanner(System.in);
static boolean[] arrFlag = new boolean[MAX+1];
static boolean[][] matBool = new boolean[MAX+1][MAX+1];
static int intN = input.nextInt();
static int intM = input.nextInt();
public static int arbol(int indice, int Count) {
arrFlag[indice] = true;
Count++;
for (int i = 1; i < intN + 1; i++) {
if (matBool[indice][i] && !(arrFlag[i])) {
Count = arbol(i, Count);
}
}
return Count;
}
public static void main(String[] args) {
int Count = 0;
for (int i = 0; i < intM; i++) {
int x = input.nextInt();
int y = input.nextInt();
matBool[x][y] = true;
matBool[y][x] = true;
}
Count = arbol(1, Count);
if ((intN == intM) && (Count == intN)) {
System.out.print("FHTAGN!");
} else {
System.out.print("NO");
}
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 111;
int N, M;
int cnt = 0;
vector<int> node[MAXN];
int visited[MAXN];
void dfs(int cur) {
if (visited[cur]) return;
visited[cur] = true;
cnt++;
for (int i = 0; i < node[cur].size(); i++) dfs(node[cur][i]);
}
int main() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
node[a].push_back(b);
node[b].push_back(a);
}
for (int i = 1; i <= N; i++) visited[i] = false;
dfs(1);
if (cnt == N && M == N)
printf("FHTAGN!\n");
else
printf("NO\n");
return 0;
}
``` |
### Prompt
In JAVA, your task is to solve the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```java
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Vector;
import java.util.Scanner;
import java.util.Stack;
/**
* 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;
Scanner in = new Scanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
static class TaskB {
public void solve(int testNumber, Scanner in, PrintWriter out) {
int n = in.nextInt(), m = in.nextInt();
if (n != m) {
out.print("NO");
return;
}
boolean[][] g = new boolean[n + 1][n + 1];
for (int i = 0; i < m; i++) {
int v1 = in.nextInt(), v2 = in.nextInt();
g[v1][v2] = true;
g[v2][v1] = true;
}
int ncalc = dfs(1, g);
if (ncalc != n) {
out.print("NO");
return;
}
out.print("FHTAGN!");
}
private int dfs(int start, boolean[][] g) {
int count = 0;
Stack<Integer> stack = new Stack<>();
stack.add(start);
boolean[] visited = new boolean[g.length];
while (!stack.isEmpty()) {
Integer curr = stack.pop();
if (visited[curr]) continue;
count++;
visited[curr] = true;
for (int i = 1; i < g.length; i++) {
if (g[curr][i] && !visited[i]) {
stack.add(i);
}
}
}
return count;
}
}
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
int N, M;
using namespace std;
int cont = 0;
long long parents[101];
long long find(long long n) {
if (n == parents[n]) {
return n;
}
long long aux = find(parents[n]);
parents[n] = aux;
return find(parents[n]);
}
long long Union(long long n1, long long n2) {
long long p1 = find(n1);
long long p2 = find(n2);
if (p1 != p2) {
parents[p1] = p2;
return p2;
}
cont++;
return -1;
}
int main() {
cin >> N >> M;
for (int i = 0; i < 101; i++) {
parents[i] = i;
}
for (int i = 0; i < M; i++) {
long long x, y;
cin >> x >> y;
Union(x, y);
}
if (cont == 1 && M >= N) {
cout << "FHTAGN!";
} else {
cout << "NO";
}
cout << endl;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int maxn = 1e2 + 10;
const double eps = 1e-9;
int mp[maxn][maxn];
int deg[maxn];
int vis[maxn];
int n, m;
void dfs(int u) {
vis[u] = 1;
for (int i = 1; i <= n; i++) {
if (!vis[i] && mp[u][i]) {
dfs(i);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
while (scanf("%d%d", &n, &m) != EOF) {
memset(vis, 0, sizeof vis);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
mp[u][v] = mp[v][u] = 1;
}
if (n == m) {
dfs(1);
int flag = 1;
for (int i = 1; i <= n; i++) {
if (!vis[i]) flag = 0;
}
if (flag)
puts("FHTAGN!");
else
puts("NO");
} else
puts("NO");
}
return 0;
}
``` |
### Prompt
Your challenge is to write a PYTHON3 solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```python3
#!/usr/bin/env python3
n, m = map(int, input().rstrip().split())
adj = [[] for i in range(n+1)]
for i in range(m):
u, v = map(int, input().rstrip().split())
adj[u].append(v)
adj[v].append(u)
vis = [False for i in range(n+1)]
ring = [None for i in range(n+1)]
ring_start = None
vis_cnt = 0
def dfs(cur, par):
vis[cur] = True
global vis_cnt, ring_start
vis_cnt += 1
found_start = []
for nxt in adj[cur]:
if nxt == par:
continue
if vis[nxt]:
if ring[nxt] != cur:
found_start.append(nxt)
else:
tmp = dfs(nxt, cur)
if tmp:
found_start.append(tmp)
if len(found_start) != 1:
return None
ring[cur] = found_start[0]
if found_start[0] == cur:
ring_start = cur
return None
return found_start[0]
dfs(1, -1)
if not ring_start or vis_cnt != n:
print("NO")
else:
print("FHTAGN!")
``` |
### Prompt
Please create a solution in CPP to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
int n, m;
int used[N];
vector<int> g[N];
void travel(int u) {
used[u] = 1;
for (auto to : g[u]) {
if (!used[to]) travel(to);
}
}
int cycle_st = -1, cycle_ed = -1;
int p[N];
int dfs(int u, int pr = -1) {
used[u] = 1;
for (auto to : g[u]) {
if (used[to] == 0) {
p[to] = u;
if (dfs(to, u)) return 1;
} else if (used[to] == 1 && to != pr) {
cycle_ed = u;
cycle_st = to;
return 1;
}
}
used[u] = 2;
return 0;
}
bool part[N];
void bfs(int u, int pr = -1) {
used[u] = 1;
for (auto to : g[u]) {
if (to == pr) continue;
if (used[to] or part[to]) {
cout << "NO";
exit(0);
}
bfs(to, u);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
travel(1);
bool bad = 0;
for (int i = 1; i <= n; i++) bad |= !used[i];
if (bad) return cout << "NO", 0;
memset(used, 0, sizeof(used));
dfs(1);
if (cycle_st == -1) return cout << "NO", 0;
vector<int> core = {cycle_st};
part[cycle_st] = 1;
while (cycle_ed != cycle_st) {
core.push_back(cycle_ed);
part[cycle_ed] = 1;
cycle_ed = p[cycle_ed];
}
memset(used, 0, sizeof(used));
for (int i = 0; i < core.size(); i++) {
int u = core[i];
if (used[u]) return cout << "NO", 0;
used[u] = 1;
for (auto to : g[u])
if (!part[to]) bfs(to, u);
}
for (int i = 1; i <= n; i++) bad |= !used[i];
if (bad) return cout << "NO", 0;
int num = n - core.size();
if (m - core.size() != num) return cout << "NO", 0;
cout << "FHTAGN!";
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int par[105];
int getpar(int x) {
if (x == par[x]) return par[x];
par[x] = getpar(par[x]);
return par[x];
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) par[i] = i;
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
int pa = getpar(a);
int pb = getpar(b);
par[max(pa, pb)] = min(pa, pb);
}
for (int i = 1; i <= n; ++i)
if (getpar(i) != 1) {
printf("NO\n");
exit(0);
}
if (n >= 3 && m == n)
printf("FHTAGN!\n");
else
printf("NO\n");
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
int parent[110];
int ranks[110];
int visit[110];
int cycle = 0;
int Findset(int i) {
int root = i;
while (root != parent[root]) root = parent[root];
while (i != root) {
int newp = parent[i];
parent[i] = root;
i = newp;
}
return root;
}
void Unionset(int x, int y) {
int xp = Findset(x);
int yp = Findset(y);
if (xp == yp)
cycle++;
else {
if (ranks[xp] < ranks[yp])
parent[xp] = yp;
else if (ranks[xp] > ranks[yp])
parent[yp] = xp;
else {
parent[yp] = xp;
ranks[xp]++;
}
}
}
int main() {
memset(visit, false, sizeof(visit));
for (int i = 0; i < 110; i++) {
parent[i] = i;
ranks[i] = -1;
}
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
visit[x] = visit[y] = true;
Unionset(x, y);
}
for (int i = 1; i <= n; i++) {
if (!visit[i]) {
printf("NO");
return 0;
}
}
if (cycle == 1)
printf("FHTAGN!");
else
printf("NO");
return 0;
}
``` |
### Prompt
Your task is to create a PYTHON3 solution to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```python3
class Nodo:
def __init__(self, value):
self.value = value
self.neighbors = []
def addNeighbor(self, neighbor):
self.neighbors.append(neighbor)
n, m = [int(x) for x in input().split()]
vertices = [None] * (n+1)
for i in range(m):
node1, node2 = [int(x) for x in input().split()]
if not vertices[node1]:
vertices[node1] = Nodo(node1)
if not vertices[node2]:
vertices[node2] = Nodo(node2)
vertices[node1].addNeighbor(vertices[node2])
vertices[node2].addNeighbor(vertices[node1])
def isCthulhu(vertices):
visited = {}
work = []
num_loops = 0
for vertice in vertices:
if vertice:
work.append(vertice)
break
while(len(work) > 0):
current = work.pop()
visited[current.value] = True
num_repeated = 0
for neighbor in current.neighbors:
if not visited.get(neighbor.value):
if neighbor not in work:
work.insert(0, neighbor)
else:
num_repeated +=1
if num_repeated > 1:
num_loops +=1
if num_loops > 1:
return False
return num_loops == 1 and len(visited.keys()) == n
if m == 0:
print("NO")
else:
print('NO'if not isCthulhu(vertices) else "FHTAGN!")
``` |
### Prompt
Please create a solution in Java to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.StringTokenizer;
public class Lunes30E
{
static class Scanner
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
public String nextLine()
{
try
{
return br.readLine();
}
catch(Exception e)
{
throw(new RuntimeException());
}
}
public String next()
{
while(!st.hasMoreTokens())
{
String l = nextLine();
if(l == null)
return null;
st = new StringTokenizer(l);
}
return st.nextToken();
}
public int nextInt()
{
return Integer.parseInt(next());
}
public long nextLong()
{
return Long.parseLong(next());
}
public double nextDouble()
{
return Double.parseDouble(next());
}
public int[] nextIntArray(int n)
{
int[] res = new int[n];
for(int i = 0; i < res.length; i++)
res[i] = nextInt();
return res;
}
public long[] nextLongArray(int n)
{
long[] res = new long[n];
for(int i = 0; i < res.length; i++)
res[i] = nextLong();
return res;
}
public double[] nextDoubleArray(int n)
{
double[] res = new double[n];
for(int i = 0; i < res.length; i++)
res[i] = nextDouble();
return res;
}
public void sortIntArray(int[] array)
{
Integer[] vals = new Integer[array.length];
for(int i = 0; i < array.length; i++)
vals[i] = array[i];
Arrays.sort(vals);
for(int i = 0; i < array.length; i++)
array[i] = vals[i];
}
public void sortLongArray(long[] array)
{
Long[] vals = new Long[array.length];
for(int i = 0; i < array.length; i++)
vals[i] = array[i];
Arrays.sort(vals);
for(int i = 0; i < array.length; i++)
array[i] = vals[i];
}
public void sortDoubleArray(double[] array)
{
Double[] vals = new Double[array.length];
for(int i = 0; i < array.length; i++)
vals[i] = array[i];
Arrays.sort(vals);
for(int i = 0; i < array.length; i++)
array[i] = vals[i];
}
public String[] nextStringArray(int n)
{
String[] vals = new String[n];
for(int i = 0; i < n; i++)
vals[i] = next();
return vals;
}
public Integer nextInteger()
{
String s = next();
if(s == null)
return null;
return Integer.parseInt(s);
}
public int[][] nextIntMatrix(int n, int m)
{
int[][] ans = new int[n][];
for(int i = 0; i < n; i++)
ans[i] = nextIntArray(m);
return ans;
}
public char[][] nextGrid(int r)
{
char[][] grid = new char[r][];
for(int i = 0; i < r; i++)
grid[i] = next().toCharArray();
return grid;
}
public static <T> T fill(T arreglo, int val)
{
if(arreglo instanceof Object[])
{
Object[] a = (Object[]) arreglo;
for(Object x : a)
fill(x, val);
}
else if(arreglo instanceof int[])
Arrays.fill((int[]) arreglo, val);
else if(arreglo instanceof double[])
Arrays.fill((double[]) arreglo, val);
else if(arreglo instanceof long[])
Arrays.fill((long[]) arreglo, val);
return arreglo;
}
<T> T[] nextObjectArray(Class <T> clazz, int size)
{
@SuppressWarnings("unchecked")
T[] result = (T[]) java.lang.reflect.Array.newInstance(clazz, size);
for(int c = 0; c < 3; c++)
{
Constructor <T> constructor;
try
{
if(c == 0)
constructor = clazz.getDeclaredConstructor(Scanner.class, Integer.TYPE);
else if(c == 1)
constructor = clazz.getDeclaredConstructor(Scanner.class);
else
constructor = clazz.getDeclaredConstructor();
}
catch(Exception e)
{
continue;
}
try
{
for(int i = 0; i < result.length; i++)
{
if(c == 0)
result[i] = constructor.newInstance(this, i);
else if(c == 1)
result[i] = constructor.newInstance(this);
else
result[i] = constructor.newInstance();
}
}
catch(Exception e)
{
throw new RuntimeException(e);
}
return result;
}
throw new RuntimeException("Constructor not found");
}
public void printLine(int... vals)
{
if(vals.length == 0)
System.out.println();
else
{
System.out.print(vals[0]);
for(int i = 1; i < vals.length; i++)
System.out.print(" ".concat(String.valueOf(vals[i])));
System.out.println();
}
}
public void printLine(long... vals)
{
if(vals.length == 0)
System.out.println();
else
{
System.out.print(vals[0]);
for(int i = 1; i < vals.length; i++)
System.out.print(" ".concat(String.valueOf(vals[i])));
System.out.println();
}
}
public void printLine(double... vals)
{
if(vals.length == 0)
System.out.println();
else
{
System.out.print(vals[0]);
for(int i = 1; i < vals.length; i++)
System.out.print(" ".concat(String.valueOf(vals[i])));
System.out.println();
}
}
public void printLine(int prec, double... vals)
{
if(vals.length == 0)
System.out.println();
else
{
System.out.printf("%." + prec + "f", vals[0]);
for(int i = 1; i < vals.length; i++)
System.out.printf(" %." + prec + "f", vals[i]);
System.out.println();
}
}
public Collection <Integer> wrap(int[] as)
{
ArrayList <Integer> ans = new ArrayList <Integer> ();
for(int i : as)
ans.add(i);
return ans;
}
public int[] unwrap(Collection <Integer> collection)
{
int[] vals = new int[collection.size()];
int index = 0;
for(int i : collection) vals[index++] = i;
return vals;
}
}
static LinkedList <Node> currentNodes = new LinkedList <Node> ();
static Node initial;
static class Node
{
ArrayList <Node> adjacents = new ArrayList <Node> ();
boolean visited;
boolean visitedOnce;
int id;
public Node(Scanner sc, int i)
{
id = i + 1;
}
ArrayList <Node> findCycle(Node[] allNodes)
{
initial = this;
currentNodes.clear();
for(Node n : allNodes) n.visited = false;
if(findCycle((Node) null))
{
Collections.reverse(currentNodes);
return new ArrayList <Node> (currentNodes);
}
else
return null;
}
boolean findCycle(Node previous)
{
if(visited)
{
if(this == initial)
return true;
else
return false;
}
currentNodes.addFirst(this);
visited = true;
for(Node n : adjacents)
{
if(n != previous)
if(n.findCycle(this))
return true;
}
currentNodes.pollFirst();
return false;
}
boolean checkOk(ArrayList <Node> allRoots, Node[] allNodes)
{
int where = allRoots.indexOf(this);
Node before = allRoots.get((where - 1 + allRoots.size()) % allRoots.size());
Node after = allRoots.get((where + 1 + allRoots.size()) % allRoots.size());
for(Node n : allNodes) n.visited = false;
for(Node n : allRoots)
{
n.visitedOnce = true;
n.visited = true;
if(n == this || n == before || n == after) continue;
for(Node x : adjacents)
if(x == n)
return false;
}
for(Node x : adjacents)
if(x != before && x != after)
if(!x.checkTreeBranch(this))
return false;
return true;
}
boolean checkTreeBranch(Node previous)
{
if(visited) return false;
visitedOnce = true;
visited = true;
for(Node n : adjacents)
if(n != previous)
if(!n.checkTreeBranch(this))
return false;
return true;
}
}
public static void main(String[] args)
{
Scanner sc = new Scanner();
int n = sc.nextInt();
int m = sc.nextInt();
Node[] allNodes = sc.nextObjectArray(Node.class, n);
for(int i = 0; i < m; i++)
{
int a = sc.nextInt() - 1;
int b = sc.nextInt() - 1;
allNodes[a].adjacents.add(allNodes[b]);
allNodes[b].adjacents.add(allNodes[a]);
}
for(Node x : allNodes)
{
ArrayList <Node> cycle = x.findCycle(allNodes);
if(cycle != null)
{
for(Node y : cycle)
if(!y.checkOk(cycle, allNodes))
{
System.out.println("NO");
return;
}
for(Node a : allNodes)
if(!a.visitedOnce)
{
System.out.println("NO");
return;
}
System.out.println("FHTAGN!");
return;
}
}
System.out.println("NO");
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> e[101];
bool used[101];
int cou, d[101];
void dfs(int x, int y, int last) {
d[y] = x;
cou++;
used[x] = 1;
for (int i = 0; i < e[x].size(); i++) {
if (e[x][i] == last) continue;
if (used[e[x][i]]) continue;
dfs(e[x][i], y + 1, x);
}
}
int main() {
int n, m, an = 1, x, y;
scanf("%d%d", &n, &m);
if (m != n) an = 0;
while (m--) {
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
if (an == 0)
puts("NO");
else {
dfs(1, 0, 0);
if (cou == n)
puts("FHTAGN!");
else
puts("NO");
}
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
int N, M, lv[105], flg = 0, cnt = 0;
struct EDGE {
int s, f, nxt;
EDGE() {}
EDGE(int a, int b, int c) : s(a), f(b), nxt(c) {}
} edge[105 * 105];
int head[105], pE;
void addedge(int s, int f) {
edge[pE] = EDGE(s, f, head[s]);
head[s] = pE++;
edge[pE] = EDGE(f, s, head[f]);
head[f] = pE++;
}
void dfs(int dep, int x, int fa) {
int i;
if (lv[x]) {
if (dep >= lv[x] + 3) flg = 1;
return;
}
lv[x] = dep;
cnt++;
for (i = head[x]; i != -1; i = edge[i].nxt) {
int to = edge[i].f;
if (to == fa) continue;
dfs(dep + 1, to, x);
}
}
int main() {
int i, j;
scanf("%d%d", &N, &M);
memset(head, -1, sizeof(head));
pE = 0;
for (i = 0; i < M; i++) {
int s, f;
scanf("%d%d", &s, &f);
addedge(s, f);
}
if (N != M)
printf("NO\n");
else {
dfs(1, 1, -1);
if (flg && cnt == N)
printf("FHTAGN!\n");
else
printf("NO\n");
}
return 0;
}
``` |
### Prompt
In PYTHON, your task is to solve the following problem:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```python
n, m = map(int, raw_input().split())
f = range(n)
def root(f, u):
r = u
while f[r] != r: r = f[r]
while f[u] != r: f[u], u = r, f[u]
return r
cir = 0
for i in xrange(m):
u, v = map(int, raw_input().split())
u, v = root(f, u - 1), root(f, v - 1)
if u == v:
cir += 1
else:
f[u] = v
conn = set([root(f, i) for i in xrange(n)])
print 'NO' if cir != 1 or len(conn) != 1 else 'FHTAGN!'
``` |
### Prompt
Develop a solution in JAVA to the problem described below:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```java
import java.util.Scanner;
public class C {
static boolean[] visited;
static int count = 0;
static int n;
static boolean[][] E;
public static void dfs(int x) {
if (visited[x])
return;
visited[x] = true;
count++;
for (int i = 0; i < n; i++)
if (E[x][i])
dfs(i);
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
n = in.nextInt();
int m = in.nextInt();
E = new boolean[n][n];
visited = new boolean[n];
for (int i = 0; i < m; i++) {
int x = in.nextInt() - 1;
int y = in.nextInt() - 1;
E[x][y] = E[y][x] = true;
}
dfs(0);
if (count == n && m == n)
System.out.println("FHTAGN!");
else
System.out.println("NO");
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers — the number of vertices n and the number of edges m of the graph (1 ≤ n ≤ 100, 0 ≤ m ≤ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 ≤ x, y ≤ n, x ≠ y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int cnt, n, mx, p = 0, parent[101];
void Make_set(int v) { parent[v] = v; }
int Find_set(int v) {
if (parent[v] == v) return v;
return Find_set(parent[v]);
}
void Union_sets(int a, int b) {
a = Find_set(a);
b = Find_set(b);
if (a != b)
parent[b] = a;
else
cnt++;
}
int main() {
int m, q, w, l, f, tui = 0;
cin >> n >> m;
cnt = 0;
for (int k = 1; k <= n; k++) Make_set(k);
for (int k = 1; k <= m; k++) {
cin >> q >> w;
Union_sets(q, w);
}
if (cnt != 1) {
cout << "NO";
return 0;
}
cnt = 0;
for (int k = 1; k <= n; k++) {
if (parent[k] == k) cnt++;
}
if (cnt == 1)
cout << "FHTAGN!";
else
cout << "NO";
return 0;
}
``` |