text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
We just discovered a new data structure in our research group: a suffix three!
It's very useful for natural language processing. Given three languages and three suffixes, a suffix three can determine which language a sentence is written in.
It's super simple, 100% accurate, and doesn't involve advanced machine learning algorithms.
Let us tell you how it works.
* If a sentence ends with "po" the language is Filipino.
* If a sentence ends with "desu" or "masu" the language is Japanese.
* If a sentence ends with "mnida" the language is Korean.
Given this, we need you to implement a suffix three that can differentiate Filipino, Japanese, and Korean.
Oh, did I say three suffixes? I meant four.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 30) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing a single string denoting the sentence. Spaces are represented as underscores (the symbol "_") for ease of reading. The sentence has at least 1 and at most 1000 characters, and consists only of lowercase English letters and underscores. The sentence has no leading or trailing underscores and no two consecutive underscores. It is guaranteed that the sentence ends with one of the four suffixes mentioned above.
Output
For each test case, print a single line containing either "FILIPINO", "JAPANESE", or "KOREAN" (all in uppercase, without quotes), depending on the detected language.
Example
Input
8
kamusta_po
genki_desu
ohayou_gozaimasu
annyeong_hashimnida
hajime_no_ippo
bensamu_no_sentou_houhou_ga_okama_kenpo
ang_halaman_doon_ay_sarisari_singkamasu
si_roy_mustang_ay_namamasu
Output
FILIPINO
JAPANESE
JAPANESE
KOREAN
FILIPINO
FILIPINO
JAPANESE
JAPANESE
Note
The first sentence ends with "po", so it is written in Filipino.
The second and third sentences end with "desu" and "masu", so they are written in Japanese.
The fourth sentence ends with "mnida", so it is written in Korean.
Tags: implementation
Correct Solution:
```
n=int(input())
for i in range(1,n+1):
str=input()
if str[-5:]=="mnida":
print("KOREAN")
elif str[-4:]=="desu" or str[-4:]=="masu":
print("JAPANESE")
else:
print("FILIPINO")
```
| 88,500 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We just discovered a new data structure in our research group: a suffix three!
It's very useful for natural language processing. Given three languages and three suffixes, a suffix three can determine which language a sentence is written in.
It's super simple, 100% accurate, and doesn't involve advanced machine learning algorithms.
Let us tell you how it works.
* If a sentence ends with "po" the language is Filipino.
* If a sentence ends with "desu" or "masu" the language is Japanese.
* If a sentence ends with "mnida" the language is Korean.
Given this, we need you to implement a suffix three that can differentiate Filipino, Japanese, and Korean.
Oh, did I say three suffixes? I meant four.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 30) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing a single string denoting the sentence. Spaces are represented as underscores (the symbol "_") for ease of reading. The sentence has at least 1 and at most 1000 characters, and consists only of lowercase English letters and underscores. The sentence has no leading or trailing underscores and no two consecutive underscores. It is guaranteed that the sentence ends with one of the four suffixes mentioned above.
Output
For each test case, print a single line containing either "FILIPINO", "JAPANESE", or "KOREAN" (all in uppercase, without quotes), depending on the detected language.
Example
Input
8
kamusta_po
genki_desu
ohayou_gozaimasu
annyeong_hashimnida
hajime_no_ippo
bensamu_no_sentou_houhou_ga_okama_kenpo
ang_halaman_doon_ay_sarisari_singkamasu
si_roy_mustang_ay_namamasu
Output
FILIPINO
JAPANESE
JAPANESE
KOREAN
FILIPINO
FILIPINO
JAPANESE
JAPANESE
Note
The first sentence ends with "po", so it is written in Filipino.
The second and third sentences end with "desu" and "masu", so they are written in Japanese.
The fourth sentence ends with "mnida", so it is written in Korean.
Tags: implementation
Correct Solution:
```
t=int(input())
for q in range(t):
a=list(input())
if(a[len(a)-1]=='o'):
print("FILIPINO")
if(a[len(a)-1]=='u'):
print("JAPANESE")
if(a[len(a)-1]=='a'):
print("KOREAN")
```
| 88,501 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We just discovered a new data structure in our research group: a suffix three!
It's very useful for natural language processing. Given three languages and three suffixes, a suffix three can determine which language a sentence is written in.
It's super simple, 100% accurate, and doesn't involve advanced machine learning algorithms.
Let us tell you how it works.
* If a sentence ends with "po" the language is Filipino.
* If a sentence ends with "desu" or "masu" the language is Japanese.
* If a sentence ends with "mnida" the language is Korean.
Given this, we need you to implement a suffix three that can differentiate Filipino, Japanese, and Korean.
Oh, did I say three suffixes? I meant four.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 30) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing a single string denoting the sentence. Spaces are represented as underscores (the symbol "_") for ease of reading. The sentence has at least 1 and at most 1000 characters, and consists only of lowercase English letters and underscores. The sentence has no leading or trailing underscores and no two consecutive underscores. It is guaranteed that the sentence ends with one of the four suffixes mentioned above.
Output
For each test case, print a single line containing either "FILIPINO", "JAPANESE", or "KOREAN" (all in uppercase, without quotes), depending on the detected language.
Example
Input
8
kamusta_po
genki_desu
ohayou_gozaimasu
annyeong_hashimnida
hajime_no_ippo
bensamu_no_sentou_houhou_ga_okama_kenpo
ang_halaman_doon_ay_sarisari_singkamasu
si_roy_mustang_ay_namamasu
Output
FILIPINO
JAPANESE
JAPANESE
KOREAN
FILIPINO
FILIPINO
JAPANESE
JAPANESE
Note
The first sentence ends with "po", so it is written in Filipino.
The second and third sentences end with "desu" and "masu", so they are written in Japanese.
The fourth sentence ends with "mnida", so it is written in Korean.
Tags: implementation
Correct Solution:
```
for _ in range(int(input())):
s=input()
if s[-2:]=='po':
print("FILIPINO")
elif s[-4:]=='masu' or s[-4:]=='desu':
print("JAPANESE")
else:
print("KOREAN")
```
| 88,502 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We just discovered a new data structure in our research group: a suffix three!
It's very useful for natural language processing. Given three languages and three suffixes, a suffix three can determine which language a sentence is written in.
It's super simple, 100% accurate, and doesn't involve advanced machine learning algorithms.
Let us tell you how it works.
* If a sentence ends with "po" the language is Filipino.
* If a sentence ends with "desu" or "masu" the language is Japanese.
* If a sentence ends with "mnida" the language is Korean.
Given this, we need you to implement a suffix three that can differentiate Filipino, Japanese, and Korean.
Oh, did I say three suffixes? I meant four.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 30) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing a single string denoting the sentence. Spaces are represented as underscores (the symbol "_") for ease of reading. The sentence has at least 1 and at most 1000 characters, and consists only of lowercase English letters and underscores. The sentence has no leading or trailing underscores and no two consecutive underscores. It is guaranteed that the sentence ends with one of the four suffixes mentioned above.
Output
For each test case, print a single line containing either "FILIPINO", "JAPANESE", or "KOREAN" (all in uppercase, without quotes), depending on the detected language.
Example
Input
8
kamusta_po
genki_desu
ohayou_gozaimasu
annyeong_hashimnida
hajime_no_ippo
bensamu_no_sentou_houhou_ga_okama_kenpo
ang_halaman_doon_ay_sarisari_singkamasu
si_roy_mustang_ay_namamasu
Output
FILIPINO
JAPANESE
JAPANESE
KOREAN
FILIPINO
FILIPINO
JAPANESE
JAPANESE
Note
The first sentence ends with "po", so it is written in Filipino.
The second and third sentences end with "desu" and "masu", so they are written in Japanese.
The fourth sentence ends with "mnida", so it is written in Korean.
Submitted Solution:
```
def main():
word_count = int(input())
words = []
for i in range(word_count):
words.append(input())
for word in words:
if word[-2:] == 'po':
print('FILIPINO')
elif word[-4:] == 'desu' or word[-4:] == 'masu':
print('JAPANESE')
elif word[-5:] == 'mnida':
print('KOREAN')
else:
print('not possible..')
if __name__ == '__main__':
main()
```
Yes
| 88,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We just discovered a new data structure in our research group: a suffix three!
It's very useful for natural language processing. Given three languages and three suffixes, a suffix three can determine which language a sentence is written in.
It's super simple, 100% accurate, and doesn't involve advanced machine learning algorithms.
Let us tell you how it works.
* If a sentence ends with "po" the language is Filipino.
* If a sentence ends with "desu" or "masu" the language is Japanese.
* If a sentence ends with "mnida" the language is Korean.
Given this, we need you to implement a suffix three that can differentiate Filipino, Japanese, and Korean.
Oh, did I say three suffixes? I meant four.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 30) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing a single string denoting the sentence. Spaces are represented as underscores (the symbol "_") for ease of reading. The sentence has at least 1 and at most 1000 characters, and consists only of lowercase English letters and underscores. The sentence has no leading or trailing underscores and no two consecutive underscores. It is guaranteed that the sentence ends with one of the four suffixes mentioned above.
Output
For each test case, print a single line containing either "FILIPINO", "JAPANESE", or "KOREAN" (all in uppercase, without quotes), depending on the detected language.
Example
Input
8
kamusta_po
genki_desu
ohayou_gozaimasu
annyeong_hashimnida
hajime_no_ippo
bensamu_no_sentou_houhou_ga_okama_kenpo
ang_halaman_doon_ay_sarisari_singkamasu
si_roy_mustang_ay_namamasu
Output
FILIPINO
JAPANESE
JAPANESE
KOREAN
FILIPINO
FILIPINO
JAPANESE
JAPANESE
Note
The first sentence ends with "po", so it is written in Filipino.
The second and third sentences end with "desu" and "masu", so they are written in Japanese.
The fourth sentence ends with "mnida", so it is written in Korean.
Submitted Solution:
```
n = int(input())
for i in range(n):
s = input()
sz = len(s)
if(sz >= 2 and s[-2:] == "po"):
print("FILIPINO")
elif(sz >= 4 and (s[-4:] == "desu" or s[-4:] == "masu")):
print("JAPANESE")
elif(sz >= 5 and s[-5:] == "mnida"):
print("KOREAN")
```
Yes
| 88,504 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We just discovered a new data structure in our research group: a suffix three!
It's very useful for natural language processing. Given three languages and three suffixes, a suffix three can determine which language a sentence is written in.
It's super simple, 100% accurate, and doesn't involve advanced machine learning algorithms.
Let us tell you how it works.
* If a sentence ends with "po" the language is Filipino.
* If a sentence ends with "desu" or "masu" the language is Japanese.
* If a sentence ends with "mnida" the language is Korean.
Given this, we need you to implement a suffix three that can differentiate Filipino, Japanese, and Korean.
Oh, did I say three suffixes? I meant four.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 30) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing a single string denoting the sentence. Spaces are represented as underscores (the symbol "_") for ease of reading. The sentence has at least 1 and at most 1000 characters, and consists only of lowercase English letters and underscores. The sentence has no leading or trailing underscores and no two consecutive underscores. It is guaranteed that the sentence ends with one of the four suffixes mentioned above.
Output
For each test case, print a single line containing either "FILIPINO", "JAPANESE", or "KOREAN" (all in uppercase, without quotes), depending on the detected language.
Example
Input
8
kamusta_po
genki_desu
ohayou_gozaimasu
annyeong_hashimnida
hajime_no_ippo
bensamu_no_sentou_houhou_ga_okama_kenpo
ang_halaman_doon_ay_sarisari_singkamasu
si_roy_mustang_ay_namamasu
Output
FILIPINO
JAPANESE
JAPANESE
KOREAN
FILIPINO
FILIPINO
JAPANESE
JAPANESE
Note
The first sentence ends with "po", so it is written in Filipino.
The second and third sentences end with "desu" and "masu", so they are written in Japanese.
The fourth sentence ends with "mnida", so it is written in Korean.
Submitted Solution:
```
t = int(input())
for i in range(t):
s = input()
if(s[-1] == 'a'):
print("KOREAN")
elif(s[-1] == 'o'):
print("FILIPINO")
else:
print("JAPANESE")
```
Yes
| 88,505 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We just discovered a new data structure in our research group: a suffix three!
It's very useful for natural language processing. Given three languages and three suffixes, a suffix three can determine which language a sentence is written in.
It's super simple, 100% accurate, and doesn't involve advanced machine learning algorithms.
Let us tell you how it works.
* If a sentence ends with "po" the language is Filipino.
* If a sentence ends with "desu" or "masu" the language is Japanese.
* If a sentence ends with "mnida" the language is Korean.
Given this, we need you to implement a suffix three that can differentiate Filipino, Japanese, and Korean.
Oh, did I say three suffixes? I meant four.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 30) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing a single string denoting the sentence. Spaces are represented as underscores (the symbol "_") for ease of reading. The sentence has at least 1 and at most 1000 characters, and consists only of lowercase English letters and underscores. The sentence has no leading or trailing underscores and no two consecutive underscores. It is guaranteed that the sentence ends with one of the four suffixes mentioned above.
Output
For each test case, print a single line containing either "FILIPINO", "JAPANESE", or "KOREAN" (all in uppercase, without quotes), depending on the detected language.
Example
Input
8
kamusta_po
genki_desu
ohayou_gozaimasu
annyeong_hashimnida
hajime_no_ippo
bensamu_no_sentou_houhou_ga_okama_kenpo
ang_halaman_doon_ay_sarisari_singkamasu
si_roy_mustang_ay_namamasu
Output
FILIPINO
JAPANESE
JAPANESE
KOREAN
FILIPINO
FILIPINO
JAPANESE
JAPANESE
Note
The first sentence ends with "po", so it is written in Filipino.
The second and third sentences end with "desu" and "masu", so they are written in Japanese.
The fourth sentence ends with "mnida", so it is written in Korean.
Submitted Solution:
```
for i in range(int(input())):
s=input()
n=len(s)
x=s[n-5:n]
if(x=="mnida"):
print("KOREAN")
x=s[n-4:n]
if x=="desu" or x=="masu":
print("JAPANESE")
x=s[n-2:n]
if x=="po":
print("FILIPINO")
```
Yes
| 88,506 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We just discovered a new data structure in our research group: a suffix three!
It's very useful for natural language processing. Given three languages and three suffixes, a suffix three can determine which language a sentence is written in.
It's super simple, 100% accurate, and doesn't involve advanced machine learning algorithms.
Let us tell you how it works.
* If a sentence ends with "po" the language is Filipino.
* If a sentence ends with "desu" or "masu" the language is Japanese.
* If a sentence ends with "mnida" the language is Korean.
Given this, we need you to implement a suffix three that can differentiate Filipino, Japanese, and Korean.
Oh, did I say three suffixes? I meant four.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 30) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing a single string denoting the sentence. Spaces are represented as underscores (the symbol "_") for ease of reading. The sentence has at least 1 and at most 1000 characters, and consists only of lowercase English letters and underscores. The sentence has no leading or trailing underscores and no two consecutive underscores. It is guaranteed that the sentence ends with one of the four suffixes mentioned above.
Output
For each test case, print a single line containing either "FILIPINO", "JAPANESE", or "KOREAN" (all in uppercase, without quotes), depending on the detected language.
Example
Input
8
kamusta_po
genki_desu
ohayou_gozaimasu
annyeong_hashimnida
hajime_no_ippo
bensamu_no_sentou_houhou_ga_okama_kenpo
ang_halaman_doon_ay_sarisari_singkamasu
si_roy_mustang_ay_namamasu
Output
FILIPINO
JAPANESE
JAPANESE
KOREAN
FILIPINO
FILIPINO
JAPANESE
JAPANESE
Note
The first sentence ends with "po", so it is written in Filipino.
The second and third sentences end with "desu" and "masu", so they are written in Japanese.
The fourth sentence ends with "mnida", so it is written in Korean.
Submitted Solution:
```
for _ in range(int(input())):
s=input().split('_')
last=s[-1]
if "po" in last:
print("FILIPINO")
elif "masu" in last or "desu" in last:
print("JAPANESE")
elif "mnida" in last:
print("KOREAN")
```
No
| 88,507 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We just discovered a new data structure in our research group: a suffix three!
It's very useful for natural language processing. Given three languages and three suffixes, a suffix three can determine which language a sentence is written in.
It's super simple, 100% accurate, and doesn't involve advanced machine learning algorithms.
Let us tell you how it works.
* If a sentence ends with "po" the language is Filipino.
* If a sentence ends with "desu" or "masu" the language is Japanese.
* If a sentence ends with "mnida" the language is Korean.
Given this, we need you to implement a suffix three that can differentiate Filipino, Japanese, and Korean.
Oh, did I say three suffixes? I meant four.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 30) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing a single string denoting the sentence. Spaces are represented as underscores (the symbol "_") for ease of reading. The sentence has at least 1 and at most 1000 characters, and consists only of lowercase English letters and underscores. The sentence has no leading or trailing underscores and no two consecutive underscores. It is guaranteed that the sentence ends with one of the four suffixes mentioned above.
Output
For each test case, print a single line containing either "FILIPINO", "JAPANESE", or "KOREAN" (all in uppercase, without quotes), depending on the detected language.
Example
Input
8
kamusta_po
genki_desu
ohayou_gozaimasu
annyeong_hashimnida
hajime_no_ippo
bensamu_no_sentou_houhou_ga_okama_kenpo
ang_halaman_doon_ay_sarisari_singkamasu
si_roy_mustang_ay_namamasu
Output
FILIPINO
JAPANESE
JAPANESE
KOREAN
FILIPINO
FILIPINO
JAPANESE
JAPANESE
Note
The first sentence ends with "po", so it is written in Filipino.
The second and third sentences end with "desu" and "masu", so they are written in Japanese.
The fourth sentence ends with "mnida", so it is written in Korean.
Submitted Solution:
```
t=int(input())
while(t):
s=input()
x=len(s)
if s[x-2:]=="po":
print("FILIPINO")
elif s[x-4:]=="desu" or s[x-4:]=="masu":
print("JAPNESE")
else:
print("KOREAN")
t=t-1
```
No
| 88,508 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We just discovered a new data structure in our research group: a suffix three!
It's very useful for natural language processing. Given three languages and three suffixes, a suffix three can determine which language a sentence is written in.
It's super simple, 100% accurate, and doesn't involve advanced machine learning algorithms.
Let us tell you how it works.
* If a sentence ends with "po" the language is Filipino.
* If a sentence ends with "desu" or "masu" the language is Japanese.
* If a sentence ends with "mnida" the language is Korean.
Given this, we need you to implement a suffix three that can differentiate Filipino, Japanese, and Korean.
Oh, did I say three suffixes? I meant four.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 30) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing a single string denoting the sentence. Spaces are represented as underscores (the symbol "_") for ease of reading. The sentence has at least 1 and at most 1000 characters, and consists only of lowercase English letters and underscores. The sentence has no leading or trailing underscores and no two consecutive underscores. It is guaranteed that the sentence ends with one of the four suffixes mentioned above.
Output
For each test case, print a single line containing either "FILIPINO", "JAPANESE", or "KOREAN" (all in uppercase, without quotes), depending on the detected language.
Example
Input
8
kamusta_po
genki_desu
ohayou_gozaimasu
annyeong_hashimnida
hajime_no_ippo
bensamu_no_sentou_houhou_ga_okama_kenpo
ang_halaman_doon_ay_sarisari_singkamasu
si_roy_mustang_ay_namamasu
Output
FILIPINO
JAPANESE
JAPANESE
KOREAN
FILIPINO
FILIPINO
JAPANESE
JAPANESE
Note
The first sentence ends with "po", so it is written in Filipino.
The second and third sentences end with "desu" and "masu", so they are written in Japanese.
The fourth sentence ends with "mnida", so it is written in Korean.
Submitted Solution:
```
t=int(input())
for _ in range(t):
st=input()
if "po" in st:
print("FILIPINO")
elif "desu" or "masu":
print("JAPANESE")
else:
print("KOREAN")
```
No
| 88,509 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We just discovered a new data structure in our research group: a suffix three!
It's very useful for natural language processing. Given three languages and three suffixes, a suffix three can determine which language a sentence is written in.
It's super simple, 100% accurate, and doesn't involve advanced machine learning algorithms.
Let us tell you how it works.
* If a sentence ends with "po" the language is Filipino.
* If a sentence ends with "desu" or "masu" the language is Japanese.
* If a sentence ends with "mnida" the language is Korean.
Given this, we need you to implement a suffix three that can differentiate Filipino, Japanese, and Korean.
Oh, did I say three suffixes? I meant four.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 30) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing a single string denoting the sentence. Spaces are represented as underscores (the symbol "_") for ease of reading. The sentence has at least 1 and at most 1000 characters, and consists only of lowercase English letters and underscores. The sentence has no leading or trailing underscores and no two consecutive underscores. It is guaranteed that the sentence ends with one of the four suffixes mentioned above.
Output
For each test case, print a single line containing either "FILIPINO", "JAPANESE", or "KOREAN" (all in uppercase, without quotes), depending on the detected language.
Example
Input
8
kamusta_po
genki_desu
ohayou_gozaimasu
annyeong_hashimnida
hajime_no_ippo
bensamu_no_sentou_houhou_ga_okama_kenpo
ang_halaman_doon_ay_sarisari_singkamasu
si_roy_mustang_ay_namamasu
Output
FILIPINO
JAPANESE
JAPANESE
KOREAN
FILIPINO
FILIPINO
JAPANESE
JAPANESE
Note
The first sentence ends with "po", so it is written in Filipino.
The second and third sentences end with "desu" and "masu", so they are written in Japanese.
The fourth sentence ends with "mnida", so it is written in Korean.
Submitted Solution:
```
n = int(input())
for i in range(n):
s = input().split("_")[-1]
if s.lower() == "po":
print("FILIPINO")
elif s.lower() == "desu" or s.lower() == "masu":
print("JAPANESE")
elif s.lower() == "mnida":
print("KOREAN")
```
No
| 88,510 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Tags: implementation, strings
Correct Solution:
```
#!/usr/bin/env python3.7
n = int(input())
for _ in range(n):
a, b, c = input(), input(), input()
for x in zip(a, b, c):
xl = len(set(x))
if xl == 3:
print("NO")
break
elif xl == 2:
if x[0]==x[1]:
print("NO")
break
else:
print("YES")
```
| 88,511 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Tags: implementation, strings
Correct Solution:
```
def solve():
a=input()
b=input()
c=input()
n=len(a)
for x in range(n):
if a[x]!=c[x] and b[x]!=c[x]:
return "NO"
return "YES"
t=int(input())
for _ in range(t):
print(solve())
```
| 88,512 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Tags: implementation, strings
Correct Solution:
```
t = int(input().strip())
for _ in range(t):
a = input().strip()
b = input().strip()
c = input().strip()
ans = True
for i in range(len(a)):
if c[i] == a[i] or c[i] == b[i]:
continue
else:
ans = False
break
if ans:
print("YES")
else:
print("NO")
```
| 88,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Tags: implementation, strings
Correct Solution:
```
for _ in [0]*int(input()):
v = list(input())
x = list(input())
q = list(input())
s = ''
k = True
for i in range(len(v)):
if x[i]==q[i]:
s = v[i]
v[i] = q[i]
q[i] = s
s = ''
elif v[i]==q[i]:
s = x[i]
x[i] = q[i]
q[i] = s
s =''
elif v[i]==x[i]:
k = False
if v == x and k:
print("YES")
else:
print("NO")
```
| 88,514 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Tags: implementation, strings
Correct Solution:
```
t=int(input())
while(t):
a=input()
b=input()
c=input()
s1=list(a)
s2=list(b)
s3=list(c)
c1=0
for i in range(len(s1)):
if(s1[i]==s2[i]==s3[i]):
c1+=1
else:
if(s1[i]==s3[i]):
t1=s3[i]
s3[i]=s2[i]
s2[i]=t1
c1+=1
else:
t1=s3[i]
s3[i]=s1[i]
s1[i]=t1
c1+=1
if(s1==s2 and c1==len(a)):
print("YES")
else:
print("NO")
t=t-1
```
| 88,515 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Tags: implementation, strings
Correct Solution:
```
for t in range(int(input())):
a, b, c = input(), input(), input()
anser = 'YES'
for i in range(len(a)):
if not (c[i] == a[i] or c[i] == b[i]):
anser = 'NO'
break
print(anser)
```
| 88,516 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Tags: implementation, strings
Correct Solution:
```
for _ in range(int(input())):
a,b,c=input(),input(),input()
ans="YES"
for i in range(len(a)):
if a[i]!=c[i] and b[i]!=c[i]:ans="NO"
print(ans)
```
| 88,517 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Tags: implementation, strings
Correct Solution:
```
for _ in range(int(input())):
a=str(input())
b=str(input())
c=str(input())
f=0
for i in range(len(a)):
if a[i]==b[i] and a[i] == c[i] or a[i] != b[i] and a[i] == c[i] or c[i] == b[i]:
f=1
else:
f=0
break
if f==1:
print('YES')
else:
print('NO')
```
| 88,518 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Submitted Solution:
```
for i in range(int(input())):
a, b, c = [input() for j in range(3)]
ans = 'yes'
for j in range(len(a)):
if c[j] != a[j] and c[j] != b[j]:
ans = 'no'
break
print(ans)
```
Yes
| 88,519 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Submitted Solution:
```
# JAI SHREE RAM
import math; from collections import *
import sys; from functools import reduce
# sys.setrecursionlimit(10**6)
def get_ints(): return map(int, input().strip().split())
def get_list(): return list(get_ints())
def get_string(): return list(input().strip().split())
def printxsp(*args): return print(*args, end="")
def printsp(*args): return print(*args, end=" ")
UGLYMOD = int(1e9)+7; SEXYMOD = 998244353; MAXN = int(1e5)
# sys.stdin=open("input.txt","r");sys.stdout=open("output.txt","w")
for _testcases_ in range(int(input())):
a = input()
b = input()
c = input()
flag = True
for i in range(len(a)):
lenOfNums = len(set([a[i], b[i], c[i]]))
if lenOfNums == 3:
flag = False
break
elif lenOfNums == 2 and a[i] == b[i]:
flag = False
break
print("YES" if flag else "NO")
'''
>>> COMMENT THE STDIN!! CHANGE ONLINE JUDGE !!
THE LOGIC AND APPROACH IS MINE @luctivud ( UDIT GUPTA )
Link may be copy-pasted here if it's taken from other source.
DO NOT PLAGIARISE.
>>> COMMENT THE STDIN!! CHANGE ONLINE JUDGE !!
'''
```
Yes
| 88,520 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Submitted Solution:
```
t=int(input())
for i in range(t):
a=input()
b=input()
c=input()
d=0
x=0
for i in c:
if i== a[x]:
d=1
elif i==b[x]:
d=1
else:
d=0
break
x+=1
if d==1:
print("YES")
else:
print("NO")
```
Yes
| 88,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Submitted Solution:
```
t = int(input())
for i in range(t):
a = input()
b = input()
c = input()
fl = True
for j in range(len(c)):
if c[j] == a[j] or c[j] == b[j]:
pass
else:
fl = False
print("NO")
break
if fl:
print("YES")
```
Yes
| 88,522 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Submitted Solution:
```
import sys
T = int(sys.stdin.readline())
for i in range(T):
a = list(map(str, sys.stdin.readline().strip()))
b = list(map(str, sys.stdin.readline().strip()))
c = list(map(str, sys.stdin.readline().strip()))
check = True
for j in range(len(c)):
if b[j] == c[j] or a[j] in [b[j], c[j]]:
continue
else:
check = False
break
if check:
print("YES")
else:
print("NO")
```
No
| 88,523 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Submitted Solution:
```
def swap(a,b):
temp=b
b=a
a=temp
return temp
test=int(input())
while test!=0:
a=input()
a1=list(a)
b=input()
b1=list(b)
c=input()
c1=list(c)
count=0
for i in range(len(a1)):
if a[i]==b[i]:
count+=1
if count==len(a1):
print("YES")
else:
flag=0
for i in range(len(a1)):
if a[i]!=b[i]:
temp=swap(a[i],c[i])
if temp!=b[i]:
temp2=swap(b[i],c[i])
if temp2!=a[i]:
flag=1
break
else:
temp=swap(a[i],c[i])
if temp!=b[i]:
temp2=swap(b[i],c[i])
if temp2!=a[i]:
flag=1
break
if flag==1:
print("NO")
else:
print("YES")
test-=1
```
No
| 88,524 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Submitted Solution:
```
t=int(input())
for i in range(t):
a=list(map(str,input().split()))
b=list(map(str,input().split()))
c=list(map(str,input().split()))
for i in range(len(a)):
if a[i]!=b[i]:
if a[i]==c[i]:
b[i]=c[i]
if b[i]==c[i]:
a[i]=c[i]
if a==b:
print('YES')
else:
print('NO')
```
No
| 88,525 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
Submitted Solution:
```
for _ in range(int(input())):
a=str(input())
b=str(input())
c=str(input())
if a==b or b==c or a==c or a[::-1]==b or a[::-1]==c or b[::-1]==a or b[::-1]==c or c[::-1]==a or c[::-1]==b:
print('YES')
else:
print("NO")
```
No
| 88,526 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
t = int(input())
for i in range(t):
x = int(input())
print("1", x - 1)
```
| 88,527 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
t=int(input())
for testcase in range(t):
sum=int(input())
print(1,sum-1)
```
| 88,528 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
t = int(input())
while t:
x = int(input())
print('1 ', x - 1)
t -= 1
```
| 88,529 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
n=int(input())
for i in range(n):
n1=int(input())
print(1,n1-1)
```
| 88,530 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
for i in range(int(input())):
n=int(input())
print(1,n-1,end=' ')
```
| 88,531 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
t = int(input())
count = 0
ans = []
while count < t :
x = int(input())
ans.append(x)
count +=1
for y in ans:
print ("1" , y-1)
```
| 88,532 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
cases=int(input())
for case in range(cases):
number=int(input())
for i in range(1,number//2+1):
if (number-i)%i==0:
print(i,number-i)
break
```
| 88,533 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
t = int(input())
for tc in range(t):
x = int(input())
a = x-1
b = 1
print(a, b)
```
| 88,534 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
# ANSHUL GAUTAM
# IIIT-D
from math import *
from copy import *
from string import * # alpha = ascii_lowercase
from random import * # l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import * # bisect_left(arr,x,start,end) => start and end parameters are temporary
from sys import stdin # bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize
from operator import * # d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter # d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)
'''
'''
def solve(l):
n = len(l)
T = int(input())
for _ in range(T):
N = int(stdin.readline())
print(1,N-1)
```
Yes
| 88,535 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
t=int(input())
while(t>0):
n=int(input())
print(1,n-1,sep=' ')
t=t-1
```
Yes
| 88,536 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
teste = int(input())
for i in range(teste):
valor = int(input())
print(1,valor-1)
```
Yes
| 88,537 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
if n % 2 == 0:
print(n//2, n//2)
else:
print(1, n - 1)
```
Yes
| 88,538 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
import math
t = int(input())
answers=[]
for n in range(t):
case = int(input())
for a in range(9):
if (a == 0): continue
for b in range(9):
if (b == 0): continue
gcd = math.gcd(a, b)
lcm = (a*b)/gcd
if ((gcd + lcm) == case):
answers.append([a, b])
break
for a in answers:
print(a[0], a[1])
```
No
| 88,539 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
print(1, 1)
print(6, 4)
```
No
| 88,540 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
t = int(input())
for _ in range(t):
x = int(input())
for i in range(1,x):
k = False
for j in range(i+1,x):
g = gcd(i,j)
if g + (i*j)/g == x:
print(i,j)
k = True
break
if k:
break
```
No
| 88,541 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
Submitted Solution:
```
t = int(input())
for x in range(t):
n = int(input())
if n == 2:
print(1, 1)
continue
print(1, n)
```
No
| 88,542 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Tags: brute force, constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
import copy
t = int(input())
def fn(ivs, v, n):
result = list()
while len(result) < n - 1:
w = None
for iv in ivs:
if v in iv:
iv.remove(v)
if len(iv) == 1:
if w is None:
w = iv.pop()
else:
return
if w is None:
return
result.append(v)
v = w
result.append(v)
return result
def check(res, sivs, n):
if res is None:
return False
for i in range(1, n):
good = False
for j in range(i):
if tuple(sorted(res[j:i + 1])) in sivs:
good = True
if not good:
return False
return True
for _ in range(t):
n = int(input())
ivs = list()
for _ in range(n - 1):
ivs.append(set(map(int, input().split(' ')[1:])))
sivs = set()
for iv in ivs:
sivs.add(tuple(iv))
for v in range(1, n + 1):
res = fn(copy.deepcopy(ivs), v, n)
if check(res, sivs, n):
print(' '.join(map(str, res)))
break
```
| 88,543 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Tags: brute force, constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
import io
import os
from collections import defaultdict
from copy import deepcopy
def solve(N, segments):
def greedy(ans, memToSeg, first):
# If a number is only in a single segment, it's either the first or last element
# We need to be able to pick the last element for us to inductively remove a segment and look for the next element that is only contained in one segment
# If there's more than one candidate, try both as the potential first
# Initially our first is unconstrained
while len(memToSeg) > 2:
candidates = [k for k, v in memToSeg.items() if len(v) == 1 and k != first]
if len(candidates) != 1:
if len(candidates) == 0:
# If we found zero candidates, it means our choice of first is invalid
assert first is not None
return None
# Otherwise we found our candidates for first and last
assert len(candidates) == 2 and first is None
for c in candidates:
# Branch the greedy to try both cases. This will only happen once
temp = greedy(deepcopy(ans), deepcopy(memToSeg), first=c)
if temp is None:
continue
# Double check that our answer works
numToIndex = {x: i for i, x in enumerate(temp)}
bad = False
for segment in segments:
mn = min(numToIndex[x] for x in segment)
mx = max(numToIndex[x] for x in segment)
if mx - mn + 1 != len(segment):
bad = True
break
if not bad:
return temp
assert False
else:
# If we only had one candidate we can continue inductively removing it as the last element
assert len(candidates) == 1
(k,) = candidates
v = memToSeg[candidates[0]]
assert len(v) == 1
(index,) = v
ans.append(k)
for x in segments[index]:
memToSeg[x].remove(index)
if len(memToSeg[x]) == 0:
assert x == k
del memToSeg[x]
# In the very end we have a single segment left of length 2 and both remaining numbers point to it
firstTwo = []
assert len(memToSeg) == 2
for k, v in memToSeg.items():
assert len(v) == 1
firstTwo.append(k)
if first is not None:
assert first in firstTwo
if firstTwo[0] == first:
ans.append(firstTwo[1])
ans.append(firstTwo[0])
else:
ans.append(firstTwo[0])
ans.append(firstTwo[1])
else:
for segment in segments:
if firstTwo[0] in segment and firstTwo[1] not in segment:
ans.append(firstTwo[0])
ans.append(firstTwo[1])
break
if firstTwo[1] in segment and firstTwo[0] not in segment:
ans.append(firstTwo[1])
ans.append(firstTwo[0])
break
else:
ans.extend(firstTwo)
return ans
memToSeg = defaultdict(set)
for i, segment in enumerate(segments):
for x in segment:
memToSeg[x].add(i)
return " ".join(map(str, reversed(greedy([], memToSeg, None))))
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
for t in range(T):
(N,) = [int(x) for x in input().split()]
segments = []
for i in range(N - 1):
segment = [int(x) for x in input().split()]
assert segment[0] == len(segment) - 1
segments.append(segment[1:])
ans = solve(N, segments)
print(ans)
```
| 88,544 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Tags: brute force, constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
from collections import Counter
from itertools import chain
def dfs(n, r, hint_sets, count, removed, result):
if len(result) == n - 1:
last = (set(range(1, n + 1)) - set(result)).pop()
result.append(last)
return True
i, including_r = 0, None
for i, including_r in enumerate(hint_sets):
if i in removed:
continue
if r in including_r:
break
removed.add(i)
next_r = []
for q in including_r:
count[q] -= 1
if count[q] == 1:
next_r.append(q)
if not next_r:
return False
if len(next_r) == 2:
nr = -1
can1, can2 = next_r
for i, h in enumerate(hint_sets):
if i not in removed:
continue
if can1 in h and can2 not in h:
nr = can1
break
if can1 not in h and can2 in h:
nr = can2
break
if nr == -1:
nr = can1
else:
nr = next_r[0]
result.append(nr)
res = dfs(n, nr, hint_sets, count, removed, result)
if res:
return True
result.pop()
for q in including_r:
count[q] += 1
return False
t = int(input())
buf = []
for l in range(t):
n = int(input())
hints = []
for _ in range(n - 1):
k, *ppp = map(int, input().split())
hints.append(ppp)
count = Counter(chain.from_iterable(hints))
most_common = count.most_common()
hint_sets = list(map(set, hints))
r = most_common[-1][0]
result = [r]
if dfs(n, r, hint_sets, dict(count), set(), result):
buf.append(' '.join(map(str, result[::-1])))
continue
r = most_common[-2][0]
result = [r]
assert dfs(n, r, hint_sets, dict(count), set(), result)
buf.append(' '.join(map(str, result[::-1])))
print('\n'.join(map(str, buf)))
```
| 88,545 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Tags: brute force, constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
segs = [tuple(sorted(int(x) for x in input().split()[1:])) for __ in range(n - 1)]
segs_set = set(segs)
segs_having = [[j for j, seg in enumerate(segs) if i in seg] for i in range(n + 1)]
unsorted = list(range(1, n + 1))
ans = []
def rb(avoid=0):
if len(unsorted) > 1:
candidate_lasts = [i for i in unsorted if len(segs_having[i]) == 1 and i != avoid]
for last in candidate_lasts:
seg_to_remove = segs_having[last][0]
for ii in segs[seg_to_remove]: segs_having[ii].remove(seg_to_remove)
unsorted.remove(last)
ans.insert(0, last)
if rb(avoid=next((i for i in candidate_lasts if i != last), avoid)):
return True
ans.pop(0)
unsorted.append(last)
for ii in segs[seg_to_remove]: segs_having[ii].append(seg_to_remove)
return False
else:
ans.insert(0, unsorted[0])
valid = all(any(tuple(sorted(ans[j:i])) in segs_set for j in range(0, i - 1)) for i in range(2, n + 1))
if not valid: ans.pop(0)
return valid
rb()
print(*ans)
```
| 88,546 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Tags: brute force, constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
def ok():
if len(ans)<n:return False
for r,si in enumerate(sii,2):
s=ss[si]
cur=set(ans[r-len(s):r])
if s!=cur:return False
return True
for _ in range(II()):
n=II()
ee=[[n**2]*n for _ in range(n)]
for ei in range(n):ee[ei][ei]=0
ss=[set(LI()[1:]) for _ in range(n-1)]
for a0 in range(1,n+1):
used=set([a0])
ans=[a0]
sii=[]
for _ in range(n-1):
nxt=[]
for si,s in enumerate(ss):
cur=s-used
if len(cur)==1:
for a in cur:nxt.append(a)
sii.append(si)
if len(nxt)!=1:break
ans.append(nxt[0])
used.add(nxt[0])
if ok():break
print(*ans)
main()
```
| 88,547 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Tags: brute force, constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
if __name__== "__main__":
t = int(input())
for _ in range(t):
n = int(input())
ns = {}
for _ in range(n - 1):
_, *p = map(int, input().split())
tp = tuple(p)
for pp in p:
ns.setdefault(pp, set()).add(tp)
first = [(k, list(v)[0]) for k, v in ns.items() if len(v) == 1]
found = False
while not found:
nns = {k: v.copy() for k, v in ns.items()}
min_index = {}
cur, cur_tp = first.pop()
result = [cur]
failed = False
while len(nns) > 0 and not failed:
nxt = set()
for k in cur_tp:
mi = n - len(result) - len(cur_tp) + 1
min_index[k] = max(min_index.get(k, 0), mi)
nsk = nns[k]
nsk.remove(cur_tp)
if k == cur:
nns.pop(k)
elif len(nsk) == 1:
nxt.add(k)
if len(nns) == len(nxt) or len(nns) == 1:
break
if len(nxt) == 0:
failed = True
else:
mmi = -1
for nx in nxt:
if min_index[nx] > mmi:
mmi = min_index[nx]
cur = nx
cur_tp = list(nns[cur])[0]
result.append(cur)
if not failed:
found = True
if len(nns) == 1:
result.append(nns.popitem()[0])
else:
a1, a2 = nns.keys()
if min_index[a1] == 1:
result.extend((a1, a2))
else:
result.extend((a2, a1))
print(" ".join(map(str, reversed(result))))
```
| 88,548 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Tags: brute force, constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
from collections import Counter
from itertools import chain
def dfs(n, r, hint_sets, count, removed, result):
# print(n, r, hint_sets, count, removed, result)
if len(result) == n - 1:
last = (set(range(1, n + 1)) - set(result)).pop()
result.append(last)
return True
i, including_r = 0, None
for i, including_r in enumerate(hint_sets):
if i in removed:
continue
if r in including_r:
break
removed.add(i)
next_r = []
for q in including_r:
count[q] -= 1
if count[q] == 1:
next_r.append(q)
if not next_r:
return False
# print(r, next_r, result)
if len(next_r) == 2:
nr = -1
can1, can2 = next_r
for h in hint_sets:
if can1 in h and can2 not in h and not h.isdisjoint(result):
nr = can1
break
if can1 not in h and can2 in h and not h.isdisjoint(result):
nr = can2
break
if nr == -1:
nr = can1
else:
nr = next_r[0]
result.append(nr)
res = dfs(n, nr, hint_sets, count, removed, result)
if res:
return True
result.pop()
for q in including_r:
count[q] += 1
return False
t = int(input())
buf = []
for l in range(t):
n = int(input())
hints = []
for _ in range(n - 1):
k, *ppp = map(int, input().split())
hints.append(ppp)
count = Counter(chain.from_iterable(hints))
most_common = count.most_common()
hint_sets = list(map(set, hints))
r = most_common[-1][0]
result = [r]
if dfs(n, r, hint_sets, dict(count), set(), result):
buf.append(' '.join(map(str, result[::-1])))
continue
r = most_common[-2][0]
result = [r]
assert dfs(n, r, hint_sets, dict(count), set(), result)
buf.append(' '.join(map(str, result[::-1])))
print('\n'.join(map(str, buf)))
```
| 88,549 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Tags: brute force, constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
def dfs(x,S):
#print(x,S)
for i in range(len(S)):
if x in S[i]:
S[i].remove(x)
#print(x,S)
LEN1=0
for s in S:
if len(s)==1:
LEN1+=1
ne=list(s)[0]
if LEN1==2:
return [-1]
if LEN1==1:
return [ne]+dfs(ne,S)
else:
return [-1]
import copy
t=int(input())
for tests in range(t):
n=int(input())
A=tuple(set(list(map(int,input().split()))[1:]) for i in range(n-1))
for i in range(1,n+1):
ANS=[i]+dfs(i,copy.deepcopy(A))
#print(i,ANS)
if -1 in ANS[:n]:
continue
else:
#print(ANS[:n])
USE=[0]*(n-1)
flag=1
for i in range(n-1,0,-1):
SET=set()
for j in range(i,-1,-1):
SET.add(ANS[j])
if SET in A:
break
else:
flag=0
break
if flag:
print(*ANS[:n])
break
```
| 88,550 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Submitted Solution:
```
import sys
from copy import copy, deepcopy
input = sys.stdin.readline
'''
n, m = map(int, input().split())
n = int(input())
A = list(map(int, input().split()))
S = input().strip()
for tests in range(int(input())):
'''
inf = 100000000000000000 # 1e17
mod = 998244353
'''
1
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
'''
def check():
F = [0] * (n + 1)
for i in range(len(ANS)):
F[ANS[i]] = i
isok = 1
for a in A:
l = inf
r = 0
for char in a:
l = min(l, F[char])
r = max(r, F[char])
# print(a, l, r,isok)
if r - l + 1 != len(a):
isok = 0
break
return isok
def dfs(x, S):
if x == n:
# check
# print(ANS)
global flag
if check()==1:
if flag==0:
flag=1
print(*ANS)
# iter find
for s in S:
new_member = 0
for char in s:
if char not in SET:
if new_member == 0:
new_member = char
else:
new_member = 0
break
if new_member != 0: # get new one
S.remove(s)
SET.add(new_member)
ANS.append(new_member)
dfs(x + 1, S)
for tests in range(int(input())):
flag = 0
n = int(input())
A = list(list(map(int, input().split()))[1:] for i in range(n - 1))
for a in A:
if len(a) == 2:
ANS = [a[0], a[1]]
S = deepcopy(A)
S.remove(a)
SET = set()
SET.add(a[0])
SET.add(a[1])
dfs(2, S)
S = deepcopy(A)
S.remove(a)
ANS = [a[1], a[0]]
SET = set()
SET.add(a[0])
SET.add(a[1])
dfs(2, S)
```
Yes
| 88,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Submitted Solution:
```
from sys import stdin, gettrace
from copy import deepcopy
if not gettrace():
def input():
return next(stdin)[:-1]
# def input():
# return stdin.buffer.readline()
def main():
def solve():
n = int(input())
segs = []
occur = [set() for _ in range(n+1)]
for j in range(n-1):
seg = frozenset(int(a) for a in input().split()[1:])
for i in seg:
occur[i].add(seg)
pl = []
for i in range(1, n+1):
if len(occur[i]) == 1:
pl.append(i)
for p in pl:
occurc = deepcopy(occur)
res = [0] * n
pos = n-1
sum = (n * (n+1))//2
while True:
sum -= p
res[pos] = p
if pos == 1:
res[0] = sum
print(' '.join(map(str, res)))
return
np = []
for seg in occurc[p]:
for i in seg:
if i == p:
continue
occurc[i].remove(seg)
if len(occurc[i]) == 1:
np.append(i)
occurc[p].remove(seg)
if len(np) == 1:
p = np[0]
elif len(np) == 2:
if len(occur[np[0]]) > len(occur[np[1]]):
p = np[0]
else:
p = np[1]
else:
break
pos -= 1
q = int(input())
for _ in range(q):
solve()
if __name__ == "__main__":
main()
```
Yes
| 88,552 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
segs = [tuple(sorted(int(x) for x in input().split()[1:])) for __ in range(n - 1)]
segs_having = [[j for j, seg in enumerate(segs) if i in seg] for i in range(n + 1)]
segs_set = set(segs)
for first in range(1, n + 1):
try:
segs_copy = [set(seg) for seg in segs]
ans = [first]
while len(ans) < n:
for seg in segs_having[ans[-1]]:
segs_copy[seg].remove(ans[-1])
ans.append(next(iter(next(seg for seg in segs_copy if len(seg) == 1))))
if all(any(tuple(sorted(ans[j:i])) in segs_set for j in range(0, i - 1)) for i in range(2, n + 1)):
print(*ans)
break
except StopIteration:
pass
```
Yes
| 88,553 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Submitted Solution:
```
from collections import defaultdict as dd
from pprint import pprint as pp
def solve():
n = int(input())
seqs = []
d = dd(list)
for _ in range(n-1):
seqs.append(list(map(int, input().split()[1:])))
for seq in seqs:
for i in range(len(seq)):
s = ' '.join(str(x) for j, x in enumerate(seq) if j != i)
d[s].append(seq[i])
for st in range(1, n+1):
seq = [st]
seq_set = {st}
for _ in range(n-1):
found = False
for l in range(len(seq)):
k = ' '.join(str(x) for x in sorted(seq[-(l+1):]))
if k in d:
for j in d[k]:
if j not in seq_set:
seq.append(j)
seq_set.add(j)
found = True
break
if found:
break
if not found:
break
if len(seq) == n:
print(' '.join(str(x) for x in seq))
break
for _ in range(int(input())):
solve()
```
Yes
| 88,554 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Submitted Solution:
```
import io
import os
from collections import defaultdict
def solve(N, segments):
memToSeg = defaultdict(set)
for i, segment in enumerate(segments):
for x in segment:
memToSeg[x].add(i)
ans = []
for i in range(N - 1):
for k, indices in memToSeg.items():
if len(indices) == 1:
(index,) = indices
ans.append(k)
for x in segments[index]:
memToSeg[x].discard(index)
if len(memToSeg[x]) == 0:
del memToSeg[x]
break
else:
assert False
(unused,) = set(range(1, N + 1)) - set(ans)
ans.append(unused)
return " ".join(map(str, ans[::-1]))
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
for t in range(T):
(N,) = [int(x) for x in input().split()]
segments = []
for i in range(N - 1):
segment = [int(x) for x in input().split()]
assert segment[0] == len(segment) - 1
segments.append(segment[1:])
ans = solve(N, segments)
print(ans)
```
No
| 88,555 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Submitted Solution:
```
a=int(input())
for i in range(a):
length=int(input())
k=[]
for i in range(length-1):
l=[int(i) for i in input().split(" ")]
for i in range(1,len(l)):
k.append(l[i])
s=set(k)
t=list(s)
for i in range(len(t)):
print(t[i],end=" ")
print("")
```
No
| 88,556 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Submitted Solution:
```
l=[]
t=int(input())
for j in range(t):
n=int(input())
for i in range(n-1):
# print(i)
m,*s=input().split(" ")
s=list(map(int,s))
l.append(s)
d=[i for j in l for i in j]
print(list(set(d)))
d,s,l=[],[],[]
```
No
| 88,557 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
Submitted Solution:
```
from sys import stdin, gettrace
from copy import deepcopy
if not gettrace():
def input():
return next(stdin)[:-1]
# def input():
# return stdin.buffer.readline()
def main():
def solve():
n = int(input())
segs = []
occur = [set() for _ in range(n+1)]
for j in range(n-1):
seg = frozenset(int(a) for a in input().split()[1:])
for i in seg:
occur[i].add(seg)
pl = []
for i in range(1, n+1):
if len(occur[i]) == 1:
pl.append(i)
for p in pl:
used = [False] * (n+1)
occurc = deepcopy(occur)
res = [0] * n
pos = n-1
while True:
used[p] = True
if pos == 1:
for r in range(1, n+1):
if not used[r]:
break
if len(occur[p]) > len(occur[r]):
res[0] = r
res[1] = p
else:
res[0] = p
res[1] = r
print(' '.join(map(str, res)))
return
res[pos] = p
np = -1
for seg in occurc[p]:
for i in seg:
if i == p:
continue
occurc[i].remove(seg)
if len(occurc[i]) == 1:
np = i
occurc[p].remove(seg)
if np == -1:
break
p = np
pos -= 1
q = int(input())
for _ in range(q):
solve()
if __name__ == "__main__":
main()
```
No
| 88,558 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Tags: 2-sat, dfs and similar, dsu, graphs, implementation
Correct Solution:
```
from sys import stdin, gettrace
if gettrace():
inputi = input
else:
def input():
return next(stdin)[:-1]
def inputi():
return stdin.buffer.readline()
def solve():
n = int(inputi())
aa = []
aa.append([0] + [int(a) for a in inputi().split()])
aa.append([0] + [int(a) for a in inputi().split()])
ndx = [[[] for _ in range(n+1)] for _ in range(2)]
for i in range(n+1):
ndx[0][aa[0][i]].append(i)
ndx[1][aa[1][i]].append(i)
res = set()
for i in range(1, n+1):
if len(ndx[0][i]) + len(ndx[1][i]) != 2:
print(-1)
return
for r in range(2):
if len(ndx[r][i]) == 2:
swaps = []
nsc = []
for j in range(2):
c = ndx[r][i][j]
swaps.append([c])
nsc.append(1)
v = aa[1-r][c]
while len(ndx[1-r][v]) == 1:
if len(ndx[r][v]) != 1:
print(-1)
return
c = ndx[r][v][0]
swaps[-1].append(c)
nsc[-1] += -1 if c in res else 1
v = aa[1-r][c]
swaps = swaps[0] if nsc[0] <= nsc[1] else swaps[1]
for c in swaps:
ndx[0][aa[0][c]].remove(c)
ndx[1][aa[1][c]].remove(c)
aa[0][c], aa[1][c] = aa[1][c], aa[0][c]
ndx[0][aa[0][c]].append(c)
ndx[1][aa[1][c]].append(c)
if c in res:
res.remove(c)
else:
res.add(c)
print(len(res))
print(' '.join(map(str, res)))
def main():
t = int(inputi())
for _ in range(t):
solve()
if __name__ == "__main__":
main()
```
| 88,559 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Tags: 2-sat, dfs and similar, dsu, graphs, implementation
Correct Solution:
```
t = int(input())
Maxn = 210000
while t > 0:
t -= 1
n = int(input())
a = input().split()
b = input().split()
a1 = [-1] * (n + 1)
a2 = [-1] * (n + 1)
b1 = [-1] * (n + 1)
b2 = [-1] * (n + 1)
for i in range(0, n):
now = int(a[i])
if a1[now] == -1:
a1[now] = i
b1[now] = 1
else:
a2[now] = i
b2[now] = 1
now = int(b[i])
if a1[now] == -1:
a1[now] = i
b1[now] = 2
else:
a2[now] = i
b2[now] = 2
flag = 0
for i in range(1, n + 1):
if a2[i] == -1:
print("-1")
flag = 1
break
if flag:
continue
to = []
nxt = []
w = []
que = []
first = [-1] * (n + 1)
col = [-1] * (n + 1)
def add(u, v, wi):
to.append(v)
nxt.append(first[u])
w.append(wi)
first[u] = len(to) - 1
to.append(u)
nxt.append(first[v])
first[v] = len(to) - 1
w.append(wi)
for i in range(1, n + 1):
if a1[i] == a2[i]:
continue
elif b1[i] == b2[i]:
add(a1[i], a2[i], 1)
else:
add(a1[i], a2[i], 0)
ans = []
for i in range(0, n):
if first[i] != -1 and col[i] == -1:
col[i] = 0
que.append(i)
q = [[i], []]
while len(que):
now = que.pop()
cur = first[now]
while cur != -1:
if col[to[cur]] == -1:
if w[cur] == 0:
col[to[cur]] = col[now]
else:
col[to[cur]] = (col[now] + 1) % 2
q[col[to[cur]]].append(to[cur])
que.append(to[cur])
cur = nxt[cur]
if len(q[0]) < len(q[1]):
while len(q[0]):
ans.append(q[0].pop() + 1)
else:
while len(q[1]):
ans.append(q[1].pop() + 1)
print(len(ans))
for i in ans:
print(i, end=' ')
print('')
```
| 88,560 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Tags: 2-sat, dfs and similar, dsu, graphs, implementation
Correct Solution:
```
import sys
# range = xrange
# input = raw_input
inp = [int(x) for x in sys.stdin.read().split()]
ii = 0
out = []
def solve(n, A):
same = [-1]*(2 * n);pos = [-1] * n
for i in range(2 * n):
a = A[i]
if pos[a] == -1:
pos[a] = i
elif pos[a] == -2:
return None
else:
p = pos[a]
pos[a] = -2
same[p] = i
same[i] = p
ans = []
found = [0] * (2 * n)
for root in range(2 * n):
if found[root]:
continue
count0 = []
count1 = []
node = root
while not found[node]:
found[node] = 1
found[same[node]] = 1
if node & 1:
count0.append(node >> 1)
else:
count1.append(node >> 1)
node = same[node ^ 1]
if len(count0) < len(count1):
ans += count0
else:
ans += count1
return ans
t = inp[ii]
ii += 1
for _ in range(t):
n = inp[ii]
ii += 1
A = [x - 1 for x in inp[ii: ii + n]]
ii += n
B = [x - 1 for x in inp[ii: ii + n]]
ii += n
A = [A[i >> 1] if i & 1 == 0 else B[i >> 1] for i in range(2 * n)]
ans = solve(n, A)
if ans is None:
out.append('-1')
else:
out.append(str(len(ans)))
out.append(' '.join(str(x + 1) for x in ans))
print('\n'.join(out))
```
| 88,561 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Tags: 2-sat, dfs and similar, dsu, graphs, implementation
Correct Solution:
```
from sys import stdin, setrecursionlimit
from collections import deque
input = stdin.readline
setrecursionlimit(int(2e5))
def getstr(): return input()[:-1]
def getint(): return int(input())
def getints(): return list(map(int, input().split()))
def getint1(): return list(map(lambda x : int(x) - 1, input().split()))
adj = col = comp = []
cnt0 = cnt1 = 0
def dfs(us, cs, cmp, n):
global adj, col, comp, cnt0, cnt1
stack = [(us, cs)]
inq = [False] * n
inq[us] = True
while len(stack) > 0:
u, c = stack.pop()
# print(u, c)
inq[u] = False
col[u] = c
if col[u] == 0: cnt0 += 1
else: cnt1 += 1
comp[u] = cmp
for v, ch in adj[u]:
if col[v] == -1 and not inq[v]:
inq[v] = True
stack.append((v, c ^ ch))
# print(col, comp)
def solve():
global adj, col, comp, cnt0, cnt1
n = getint()
a = []
pos = [[] for _ in range(n)]
adj = [[] for _ in range(n)]
for i in [0, 1]:
a.append(getint1())
for j, x in enumerate(a[i]):
pos[x].append(j)
for i, c in enumerate(pos):
if len(c) != 2:
print("-1")
return
if c[0] == c[1]:
continue
r1 = int(a[0][c[0]] != i)
r2 = int(a[0][c[1]] != i)
adj[c[0]].append((c[1], int(r1 == r2)))
adj[c[1]].append((c[0], int(r1 == r2)))
# print(adj)
col = [-1] * n
comp = [-1] * n
colcnt = []
ans = cnt = 0
# cnt = 0
for i in range(n):
if col[i] == -1:
cnt0, cnt1 = 0, 0
dfs(i, 0, cnt, n)
cnt += 1
colcnt.append((cnt0, cnt1))
ans += min(cnt0, cnt1)
# print(colcnt)
print(ans)
alist = []
for i in range(n):
chz = int(colcnt[comp[i]][0] < colcnt[comp[i]][1])
if col[i] ^ chz:
alist.append(i + 1)
# print(len(alist))
print(*alist)
if __name__ == "__main__":
# solve()
# for t in range(getint()):
# print("Case #{}: ".format(t + 1), end="")
# solve()
for _ in range(getint()):
solve()
```
| 88,562 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Tags: 2-sat, dfs and similar, dsu, graphs, implementation
Correct Solution:
```
import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
#from decimal import Decimal
from fractions import Fraction
#sys.setrecursionlimit(100000)
INF = float('inf')
mod = int(1e9)+7
for t in range(int(data())):
n=int(data())
a1=mdata()
a2=mdata()
d=dd(int)
g=[[] for i in range(n+1)]
for i in range(n):
d[a1[i]] += 1
d[a2[i]] += 1
if a1[i]==a2[i]:
continue
g[a1[i]].append((a2[i],i+1,0))
g[a2[i]].append((a1[i],i+1,1))
if max(d.values())>2:
out(-1)
continue
vis=[0]*(n+1)
vis1=[0]*(n+1)
ans=[]
for i in range(1,n+1):
if vis[i]==0 and g[i]:
s=[[],[]]
vis[i]=1
s[g[i][0][2]].append(g[i][0][1])
s[1-g[i][1][2]].append(g[i][1][1])
vis[g[i][0][0]] = -1
vis[g[i][1][0]] = 1
vis1[g[i][0][1]] = 1
vis1[g[i][1][1]] = 1
q=[]
q.append(g[i][0][0])
q.append(g[i][1][0])
while q:
a=q.pop()
if vis[a]==1:
for nei in g[a]:
if vis1[nei[1]]==0:
s[1-nei[2]].append(nei[1])
vis[nei[0]] = -1
vis1[nei[1]] = 1
q.append(nei[0])
else:
for nei in g[a]:
if vis1[nei[1]]==0:
s[1-nei[2]].append(nei[1])
vis[nei[0]] = 1
vis1[nei[1]] = 1
q.append(nei[0])
if len(s[0])<len(s[1]):
ans+=s[0]
else:
ans+=s[1]
out(len(ans))
outl(ans)
```
| 88,563 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Tags: 2-sat, dfs and similar, dsu, graphs, implementation
Correct Solution:
```
from collections import defaultdict,deque
import sys
input=sys.stdin.readline
def bfs(i):
queue=deque([(i,1)])
while queue:
#print(queue)
vertex,colour=queue.popleft()
res.append(vertex)
if colour==1:
up,down=a[vertex],b[vertex]
else:
up,down=b[vertex],a[vertex]
for child in graph[vertex]:
if not vis[child]:
vis[child]=True
if a[child]==up or b[child]==down:
tmp.append(child)
queue.append((child,0))
else:
queue.append((child,1))
t=int(input())
for ii in range(t):
n=int(input())
a=[int(i) for i in input().split() if i!='\n']
b=[int(i) for i in input().split() if i!='\n']
data=[[] for _ in range(n)]
for i in range(n):
data[a[i]-1].append(i)
data[b[i]-1].append(i)
graph=defaultdict(list)
for i in range(n):
if len(data[i])!=2:
print(-1)
break
else:
for i in range(n):
u,v=data[i][0],data[i][1]
graph[u].append(v)
graph[v].append(u)
#print(graph,data)
vis,ans=[False]*(n),[]
for i in range(n):
if not vis[i]:
tmp,res=[],[]
vis[i]=True
bfs(i)
if len(res)-len(tmp)>=len(tmp):
ans+=tmp
else:
tmp=set(tmp)
for i in res:
if i not in tmp:
ans.append(i)
print(len(ans))
ans=[i+1 for i in ans]
print(*ans)
```
| 88,564 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Tags: 2-sat, dfs and similar, dsu, graphs, implementation
Correct Solution:
```
import sys
from collections import deque
input=sys.stdin.readline
#sys.setrecursionlimit(2*10**5)
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
data=[[] for i in range(n)]
for i in range(n):
data[a[i]-1].append(i)
data[b[i]-1].append(i)
for i in range(n):
if len(data[i])!=2:
print(-1)
break
else:
edge=[[] for i in range(n)]
for i in range(n):
u,v=data[i][0],data[i][1]
edge[u].append((v,i))
edge[v].append((u,i))
seen=[False]*n
temp=[]
res=0
def dfs(v,cond):
global temp,res
res.append(v)
if cond==1:
up,down=a[v],b[v]
else:
up,down=b[v],a[v]
for nv,val in edge[v]:
if not seen[nv]:
seen[nv]=True
if a[nv]==up or b[nv]==down:
temp.append(nv)
dfs(nv,-1)
else:
dfs(nv,1)
def bfs(i):
global temp,res
deq=deque([(i,1)])
while deq:
v,cond=deq.popleft()
res.append(v)
if cond==1:
up,down=a[v],b[v]
else:
up,down=b[v],a[v]
for nv,val in edge[v]:
if not seen[nv]:
seen[nv]=True
if a[nv]==up or b[nv]==down:
temp.append(nv)
deq.append((nv,-1))
else:
deq.append((nv,1))
ans=[]
for i in range(0,n):
if not seen[i]:
res=[]
temp=[]
seen[i]=True
bfs(i)
if len(res)-len(temp)>=len(temp):
ans+=temp
else:
temp=set(temp)
for v in res:
if v not in temp:
ans.append(v)
if ans:
ans=[ans[i]+1 for i in range(len(ans))]
print(len(ans))
print(*ans)
```
| 88,565 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Tags: 2-sat, dfs and similar, dsu, graphs, implementation
Correct Solution:
```
from bisect import *
from collections import *
from math import gcd,ceil,sqrt,floor,inf
from heapq import *
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *
#------------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
#------------------------------------------------------------------------
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
farr=[1]
ifa=[]
def fact(x,mod=0):
if mod:
while x>=len(farr):
farr.append(farr[-1]*len(farr)%mod)
else:
while x>=len(farr):
farr.append(farr[-1]*len(farr))
return farr[x]
def ifact(x,mod):
global ifa
ifa.append(pow(farr[-1],mod-2,mod))
for i in range(x,0,-1):
ifa.append(ifa[-1]*i%mod)
ifa=ifa[::-1]
def per(i,j,mod=0):
if i<j: return 0
if not mod:
return fact(i)//fact(i-j)
return farr[i]*ifa[i-j]%mod
def com(i,j,mod=0):
if i<j: return 0
if not mod:
return per(i,j)//fact(j)
return per(i,j,mod)*ifa[j]%mod
def catalan(n):
return com(2*n,n)//(n+1)
def linc(f,t,l,r):
while l<r:
mid=(l+r)//2
if t>f(mid):
l=mid+1
else:
r=mid
return l
def rinc(f,t,l,r):
while l<r:
mid=(l+r+1)//2
if t<f(mid):
r=mid-1
else:
l=mid
return l
def ldec(f,t,l,r):
while l<r:
mid=(l+r)//2
if t<f(mid):
l=mid+1
else:
r=mid
return l
def rdec(f,t,l,r):
while l<r:
mid=(l+r+1)//2
if t>f(mid):
r=mid-1
else:
l=mid
return l
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def binfun(x):
c=0
for w in arr:
c+=ceil(w/x)
return c
def lowbit(n):
return n&-n
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
'''
class SMT:
def __init__(self,arr):
self.n=len(arr)-1
self.arr=[0]*(self.n<<2)
self.lazy=[0]*(self.n<<2)
def Build(l,r,rt):
if l==r:
self.arr[rt]=arr[l]
return
m=(l+r)>>1
Build(l,m,rt<<1)
Build(m+1,r,rt<<1|1)
self.pushup(rt)
Build(1,self.n,1)
def pushup(self,rt):
self.arr[rt]=self.arr[rt<<1]+self.arr[rt<<1|1]
def pushdown(self,rt,ln,rn):#lr,rn表区间数字数
if self.lazy[rt]:
self.lazy[rt<<1]+=self.lazy[rt]
self.lazy[rt<<1|1]=self.lazy[rt]
self.arr[rt<<1]+=self.lazy[rt]*ln
self.arr[rt<<1|1]+=self.lazy[rt]*rn
self.lazy[rt]=0
def update(self,L,R,c,l=1,r=None,rt=1):#L,R表示操作区间
if r==None: r=self.n
if L<=l and r<=R:
self.arr[rt]+=c*(r-l+1)
self.lazy[rt]+=c
return
m=(l+r)>>1
self.pushdown(rt,m-l+1,r-m)
if L<=m: self.update(L,R,c,l,m,rt<<1)
if R>m: self.update(L,R,c,m+1,r,rt<<1|1)
self.pushup(rt)
def query(self,L,R,l=1,r=None,rt=1):
if r==None: r=self.n
#print(L,R,l,r,rt)
if L<=l and R>=r:
return self.arr[rt]
m=(l+r)>>1
self.pushdown(rt,m-l+1,r-m)
ans=0
if L<=m: ans+=self.query(L,R,l,m,rt<<1)
if R>m: ans+=self.query(L,R,m+1,r,rt<<1|1)
return ans
'''
class DSU:#容量+路径压缩
def __init__(self,n):
self.c=[-1]*n
def same(self,x,y):
return self.find(x)==self.find(y)
def find(self,x):
if self.c[x]<0:
return x
self.c[x]=self.find(self.c[x])
return self.c[x]
def union(self,u,v):
u,v=self.find(u),self.find(v)
if u==v:
return False
if self.c[u]<self.c[v]:
u,v=v,u
self.c[u]+=self.c[v]
self.c[v]=u
return True
def size(self,x): return -self.c[self.find(x)]
class UFS:#秩+路径
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return prime
def dij(s,graph):
d={}
d[s]=0
heap=[(0,s)]
seen=set()
while heap:
dis,u=heappop(heap)
if u in seen:
continue
for v in graph[u]:
if v not in d or d[v]>d[u]+graph[u][v]:
d[v]=d[u]+graph[u][v]
heappush(heap,(d[v],v))
return d
def GP(it): return [[ch,len(list(g))] for ch,g in groupby(it)]
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
@bootstrap
def dfs(r,p):
if len(g[r])==1 and p!=-1:
isl[r]=1
yield 1
tmp=0
for ch in g[r]:
if ch!=p:
tmp+=yield(dfs(ch,r))
cnt[r]+=tmp
if p==-1 and len(g[r])==1:
isl[r]=1
cnt[g[r][0]]+=1
yield 0
t=N()
for i in range(t):
n=N()
a=RLL()
b=RLL()
c=Counter(a)+Counter(b)
if any(c[i]!=2 for i in range(1,n+1)):
print(-1)
else:
fi={}
se={}
for i in range(n):
if a[i] not in fi:
fi[a[i]]=i
else:
se[a[i]]=i
if b[i] not in fi:
fi[b[i]]=i
else:
se[b[i]]=i
#vis=[0]*(1+n)
uf=UFS(n+1)
ans=0
res=[]
g=[[] for i in range(1+n)]
for i in range(1,n+1):
if fi[i]!=se[i]:
uf.union(fi[i],se[i])
for i in range(n):
g[uf.find(i)].append(i)
for i in range(n):
if len(g[i])<2:
continue
rem=[g[i][0]+1]
inv=[]
ind=g[i][0]
cur=b[ind]
while cur!=a[g[i][0]]:
for j in (fi[cur],se[cur]):
if j!=ind:
if a[j]==cur:
rem.append(j+1)
cur=b[j]
else:
inv.append(j+1)
cur=a[j]
ind=j
break
if len(rem)<=len(inv):
res+=rem
ans+=len(rem)
else:
res+=inv
ans+=len(inv)
print(ans)
print(*res)
'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thread(target=main)
t.start()
t.join()
'''
'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thread(target=main)
t.start()
t.join()
'''
```
| 88,566 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
# ------------------------------
# f = open('../input.txt')
# sys.stdin = f
def main():
for _ in range(N()):
n = N()
arra = RLL()
arrb = RLL()
rec = [0]*(n+1)
prec = [[] for _ in range(n+1)]
for i in range(n):
rec[arra[i]]+=1
rec[arrb[i]]+=1
prec[arra[i]].append(i)
prec[arrb[i]].append(i)
for i in range(1, n+1):
if rec[i]!=2:
print(-1)
break
else:
res, reca, recb = [], [], []
vis = [0]*(n+1)
@bootstrap
def dfs(node, pos):
nonlocal reca, recb, vis
if vis[node] == 1: yield None
vis[node] = 1
for p in prec[node]:
if p==pos: continue
if arra[p]==node:
reca.append(p)
yield dfs(arrb[p], p)
else:
recb.append(p)
yield dfs(arra[p], p)
yield None
yield None
for i in range(1, n+1):
if vis[i] or prec[0]==prec[1]: continue
dfs(i, 0)
if len(reca)>len(recb):
res.extend(recb)
else:
res.extend(reca)
reca.clear()
recb.clear()
print(len(res))
print(*[i+1 for i in res])
if __name__ == "__main__":
main()
```
Yes
| 88,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Submitted Solution:
```
import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
#from decimal import Decimal
from fractions import Fraction
#sys.setrecursionlimit(100000)
INF = float('inf')
mod = int(1e9)+7
for t in range(int(data())):
n=int(data())
a1=mdata()
a2=mdata()
d=dd(int)
g=[[] for i in range(n+1)]
for i in range(n):
d[a1[i]] += 1
d[a2[i]] += 1
if a1[i]==a2[i]:
continue
g[a1[i]].append((a2[i],i+1,0))
g[a2[i]].append((a1[i],i+1,1))
if max(d.values())>2:
out(-1)
continue
vis=[0]*(n+1)
vis1=[0]*(n+1)
ans=[]
for i in range(1,n+1):
if vis[i]==0 and g[i]:
s=[[],[]]
vis[i]=1
a,b=g[i][0],g[i][1]
s[a[2]].append(a[1])
s[1-b[2]].append(b[1])
vis[a[0]] = -1
vis[b[0]] = 1
vis1[a[1]] = 1
vis1[b[1]] = 1
q=[]
q.append(g[i][0][0])
q.append(g[i][1][0])
while q:
a=q.pop()
for nei in g[a]:
if vis1[nei[1]]==0:
s[1-nei[2]].append(nei[1])
vis[nei[0]] = -1*vis[a]
vis1[nei[1]] = 1
q.append(nei[0])
if len(s[0])<len(s[1]):
ans+=s[0]
else:
ans+=s[1]
out(len(ans))
outl(ans)
```
Yes
| 88,568 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Submitted Solution:
```
for t in range(int(input())):
n = int(input())
aa = [
[int(s)-1 for s in input().split(' ')]
for _ in [0, 1]
]
maxv = max(max(aa[0]), max(aa[1]))
minv = min(min(aa[0]), min(aa[1]))
if minv != 0 or maxv != n - 1:
print(-1)
continue
counts = [0] * n
index = [[] for _ in range(n)]
for row in aa:
for x, a in enumerate(row):
counts[a] += 1
index[a] += [x]
if not min(counts) == 2 == max(counts):
print(-1)
continue
proc = [False] * n
ans = []
for i in range(n):
if proc[i]:
continue
swapped = set()
used = set()
curcol = i
curval = aa[0][i]
while True:
proc[curcol] = True
used.add(curcol)
if aa[0][curcol] == curval:
nexval = aa[1][curcol]
else:
nexval = aa[0][curcol]
swapped.add(curcol)
nexcol = index[nexval][1] if index[nexval][0] == curcol else index[nexval][0]
curcol = nexcol
curval = nexval
if curcol == i:
break
part = swapped if 2 * len(swapped) <= len(used) else used.difference(swapped)
ans += part
print(len(ans))
print(' '.join(str(v + 1) for v in ans))
```
Yes
| 88,569 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Submitted Solution:
```
import io
import os
from collections import Counter, defaultdict, deque
def bfs(source, getNbr):
q = deque([source])
dist = {source: 0}
while q:
node = q.popleft()
d = dist[node]
for nbr in getNbr(node):
if nbr not in dist:
q.append(nbr)
dist[nbr] = d + 1
return dist
def solve(N, A1, A2):
A = A1 + A2 # index bottom row with N to 2N - 1
# Put edge for any two cells that have to be on opposite sides
graph = [[] for i in range(2 * N)]
# Put edge between same column
for i in range(N):
if A[i] != A[i + N]: # Skip columns with same values which is handled below
graph[i].append(i + N)
graph[i + N].append(i)
# Put edge between same value
valToCols = defaultdict(list)
for i, x in enumerate(A):
valToCols[x].append(i)
for x in range(1, N + 1):
if len(valToCols[x]) != 2:
return -1
i, j = valToCols[x]
graph[i].append(j)
graph[j].append(i)
def getNbr(u):
return graph[u]
# Two color
ans = []
seen = {}
for source in range(2 * N):
if source not in seen:
dist = bfs(source, getNbr)
for u in dist.keys():
color = dist[u] % 2
for v in graph[u]:
color2 = dist[v] % 2
if color == color2: # conflict
return -1
# The components can flip, choose smaller
cols1 = [u for u in dist.keys() if u < N and dist[u] % 2 == 0]
cols2 = [u for u in dist.keys() if u < N and dist[u] % 2 == 1]
if len(cols1) < len(cols2):
ans.extend(cols1)
else:
ans.extend(cols2)
seen.update(dist)
return str(len(ans)) + "\n" + " ".join(str(c + 1) for c in ans)
if False:
# print(solve(5, [1, 1, 2, 3, 4], [2, 3, 4, 5, 5]))
import random
random.seed(0)
from itertools import combinations, product
for t in range(10000):
N = 5
for perm1 in product(range(1, N + 1), repeat=N):
for perm2 in product(range(1, N + 1), repeat=N):
best = float("inf")
for mask in range(1 << N):
p1 = list(perm1)
p2 = list(perm2)
for i in range(N):
if mask & (1 << i):
p1[i], p2[i] = p2[i], p1[i]
if sorted(p1) == sorted(p2) == sorted(range(1, N + 1)):
best = min(best, bin(mask).count("1"))
if best == float("inf"):
best = -1
ans = int(str(solve(N, perm1, perm2)).split("\n")[0])
if ans != best:
print(perm1, perm2, best, ans)
exit()
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
for t in range(T):
(N,) = [int(x) for x in input().split()]
A1 = [int(x) for x in input().split()]
A2 = [int(x) for x in input().split()]
ans = solve(N, A1, A2)
print(ans)
```
Yes
| 88,570 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Submitted Solution:
```
#list(map(int,input().split()))
```
No
| 88,571 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Submitted Solution:
```
from collections import Counter
for _ in range(int(input())):
n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = Counter(A + B)
if any(v > 2 for v in C.values()):
print(-1)
continue
adj = [set() for _ in range(n)]
for l in (A, B):
D = {}
for i, v in enumerate(l):
if v in D:
j = D[v]
adj[i].add(j)
adj[j].add(i)
else:
D[v] = i
R = []
V = [False] * n
for i in range(n):
if V[i]: continue
V[i] = True
use = len(adj[i]) == 2
Q = [(i, use)]
for i, use in Q:
if use:
R.append(i+1)
for j in adj[i]:
if V[j]: continue
V[j] = True
Q.append((j, not use))
print(len(R))
print(*R)
```
No
| 88,572 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Submitted Solution:
```
from collections import Counter
for iota in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
temp=a[:]+b[:]
count=Counter(temp)
ans=0
for i in range(n):
if count[n]%2==1:
ans=-1
break
if ans==-1:
print(ans)
continue
anslist=[]
temp=a[:]
for i in range(n):
if a[i]==b[i]:
continue
if (b[i] not in temp) and ((temp[i] in (temp[:i]+temp[i+1:]))or (temp[i] in b[i+1:])):
temp[i],b[i]=b[i],temp[i]
ans+=1
anslist.append(i+1)
print(ans)
print(*anslist)
```
No
| 88,573 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
Submitted Solution:
```
import collections
def last(x,y):
s1=collections.Counter(x)
s2=collections.Counter(y)
n=len(x)
s=[]
count=0
res=[]
for i in range(1,n+1):
s.append(i)
s=collections.Counter(s)
for i in range(n):
if s1==s:
if s2==s:
print(count)
if res:
for i in res:
print(i, " ", end='')
print()
return
else:
print(-1)
return
if s2==s:
if s1==s:
print(count)
if res:
for i in res:
print(i, " ", end='')
print()
return
else:
print(-1)
return
if s1[y[i]]!=0 and s2[x[i]]!=0:
continue
if s1[y[i]]==0 or s2[x[i]]!=0:
res.append(i)
count+=1
s1[x[i]]-=1
s1[y[i]]+=1
s2[y[i]]-=1
s2[x[i]]+=1
print(count)
if res:
for i in res:
print(i," ",end='')
print()
t=int(input())
for i in range(t):
n=int(input())
x=[int(i) for i in input().split()][:n]
y=[int(i) for i in input().split()][:n]
last(x,y)
```
No
| 88,574 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Tags: constructive algorithms, dfs and similar, dp, graphs, greedy, shortest paths
Correct Solution:
```
import sys
from math import ceil, gcd
from collections import deque
input = sys.stdin.buffer.readline
# def print(val):
# sys.stdout.write(str(val) + '\n')
n, m = [int(i) for i in input().split()]
adj = [[] for i in range(n+1)]
mark = [0] * (n+1)
d = [-1] * (n+1)
c = [-1] * (n+1)
for i in range(m):
u, v, b = [int(i) for i in input().split()]
adj[v].append((u,b))
q = deque()
q.append(n)
d[n] = 0
mark[n] = 1
while q:
f = q.popleft()
for i in adj[f]:
if mark[i[0]] == 0:
if c[i[0]] == -1:
if i[1] == 1:
c[i[0]] = 0
else:
c[i[0]] = 1
elif c[i[0]] == i[1]:
d[i[0]] = d[f]+1
q.append(i[0])
mark[i[0]] = 1
sys.stdout.write(str(d[1]))
sys.stdout.write('\n')
for i in range(1, n+1):
if c[i] == -1:
sys.stdout.write(str(1))
else:
sys.stdout.write(str(c[i]))
sys.stdout.write('\n')
```
| 88,575 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Tags: constructive algorithms, dfs and similar, dp, graphs, greedy, shortest paths
Correct Solution:
```
from sys import stdin
n,m = map(int,stdin.readline().split())
lis = [ [] for i in range(n) ]
for i in range(m):
u,v,t = map(int,stdin.readline().split())
u -= 1
v -= 1
lis[v].append((u,t))
from collections import deque
q = deque([n-1])
c = [None] * n
d = [float("inf")] * n
d[n-1] = 0
c[n-1] = 0
while len(q) > 0:
v = q.popleft()
for nex,vc in lis[v]:
if c[nex] == None:
c[nex] = vc ^ 1
elif c[nex] == vc and d[nex] > d[v]+1:
d[nex] = d[v] + 1
q.append(nex)
for i in range(n):
if c[i] == None:
c[i] = 0
if d[0] == float("inf"):
print (-1)
else:
print (d[0])
print ("".join(map(str,c)))
```
| 88,576 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Tags: constructive algorithms, dfs and similar, dp, graphs, greedy, shortest paths
Correct Solution:
```
import io
import os
import sys
import math
from typing import NamedTuple
from collections import deque
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
fileno = sys.stdin.fileno()
input = io.BytesIO(
os.read(fileno, os.fstat(fileno).st_size)
).readline
class Edge(NamedTuple):
to: int
color: int
INF = 1_000_000
N, M = map(int, input().split())
A = [[] for i in range(N)]
for i in range(M):
x, y, c = map(int, input().split())
x -= 1
y -= 1
edge = Edge(to=x, color=c)
A[y].append(edge)
color = [None for i in range(N)]
b = [INF for i in range(N)]
w = [INF for i in range(N)]
dp = [INF for i in range(N)]
b[N-1] = w[N-1] = dp[N-1] = 0
q = deque([N-1])
while q:
vertex = q.popleft()
if color[vertex] is not None:
continue
# print("Process vertex ", vertex + 1)
color[vertex] = int(b[vertex] < w[vertex])
if dp[vertex] == INF:
raise ValueError("Dist is too big %d " % (vertex + 1))
for edge in A[vertex]:
if color[edge.to] is not None:
# skip this edge
continue
if edge.color == 0:
# black
b[edge.to] = min(b[edge.to], dp[vertex] + 1)
else:
# white
w[edge.to] = min(w[edge.to], dp[vertex] + 1)
dp[edge.to] = max(b[edge.to], w[edge.to])
if dp[edge.to] != INF:
q.append(edge.to)
for i in range(N):
if color[i] is None:
color[i] = int(b[i] < w[i])
# print("Black ", b)
# print("Write ", w)
# print("DP ", dp)
print(dp[0] if dp[0] != INF else -1)
print(''.join(map(str, color)))
```
| 88,577 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Tags: constructive algorithms, dfs and similar, dp, graphs, greedy, shortest paths
Correct Solution:
```
import sys
sys.setrecursionlimit(10**5)
int1 = lambda x: int(x)-1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
from heapq import *
inf=10**9
n,m=MI()
to=[[] for _ in range(n)]
ot=[[] for _ in range(n)]
for _ in range(m):
u,v,t=MI()
u,v=u-1,v-1
to[u].append((v,t))
ot[v].append((u,t))
dp=[inf]*n
dp[n-1]=0
ans=[-1]*n
hp=[]
heappush(hp,(0,n-1))
while hp:
d,u=heappop(hp)
if d>dp[u]:continue
for v,t in ot[u]:
if dp[v]!=inf:continue
if ans[v]==t and dp[v]>d+1:
dp[v]=d+1
heappush(hp,(d+1,v))
if ans[v]==-1:ans[v]=1-t
for u in range(n):
if ans[u]==-1:ans[u]=1
print(-1 if dp[0]==inf else dp[0])
print(*ans,sep="")
```
| 88,578 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Tags: constructive algorithms, dfs and similar, dp, graphs, greedy, shortest paths
Correct Solution:
```
import sys
input = sys.stdin.readline
from collections import deque
#put in, get out and pop
G = list()
vis = []
col = []
dis = []
def bfs(s):
q = deque([s])
q.append(s)
vis = [0]*(s+1)
col = [-1]*(s+1)
# print(col)
dis = [0x3f3f3f3f]*(s+1)
# print(s)
col[s] = 0
dis[s] = 0
while q:
v = q.popleft()
vis[v] = 1
for (u, w) in G[v]:
if vis[u]:
continue
if col[u] == -1:
col[u] = 1-w
elif col[u] == w and dis[u]>dis[v]+1:
dis[u] = dis[v] + 1
q.append(u)
if dis[1] == 0x3f3f3f3f:
print(-1)
else:
print(dis[1])
for i in range(1, s+1):
print(max(col[i], 0), end='')
def main():
n, m = map(int, input().split())
for i in range(int(n)+1):
G.append([])
for i in range (m):
u, v, w = map(int, input().split())
G[v].append((u, w))
bfs(n)
if __name__ == '__main__':
main()
```
| 88,579 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Tags: constructive algorithms, dfs and similar, dp, graphs, greedy, shortest paths
Correct Solution:
```
import sys;input=sys.stdin.readline
N, M = map(int, input().split())
d = [set() for _ in range(N+1)]
for _ in range(M):
u, v, t = map(int, input().split())
d[v].add((u, t))
s = [-1]*(N+1)
s[N] = 1
from collections import deque
queue=deque([N])
vs = set([N])
dist = [0] * (N+1)
while queue:
v = queue.popleft()
for u, t in d[v]:
if u in vs:
continue
if s[u] == -1:
s[u] = 1-t
continue
if s[u] != t:
continue
vs.add(u)
queue.append(u)
dist[u] = dist[v] + 1
R = dist[1]
if N != 1:
print(R if R else -1)
for i in range(N+1):
if s[i] == -1:
s[i] = 0
print("".join(str(c) for c in s[1:]))
else:
print(0)
print("1")
```
| 88,580 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Tags: constructive algorithms, dfs and similar, dp, graphs, greedy, shortest paths
Correct Solution:
```
from sys import stdin
n,m = map(int,stdin.readline().split())
lis = [ [] for i in range(n) ]
for i in range(m):
u,v,t = map(int,stdin.readline().split())
u -= 1
v -= 1
lis[v].append((u,t))
from collections import deque
q = deque([n-1])
c = [None] * n
d = [float("inf")] * n
d[n-1] = 0
c[n-1] = 0
while len(q) > 0:
v = q.popleft()
for nex,vc in lis[v]:
if c[nex] == None:
c[nex] = vc ^ 1
elif c[nex] == vc and d[nex] == float("inf"):
d[nex] = d[v] + 1
q.append(nex)
for i in range(n):
if c[i] == None:
c[i] = 0
if d[0] == float("inf"):
print (-1)
else:
print (d[0])
print ("".join(map(str,c)))
```
| 88,581 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Tags: constructive algorithms, dfs and similar, dp, graphs, greedy, shortest paths
Correct Solution:
```
import sys
input = sys.stdin.readline
from collections import deque
n, m = map(int, input().split());back = [[] for i in range(n)]
for _ in range(m):u, v, w = map(int, input().split());u -= 1;v -= 1;back[v].append((u,w))
out = [2] * n;outl = [-1] * n;outl[-1] = 0;q = deque([n - 1])
while q:
v = q.popleft()
for u, w in back[v]:
if out[u] != w:out[u] = 1 - w
else:
if outl[u] == -1:outl[u] = outl[v] + 1;q.append(u)
out = [v if v != 2 else 1 for v in out];print(outl[0]);print(''.join(map(str,out)))
```
| 88,582 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Submitted Solution:
```
import sys
input = sys.stdin.readline
from collections import deque
n, m = map(int, input().split())
back = [[] for i in range(n)]
for _ in range(m):
u, v, w = map(int, input().split())
u -= 1
v -= 1
back[v].append((u,w))
out = [2] * n
outl = [-1] * n
outl[-1] = 0
q = deque([n - 1])
while q:
v = q.popleft()
for u, w in back[v]:
if out[u] != w:
out[u] = 1 - w
else:
if outl[u] == -1:
outl[u] = outl[v] + 1
q.append(u)
out = [v if v != 2 else 1 for v in out]
print(outl[0])
print(''.join(map(str,out)))
```
Yes
| 88,583 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Submitted Solution:
```
# Fast IO (be careful about bytestring, not on interactive)
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n,m = map(int,input().split())
inverseAdjacencyList = []
color = [-1] * n
for _ in range(n):
inverseAdjacencyList.append([])
for _ in range(m):
u,v,t = map(int,input().split())
if u != v:
inverseAdjacencyList[v-1].append((u-1,t))
for i in range(n):
inverseAdjacencyList[i].sort()
distance = [-1] * n
distance[n-1] = 0
bfsQueue = [n-1]
bfsQueueIndex = 0
while len(bfsQueue) > bfsQueueIndex:
curElem = bfsQueue[bfsQueueIndex]
bfsQueueIndex += 1
i = 0
while i < len(inverseAdjacencyList[curElem]):
elemConsidered = inverseAdjacencyList[curElem][i][0]
if distance[elemConsidered] != -1:
i += 1
continue
if color[elemConsidered] == inverseAdjacencyList[curElem][i][1]:
bfsQueue.append(elemConsidered)
distance[elemConsidered] = distance[curElem] + 1
else:
color[elemConsidered] = 1 - inverseAdjacencyList[curElem][i][1]
i += 1
for i in range(n):
if color[i] == -1:
color[i] = 0
print(distance[0])
print("".join(map(str,color)))
```
Yes
| 88,584 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Submitted Solution:
```
import sys
input = sys.stdin.readline
n,m=map(int,input().split())
EDGE_inv=[dict() for i in range(n+1)]
for i in range(m):
u,v,t=map(int,input().split())
if u==v:
continue
if u in EDGE_inv[v]:
if EDGE_inv[v][u]==t:
continue
else:
EDGE_inv[v][u]=2
else:
EDGE_inv[v][u]=t
#print(EDGE_inv)
import heapq
H=[(0,n)]
DIST=[1<<30]*(n+1)
DIST[n]=0
ANS=[-1]*(n+1)
while H:
#print(H)
dist,ind = heapq.heappop(H)
for fr in EDGE_inv[ind]:
if EDGE_inv[ind][fr]==2:
if DIST[fr]>DIST[ind]+1:
DIST[fr]=DIST[ind]+1
heapq.heappush(H,(DIST[fr],fr))
else:
nd = EDGE_inv[ind][fr]
if ANS[fr]!=nd:
ANS[fr]=1-nd
else:
if DIST[fr]>DIST[ind]+1:
DIST[fr]=DIST[ind]+1
heapq.heappush(H,(DIST[fr],fr))
#print(DIST)
#print(ANS)
ALIST=[]
for i in range(1,n+1):
if ANS[i]==1:
ALIST.append(1)
else:
ALIST.append(0)
if DIST[1]==1<<30:
print(-1)
else:
print(DIST[1])
print("".join(map(str,ALIST)))
```
Yes
| 88,585 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Submitted Solution:
```
import sys
int1 = lambda x: int(x)-1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
from collections import deque
inf=10**9
n,m=MI()
ot=[[] for _ in range(n)]
for _ in range(m):
u,v,t=MI()
u,v=u-1,v-1
ot[v].append((u,t))
dp=[inf]*n
dp[n-1]=0
ans=[-1]*n
q=deque()
q.append((0,n-1))
while q:
d,u=q.popleft()
if d>dp[u]:continue
for v,t in ot[u]:
if dp[v]!=inf:continue
if ans[v]==t and dp[v]>d+1:
dp[v]=d+1
q.append((d+1,v))
if ans[v]==-1:ans[v]=1-t
for u in range(n):
if ans[u]==-1:ans[u]=1
print(-1 if dp[0]==inf else dp[0])
print(*ans,sep="")
```
Yes
| 88,586 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Submitted Solution:
```
# Fast IO (be careful about bytestring, not on interactive)
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n,m = map(int,input().split())
inverseAdjacencyList = []
color = [-1] * n
for _ in range(n):
inverseAdjacencyList.append([])
for _ in range(m):
u,v,t = map(int,input().split())
inverseAdjacencyList[v-1].append((u-1,t))
for i in range(n):
inverseAdjacencyList.sort()
distance = [-1] * n
distance[n-1] = 0
bfsQueue = [n-1]
bfsQueueIndex = 0
while len(bfsQueue) > bfsQueueIndex:
curElem = bfsQueue[bfsQueueIndex]
bfsQueueIndex += 1
i = 0
while i < len(inverseAdjacencyList[curElem]):
elemConsidered = inverseAdjacencyList[curElem][i][0]
if len(inverseAdjacencyList[curElem]) > i + 1 and inverseAdjacencyList[curElem][i+1][0] == elemConsidered:
bfsQueue.append(elemConsidered)
distance[elemConsidered] = distance[curElem] + 1
i += 1
elif color[elemConsidered] == inverseAdjacencyList[curElem][i][1]:
bfsQueue.append(elemConsidered)
distance[elemConsidered] = distance[curElem] + 1
else:
color[elemConsidered] = 1 - inverseAdjacencyList[curElem][i][1]
i += 1
for i in range(n):
if color[i] == -1:
color[i] = 0
print(distance[0])
print("".join(map(str,color)))
```
No
| 88,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Submitted Solution:
```
import sys;input=sys.stdin.readline
N, M = map(int, input().split())
d = [set() for _ in range(N+1)]
for _ in range(M):
u, v, t = map(int, input().split())
d[v].add((u, t))
s = [-1]*(N+1)
s[N] = 1
from collections import deque
queue=deque([N])
vs = set([N])
dist = [-1] * (N+1)
while queue:
v = queue.popleft()
for u, t in d[v]:
if u in vs:
continue
if s[u] == -1:
s[u] = 1-t
continue
if s[u] != t:
continue
vs.add(u)
queue.append(u)
dist[u] = dist[v] + 1
R = dist[1]
print(R)
for i in range(N+1):
if s[i] == -1:
s[i] = 0
print("".join(str(c) for c in s[1:]))
```
No
| 88,588 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Submitted Solution:
```
import sys;input=sys.stdin.readline
N, M = map(int, input().split())
d = [set() for _ in range(N+1)]
for _ in range(M):
u, v, t = map(int, input().split())
d[v].add((u, t))
s = [-1]*(N+1)
s[N] = 1
from collections import deque
queue=deque([N])
vs = set([N])
dist = [0] * (N+1)
while queue:
v = queue.popleft()
for u, t in d[v]:
if u in vs:
continue
if s[u] == -1:
s[u] = 1-t
continue
if s[u] != t:
continue
vs.add(u)
queue.append(u)
dist[u] = dist[v] + 1
R = dist[1]
print(R if R else -1)
for i in range(N+1):
if s[i] == -1:
s[i] = 0
print("".join(str(c) for c in s[1:]))
```
No
| 88,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
Submitted Solution:
```
def do(n,m, edges):
Q = []
global last
addEdgesForEdge(n, edges, Q, (n, -1, 1), n)
while len(Q) > 0:
newQ = []
v = 0
for e in Q:
v += addEdgesForEdge(e[0][0], edges, newQ, (e[0], e[1], e[2] + 1), n)
if v < 0:
print(-1)
print(path(last, [0]*n))
return None
Q = newQ
print(path(last, [0]*n))
def path(prev, arr):
if(prev[1] == -1):
return ""
arr[prev[0][0]-1] = prev[0][1]
path(prev[1], arr)
return ''.join(map(str, arr))
last = None
def addEdgesForEdge(n, edges, Q, path, N):
if path[2] > N + 1:
return -1
global last
for e in edges[n]:
if(e[0] == 1):
last = (e, path, path[2] + 1)
continue
Q.append((e, path, path[2] + 1))
return 0
n, m = map(int, input().split())
edges = {}#reverse
for i in range(m):
a, b, c = map(int, input().split())
if b not in edges:
edges[b] = []
edges[b].append((a,c))
do(n, m, edges)
```
No
| 88,590 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zookeeper is playing a game. In this game, Zookeeper must use bombs to bomb a string that consists of letters 'A' and 'B'. He can use bombs to bomb a substring which is either "AB" or "BB". When he bombs such a substring, the substring gets deleted from the string and the remaining parts of the string get concatenated.
For example, Zookeeper can use two such operations: AABABBA → AABBA → AAA.
Zookeeper wonders what the shortest string he can make is. Can you help him find the length of the shortest string?
Input
Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 20000) — the number of test cases. The description of the test cases follows.
Each of the next t lines contains a single test case each, consisting of a non-empty string s: the string that Zookeeper needs to bomb. It is guaranteed that all symbols of s are either 'A' or 'B'.
It is guaranteed that the sum of |s| (length of s) among all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print a single integer: the length of the shortest string that Zookeeper can make.
Example
Input
3
AAA
BABA
AABBBABBBB
Output
3
2
0
Note
For the first test case, you can't make any moves, so the answer is 3.
For the second test case, one optimal sequence of moves is BABA → BA. So, the answer is 2.
For the third test case, one optimal sequence of moves is AABBBABBBB → AABBBABB → AABBBB → ABBB → AB → (empty string). So, the answer is 0.
Tags: brute force, data structures, greedy, strings
Correct Solution:
```
for _ in " "*int(input()):
s=input()
if "B" not in s:
print(len(s))
elif "A" not in s:
print(len(s)%2)
else:
sm=0
n=len(s)
cnt=0
ind = ''.join(s).rindex('B')
for i in range(ind+1):
if s[i] == "A":
sm+=1
if s[i] == "B":
if sm>0:
sm-=1
else:
cnt+=1
print((cnt%2)+(sm)+(n-1-ind))
```
| 88,591 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zookeeper is playing a game. In this game, Zookeeper must use bombs to bomb a string that consists of letters 'A' and 'B'. He can use bombs to bomb a substring which is either "AB" or "BB". When he bombs such a substring, the substring gets deleted from the string and the remaining parts of the string get concatenated.
For example, Zookeeper can use two such operations: AABABBA → AABBA → AAA.
Zookeeper wonders what the shortest string he can make is. Can you help him find the length of the shortest string?
Input
Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 20000) — the number of test cases. The description of the test cases follows.
Each of the next t lines contains a single test case each, consisting of a non-empty string s: the string that Zookeeper needs to bomb. It is guaranteed that all symbols of s are either 'A' or 'B'.
It is guaranteed that the sum of |s| (length of s) among all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print a single integer: the length of the shortest string that Zookeeper can make.
Example
Input
3
AAA
BABA
AABBBABBBB
Output
3
2
0
Note
For the first test case, you can't make any moves, so the answer is 3.
For the second test case, one optimal sequence of moves is BABA → BA. So, the answer is 2.
For the third test case, one optimal sequence of moves is AABBBABBBB → AABBBABB → AABBBB → ABBB → AB → (empty string). So, the answer is 0.
Tags: brute force, data structures, greedy, strings
Correct Solution:
```
num = int(input())
while num != 0:
s = input()
ans = len(s)
temp = 0
for i in s:
if i == 'B' and temp != 0:
ans = ans - 2
temp = temp - 1
else:
temp = temp + 1
num = num - 1
print(ans)
```
| 88,592 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zookeeper is playing a game. In this game, Zookeeper must use bombs to bomb a string that consists of letters 'A' and 'B'. He can use bombs to bomb a substring which is either "AB" or "BB". When he bombs such a substring, the substring gets deleted from the string and the remaining parts of the string get concatenated.
For example, Zookeeper can use two such operations: AABABBA → AABBA → AAA.
Zookeeper wonders what the shortest string he can make is. Can you help him find the length of the shortest string?
Input
Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 20000) — the number of test cases. The description of the test cases follows.
Each of the next t lines contains a single test case each, consisting of a non-empty string s: the string that Zookeeper needs to bomb. It is guaranteed that all symbols of s are either 'A' or 'B'.
It is guaranteed that the sum of |s| (length of s) among all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print a single integer: the length of the shortest string that Zookeeper can make.
Example
Input
3
AAA
BABA
AABBBABBBB
Output
3
2
0
Note
For the first test case, you can't make any moves, so the answer is 3.
For the second test case, one optimal sequence of moves is BABA → BA. So, the answer is 2.
For the third test case, one optimal sequence of moves is AABBBABBBB → AABBBABB → AABBBB → ABBB → AB → (empty string). So, the answer is 0.
Tags: brute force, data structures, greedy, strings
Correct Solution:
```
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
def gift():
for _ in range(t):
aabb = input()
n = len(aabb)
ans = n
curB = 0
for i in range(n):
#print(i, curB,aabb[n-1-i])
if aabb[n-1-i]=='B':
curB += 1
else:
if curB>=1:
ans -= 2
curB -= 1
ans -= (curB//2)*2
yield ans
if __name__ == '__main__':
t= int(input())
ans = gift()
print(*ans,sep='\n')
#"{} {} {}".format(maxele,minele,minele)
```
| 88,593 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zookeeper is playing a game. In this game, Zookeeper must use bombs to bomb a string that consists of letters 'A' and 'B'. He can use bombs to bomb a substring which is either "AB" or "BB". When he bombs such a substring, the substring gets deleted from the string and the remaining parts of the string get concatenated.
For example, Zookeeper can use two such operations: AABABBA → AABBA → AAA.
Zookeeper wonders what the shortest string he can make is. Can you help him find the length of the shortest string?
Input
Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 20000) — the number of test cases. The description of the test cases follows.
Each of the next t lines contains a single test case each, consisting of a non-empty string s: the string that Zookeeper needs to bomb. It is guaranteed that all symbols of s are either 'A' or 'B'.
It is guaranteed that the sum of |s| (length of s) among all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print a single integer: the length of the shortest string that Zookeeper can make.
Example
Input
3
AAA
BABA
AABBBABBBB
Output
3
2
0
Note
For the first test case, you can't make any moves, so the answer is 3.
For the second test case, one optimal sequence of moves is BABA → BA. So, the answer is 2.
For the third test case, one optimal sequence of moves is AABBBABBBB → AABBBABB → AABBBB → ABBB → AB → (empty string). So, the answer is 0.
Tags: brute force, data structures, greedy, strings
Correct Solution:
```
for _ in range(int(input())):
ans = 0
for i in input():
if i == 'B' and ans != 0:
ans -= 1
else:
ans += 1
print(ans)
```
| 88,594 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zookeeper is playing a game. In this game, Zookeeper must use bombs to bomb a string that consists of letters 'A' and 'B'. He can use bombs to bomb a substring which is either "AB" or "BB". When he bombs such a substring, the substring gets deleted from the string and the remaining parts of the string get concatenated.
For example, Zookeeper can use two such operations: AABABBA → AABBA → AAA.
Zookeeper wonders what the shortest string he can make is. Can you help him find the length of the shortest string?
Input
Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 20000) — the number of test cases. The description of the test cases follows.
Each of the next t lines contains a single test case each, consisting of a non-empty string s: the string that Zookeeper needs to bomb. It is guaranteed that all symbols of s are either 'A' or 'B'.
It is guaranteed that the sum of |s| (length of s) among all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print a single integer: the length of the shortest string that Zookeeper can make.
Example
Input
3
AAA
BABA
AABBBABBBB
Output
3
2
0
Note
For the first test case, you can't make any moves, so the answer is 3.
For the second test case, one optimal sequence of moves is BABA → BA. So, the answer is 2.
For the third test case, one optimal sequence of moves is AABBBABBBB → AABBBABB → AABBBB → ABBB → AB → (empty string). So, the answer is 0.
Tags: brute force, data structures, greedy, strings
Correct Solution:
```
from collections import deque
t = int(input())
for _ in range(t):
s=input()
n = len(s)
stack = deque()
for i in range(n):
if s[i]=='B' and stack:
stack.pop()
else:
stack.append(s[i])
length = len(stack)
ans = 0
if length>=1:
temp = []
prev ,prevIdx = stack[0],0
for i in range(1,length):
if stack[i]!=prev:
temp.append((prev,i-prevIdx))
prev = stack[i]
prevIdx = i
temp.append((prev,length-prevIdx))
length = len(temp)
for i in range(length):
if temp[i][0]=='B' and temp[i][1]&1:
ans+=1
else:
ans+=temp[i][1]
print(ans)
```
| 88,595 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zookeeper is playing a game. In this game, Zookeeper must use bombs to bomb a string that consists of letters 'A' and 'B'. He can use bombs to bomb a substring which is either "AB" or "BB". When he bombs such a substring, the substring gets deleted from the string and the remaining parts of the string get concatenated.
For example, Zookeeper can use two such operations: AABABBA → AABBA → AAA.
Zookeeper wonders what the shortest string he can make is. Can you help him find the length of the shortest string?
Input
Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 20000) — the number of test cases. The description of the test cases follows.
Each of the next t lines contains a single test case each, consisting of a non-empty string s: the string that Zookeeper needs to bomb. It is guaranteed that all symbols of s are either 'A' or 'B'.
It is guaranteed that the sum of |s| (length of s) among all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print a single integer: the length of the shortest string that Zookeeper can make.
Example
Input
3
AAA
BABA
AABBBABBBB
Output
3
2
0
Note
For the first test case, you can't make any moves, so the answer is 3.
For the second test case, one optimal sequence of moves is BABA → BA. So, the answer is 2.
For the third test case, one optimal sequence of moves is AABBBABBBB → AABBBABB → AABBBB → ABBB → AB → (empty string). So, the answer is 0.
Tags: brute force, data structures, greedy, strings
Correct Solution:
```
import bisect
def solve(s):
n = len(s)
stack = []
for j in range(n):
if stack:
if s[j] == 'B':
stack.pop()
else:
stack.append('A')
else:
stack.append(s[j])
return len(stack)
t = int(input())
ans = []
for i in range(t):
s = list(input())
ans.append(solve(s))
# print(ans)
for test in ans:
print(test)
```
| 88,596 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zookeeper is playing a game. In this game, Zookeeper must use bombs to bomb a string that consists of letters 'A' and 'B'. He can use bombs to bomb a substring which is either "AB" or "BB". When he bombs such a substring, the substring gets deleted from the string and the remaining parts of the string get concatenated.
For example, Zookeeper can use two such operations: AABABBA → AABBA → AAA.
Zookeeper wonders what the shortest string he can make is. Can you help him find the length of the shortest string?
Input
Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 20000) — the number of test cases. The description of the test cases follows.
Each of the next t lines contains a single test case each, consisting of a non-empty string s: the string that Zookeeper needs to bomb. It is guaranteed that all symbols of s are either 'A' or 'B'.
It is guaranteed that the sum of |s| (length of s) among all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print a single integer: the length of the shortest string that Zookeeper can make.
Example
Input
3
AAA
BABA
AABBBABBBB
Output
3
2
0
Note
For the first test case, you can't make any moves, so the answer is 3.
For the second test case, one optimal sequence of moves is BABA → BA. So, the answer is 2.
For the third test case, one optimal sequence of moves is AABBBABBBB → AABBBABB → AABBBB → ABBB → AB → (empty string). So, the answer is 0.
Tags: brute force, data structures, greedy, strings
Correct Solution:
```
import re
from collections import deque
T = int(input())
for test in range(T):
a = input()
basket = deque(re.findall('A+|B+', a))
i = 0
while i < len(basket) - 1: # A 덩어리가 마지막에 있으면 안된다.
if basket[i][0] != 'A':
i += 1
continue
temp = len(basket[i]) - len(basket[i + 1])
del basket[i]
del basket[i]
if temp == 0:
continue
elif temp > 0:
if len(basket) == i:
basket.append('A' * temp)
else:
basket[i] += 'A' * temp
else:
if i == 0:
basket.appendleft('B' * abs(temp))
else:
basket[i - 1] += 'B' * abs(temp)
ans = 0
for elem in basket:
if elem[0] == 'B':
ans += len(elem) % 2
else:
ans += len(elem)
print(ans)
```
| 88,597 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Zookeeper is playing a game. In this game, Zookeeper must use bombs to bomb a string that consists of letters 'A' and 'B'. He can use bombs to bomb a substring which is either "AB" or "BB". When he bombs such a substring, the substring gets deleted from the string and the remaining parts of the string get concatenated.
For example, Zookeeper can use two such operations: AABABBA → AABBA → AAA.
Zookeeper wonders what the shortest string he can make is. Can you help him find the length of the shortest string?
Input
Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 20000) — the number of test cases. The description of the test cases follows.
Each of the next t lines contains a single test case each, consisting of a non-empty string s: the string that Zookeeper needs to bomb. It is guaranteed that all symbols of s are either 'A' or 'B'.
It is guaranteed that the sum of |s| (length of s) among all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print a single integer: the length of the shortest string that Zookeeper can make.
Example
Input
3
AAA
BABA
AABBBABBBB
Output
3
2
0
Note
For the first test case, you can't make any moves, so the answer is 3.
For the second test case, one optimal sequence of moves is BABA → BA. So, the answer is 2.
For the third test case, one optimal sequence of moves is AABBBABBBB → AABBBABB → AABBBB → ABBB → AB → (empty string). So, the answer is 0.
Tags: brute force, data structures, greedy, strings
Correct Solution:
```
i = int(input())
for _ in range(i):
test = list(input())
ch = 0
totlen = len(test)
acount = 0
abcount = 0
aindex = []
for _ in range(len(test)):
if test[_]=='A':
test[_] = 'A*'
aindex.append(_)
acount += 1
elif acount > 0:
test[_] = '*'
ai = aindex.pop()
test[ai] = '*'
acount -= 1
abcount += 1
bbcount = 0
bcount = 0
for _ in test:
if _ == 'B':
if bcount > 0:
bbcount +=1
bcount = 0
else:
bcount = 1
elif _ == 'A*' or _ == 'A':
bcount = 0
print(totlen - abcount*2 - bbcount*2)
```
| 88,598 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Zookeeper is playing a game. In this game, Zookeeper must use bombs to bomb a string that consists of letters 'A' and 'B'. He can use bombs to bomb a substring which is either "AB" or "BB". When he bombs such a substring, the substring gets deleted from the string and the remaining parts of the string get concatenated.
For example, Zookeeper can use two such operations: AABABBA → AABBA → AAA.
Zookeeper wonders what the shortest string he can make is. Can you help him find the length of the shortest string?
Input
Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 20000) — the number of test cases. The description of the test cases follows.
Each of the next t lines contains a single test case each, consisting of a non-empty string s: the string that Zookeeper needs to bomb. It is guaranteed that all symbols of s are either 'A' or 'B'.
It is guaranteed that the sum of |s| (length of s) among all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print a single integer: the length of the shortest string that Zookeeper can make.
Example
Input
3
AAA
BABA
AABBBABBBB
Output
3
2
0
Note
For the first test case, you can't make any moves, so the answer is 3.
For the second test case, one optimal sequence of moves is BABA → BA. So, the answer is 2.
For the third test case, one optimal sequence of moves is AABBBABBBB → AABBBABB → AABBBB → ABBB → AB → (empty string). So, the answer is 0.
Submitted Solution:
```
import sys
readline = sys.stdin.readline
T = int(readline())
Ans = [None]*T
for qu in range(T):
S = [1 if s == 'A' else 0 for s in readline().strip()]
stack = []
for s in S:
if s:
stack.append(s)
else:
if stack and stack[-1] == 1:
stack.pop()
else:
stack.append(s)
stack2 = []
for s in stack:
if s:
stack2.append(s)
else:
if stack2 and stack2[-1] == 0:
stack2.pop()
else:
stack2.append(s)
Ans[qu] = len(stack2)
print('\n'.join(map(str, Ans)))
```
Yes
| 88,599 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.