input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N, M = [int(_) for _ in input().split()]
ab = [input().split() for _ in range(M)]
N = str(N)
ne = []
for i in ab:
if i[0] == "1":
ne += [i[1]]
for j in ab:
if j[0] in ne and j[1] == N:
print("POSSIBLE")
exit()
print("IMPOSSIBLE") | N, M = [int(_) for _ in input().split()]
ab = [input().split() for _ in range(M)]
goal = {i:0 for i in range(1, N+1)}
N = str(N)
ne = []
for i in ab:
if i[0] == "1":
goal[int(i[1])] = 1
for j in ab:
if goal[int(j[0])] and j[1] == N:
print("POSSIBLE")
exit()
print("IMPOSSIBLE") | p03645 |
N, M = list(map(int,input().split()))
S = []
for i in range(M):
S.append(list(map(int, input().split())))
toN =[]
first = []
end = False
for i in range(M):
if S[i][1] == N:
toN.append(S[i][0])
for i in range(M):
if S[i][0] == 1:
first.append(S[i][1])
for i in toN:
if end:
break
for j in first:
if end:
break
if i == j:
print("POSSIBLE")
end = True
break
if not end:
print("IMPOSSIBLE") | N, M = list(map(int,input().split()))
S = []
for i in range(M):
S.append(list(map(int, input().split())))
toN =[]
first = []
end = False
for i in range(M):
if S[i][1] == N:
toN.append(S[i][0])
for i in range(M):
if S[i][0] == 1:
first.append(S[i][1])
toN = set(toN)
first = set(first)
if toN.intersection(first):
print("POSSIBLE")
else:
print("IMPOSSIBLE") | p03645 |
N, M = list(map(int, input().split()))
ans = 'IMPOSSIBLE'
abl1 = []
abl2 = []
for _ in range(M):
ab = list(map(int,input().split()))
if ab[0] == 1:
abl1.append(ab)
elif ab[1] == N:
abl2.append(ab)
for i in abl1:
if [i[1], N] in abl2:
ans = 'POSSIBLE'
print(ans) | N, M = list(map(int, input().split()))
abl1 = set()
abl2 = set()
for _ in range(M):
ab = list(map(int,input().split()))
if ab[0] == 1:
abl1.add(ab[1])
elif ab[1] == N:
abl2.add(ab[0])
for i in abl1:
if i in abl2:
print("POSSIBLE")
exit()
print("IMPOSSIBLE") | p03645 |
import collections
n,m = list(map(int,input().split()))
s = [list(map(int,input().split())) for i in range(m)]
q = collections.deque()
for i in range(m):
if s[i][0] == 1:
q.append(s[i][1])
for i in s:
for j in q:
if j in i and n in i:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
| n,m = list(map(int,input().split()))
s1 = set()
s2 = set()
for i in range(m):
a,b = list(map(int,input().split()))
if a == 1:
s1.add(b)
elif b == 1:
s1.add(a)
elif a == n:
s2.add(b)
elif b == n:
s2.add(a)
if s1.isdisjoint(s2):
print("IMPOSSIBLE")
else:
print("POSSIBLE")
| p03645 |
n, m = list(map(int, input().split()))
P, M = ("POSSIBLE", "IMPOSSIBLE")
dic = {}
for _ in range(m):
a, b = list(map(int, input().split()))
if dic.get(a) is None: dic[a] = [b]
else: dic[a] = dic[a] + [b]
if dic.get(b) is None: dic[b] = [a]
else: dic[b] = dic[b] + [a]
if dic.get(n) is None:
print(M)
exit()
arr = dic[n]
for i in arr:
if 1 in dic[i]:
print(P)
exit()
print(M) | def answer(destination, services):
P, M = ("POSSIBLE", "IMPOSSIBLE")
dic = {}
for a, b in services:
if dic.get(a) is None:
dic[a] = [b]
else:
dic[a].append(b)
if dic.get(b) is None:
dic[b] = [a]
else:
dic[b].append(a)
if dic.get(destination) is None: return M
arr = dic[destination]
for i in arr:
if 1 in dic[i]:
return P
return M
n, m = list(map(int, input().split()))
services = []
for _ in range(m):
a, b = list(map(int, input().split()))
services.append((a, b))
print((answer(n, services))) | p03645 |
N, M = list(map(int,input().split()))
AB = []
for _ in range(M):
a,b = list(map(int,input().split()))
if a == 1 or b== N:
AB.append((a,b))
AB = set(AB)
for ab in AB:
if ab[0] == 1:
for cd in AB:
if cd[1] == N and ab[1] == cd[0]:
print("POSSIBLE")
exit()
print("IMPOSSIBLE") | N, M = list(map(int,input().split()))
AB = []
for _ in range(M):
a,b = list(map(int,input().split()))
if a == 1 or b== N:
AB.append((a,b))
set1 = set()
set2 = set()
for ab in AB:
if ab[0] == 1:
set1.add(ab[1])
if ab[1] == N:
set2.add(ab[0])
if set1 & set2:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | p03645 |
n,m=list(map(int,input().split()))
first=[]
second=[]
for i in range(m):
ai,bi=list(map(int,input().split()))
if ai==1:
first.append(bi)
elif bi==n:
second.append(ai)
fset,sset=set(first),set(second)
if len(list(fset&sset))>=1:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | n,m=list(map(int,input().split()))
check=[0]*n
ans="IMPOSSIBLE"
for i in range(m):
ai,bi=list(map(int,input().split()))
if ai==1:
if check[bi-1]==1:
ans="POSSIBLE"
break
else:
check[bi-1]+=1
elif bi==n:
if check[ai-1]==1:
ans="POSSIBLE"
break
else:
check[ai-1]+=1
print(ans) | p03645 |
N, M, *A = list(map(int, open(0).read().split()))
A = [(A[i], A[i+1]) for i in range(0, M*2, 2)]
E = [[] for _ in range(N)]
for a, b in A:
a -= 1; b -= 1
E[a].append(b)
E[b].append(a)
def search(d=2, v=0, g=N-1):
if d == 0:
if v == g:
return True
else:
return False
for to in E[v]:
if search(d-1, to, g):
return True
return False
if search():
print('POSSIBLE')
else:
print('IMPOSSIBLE') | import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
G = [[] for _ in [0]*N]
for _ in [0]*M:
a, b = list(map(int, input().split()))
a -= 1; b -= 1
G[a].append(b)
G[b].append(a)
for v in G[0]:
if N-1 in G[v]:
print('POSSIBLE')
break
else:
print('IMPOSSIBLE') | p03645 |
N,M = list(map(int,input().split(" ")))
first = []
second = []
flag = 0
for i in range(M):
a,b = list(map(int,input().split(" ")))
if b == N:
second.append(a)
if a == 1:
first.append(b)
if len(first) == 0 or len(second) == 0:
print("IMPOSSIBLE")
else:
for j in range(len(first)):
for k in range(len(second)):
if first[j] == second[k]:
print("POSSIBLE")
flag = 1
break
if flag == 0:
print("IMPOSSIBLE") | N,M = list(map(int,input().split(" ")))
first = []
second = []
flag = 0
end = True
for i in range(M):
a,b = list(map(int,input().split(" ")))
if b == N:
second.append(a)
if a == 1:
first.append(b)
first.sort()
second.sort()
if len(first) == 0 or len(second) == 0:
print("IMPOSSIBLE")
else:
firsti = 0
secondi = 0
while(end == True):
if first[firsti] == second[secondi]:
print("POSSIBLE")
break
elif first[firsti] < second[secondi]:
firsti += 1
if firsti > len(first) - 1:
print("IMPOSSIBLE")
break
else:
secondi += 1
if secondi > len(second) - 1:
print("IMPOSSIBLE")
break
| p03645 |
n,m=list(map(int,input().split()));a,b=[],[]
for i in range(m):
aa,bb=list(map(int,input().split()))
a.append(aa);b.append(bb)
c=[]
for i in range(m):
if a[i]==1:c.append(b[i])
for i in range(m):
if b[i]==n:
if a[i] in c:print("POSSIBLE");exit()
print("IMPOSSIBLE") | n,m=list(map(int,input().split()));a=[]
for i in range(m):
aa,bb=list(map(int,input().split()))
if aa==1:a.append(bb)
if bb==n:a.append(aa)
a.sort()
for i in range(len(a)-1):
if a[i]==a[i+1]:print("POSSIBLE");exit()
print("IMPOSSIBLE") | p03645 |
n,m=list(map(int,input().split()));a=[]
for i in range(m):
aa,bb=list(map(int,input().split()))
if aa==1:a.append(bb)
if bb==n:a.append(aa)
a.sort()
for i in range(len(a)-1):
if a[i]==a[i+1]:print("POSSIBLE");exit()
print("IMPOSSIBLE") | n,m=list(map(int,input().split()))
s,t=set(),set()
for _ in range(m):
a,b=list(map(int,input().split()))
if a==1:t.add(b)
if b==n:s.add(a)
if s&t:print("POSSIBLE")
else:print("IMPOSSIBLE") | p03645 |
n, m = list(map(int, input().split()))
transit = []
transit_ = []
for a,b in (list(map(int, input().split())) for _ in range(m)):
if a == 1:
transit.append(b)
if b == n:
transit_.append(a)
if set(transit)&set(transit_):
print("POSSIBLE")
else:
print("IMPOSSIBLE") | import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
transit = []
transit_ = []
for a,b in (list(map(int, input().split())) for _ in range(m)):
if a == 1:
transit.append(b)
if b == n:
transit_.append(a)
if set(transit)&set(transit_):
print("POSSIBLE")
else:
print("IMPOSSIBLE") | p03645 |
import itertools
N, M = list(map(int, input().split()))
AB = [tuple(sorted(map(int, input().split(' ')))) for _ in range(M)]
ans = 0
for i in range(2, N):
if tuple([1, i]) in AB and tuple([i, N]) in AB:
print('POSSIBLE')
break
else:
print('IMPOSSIBLE')
| n, m = list(map(int, input().split()))
sa = set()
sb = set()
for _ in range(m):
a, b = list(map(int, input().split()))
if a == 1:
sb.add(b)
if b == n:
sa.add(a)
print(('POSSIBLE' if len(sa&sb) != 0 else 'IMPOSSIBLE'))
| p03645 |
n, m = list(map(int, input().split()))
first = [0]
a = 1
for i in range(0, m):
b = (list(map(int, input().split())))
if b[0] == 1:
if b[1] in first:
print('POSSIBLE')
a = 0
break
else:
first.append(b[1])
if b[1] == n:
if b[0] in first:
print('POSSIBLE')
a = 0
break
else:
first.append(b[0])
if a:
print('IMPOSSIBLE') | n, m = list(map(int, input().split()))
des= [0]*(n+1)
a = 1
for i in range(0, m):
b = (list(map(int, input().split())))
if b[0] == 1:
des[b[1]] += 1
if des[b[1]] == 2:
print('POSSIBLE')
a = 0
break
if b[1] == n:
des[b[0]] += 1
if des[b[0]] == 2:
print('POSSIBLE')
a = 0
break
if a:
print('IMPOSSIBLE')
| p03645 |
from collections import deque
N,M=list(map(int,input().split()))
sa=deque([])
en=deque([])
for _ in range(M):
a,b=list(map(int,input().split()))
if a==1:
sa.append(b)
elif b==N:
en.append(a)
print(('POSSIBLE' if any([x in en for x in sa]) else 'IMPOSSIBLE')) | N,M=list(map(int,input().split()))
AB=[[int(x) for x in input().split()] for _ in range(M)]
sa=set()
en=set()
for a,b in AB:
if a>b:
a,b=b,a
if a==1:
sa.add(b)
if b==N:
en.add(a)
print(('POSSIBLE' if sa&en else 'IMPOSSIBLE')) | p03645 |
n, m = list(map(int, input().split()))
a = [input().split() for _ in range(m)]
A = set()
B = set()
for i in range(m):
if a[i][0] == "1":
A.add(a[i][1])
if a[i][1] == str(n):
B.add(a[i][0])
if A & B:
print("POSSIBLE")
break
else:
print("IMPOSSIBLE")
| n, m = list(map(int, input().split()))
a = [input().split() for _ in range(m)]
A = []
B = []
for i in range(m):
if a[i][0] == "1":
A.append(a[i][1])
if a[i][1] == str(n):
B.append(a[i][0])
print(("POSSIBLE" if set(A) & set(B) else "IMPOSSIBLE"))
| p03645 |
n,m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
ab.sort()
AB = sorted(ab, reverse=True, key=lambda x:x[1])
s = []
ans = "IMPOSSIBLE"
for a,b in ab:
if a == 1: s.append(b)
else: break
for A, B in AB:
if B == n:
if A in s:
ans = "POSSIBLE"
else: break
print(ans) | n,m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
ab.sort()
AB = sorted(ab, reverse=True, key=lambda x:x[1])
s = [0] * n
ans = "IMPOSSIBLE"
for a,b in ab:
if a == 1: s[b-1] = 1
else: break
for A, B in AB:
if B == n:
if s[A-1] == 1:
ans = "POSSIBLE"
else: break
print(ans) | p03645 |
n,m = list(map(int, input().split()))
s = []
g = []
for _ in range(m):
a,b = list(map(int, input().split()))
if a == 1: s.append(b)
elif b == n: g.append(a)
s.sort()
g.sort()
if min(len(s), len(g)) == len(g): x,y = g,s
else: x,y = s,g
ok = False
for v in x:
if v in y:
ok = True
break
print(("POSSIBLE" if ok else "IMPOSSIBLE")) | n,m = list(map(int, input().split()))
l = [0] * (n+1)
for _ in range(m):
a,b = list(map(int, input().split()))
if a == 1: l[b] += 1
if b == n: l[a] += 1
print(("POSSIBLE" if 2 in l else "IMPOSSIBLE")) | p03645 |
n,m = list(map(int, input().split()))
l = [0] * (n+1)
for _ in range(m):
a,b = list(map(int, input().split()))
if a == 1: l[b] += 1
if b == n: l[a] += 1
print(("POSSIBLE" if 2 in l else "IMPOSSIBLE")) | n,m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
start = []
goal = []
for a,b in ab:
if a == 1: start.append(b)
elif b == n: goal.append(a)
print(("POSSIBLE" if list(set(start) & set(goal)) else "IMPOSSIBLE")) | p03645 |
import sys
from collections import defaultdict
N, M = list(map(int, input().split()))
inter = []
goalable = defaultdict(lambda: False)
for i in range(M):
start, end = list(map(int, input().split()))
if start == 1:
inter.append(end)
else:
if end == N:
goalable[start] = True
for i in inter:
if goalable[i]:
print("POSSIBLE")
sys.exit()
print("IMPOSSIBLE") | N, M = list(map(int, input().split()))
inter, goalable = set(), set()
for i in range(M):
a, b = list(map(int, input().split()))
if a == 1:
inter.add(b)
if b == N:
goalable.add(a)
flag = inter & goalable
print(("POSSIBLE" if flag else "IMPOSSIBLE")) | p03645 |
n,m = list(map(int,input().split()))
a = [0 for _ in range(m)]
b = [0 for _ in range(m)]
for i in range(m):
a[i],b[i] = list(map(int,input().split()))
go = []
for i in range(len(a)):
if (a[i] == 1):
go.append(b[i])
a[i],b[i] == 0,0
u = 0
t = len(a)
while(u < t):
if a[u] == 0:
del(a[u])
del(b[u])
t -= 1
if b[u] != n:
del(a[u])
del(b[u])
t -= 1
u += 1
for i in range(len(go)):
for j in range(len(a)):
if(go[i] == a[j]):
if(b[j] == n):
print("POSSIBLE")
exit()
print("IMPOSSIBLE") | n,m = list(map(int,input().split()))
a = [0 for _ in range(m)]
b = [0 for _ in range(m)]
for i in range(m):
a[i],b[i] = list(map(int,input().split()))
go = []
goal = []
for i in range(len(a)):
if a[i] == 1:
go.append(b[i])
if b[i] == n:
goal.append(a[i])
count = [0 for i in range(n)]
for i in range(len(go)):
count[go[i]-1] = 1
for i in range(len(goal)):
count[goal[i]-1] += 1
for i in range(len(count)):
if count[i] > 1:
print("POSSIBLE")
exit()
print("IMPOSSIBLE") | p03645 |
a=input().split()
N=int(a[0])
M=int(a[1])
first=[]
second=[]
i=0
while i<M:
y=input().split()
if int(y[0])==1:
first.append(y[1])
elif int(y[1])==N:
second.append(y[0])
i+=1
if any(i in first for i in second):
print("POSSIBLE")
else:
print("IMPOSSIBLE") | a=input().split()
N=int(a[0])
M=int(a[1])
first=[]
second=[]
i=0
while i<M:
y=input().split()
if int(y[0])==1:
first.append(y[1])
elif int(y[1])==N:
second.append(y[0])
i+=1
first=set(first)
second=set(second)
if len(first.intersection(second))>0:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | p03645 |
N, M = list(map(int, input().split()))
X, Y = [],[]
for i in range(M):
A, B = list(map(int, input().split()))
if A == 1:
X.append(B)
elif B == N:
Y.append(A)
for i in X:
for j in Y:
if i == j:
print("POSSIBLE")
exit(0)
print("IMPOSSIBLE") | N, M = list(map(int, input().split()))
cnt = [0]*N
for i in range(M):
A, B = list(map(int, input().split()))
if A == 1:
cnt[B] += 1
elif B == N:
cnt[A] += 1
if 2 in cnt:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | p03645 |
n,m = list(map(int, input().split()))
ab = []
num = 0
for i in range(m):
a,b = list(map(int, input().split()))
if a == 1 or b == n:
num += 1
ab.append((a,b))
ab.sort()
x = 'IMPOSSIBLE'
for h in range(num):
if (ab[h][1],n) in ab:
x = 'POSSIBLE'
break
print(x) | n,m = list(map(int, input().split()))
b1 = []
b2 = []
for i in range(m):
a,b = list(map(int, input().split()))
if a == 1:
b1.append(b)
if b == n:
b2.append(a)
if len(b1) + len(b2) == len(list(set(b1+b2))):
print('IMPOSSIBLE')
else:
print('POSSIBLE') | p03645 |
import sys
from collections import deque
l = deque(sys.stdin.readlines())
n, m = (int(x) for x in l[0].split())
l.popleft()
from_1, to_n = set(), set()
for a, b in deque((int(x) for x in l[i].split()) for i in range(m)):
if a == 1: from_1.add(b)
elif b == n: to_n.add(a)
print(("POSSIBLE" if from_1 & to_n else "IMPOSSIBLE")) | import sys
l = sys.stdin.readlines()
n, m = (int(x) for x in l[0].split())
from_1, to_n = set(), set()
for a, b in ((int(x) for x in l[i].split()) for i in range(1, m+1)):
if a == 1: from_1.add(b)
elif b == n: to_n.add(a)
print(("POSSIBLE" if from_1 & to_n else "IMPOSSIBLE"))
| p03645 |
import sys
l = sys.stdin.readlines()
n, m = (int(x) for x in l[0].split())
from_1, to_n = set(), set()
for a, b in ((int(x) for x in l[i].split()) for i in range(1, m+1)):
if a == 1: from_1.add(b)
elif b == n: to_n.add(a)
print(("POSSIBLE" if from_1 & to_n else "IMPOSSIBLE"))
| import sys
l = sys.stdin.readlines()
n, m = l[0].split()
from_1, to_n = set(), set()
for a, b in (l[i].split() for i in range(1, int(m)+1)):
if a == '1': from_1.add(b)
elif b == n: to_n.add(a)
print(("POSSIBLE" if from_1 & to_n else "IMPOSSIBLE"))
| p03645 |
import sys
import math
import collections
import itertools
import array
import inspect
# Set max recursion limit
sys.setrecursionlimit(1000000)
# Debug output
def chkprint(*args):
names = {
id(v): k
for k, v in list(inspect.currentframe().f_back.f_locals.items())
}
print((', '.join(
names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args)))
# Binary converter
def to_bin(x):
return bin(x)[2:]
def li_input():
return [int(_) for _ in input().split()]
def gcd(n, m):
if n % m == 0:
return m
else:
return gcd(m, n % m)
def gcd_list(L):
v = L[0]
for i in range(1, len(L)):
v = gcd(v, L[i])
return v
def lcm(n, m):
return (n * m) // gcd(n, m)
def lcm_list(L):
v = L[0]
for i in range(1, len(L)):
v = lcm(v, L[i])
return v
# Width First Search (+ Distance)
def wfs_d(D, N, K):
"""
D: 隣接行列(距離付き)
N: ノード数
K: 始点ノード
"""
dfk = [-1] * (N + 1)
dfk[K] = 0
cps = [(K, 0)]
r = [False] * (N + 1)
r[K] = True
while len(cps) != 0:
n_cps = []
for cp, cd in cps:
for i, dfcp in enumerate(D[cp]):
if dfcp != -1 and not r[i]:
dfk[i] = cd + dfcp
n_cps.append((i, cd + dfcp))
r[i] = True
cps = n_cps[:]
return dfk
# Depth First Search (+Distance)
def dfs_d(v, pre, dist):
"""
v: 現在のノード
pre: １つ前のノード
dist: 現在の距離
以下は別途用意する
D: 隣接リスト(行列ではない)
D_dfs_d: dfs_d関数で用いる，始点ノードから見た距離リスト
"""
global D
global D_dfs_d
D_dfs_d[v] = dist
for next_v, d in D[v]:
if next_v != pre:
dfs_d(next_v, v, dist + d)
return
# --------------------------------------------
dp = None
def main():
N, M = li_input()
DL = [[] for _ in range(N + 1)]
for i in range(M):
a, b = li_input()
DL[a].append(b)
DL[b].append(a)
i = 0
R = [1]
C = [1]
while len(C) != 0 and i < 2:
nC = []
for c in C:
for dl in DL[c]:
if dl == N:
print("POSSIBLE")
return
if dl not in R:
R.append(dl)
nC.append(dl)
C = nC[:]
i += 1
print("IMPOSSIBLE")
main()
| import sys
import math
import collections
import itertools
import array
import inspect
# Set max recursion limit
sys.setrecursionlimit(1000000)
# Debug output
def chkprint(*args):
names = {
id(v): k
for k, v in list(inspect.currentframe().f_back.f_locals.items())
}
print((', '.join(
names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args)))
# Binary converter
def to_bin(x):
return bin(x)[2:]
def li_input():
return [int(_) for _ in input().split()]
def gcd(n, m):
if n % m == 0:
return m
else:
return gcd(m, n % m)
def gcd_list(L):
v = L[0]
for i in range(1, len(L)):
v = gcd(v, L[i])
return v
def lcm(n, m):
return (n * m) // gcd(n, m)
def lcm_list(L):
v = L[0]
for i in range(1, len(L)):
v = lcm(v, L[i])
return v
# Width First Search (+ Distance)
def wfs_d(D, N, K):
"""
D: 隣接行列(距離付き)
N: ノード数
K: 始点ノード
"""
dfk = [-1] * (N + 1)
dfk[K] = 0
cps = [(K, 0)]
r = [False] * (N + 1)
r[K] = True
while len(cps) != 0:
n_cps = []
for cp, cd in cps:
for i, dfcp in enumerate(D[cp]):
if dfcp != -1 and not r[i]:
dfk[i] = cd + dfcp
n_cps.append((i, cd + dfcp))
r[i] = True
cps = n_cps[:]
return dfk
# Depth First Search (+Distance)
def dfs_d(v, pre, dist):
"""
v: 現在のノード
pre: １つ前のノード
dist: 現在の距離
以下は別途用意する
D: 隣接リスト(行列ではない)
D_dfs_d: dfs_d関数で用いる，始点ノードから見た距離リスト
"""
global D
global D_dfs_d
D_dfs_d[v] = dist
for next_v, d in D[v]:
if next_v != pre:
dfs_d(next_v, v, dist + d)
return
# --------------------------------------------
dp = None
def main():
N, M = li_input()
L = []
for i in range(M):
a, b = li_input()
if a == 1:
L.append(b)
if b == N:
L.append(a)
if len(L) == len(set(L)):
print("IMPOSSIBLE")
else:
print("POSSIBLE")
main()
| p03645 |
import sys
input = sys.stdin.readline
def read():
N, M = list(map(int, input().strip().split()))
AB = []
for i in range(M):
a, b = list(map(int, input().strip().split()))
AB.append((a, b))
return N, M, AB
def solve(N, M, AB):
S = [False for i in range(N+1)]
T = [False for i in range(N+1)]
for a, b in AB:
if a > b:
a, b = b, a
if a == 1:
S[b] = True
elif b == N:
T[a] = True
for s, t in zip(S, T):
if s and t:
return "POSSIBLE"
return "IMPOSSIBLE"
if __name__ == '__main__':
inputs = read()
print(("%s" % solve(*inputs)))
| import sys
input = sys.stdin.readline
def read():
N, M = list(map(int, input().strip().split()))
AB = []
for i in range(M):
a, b = list(map(int, input().strip().split()))
AB.append((a, b))
return N, M, AB
def solve(N, M, AB):
is_ok = True
mid_b = set()
mid_a = set()
for a, b in AB:
if a == 1:
mid_b.add(b)
elif b == N:
mid_a.add(a)
is_ok = len(mid_a.intersection(mid_b)) > 0
return "POSSIBLE" if is_ok else "IMPOSSIBLE"
if __name__ == '__main__':
inputs = read()
print((solve(*inputs)))
| p03645 |
N, M = list(map(int,input().split()))
P = [list(map(int,input().split())) for _ in range(M)]
P.sort()
Q = []
s = -1
ans = ("IMPOSSIBLE")
for i in range (M):
if P[i][0] == 1:
Q.append(P[i][1])
else:
s = i - 1
break
if s >= 0:
for j in range(s, M):
if P[j][1] == N:
if P[j][0] in Q:
ans = ("POSSIBLE")
print(ans) | N, M = list(map(int,input().split()))
P = [list(map(int,input().split())) for _ in range(M)]
P.sort()
q = -1
ans = ("IMPOSSIBLE")
for i in range (M):
if P[i][0] == 1:
p = P[i][1]
if q < 0:
if i > 0:
q = i - 1
else:
q = 0
for j in range(q, M):
if P[j][0] == p:
if P[j][1] == N:
ans = ("POSSIBLE")
break
elif P[j][0] > p:
if q >= 0:
q = j - 1
else:
q = 0
break
else:
break
print(ans) | p03645 |
N, M = list(map(int,input().split()))
#訪れることができるかのリスト
lst = [0] * N
flag = False #フラグを立てる
for i in range(M): #M種の定期船について確認
a, b = list(map(int,input().split()))
if a == 1: #スタートが1の時
if lst[b-1] == 1: #Nから1回で来る船があるならOK
flag = True
else:
lst[b-1] = 1 #Nから1回で来る船がない時、1からは1回で来れることをメモ
if b == N: #ゴールがNの時
if lst[a-1] == 1: #1から1回で来る船があるならOK
flag = True
else:
lst[a-1] = 1 #1から1回で来る船がない時、Nからは1回で来れることメモ
if flag:
print ('POSSIBLE')
else:
print ('IMPOSSIBLE')
| import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
G = [tuple(map(int, input().split())) for _ in range(M)]
G.sort(key = lambda x: x[0])
check = [False] * (N + 1)
for a, b in G:
if a == 1:
check[b] = True
else:
if check[a] and b == N:
print ('POSSIBLE')
exit()
print ('IMPOSSIBLE') | p03645 |
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
arr = []
for x in ab:
if n in x:
if x.index(n) == 0:
arr.append(x[1])
else:
arr.append(x[0])
for a, b in ab:
if a in arr:
if b == 1:
print('POSSIBLE')
exit()
if b in arr:
if a == 1:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
| n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
s = set()
for x in ab:
if n in x:
if x.index(n) == 0:
s.add(x[1])
else:
s.add(x[0])
for a, b in ab:
if a in s:
if b == 1:
print('POSSIBLE')
exit()
if b in s:
if a == 1:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
| p03645 |
N,M=list(map(int,input().split()))
sa=set()
sb=set()
for i in range(M):
a,b=list(map(int,input().split()))
if a==1:sb.add(b)
if b==N:sa.add(a)
print(("IMPOSSIBLE" if len(sa&sb)==0 else "POSSIBLE"))
| n, m = list(map(int, input().split()))
sa = set()
sb = set()
for i in range(m):
a, b = list(map(int, input().split()))
if a == 1:
sb.add(b)
if b == n:
sa.add(a)
print(('IMPOSSIBLE' if len(sa & sb) == 0 else 'POSSIBLE'))
| p03645 |
from collections import defaultdict
N, M = list(map(int, input().split()))
d = defaultdict(list)
for i in range(M):
a,b = list(map(int, input().split()))
d[a].append(b)
for i,j in list(d.items()):
if i!=1:
continue
for k in j:
if N in d[k]:
print('POSSIBLE')
exit()
print('IMPOSSIBLE') | from collections import defaultdict
N, M = list(map(int, input().split()))
d = defaultdict(list)
for i in range(M):
a,b = list(map(int, input().split()))
d[a].append(b)
for j in d[1]:
if N in d[j]:
print('POSSIBLE')
exit()
print('IMPOSSIBLE') | p03645 |
n, m = list(map(int, input().split()))
s = []
e = []
for i in range(m):
a, b = list(map(int, input().split()))
if a == 1 and b not in s:
s.append(b)
elif b == n and a not in e:
e.append(a)
if len(set(s) & set(e)) != 0:
print('POSSIBLE')
else:
print('IMPOSSIBLE')
| n, m = list(map(int, input().split()))
s = []
e = []
for i in range(m):
a, b = list(map(int, input().split()))
if a == 1:
s.append(b)
elif b == n:
e.append(a)
if len(set(s) & set(e)) != 0:
print('POSSIBLE')
else:
print('IMPOSSIBLE')
| p03645 |
n, m = list(map(int, input().split()))
r = [[0, 0] for _ in range(m)]
ln = []
l1 = []
for i in range(m):
r[i][0], r[i][1] = list(map(int, input().split()))
if r[i][1] == n:
ln.append(i)
if r[i][0] == 1:
l1.append(i)
ans = "IMPOSSIBLE"
for i in l1:
for j in ln:
if r[i][1] == r[j][0]:
ans = "POSSIBLE"
break
print(ans)
| n, m = list(map(int, input().split()))
l = [0] * n
r = []
for i in range(m):
a, b = list(map(int, input().split()))
if a == 1:
r.append(b)
if b == n:
l[a - 1] = 1
ans = "IMPOSSIBLE"
for i in r:
if l[i - 1] == 1:
ans = "POSSIBLE"
print(ans) | p03645 |
# ABC068c
import collections
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
n, m = list(map(int, input().split()))
INF = 10**12
class Edge: # 通常の辺
def __init__(self, to, cost):
self.to = to
self.cost = cost
class Dijkstra: # ダイクストラ法 O(E * logV)
def __init__(self, n):
self.n = n
self.dist = [INF for _ in range(n)]
self.edges = [list() for _ in range(n)]
self.q = collections.deque()
def calcShortest(self, start):
self.q.append((start, 0))
while(len(self.q) != 0):
v, cost = self.q.popleft()
if self.dist[v] <= cost:
continue
self.dist[v] = cost
for edge in self.edges[v]:
self.q.append((edge.to, cost+edge.cost))
def addEdge(self, st, gl, cost):
self.edges[st].append(Edge(gl, cost))
v = Dijkstra(n)
for _ in range(m):
a, b = list(map(int, input().split()))
v.addEdge(a-1, b-1, 1)
v.addEdge(b-1, a-1, 1)
v.calcShortest(0)
if v.dist[n-1] <= 2:
print('POSSIBLE')
exit(0)
print('IMPOSSIBLE')
| # ABC068c
import collections
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
n, m = list(map(int, input().split()))
INF = 10**12
class Edge: # 通常の辺
def __init__(self, to, cost):
self.to = to
self.cost = cost
class Dijkstra: # ダイクストラ法 O(E * logV)
def __init__(self, n):
self.n = n
self.dist = [INF for _ in range(n)]
self.edges = [list() for _ in range(n)]
self.q = collections.deque()
def calcShortest(self, start):
self.q.append((start, 0))
while(len(self.q) != 0):
v, cost = self.q.popleft()
if cost > 3:
continue
if self.dist[v] <= cost:
continue
self.dist[v] = cost
for edge in self.edges[v]:
self.q.append((edge.to, cost+edge.cost))
def addEdge(self, st, gl, cost):
self.edges[st].append(Edge(gl, cost))
v = Dijkstra(n)
for _ in range(m):
a, b = list(map(int, input().split()))
v.addEdge(a-1, b-1, 1)
v.addEdge(b-1, a-1, 1)
v.calcShortest(0)
if v.dist[n-1] <= 2:
print('POSSIBLE')
exit(0)
print('IMPOSSIBLE')
| p03645 |
n,m = list(map(int,input().split()))
First = []
Second = []
for i in range(m):
a,b = list(map(int,input().split()))
if a == 1:
First.append(b)
if b == n:
Second.append(a)
for i in range(1,n+1):
if i in First and i in Second:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
| n,m = list(map(int,input().split()))
route = [0]*(n+10)
for i in range(m):
a,b = list(map(int,input().split()))
if a == 1:
route[b] += 1
if b == n:
route[a] += 1
if 2 in route:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | p03645 |
from collections import deque
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
ship = [[] for i in range(N)]
for i in range(M):
a,b = list(map(int, input().split()))
a -= 1
b -= 1
ship[a].append(b)
H = deque()
H.append(0)
visited = [0]*N
visited[0] = 1
while (4 not in visited) and H:
x = H.popleft()
for y in ship[x]:
if visited[y] == 0:
H.append(y)
visited[y] = visited[x] + 1
if 0 < visited[N-1] < 4:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | from collections import deque
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
ship = [[] for i in range(N)]
for i in range(M):
a,b = list(map(int, input().split()))
a -= 1
b -= 1
ship[a].append(b)
visited = []
for i in ship[0]:
visited.append(i)
for j in ship[i]:
visited.append(j)
if N-1 in visited:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | p03645 |
n,m =list(map(int,input().split()))
ab = [[int(i) for i in input().split()] for _ in range(m)]
visited = [False]*n
visited[0] = True
q = []
for j in range(m):
if ab[j][0]==1:
q.append((ab[j][1]))
visited[ab[j][1]-1] = True
while q:
c = q.pop()
for j in range(m):
if ab[j][0]==c:
visited[ab[j][1]-1] = True
print(('POSSIBLE' if visited[n-1] else 'IMPOSSIBLE')) | n,m =list(map(int,input().split()))
visited = False
q = [[] for _ in range(n)]
flag = False
for j in range(m):
a,b = list(map(int,input().split()))
q[a].append(b)
while q[1]:
c = q[1].pop()
if n in q[c]:
flag = True
print(('POSSIBLE' if flag==True else 'IMPOSSIBLE')) | p03645 |
n,m = list(map(int,input().split()))
lis = [[] for i in range(n)] #なぜか知らんけど[[]]*nじゃだめらしい
for i in range(m):
a,b = list(map(int,input().split()))
lis[a-1].append(b-1)
lis[b-1].append(a-1)
for i in set(lis[-1]):
if i in set(lis[0]):
print('POSSIBLE')
exit()
print('IMPOSSIBLE') | n,m = list(map(int,input().split()))
lis = [[] for i in range(n)] #なぜか知らんけど[[]]*nじゃだめらしい
for i in range(m):
a,b = list(map(int,input().split()))
lis[a-1].append(b-1)
lis[b-1].append(a-1)
if set(lis[-1]).isdisjoint(set(lis[0])):
print('IMPOSSIBLE')
else:
print('POSSIBLE') | p03645 |
n,m = list(map(int,input().split()))
lis = [[] for i in range(n)] #なぜか知らんけど[[]]*nじゃだめらしい
for i in range(m):
a,b = list(map(int,input().split()))
lis[a-1].append(b-1)
lis[b-1].append(a-1)
if set(lis[-1]).isdisjoint(set(lis[0])):
print('IMPOSSIBLE')
else:
print('POSSIBLE') |
n,m = list(map(int,input().split()))
lis = [[] for i in range(n)] #なぜか知らんけど[[]]*nじゃだめらしい
for i in range(m):
a,b = list(map(int,input().split()))
lis[a-1].append(b-1)
lis[b-1].append(a-1)
if set(lis[-1]).isdisjoint(set(lis[0])): #交叉しているか？
print('IMPOSSIBLE')
else:
print('POSSIBLE') | p03645 |
N,M = list(map(int, input().split()))
islands = {}
for i in range(M):
a,b = list(map(int, input().split()))
if a not in islands:
islands[a] = {}
if b not in islands:
islands[b] = {}
islands[a][b] = islands[b][a] = 1
if N not in islands:
print('IMPOSSIBLE')
exit()
for i in list(islands[1].keys()):
if i in islands[N]:
print('POSSIBLE')
exit()
print('IMPOSSIBLE') | n,m = list(map(int, input().split()))
d = {}
for _ in range(m):
a,b = list(map(int, input().split()))
if a not in d:
d[a] = {}
if b not in d:
d[b] = {}
d[a][b] = d[b][a] = 1
for v in list(d.values()):
if 1 in v and n in v:
print('POSSIBLE')
break
else:
print('IMPOSSIBLE')
| p03645 |
n,m = list(map(int, input().split()))
d = {}
for _ in range(m):
a,b = list(map(int, input().split()))
if a not in d:
d[a] = {}
if b not in d:
d[b] = {}
d[a][b] = d[b][a] = 1
for v in list(d.values()):
if 1 in v and n in v:
print('POSSIBLE')
break
else:
print('IMPOSSIBLE')
|
def resolve():
n,m = list(map(int, input().split()))
d = {}
for i in range(m):
a,b = list(map(int, input().split()))
if a not in d:
d[a] = {}
if b not in d:
d[b] = {}
d[a][b] = d[b][a] = 1
if 1 not in d or n not in d:
print('IMPOSSIBLE')
return
for a in list(d[1].keys()):
if a in d[n]:
print('POSSIBLE')
break
else:
print('IMPOSSIBLE')
if __name__ == '__main__':
resolve()
| p03645 |
N,M = list(map(int, input().split()))
A = [0] * M
B = [0] * M
for i in range(M):
A[i],B[i] = list(map(int, input().split()))
ans = 'IMPOSSIBLE'
for i in range(M):
if(A[i] == 1):
for j in range(M):
if(B[i] == A[j] and B[j] == N):
ans = 'POSSIBLE'
break
print(ans) | N,M = list(map(int, input().split()))
A = [0] * M
B = [0] * M
for i in range(M):
A[i],B[i] = list(map(int, input().split()))
aa = []
bb = []
for i in range(M):
if(A[i] == 1):
aa.append(B[i])
if(B[i] == N):
bb.append(A[i])
aa = set(aa)
bb = set(bb)
ret = aa & bb
if (len(ret) == 0):
print("IMPOSSIBLE")
else:
print("POSSIBLE") | p03645 |
def main():
n, m = list(map(int, input().split()))
islands_to_1 = []
islands_to_n = []
for _ in range(m):
boat = list(map(int, input().split()))
if 1 in boat:
islands_to_1.append(max(boat))
if n in boat:
islands_to_n.append(min(boat))
for island_to_1 in islands_to_1:
if island_to_1 in islands_to_n:
print("POSSIBLE")
return
print("IMPOSSIBLE")
return
if __name__ == "__main__":
main()
| def main():
n, m = list(map(int, input().split()))
islands_to_1 = [0 for _ in range(n+1)]
islands_to_n = []
for _ in range(m):
boat = list(map(int, input().split()))
if 1 in boat:
islands_to_1[boat[1]] = 1
if n in boat:
islands_to_n.append(min(boat))
for island_to_n in islands_to_n:
if islands_to_1[island_to_n] == 1:
print("POSSIBLE")
return
print("IMPOSSIBLE")
return
if __name__ == "__main__":
main()
| p03645 |
import sys
input = sys.stdin.readline
n,m = (int(i) for i in input().split())
ab = [[int(i)-1 for i in input().split()] for i in range(m)]
ab = list([x for x in ab if x[0]==0 or x[1]==n-1])
ab0 = list([x for x in ab if x[0]==0])
abn = list([x for x in ab if x[1]==n-1])
ab0 = list([x[1] for x in ab0])
abn = list([x[0] for x in abn])
res="IMPOSSIBLE"
for x in ab0:
if x in abn:
res= "POSSIBLE"
break
print(res) | import sys
input = sys.stdin.readline
n,m = (int(i) for i in input().split())
ab = [[int(i)-1 for i in input().split()] for i in range(m)]
ab = list([x for x in ab if x[0]==0 or x[1]==n-1])
ab0 = list([x for x in ab if x[0]==0])
abn = list([x for x in ab if x[1]==n-1])
ab0_bin = ["0"]*n
abn_bin = ["0"]*n
for x in ab0:
ab0_bin[x[1]] = "1"
for x in abn:
abn_bin[x[0]] = "1"
ab0_bin = "".join(ab0_bin)
abn_bin = "".join(abn_bin)
if bin(int(ab0_bin,2) & int(abn_bin, 2))[2:].count("1") > 0:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | p03645 |
def main():
from collections import deque
N, M = (int(i) for i in input().split())
G = [[] for i in range(N+1)]
G_color = ['WHITE' for _ in range(N+1)]
G_distance = [float('inf') for _ in range(N+1)]
for i in range(M):
a, b = (int(i) for i in input().split())
G[a].append(b)
G[b].append(a)
def bfs(s):
"""
G_color: BLACK if visited, GRAY if discovered, but will visit, WHITE
if not discovered
G_distance: a distance from s to v when algorithm computed
"""
G_color[s] = 'GRAY'
G_distance[s] = 0
Q = deque()
Q.append(s)
while Q:
u = Q.popleft()
for v in G[u]:
if G_color[v] == 'WHITE':
G_color[v] = 'GRAY'
G_distance[v] = G_distance[u] + 1
Q.append(v)
# distance <= 2 が探索し終わったら終わり
if G_distance[v] == 3:
return None
G_color[u] = 'BLACK'
bfs(1)
if G_color[N] != 'WHITE' and G_distance[N] <= 2:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
if __name__ == '__main__':
main()
| def main():
import sys
input = sys.stdin.buffer.readline
N, M = (int(i) for i in input().split())
edge = [[] for _ in range(N)]
for i in range(M):
a, b = (int(i) for i in input().split())
edge[a-1].append((1, b-1))
edge[b-1].append((1, a-1))
from heapq import heappop, heappush
def dijkstra(G, s):
d = [10**12]*N
used = [True] * N # True:未確定
d[s] = 0
used[s] = False
edges = []
for e in G[s]:
heappush(edges, e)
while len(edges):
c, v = heappop(edges)
if not used[v]:
continue
d[v] = c
used[v] = False
for nexc, nexv in G[v]:
if used[nexv]:
heappush(edges, (nexc+c, nexv))
return d
dist = dijkstra(edge, 0)
if dist[N-1] <= 2:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
if __name__ == '__main__':
main()
| p03645 |
import sys
N, M = list(map(int, input().split()))
s = []
e = []
for _ in range(M):
tmp = list(map(int, input().split()))
if 1 in tmp:
s.append(max(tmp))
elif N in tmp:
e.append(min(tmp))
for ss in s:
if ss in e:
print("POSSIBLE")
sys.exit()
print("IMPOSSIBLE") | import sys
N, M = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(M)]
B = []
for i in range(M):
if 1 in A[i]:
B.append(A[i][1])
elif N in A[i]:
B.append(A[i][0])
C = set(B)
if len(C) == len(B):
print("IMPOSSIBLE")
else:
print("POSSIBLE") | p03645 |
n, m = list(map(int, input().split()))
info = sorted([list(map(int, input().split())) for _ in range(m)])
q = []
t = m
append = q.append
for i in range(m):
if info[i][0] == 1:
append(info[i][1])
else:
t = i
break
for j in range(t, m):
if info[j][1] == n:
if info[j][0] in q:
print("POSSIBLE")
break
else:
print("IMPOSSIBLE") | n, m = list(map(int, input().split()))
side1 = set()
side2 = set()
for i in range(m):
a, b = list(map(int, input().split()))
if a == 1:
side1.add(b)
elif b == n:
side2.add(a)
print((("" if side1 & side2 else "IM") + "POSSIBLE")) | p03645 |
#!/usr/bin/env python3
import sys, math, fractions, itertools
YES = "POSSIBLE" # type: str
NO = "IMPOSSIBLE" # type: str
def solve(N: int, M: int, a: "List[int]", b: "List[int]"):
G = [[] for _ in range(N)]
for i in range(M):
G[a[i]-1].append(b[i]-1)
G[b[i]-1].append(a[i]-1)
flag = False
for g in G[0]:
if g in G[-1]:
flag = True
if flag:
print('POSSIBLE')
else:
print('IMPOSSIBLE')
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
a = [int()] * (M) # type: "List[int]"
b = [int()] * (M) # type: "List[int]"
for i in range(M):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
solve(N, M, a, b)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys, math, fractions, itertools, bisect
YES = "POSSIBLE" # type: str
NO = "IMPOSSIBLE" # type: str
def solve(N: int, M: int, a: "List[int]", b: "List[int]"):
G = [[] for _ in range(N)]
for i in range(M):
G[a[i]-1].append(b[i]-1)
G[b[i]-1].append(a[i]-1)
G[0].sort()
G[-1].sort()
flag = False
for g in G[0]:
i = bisect.bisect_left(G[-1], g)
if 0 <= i <= len(G[-1])-1:
if G[-1][i] == g:
flag = True
if flag:
print('POSSIBLE')
else:
print('IMPOSSIBLE')
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
a = [int()] * (M) # type: "List[int]"
b = [int()] * (M) # type: "List[int]"
for i in range(M):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
solve(N, M, a, b)
if __name__ == '__main__':
main()
| p03645 |
import sys
n,m=list(map(int,input().split()))
a = [[int(i) for i in input().split()] for i in range(m)]
c=[]
a = sorted(a,key = lambda x:-x[1])
#print(a[0][0],a[0][1])
for i in range(m):
if a[i][1] < n:
break
else:
c.append(a[i][0])
a = sorted(a,key = lambda x:x[0])
for i in range(m):
if a[i][0] > 1:
break
if a[i][1] in c:
print("POSSIBLE")
sys.exit()
print("IMPOSSIBLE")
| import sys
n,m=list(map(int,input().split()))
a = [[int(i) for i in input().split()] for i in range(m)]
c=[]
s=[]
a = sorted(a,key = lambda x:-x[1])
#print(a[0][0],a[0][1])
for i in range(m):
if a[i][1] < n:
break
else:
c.append(a[i][0])
c=set(c)
a = sorted(a,key = lambda x:x[0])
for i in range(m):
if a[i][0] > 1:
break
else:
s.append(a[i][1])
#if a[i][1] in c:
s=set(s)
for i in s:
if i in c:
print("POSSIBLE")
sys.exit()
print("IMPOSSIBLE")
| p03645 |
N, M = list(map(int, input().split()))
one2 = []
toN = []
for _ in range(M):
a, b = list(map(int, input().split()))
if a == 1:
one2.append(b)
if b == N:
toN.append(a)
flag = False
for a in one2:
if a in toN:
flag = True
break
if flag:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
| N, M = list(map(int, input().split()))
one2 = set()
toN = set()
for _ in range(M):
a, b = list(map(int, input().split()))
if a == 1:
one2.add(b)
if b == N:
toN.add(a)
inter = one2 & toN
if len(inter) > 0:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
| p03645 |
N,M = list(map(int,input().split()))
ans = "IMPOSSIBLE"
f = []
s = []
for i in range(M):
a,b = [int(x)-1 for x in input().split()]
if a == 0:
f.append(b)
if b == N-1:
s.append(a)
if len(f) > len(s):
for i in range(len(s)):
if s[i] in f:
ans = "POSSIBLE"
break
else:
for i in range(len(f)):
if f[i] in s:
ans = "POSSIBLE"
break
print(ans) | N,M = list(map(int,input().split()))
ans = "IMPOSSIBLE"
f = dict(list(zip(list(range(N)),[0]*N)))
s = dict(list(zip(list(range(N)),[0]*N)))
for i in range(M):
a,b = [int(x)-1 for x in input().split()]
if a == 0:
f[b] = 1
if b == N-1:
s[a] = 1
if len(f) > len(s):
for i in range(len(s)):
if s[i] == 1 and f[i] == 1:
ans = "POSSIBLE"
break
else:
for i in range(len(f)):
if f[i] == 1 and s[i] == 1:
ans = "POSSIBLE"
break
print(ans) | p03645 |
import sys
n,m=list(map(int,input().split()))
a=[]
b=[]
l=[]
for i in range(m):
c=[int(i) for i in input().split()]
a.append(c[0])
b.append(c[1])
if a[i]==1 or b[i]==1:
l.append(a[i]*b[i])
for i in range(m):
if b[i]==n:
if a[i] in l:
print("POSSIBLE")
sys.exit()
if a[i]==n:
if b[i] in l:
print("POSSIBLE")
sys.exit()
print("IMPOSSIBLE") | import sys
n,m=list(map(int,input().split()))
a=[]
b=[]
l1=[False for i in range(n)]
ln=[False for i in range(n)]
for i in range(m):
c=[int(i) for i in input().split()]
a.append(c[0])
b.append(c[1])
if c[0]==1 or c[1]==1:
l1[c[0]*c[1]]=True
if c[0]==n or c[1]==n:
ln[c[0]*c[1]//n]=True
for i in range(n):
if l1[i] and ln[i]:
print("POSSIBLE")
sys.exit()
print("IMPOSSIBLE")
| p03645 |
n, m = list(map(int, input().split()))
A = 0
B = 1
mid = [0] * (n+1)
goal = [0] * (n+1)
ab = []
for i in range(m):
a,b = list(map(int, input().split()))
ab.append([a, b])
if a == 1:
mid[b] += 1
elif b == n:
goal[a] += 1
# print(mid)
# print(goal)
for i in range(n+1):
if mid[i] == 1 and goal[i] == 1:
print("POSSIBLE")
exit()
print("IMPOSSIBLE") | n, m = list(map(int, input().split()))
A = 0
B = 1
cnt = [0] * (n+1)
ab = []
for i in range(m):
a,b = list(map(int, input().split()))
ab.append([a, b])
if a == 1:
cnt[b] += 1
elif b == n:
cnt[a] += 1
for i in range(n+1):
if cnt[i] == 2:
print("POSSIBLE")
exit()
print("IMPOSSIBLE") | p03645 |
n,m = list(map(int,input().split()))
a = []
z = []
p = 0
for i in range(m):
x,y = list(map(int,input().split()))
if x == 1:
z.append(y)
elif y == n:
a.append(x)
p += 1
else:
pass
flg = False
for i in range(p):
if a[i] in z:
flg = True
break
if flg:
print('POSSIBLE')
else:
print('IMPOSSIBLE') | n,m = list(map(int,input().split()))
a = [] # 1 → x
z = [] # x → n
an = 0
zn = 0
for i in range(m):
x,y = list(map(int,input().split()))
if x == 1:
zn += 1
z.append(y)
elif y == n:
an += 1
a.append(x)
else:
pass
a.sort()
z.sort()
i = 0
j = 0
while i < an and j < zn:
if a[i] == z[j]:
print('POSSIBLE')
exit(0)
else:
if a[i] > z[j]:
j += 1
else:
i += 1
print('IMPOSSIBLE') | p03645 |
N,M = list(map(int, input().split()))
S = []
for _ in range(M):
D = list(map(int, input().split()))
S.append(D)
#S.sort(key=lambda x:x[0])
S.sort()
first = []
for tmp in S:
if tmp[0]!=1:
break
first.append(tmp[1])
for tmp in S:
if tmp[1] == N and tmp[0] in first:
print("POSSIBLE")
exit()
print("IMPOSSIBLE") | N,M = list(map(int, input().split()))
S = []
for _ in range(M):
D = list(map(int, input().split()))
S.append(D)
set1=set()
set2=set()
for tmp in S:
if tmp[0]==1:
set1.add(tmp[1])
if tmp[1]==N:
set2.add(tmp[0])
if len(set1&set2) == 0:
print("IMPOSSIBLE")
else:
print("POSSIBLE") | p03645 |
N, M = list(map(int, input().split()))
A = []
for i in range(M):
A.append(list(map(int, input().split())))
D1 = [A[i][1] for i in range(M) if A[i][0] == 1]
D2 = [A[i][1] for i in range(M) if A[i][0] in D1]
if N in D2:
print ("POSSIBLE")
else:
print ("IMPOSSIBLE") | N, M = list(map(int, input().split()))
A = []
for i in range(M):
A.append(list(map(int, input().split())))
D1 = set(A[i][1] for i in range(M) if A[i][0] == 1)
D2 = set(A[i][0] for i in range(M) if A[i][1] == N)
if len(D1 & D2) != 0:
print ("POSSIBLE")
else:
print ("IMPOSSIBLE") | p03645 |
n, m = list(map(int, input().split()))
a = [0] * m
b = [0] * m
for i in range(m):
a[i], b[i] = list(map(int, input().split()))
first = []
second = []
for i in range(m):
if a[i] == 1:
first.append(b[i])
if b[i] == n:
second.append(a[i])
ans = 'IMPOSSIBLE'
for i in first:
if i in second:
ans = 'POSSIBLE'
print(ans) | n, m = list(map(int, input().split()))
a = [0] * m
b = [0] * m
first = set()
second = set()
for i in range(m):
a[i], b[i] = list(map(int, input().split()))
if a[i] == 1:
first.add(b[i])
if b[i] == n:
second.add(a[i])
ans = 'IMPOSSIBLE'
if first & second:
ans = 'POSSIBLE'
print(ans) | p03645 |
n,m = list(map(int,input().split()))
ab = [list(map(int,input().split()))for i in range(m)]
from1 = []
to_n = []
for i in range(m):
if ab[i][0] == 1:
from1.append(ab[i][1])
if ab[i][1] == n:
to_n.append(ab[i][0])
for i in range(len(from1)):
if from1[i] in to_n:
print('POSSIBLE')
break
else:print('IMPOSSIBLE')
| import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
ab = [list(map(int,input().split()))for i in range(m)]
from1 = []
to_n = []
for i in range(m):
if ab[i][0] == 1:
from1.append(ab[i][1])
if ab[i][1] == n:
to_n.append(ab[i][0])
from1.sort()
to_n.sort()
'''
for i in range(len(from1)):
if from1[i] in to_n:
print('POSSIBLE')
break
else:print('IMPOSSIBLE')
二分探索で実装できそう
'''
def bisearch(data,value):#data:ソート済みリスト value:調べる値
left = 0
right = len(data) - 1
while left <= right:
mid = (left + right)//2
if data[mid] == value:
return mid
elif data[mid] < value:
left = mid + 1
else:
right = mid - 1
return -1
for i in range(len(from1)):
if bisearch(to_n,from1[i]) != -1:
print('POSSIBLE')
break
else:print('IMPOSSIBLE')
| p03645 |
n,m = list(map(int,input().split()))
l = [list(map(int,input().split())) for i in range(m)]
a = []
b = []
for i in l:
if i[0] == 1:
a.append(i[1])
if i[1] == n:
b.append(i[0])
print(("POSSIBLE" if len(set(a)&set(b)) > 0 else "IMPOSSIBLE")) | n,m = list(map(int,input().split()))
a = set()
b = set()
for i in range(m):
a_,b_ = list(map(int,input().split()))
if a_ == 1:
a.add(b_)
if b_ == n:
b.add(a_)
print(("POSSIBLE" if a&b else "IMPOSSIBLE")) | p03645 |
N,M = list(map(int,input().split()))
judge = 0 #0:不可,1:可
if(M >= 2):
#N*N行列 島a~b間に定期便あり:1,なし:0
island = []
for i in range(N):
island.append([0]*N)
island1 = []
for i in range(M):
a,b = list(map(int,input().split()))
a,b = a-1,b-1
island[a][b] = 1
island[b][a] = 1
if(a == 0):
island1.append(b)
elif(b == 0):
island1.append(b)
for i in island1:
if(island[i][N-1] == 1):#配列(リスト)の要素のアクセスO(1)
judge = 1
break
if(judge == 0):
print('IMPOSSIBLE')
else:
print('POSSIBLE') | N,M = list(map(int,input().split()))
judge = 0 #0:不可,1:可
if(M >= 2):
#リスト 島1~a間に定期便あり:1,なし:0
island1 = [0]*N
#リスト 島b~N間に定期便あり:1,なし:0
islandN = [0]*N
for i in range(M):
a,b = list(map(int,input().split()))
a,b = a-1,b-1
if(a == 0): island1[b] = 1
if(b == 0): island1[a] = 1
if(a == N-1): islandN[b] = 1
if(b == N-1): islandN[a] = 1
for i in range(len(island1)):
if((island1[i] == 1)and(islandN[i] == 1)):
judge = 1
break
if(judge == 0):
print('IMPOSSIBLE')
else:
print('POSSIBLE') | p03645 |
from collections import deque
N, M = list(map(int, input().split()))
left = deque([])
right = deque([])
for i in range(M):
a, b = list(map(int, input().split()))
if a == 1:
left.append(b)
elif b == N:
right.append(a)
flag = False
for r in right:
if r in left:
flag = True
break
if flag:
print('POSSIBLE')
else:
print('IMPOSSIBLE')
| N, M = list(map(int, input().split()))
left = []
right = []
for i in range(M):
a, b = list(map(int, input().split()))
if a == 1:
left.append(b)
elif b == N:
right.append(a)
flag = False
left = set(left)
for r in right:
if r in left:
flag = True
break
if flag:
print('POSSIBLE')
else:
print('IMPOSSIBLE') | p03645 |
# https://atcoder.jp/contests/abc068/tasks/arc079_a
import itertools
from collections import Counter
from collections import defaultdict
import bisect
def main():
N, M = list(map(int, input().split()))
s_list = []
g_list = []
for _ in range(M):
a, b = list(map(int, input().split()))
if a == 1:
s_list.append(b)
if b == N:
g_list.append(a)
for s in s_list:
if s in g_list:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
if __name__ == '__main__':
main()
| # https://atcoder.jp/contests/abc068/tasks/arc079_a
import itertools
import collections
import bisect
def main():
N, M = list(map(int, input().split()))
src = {}
A = []
B = []
for _ in range(M):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
if a == 1:
src[b] = 1
for i in range(M):
if A[i] in src and B[i] == N:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
if __name__ == '__main__':
main()
| p03645 |
N,M = list(map(int,input().split()))
a_list=[]
pass_1= []
for i in range(M):
a = list(map(int,input().split()))
if(a[0]==1):
pass_1.append(a[1])
if(a[1]==N):
a_list.append(a)
for j in pass_1:
if([j,N] in a_list):
print("POSSIBLE")
exit()
print("IMPOSSIBLE") | N,M = list(map(int,input().split()))
a_list=[]
pass_1= []
for i in range(M):
a = list(map(int,input().split()))
if(a[0]==1):
pass_1.append(a[1])
elif(a[1]==N):
a_list.append(a[0])
if list(set(pass_1) & set(a_list)):
print('POSSIBLE')
else:
print('IMPOSSIBLE') | p03645 |
n,m = list(map(int,input().split()))
A = [[int(i) for i in input().split()] for j in range(m)]
B = []
C = []
for i in A:
if 1 in i:
B += i
for i in A:
a,b = i
if a in B:
C.append(b)
elif b in B:
C.append(a)
if n in C or n in B:
print('POSSIBLE')
else:
print('IMPOSSIBLE')
| n,m = list(map(int,input().split()))
A = [[int(i) for i in input().split()] for j in range(m)]
B = []
C = []
for i in A:
if 1 in i:
B += i
B = set(B)
for i in A:
a,b = i
if a in B:
C.append(b)
elif b in B:
C.append(a)
C = set(C)
if n in C or n in B:
print('POSSIBLE')
else:
print('IMPOSSIBLE') | p03645 |
from collections import deque
N, M = list(map(int, input().split()))
edges = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
edges[a].append(b)
edges[b].append(a)
def dfs(start, end):
minDist = [-1 for _ in range(N)]
minDist[start] = 0
que = deque([])
que.append((start, 0))
while que:
now, dist = que.popleft()
minDist[now] = dist
if now == end:
return dist
for to in edges[now]:
if minDist[to] >= 0:
continue
que.append((to, dist + 1))
return float('inf')
if dfs(0, N - 1) <= 2:
print('POSSIBLE')
else:
print('IMPOSSIBLE') | N, M = list(map(int, input().split()))
edges =[set() for _ in range(N + 1)]
one = set()
for _ in range(M):
fr, to = list(map(int, input().split()))
edges[fr].add(to)
edges[to].add(fr)
if fr == 1:
one.add(to)
if to == 1:
one.add(fr)
for fr in one:
if N in edges[fr]:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
| p03645 |
def Dijkstra(N, edges, s):
from heapq import heappush, heappop, heapify
dist = [10**20 for _ in range(N)]
dist[s], h = 0, [[0, s]]
while (len(h)):
p = heappop(h)
d, v = p[0], p[1]
if d > dist[v]:
continue
for i in range(len(edges[v])):
u = edges[v][i]
if d + 1 < dist[u]:
dist[u] = d + 1
heappush(h, [dist[u], u])
return dist
N, M = list(map(int, input().split()))
es = [[] for _ in range(N)]
for _ in range(M):
a, b = [int(x) - 1 for x in input().split()]
es[a].append(b)
es[b].append(a)
dist = Dijkstra(N, es, 0)
if dist[N - 1] == 2:
print('POSSIBLE')
else:
print('IMPOSSIBLE') | import sys
input = sys.stdin.readline
def Dijkstra(N, edges, s):
from heapq import heappush, heappop, heapify
dist = [10**18 for _ in range(N)]
dist[s], h = 0, [[0, s]]
while (len(h)):
p = heappop(h)
d, v = p[0], p[1]
if d > dist[v]:
continue
for i in range(len(edges[v])):
u = edges[v][i]
if d + 1 < dist[u]:
dist[u] = d + 1
heappush(h, [dist[u], u])
return dist
N, M = list(map(int, input().split()))
es = [[] for _ in range(N)]
for _ in range(M):
a, b = [int(x) - 1 for x in input().split()]
es[a].append(b)
es[b].append(a)
dist = Dijkstra(N, es, 0)
if dist[N - 1] == 2:
print('POSSIBLE')
else:
print('IMPOSSIBLE') | p03645 |
import sys
inint = lambda: int(sys.stdin.readline())
inintm = lambda: list(map(int, sys.stdin.readline().split()))
inintl = lambda: list(inintm())
instrm = lambda: list(map(str, sys.stdin.readline().split()))
instrl = lambda: list(instrm())
n, m = inintm()
t = []
for _ in range(m):
a, b = inintm()
if a == 1:
if b in t:
print("POSSIBLE")
exit()
t.append(b)
elif b == n:
if a in t:
print("POSSIBLE")
exit()
t.append(a)
print("IMPOSSIBLE")
| import sys
inint = lambda: int(sys.stdin.readline())
inintm = lambda: list(map(int, sys.stdin.readline().split()))
inintl = lambda: list(inintm())
instrm = lambda: list(map(str, sys.stdin.readline().split()))
instrl = lambda: list(instrm())
n, m = inintm()
t = [0]*(n+1)
for _ in range(m):
a, b = inintm()
if a == 1:
if t[b] == 1:
print("POSSIBLE")
exit()
t[b] = 1
elif b == n:
if t[a] == 1:
print("POSSIBLE")
exit()
t[a] = 1
print("IMPOSSIBLE")
| p03645 |
n,m = list(map(int, input().split()))
a = [0] * m
b = [0] * m
for i in range(m):
a[i],b[i] = list(map(int,input().split()))
c = []
d = []
for i in range(m):
if a[i] == 1:
c.append(b[i])
if b[i] == n:
d.append(a[i])
ans = False
c = list(set(c))
for i in c:
if d.count(i) >=1:
ans = True
break
if ans:
print('POSSIBLE')
else:
print('IMPOSSIBLE') | n,m = list(map(int,input().split()))
a = [0 for _ in range(m)]
b = [0 for _ in range(m)]
for i in range(m):
a[i],b[i] = list(map(int,input().split()))
go = []
goal = []
for i in range(len(a)):
if a[i] == 1:
go.append(b[i])
if b[i] == n:
goal.append(a[i])
count = [0 for i in range(n)]
for i in range(len(go)):
count[go[i]-1] = 1
for i in range(len(goal)):
count[goal[i]-1] += 1
for i in range(len(count)):
if count[i] > 1:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
| p03645 |
from sys import stdin
N,M = [int(x) for x in stdin.readline().rstrip().split()]
data = []
for _ in range(M):
data.append([int(x) for x in stdin.readline().rstrip().split()])
shima = []
flag = False
for i in sorted(data):
if i[0] == 1:
shima.append(i[1])
if (i[1] == N) and (i[0] in shima):
flag = True
break
if flag:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | from sys import stdin
N,M = [int(x) for x in stdin.readline().rstrip().split()]
data = []
for _ in range(M):
data.append([int(x) for x in stdin.readline().rstrip().split()])
shima = set()
flag = False
for i in sorted(data):
if i[0] == 1:
shima.add(i[1])
if (i[1] == N) and (i[0] in shima):
flag = True
break
if flag:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | p03645 |
N, M = list(map(int, input().split()))
s = []
e = []
for i in range(M):
a, b = list(map(int, input().split()))
if a == 1:
s.append(b)
if b == N:
e.append(a)
ans = 'IMPOSSIBLE'
for k in s:
if k in e:
ans = 'POSSIBLE'
break
print(ans) | N, M = list(map(int, input().split()))
s = []
e = []
for i in range(M):
a, b = list(map(int, input().split()))
if a == 1:
s.append(b)
if b == N:
e.append(a)
if set(s) & set(e):
print('POSSIBLE')
else:
print('IMPOSSIBLE')
| p03645 |
from collections import deque
N, M = [int(x) for x in input().split()]
fst_to = deque([])
sec_from = deque([])
for a, b in [[int(x) for x in input().split()] for _ in range(M)]:
if a == 1:
fst_to.append(b)
elif b == N:
sec_from.append(a)
ret = 'IMPOSSIBLE'
for a in fst_to:
if a in sec_from:
ret = 'POSSIBLE'
break
print(ret) | from collections import deque
N, M = [int(x) for x in input().split()]
fst_to = deque([])
sec_from = deque([])
for a, b in [[int(x) for x in input().split()] for _ in range(M)]:
if a == 1:
fst_to.append(b)
elif b == N:
sec_from.append(a)
ret = 'IMPOSSIBLE'
if set(fst_to) & set(sec_from):
ret = 'POSSIBLE'
print(ret) | p03645 |
n, m = list(map(int,input().split()))
ab = [[] for _ in range(n+2)]
for _ in range(m):
a, b = list(map(int, input().split()))
ab[a].append(b)
ab[b].append(a)
if any((i in ab[n]) for i in ab[1]):
print("POSSIBLE")
else:
print("IMPOSSIBLE") | n, m = list(map(int,input().split()))
ab = [0 for _ in range(n+2)]
for _ in range(m):
a, b = list(map(int, input().split()))
if a==1:
ab[b] += 1
continue
elif b == n:
ab[a] += 1
continue
if max(ab) == 2:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | p03645 |
# -*- coding: utf-8 -*-
N, M = list(map(int, input().split()))
start, finish = [], []
for i in range(M):
a, b = list(map(int, input().split()))
if a == 1:
start.append(b)
elif b == N:
finish.append(a)
for s in start:
for f in finish:
if s == f:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
| # -*- coding: utf-8 -*-
N, M = list(map(int, input().split()))
start, finish = [], []
for i in range(M):
a, b = list(map(int, input().split()))
if a == 1:
start.append(b)
elif b == N:
finish.append(a)
if set(start) & set(finish):
print('POSSIBLE')
else:
print('IMPOSSIBLE')
| p03645 |
N,M=list(map(int,input().split()))
a=[]
b=[]
e=[]
f=[]
g=0
for i in range(M):
c,d = list(map(int,input().split()))
a.append(c)
b.append(d)
for j in range(M):
if b[j]!=N:
if a[j]!=1:
pass
else:
e.append(b[j])
else:
f.append(a[j])
if (len(e)==0) or (len(f)==0):
print('IMPOSSIBLE')
else:
for l in range(len(e)):
if e[l] in f:
g += 1
break
else:
pass
if g>0:
print('POSSIBLE')
else:
print('IMPOSSIBLE') | N,M=list(map(int,input().split()))
island=[[] for i in range(N)]
for j in range(M):
c,d=list(map(int,input().split()))
island[d-1].append(c)
island[c-1].append(d)
f = 0
for k in range(N):
if 1 in island[k]:
if N in island[k]:
f += 1
break
else:
pass
else:
pass
if f>0:
print('POSSIBLE')
else:
print('IMPOSSIBLE') | p03645 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**9)
# from numba import njit
# from collections import Counter
# from itertools import accumulate
# import numpy as np
# from heapq import heappop,heappush
# from bisect import bisect_left
# @njit
def solve(n,m,l):
edges = {i+1:[] for i in range(n)}
for i in range(m):
a,b = l[i]
edges[a].append(b)
edges[b].append(a)
def dfs(start,end,rest):
if rest == 0:
return start == end
else:
return any(dfs(nextNode,end,rest-1) for nextNode in edges[start])
return dfs(1,n,2)
def main():
N,M = list(map(int,input().split()))
l = [tuple(map(int,input().split())) for _ in range(M)]
print(("POSSIBLE" if solve(N,M,l) else "IMPOSSIBLE"))
return
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**9)
# from numba import njit
# from collections import Counter
# from itertools import accumulate
# import numpy as np
# from heapq import heappop,heappush
# from bisect import bisect_left
# @njit
def solve(n,m,l):
edges = {i+1:[] for i in range(n)}
for i in range(m):
a,b = l[i]
edges[a].append(b)
edges[b].append(a)
return any(1 in v and n in v for k,v in list(edges.items()))
def main():
N,M = list(map(int,input().split()))
l = [tuple(map(int,input().split())) for _ in range(M)]
print(("POSSIBLE" if solve(N,M,l) else "IMPOSSIBLE"))
return
if __name__ == '__main__':
main()
| p03645 |
import bisect
N, M = list(map(int, input().split()))
a = [None for i in range(2 * M)]
flag = 0
for i in range(M):
A, B = list(map(int, input().split()))
a[2*i] = [A, B]
a[2*i+1] = [B, A]
a.sort()
b = a[:]
b.reverse()
one = []
two = []
for i in range(M):
if a[i][0] == 1:
one.append(a[i][1])
else:
break
for i in range(M):
if b[i][0] == N:
two.append(b[i][1])
else:
break
for i in range(len(one)):
for j in range(len(two)):
if one[i] == two[j]:
flag = 1
print("POSSIBLE")
break
if flag == 0:
print("IMPOSSIBLE")
| import sys
N, M = list(map(int, input().split()))
ship = [[] for i in range(N+1)]
for i in range(M):
a, b = list(map(int, input().split()))
ship[a].append(b)
ship[b].append(a)
flag = 0
for i in ship[1]:
if N in ship[i]:
flag = 1
if flag == 1:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
| p03645 |
import sys
N, M = list(map(int, input().split()))
ship = [[] for i in range(N+1)]
for i in range(M):
a, b = list(map(int, input().split()))
ship[a].append(b)
ship[b].append(a)
flag = 0
for i in ship[1]:
if N in ship[i]:
flag = 1
if flag == 1:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
| import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
ship = [[] for i in range(N+1)]
for i in range(M):
a, b = list(map(int, input().split()))
ship[a].append(b)
ship[b].append(a)
flag = 0
for i in ship[1]:
if N in ship[i]:
flag = 1
if flag == 1:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
| p03645 |
from collections import defaultdict
from heapq import heappop, heappush
class Graph(object):
"""
隣接リストによる有向グラフ
"""
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, src, dst, weight=1):
self.graph[src].append((dst, weight))
def get_nodes(self):
return list(self.graph.keys())
class Dijkstra(object):
"""
ダイクストラ法（二分ヒープ）による最短経路探索
計算量: O((E+V)logV)
"""
def __init__(self, graph, start):
self.g = graph.graph
# startノードからの最短距離
# startノードは0, それ以外は無限大で初期化
self.dist = defaultdict(lambda: float('inf'))
self.dist[start] = 0
# 最短経路での1つ前のノード
self.prev = defaultdict(lambda: None)
# startノードをキューに入れる
self.Q = []
heappush(self.Q, (self.dist[start], start))
while self.Q:
# 優先度（距離）が最小であるキューを取り出す
dist_u, u = heappop(self.Q)
if self.dist[u] < dist_u:
continue
for v, weight in self.g[u]:
alt = dist_u + weight
if self.dist[v] > alt:
self.dist[v] = alt
self.prev[v] = u
heappush(self.Q, (alt, v))
def shortest_distance(self, goal):
"""
startノードからgoalノードまでの最短距離
"""
return self.dist[goal]
def shortest_path(self, goal):
"""
startノードからgoalノードまでの最短経路
"""
path = []
node = goal
while node is not None:
path.append(node)
node = self.prev[node]
return path[::-1]
if __name__ == "__main__":
n, m = list(map(int, input().split()))
g1 = Graph()
for i in range(m):
a, b = list(map(int, input().split()))
g1.add_edge(a-1, b-1)
g1.add_edge(b-1, a-1)
d = Dijkstra(g1, 0)
if d.dist[n-1] == 2:
print('POSSIBLE')
else:
print('IMPOSSIBLE')
| from collections import defaultdict
def main():
N, M = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(M)]
g = defaultdict(list)
for n in ab:
g[n[0]].append(n[1])
if 1 not in g:
print('IMPOSSIBLE')
exit()
for i in g[1]:
if i not in g:
continue
for j in g[i]:
if j == N:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
if __name__ == "__main__":
main()
| p03645 |
N,M=list(map(int,input().split()))
a=[]
b=[]
for i in range(M):
c,d=list(map(int,input().split()))
if c==1:
a.append(d)
if d==N:
b.append(c)
#O(M)
flag = False
for idx in a:
if idx in b:
print("POSSIBLE")
exit()
print("IMPOSSIBLE") | N,M=list(map(int,input().split()))
G = [list() for i in range(N+1)]
for i in range(M):
a,b=list(map(int,input().split()))
G[a].append(b)
G[b].append(a)
#O(M)
flag = False
for i in G[1]:
if N in G[i]:
flag = True
break
if flag:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | p03645 |
N, M = list(map(int, input().split()))
ab_list = sorted([list(map(int, input().split())) for _ in range(M)])
ans = "IMPOSSIBLE"
second_island = []
for a, b in ab_list:
if a == 1:
second_island.append(b)
if b == N:
if a in second_island:
ans = "POSSIBLE"
break
print(ans) | n, m = list(map(int, input().split()))
sa = set()
sb = set()
for _ in range(m):
a, b = list(map(int, input().split()))
if a == 1:
sb.add(b)
if b == n:
sa.add(a)
print(('POSSIBLE' if len(sa&sb) != 0 else 'IMPOSSIBLE')) | p03645 |
import sys
n, m = list(map(int, input().split()))
p = [list(map(int, input().split())) for _ in range(m)]
ln1 = []
ln2 = []
for i in p:
if i[0] == 1:
ln1.append(i[1])
for j in p:
if j[1] == n:
ln2.append(j[0])
for k in ln1:
if k in ln2:
print('POSSIBLE')
sys.exit()
print('IMPOSSIBLE') | import sys
n, m = list(map(int, input().split()))
p = [list(map(int, input().split())) for _ in range(m)]
ln1 = []
ln2 = []
for i in p:
if i[0] == 1:
ln1.append(i[1])
for j in p:
if j[1] == n:
ln2.append(j[0])
if len(set(ln1) & set(ln2)) == 0:
print('IMPOSSIBLE')
else:
print('POSSIBLE') | p03645 |
# グラフわからんのでグラフアルゴリズム忘れた
# dfsでやる 限度2回
n, m = list(map(int, input().split()))
graph = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
graph[a - 1].append(b - 1)
graph[b - 1].append(a - 1)
def dfs(t, c, used):
if c != 0 and t == n - 1:
return True
if c == 0:
return False
flag = False
for g in graph[t]:
if g in used:
continue
next_used = used[:]
next_used.append(g)
flag = dfs(g, c - 1, next_used)
if flag:
break
return flag
for x in graph[0]:
if dfs(x, 2, [x]):
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
| # グラフわからんのでグラフアルゴリズム忘れた
# dfsでやる 限度2回c
# なんかしらんけどdfsが2TLEになるので諦めた それぞれの島について1とNがあれば良い
n, m = list(map(int, input().split()))
graph = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
graph[a - 1].append(b - 1)
graph[b - 1].append(a - 1)
for g in graph[1 : n - 1]:
c = 0
for v in g:
if c >= 2:
break
if v == 0 or v == n - 1:
c += 1
if c == 2:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
| p03645 |
n,m = list(map(int,input().split()))
A = set()
B = set()
for _ in range(m):
x = list(map(int,input().split()))
if x[0]==1:
A = A|set(x)
elif x[1]==n:
B = B|set(x)
if len(A&B)>0:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | N,M=list(map(int,input().split()))
sa=set()
sb=set()
for i in range(M):
a,b=list(map(int,input().split()))
if a==1:sb.add(b)
if b==N:sa.add(a)
print(("IMPOSSIBLE" if len(sa&sb)==0 else "POSSIBLE")) | p03645 |
# -*- coding: utf-8 -*-
import math
N, M = list(map(int, input().split()))
start = []
goal = []
for i in range(M):
l1, l2 = list(map(int, input().split()))
if (l1 == 1):
start.append([l1, l2])
if (l2 == N):
goal.append([l1, l2])
def check(st, go):
for i in st:
if ([i[1], N] in go):
return(True)
return(False)
if (check(start, goal)):
print('POSSIBLE')
else:
print('IMPOSSIBLE')
| # -*- coding: utf-8 -*-
import math
N, M = list(map(int, input().split()))
start = [False] * N
goal = [False] * N
for i in range(M):
a1, a2 = list(map(int, input().split()))
if (a1 == 1):
start[a2 - 1] = True
if (a2 == N):
goal[a1 - 1] = True
def check():
for i in range(N):
if (start[i] & goal[i]):
return('POSSIBLE')
return('IMPOSSIBLE')
print((check()))
| p03645 |
N, M=list(map(int, input().split()))
ab=[list(map(int, input().split())) for _ in range(M)]
s=[]
g=[]
for i, j in ab:
if i==1:
s.append(j)
elif j==1:
s.append(i)
elif i==N:
g.append(j)
elif j==N:
g.append(i)
flag=0
for i in range(len(s)):
if s[i] in g:
flag=1
break
print(("POSSIBLE" if flag else "IMPOSSIBLE"))
| N, M=list(map(int, input().split()))
ab=[list(map(int, input().split())) for _ in range(M)]
b=set()
for i,j in ab:
if i==1 or j==N:
b.add((i,j))
print(("IM"*(not(any(((1,i) in b and (i,N) in b) for i in range(N))))+"POSSIBLE"))
| p03645 |
n,m = list(map(int,input().split()))
a = []
b = []
ans = ""
for i in range(m):
tmp1,tmp2 = list(map(int,input().split()))
a.append(tmp1)
b.append(tmp2)
xton = []
#nへ向かう便が出てる島を確認する
for i in range(m):
if b[i] == n:
xton.append(a[i])
#nへ向かう便が出ている島へ1から向かう便があるか確認する
for i in range(m):
if a[i] == 1 and b[i] in xton:
ans = "POSSIBLE"
break
else:
ans = "IMPOSSIBLE"
print(ans) | n,m = list(map(int,input().split()))
a = []
b = []
ans = ""
for i in range(m):
tmp1,tmp2 = list(map(int,input().split()))
a.append(tmp1)
b.append(tmp2)
xton = set()
#nへ向かう便が出てる島を確認する
for i in range(m):
if b[i] == n:
xton.add(a[i])
#nへ向かう便が出ている島へ1から向かう便があるか確認する
for i in range(m):
if a[i] == 1 and b[i] in xton:
ans = "POSSIBLE"
break
else:
ans = "IMPOSSIBLE"
print(ans) | p03645 |
def main():
n, m = list(map(int, input().split()))
a, b = [], []
to_n = []
for _ in range(m):
x, y = list(map(int, input().split()))
a.append(x)
b.append(y)
if y == n:
to_n.append(x)
for j in range(m):
if a[j] == 1:
if b[j] in to_n:
return 'POSSIBLE'
return 'IMPOSSIBLE'
print((main())) | def main():
n, m = list(map(int, input().split()))
a, b = [], []
from_1 = set()
to_n = set()
for _ in range(m):
x, y = list(map(int, input().split()))
if x == 1:
from_1.add(y)
continue
if y == n:
to_n.add(x)
continue
ans = from_1 & to_n
if ans:
return "POSSIBLE"
return 'IMPOSSIBLE'
print((main())) | p03645 |
import sys
n, m = list(map(int, input().split()))
a_list1 = []
b_list1 = []
a_list2 = []
b_list2 = []
for i in range(m):
a, b = list(map(int, input().split()))
if a == 1:
a_list1.append(a)
b_list1.append(b)
elif b == n:
a_list2.append(a)
b_list2.append(b)
for i in range(len(a_list1)):
for j in range(len(a_list2)):
if b_list1[i] == a_list2[j]:
print('POSSIBLE')
sys.exit()
print('IMPOSSIBLE')
| import sys
n, m = list(map(int, input().split()))
mid_set1 = set([])
mid_set2 = set([])
for i in range(m):
a, b = list(map(int, input().split()))
if a == 1:
mid_set1.add(b)
elif b == n:
mid_set2.add(a)
if len(mid_set1&mid_set2) > 0:
print('POSSIBLE')
sys.exit()
print('IMPOSSIBLE')
| p03645 |
N, M = list(map(int, input().split()))
ab = [list(map(int, input().split())) for i in range(M)]
second = []
flag = False
for x in range(M):
if ab[x][0] == 1:
second.append(ab[x][1])
for y in range(len(second)):
for z in range(M):
if ab[z][0] == second[y] and ab[z][1] == N:
flag = True
if flag:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
| N, M = list(map(int, input().split()))
ab = [list(map(int, input().split())) for i in range(M)]
start = []
goal = []
flag = False
for x in range(M):
if ab[x][0] == 1:
start.append(ab[x][1])
if ab[x][1] == N:
goal.append(ab[x][0])
start_goal = set(start) & set(goal)
if start_goal:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
| p03645 |
def takahasi(n , m , a):
ans = "IMPOSSIBLE"
list1 = []
listn = []
for i in range(m):
if a[i][0] == 1:
list1.append(a[i][1])
elif a[i][1] == n:
listn.append(a[i][0])
for i in range(len(list1)):
if listn.count(list1[i]) != 0:
ans = "POSSIBLE"
return ans
def main():
n , m = list(map(int , input().split()))
a = [list(map(int,input().split())) for i in range(m)]
print((takahasi(n , m , a)))
if __name__ == '__main__':
main() | def takahasi(n , m , a):
ans = "IMPOSSIBLE"
list1n = []
for i in range(m):
if a[i][0] == 1 or a[i][1] == n:
list1n.append(a[i][1] if a[i][0] == 1 else a[i][0])
if len(list1n) != len(set(list1n)):
ans = "POSSIBLE"
return ans
def main():
n , m = list(map(int , input().split()))
a = [list(map(int,input().split())) for i in range(m)]
print((takahasi(n , m , a)))
if __name__ == '__main__':
main() | p03645 |
import sys
import heapq
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = list(map(int, input().split()))
edge = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
edge[a - 1].append([1, b - 1])
edge[b - 1].append([1, a - 1])
# ダイクストラ法：O(ElogV)
def dijkstra_heap(s):
# 始点sから各頂点への最短距離
d = [float("inf")] * n
used = [True] * n # True:未確定
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist, e)
while len(edgelist):
minedge = heapq.heappop(edgelist)
# まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge[1]]:
continue
v = minedge[1]
d[v] = minedge[0]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist, [e[0] + d[v], e[1]])
return d
L = dijkstra_heap(n - 1)
if L[0] <= 2:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
if __name__ == '__main__':
resolve()
| # https://atcoder.jp/contests/abc068/submissions/12987221
# C - Cat Snuke and a Voyage
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = list(map(int, input().split()))
edge = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
edge[a - 1].append(b - 1)
edge[b - 1].append(a - 1)
for i in edge[0]:
if n - 1 in set(edge[i]):
print("POSSIBLE")
break
else:
print("IMPOSSIBLE")
if __name__ == '__main__':
resolve()
| p03645 |
N, M = list(map(int, input().split()))
atb = [list(map(int, input().split())) for _ in range(M)]
flg = 0
#愚直にやる
for i in range(2, N, 1):
#定期便ある?
if [1, i] in atb:
if [i, N] in atb:
print("POSSIBLE")
flg = 1
if flg==0:
print("IMPOSSIBLE") | N, M = list(map(int, input().split()))
sa = set()
sb = set()
for i in range(M):
a,b = list(map(int, input().split()))
if a==1:
sa.add(b)
elif b==N:
sb.add(a)
print(("POSSIBLE" if len(sa&sb)!=0 else "IMPOSSIBLE")) | p03645 |
# -*- coding: utf-8 -*-
import itertools
import sys
ships = []
N, M = [int(x) for x in input().split()]
for i in range(M):
ships.append([int(x) for x in input().split()])
from_1 = [ship[1] for ship in ships if ship[0] == 1]
to_N = [ship[0] for ship in ships if ship[1] == N]
for land in from_1:
if land in to_N:
print("POSSIBLE")
sys.exit()
print("IMPOSSIBLE") | # -*- coding: utf-8 -*-
ships = []
N, M = [int(x) for x in input().split()]
for i in range(M):
ships.append([int(x) for x in input().split()])
from_1 = set([ship[1] for ship in ships if ship[0] == 1])
to_N = set([ship[0] for ship in ships if ship[1] == N])
if from_1.intersection(to_N):
print("POSSIBLE")
else:
print("IMPOSSIBLE")
| p03645 |
from collections import Counter
from functools import reduce
# import statistics
import bisect
import copy
import fractions
import math
import pprint
import random
import sys
import time
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def MI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def IS(): return eval(input())
def C(x): return Counter(x)
def GCD_LIST(numbers):
return reduce(fractions.gcd, numbers)
def LCM_LIST(numbers):
return reduce(LCM, numbers)
def LCM(m, n):
return (m * n // fractions.gcd(m, n))
def unite(x, y):
# それぞれのノードの根を求める
x = root(x)
y = root(y)
if x == y:
return
# node[x]の根をyに変更する
node[x] = y
def same(x,y): return bool(root(x) == root(y))
def root(x):
if node[x] == x: # xが根の場合
return x
else:
node[x] = root(node[x]) # 経路圧縮
return node[x]
def dfs(v,depth):
# ノードに訪れた
visited[v] = 1
if depth == 2:
return
for a, b in sides:
if v == a-1:
depth += 1
dfs(b-1, depth)
depth -= 1
n, m = MI()
sides = [LI() for _ in range(m)]
islands = [[0] * 2 for _ in range(n)]
for a, b in sides:
if a-1 == 0:
islands[b-1][0] = 1
if b-1 == n-1:
islands[a-1][1] = 1
for a, b in islands:
if a == b == 1:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
| from collections import Counter
from functools import reduce
# import statistics
import bisect
import copy
import fractions
import math
import pprint
import random
import sys
import time
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def MI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def IS(): return eval(input())
def C(x): return Counter(x)
def GCD_LIST(numbers):
return reduce(fractions.gcd, numbers)
def LCM_LIST(numbers):
return reduce(LCM, numbers)
def LCM(m, n):
return (m * n // fractions.gcd(m, n))
def unite(x, y):
# それぞれのノードの根を求める
x = root(x)
y = root(y)
if x == y:
return
# node[x]の根をyに変更する
node[x] = y
def same(x,y): return bool(root(x) == root(y))
def root(x):
if node[x] == x: # xが根の場合
return x
else:
node[x] = root(node[x]) # 経路圧縮
return node[x]
def dfs(v,depth):
# ノードに訪れた
visited[v] = 1
if depth == 2:
return
for a, b in sides:
if v == a-1:
depth += 1
dfs(b-1, depth)
depth -= 1
n, m = MI()
a, b = set(), set()
for i in range(m):
x, y = MI()
if x == 1:
a.add(y)
if y == n:
b.add(x)
print(("POSSIBLE" if a&b else "IMPOSSIBLE"))
| p03645 |
from collections import defaultdict
N,M=list(map(int,input().split()))
dict=defaultdict(int)
l1=[]
l2=[]
for i in range(M):
a,b=list(map(int,input().split()))
if a==1:
l1.append(b)
if b==N:
dict[a]=1
for i in l1:
if dict[i]:
print("POSSIBLE")
quit()
print("IMPOSSIBLE")
|
N,M=list(map(int,input().split()))
t=set()
s=set()
for i in range(M):
a,b=list(map(int,input().split()))
if a==1:
s.add(b)
if b==N:
t.add(a)
for i in s:
if i in t:
print("POSSIBLE")
quit()
print("IMPOSSIBLE")
| p03645 |
N,M = list(map(int,input().split()))
goto_N = [0]*N
from_1 = [0]*N
for _ in range(M):
a,b = list(map(int,input().split()))
if a == 1:
from_1[b] = 1
elif b == N:
goto_N[a] = 1
for i in range(N):
if goto_N[i] and from_1[i]:
print("POSSIBLE")
exit()
print("IMPOSSIBLE") | N,M = list(map(int,input().split()))
##1からきている&&Nに行ける
road = [0]*N
for _ in range(M):
a,b = list(map(int,input().split()))
if a == 1:
road[b-1] += 1
elif b == N:
road[a-1] += 1
if 2 in road:
print("POSSIBLE")
else:
print("IMPOSSIBLE") | p03645 |
n, m = list(map(int,input().split()))
aaa = 0
tbin_1 = []
tbin_n = []
for i in range(m):
xxx = list(map(int,input().split()))
if xxx[0] == 1:
tbin_1.append(xxx[1])
if xxx[1] in tbin_n:
aaa = 1
break
elif xxx[1] == n :
tbin_n.append(xxx[0])
if xxx[0] in tbin_1:
aaa = 1
break
else:
None
if aaa == 1 :
print('POSSIBLE')
else:
print('IMPOSSIBLE') | n, m = list(map(int,input().split()))
boolins =[]
for i in range(n):
boolins.append(0)
for i in range(m):
xxx = list(map(int,input().split()))
if xxx[0] == 1:
boolins[xxx[1]] = boolins[xxx[1]] + 1
elif xxx[1] == n :
boolins[xxx[0]]=boolins[xxx[0]]+ 1
else:
None
if 2 in boolins:
print('POSSIBLE')
else:
print('IMPOSSIBLE') | p03645 |
from collections import defaultdict
d = defaultdict(list)
n, m = list(map(int, input().split()))
for _ in range(m):
a, b = list(map(int, input().split()))
d[a].append(b)
# アクセスを高速にするためにsetに変換
for a in list(d.keys()):
d[a] = set(d[a])
def solve(n, d):
for a in d[1]:
if n in d[a]:
return 'POSSIBLE'
return 'IMPOSSIBLE'
print((solve(n, d)))
| from collections import defaultdict
d = defaultdict(set)
n, m = list(map(int, input().split()))
for _ in range(m):
a, b = list(map(int, input().split()))
d[a].add(b)
def solve(n, d):
for a in d[1]:
if n in d[a]:
return 'POSSIBLE'
return 'IMPOSSIBLE'
print((solve(n, d)))
| p03645 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.