2021.04.24

Author: seono

python/Samsung/11688.py

@@ -0,0 +1,16 @@
+import sys
+
+sys.stdin = open("input.txt", "r")
+cnt = 0
+def gcd(a,b):
+    global cnt
+    cnt+=1
+    return gcd(b,a%b)+a//b if b else a-1
+
+T = int(input())
+# 여러개의 테스트 케이스가 주어지므로, 각각을 처리합니다.
+for test_case in range(1, T + 1):
+    a,b = map(int,input().split())
+    cnt = 0
+    print("#"+str(test_case),gcd(a,b)-1)
+    print(cnt)

python/Samsung/1949.py

@@ -0,0 +1,54 @@
+import sys
+sys.stdin = open("input.txt", "r")
+
+d=[(0,1),(1,0),(-1,0),(0,-1)]
+
+def getHighest():
+    global N
+    ret = []
+    hi = -1e10
+    for y in range(N):
+        for x in range(N):
+            if arr[y][x]>hi:
+                ret = [(y,x)]
+                hi = arr[y][x]
+            elif arr[y][x]==hi:
+                ret.append((y,x))
+    return ret
+
+def dfs(y,x):
+    global N
+    visited = [[0]*N for _ in range(N)]
+    visited[y][x] = 1
+    st = [(y,x,1)]
+    ret = 0
+    while st:
+        y,x,l = st.pop()
+        ret = max(ret,l)
+        for dy,dx in d:
+            ny,nx = y+dy,x+dx
+            if ny<0 or ny>=N or nx<0 or nx>=N or visited[ny][nx]>=l: continue
+            if arr[ny][nx]<arr[y][x]:
+                st.append((ny,nx,l+1))
+                visited[ny][nx]=l+1
+    return ret
+
+def sol():
+    global K,N
+    ans = 1
+    h_list = getHighest()
+    for y in range(N):
+        for x in range(N):
+            for i in range(1,K+1):
+                arr[y][x]-=i
+                for ty,tx in h_list:
+                    ans = max(ans,dfs(ty,tx))
+                arr[y][x]+=i
+    return ans
+
+T = int(input())
+# 여러개의 테스트 케이스가 주어지므로, 각각을 처리합니다.
+for test_case in range(1, T + 1):
+    N, K = map(int,input().split())
+    arr = [list(map(int,input().split())) for _ in range(N)]
+    print("#"+str(test_case),sol())

python/Samsung/1953.py

@@ -0,0 +1,49 @@
+import sys
+
+
+direction = {0:[],1:[(1,0),(-1,0),(0,1),(0,-1)], 2:[(1,0),(-1,0)], 3:[(0,1),(0,-1)], 
+             4:[(-1,0),(0,1)], 5:[(1,0),(0,1)], 6:[(1,0),(0,-1)], 7:[(-1,0),(0,-1)]}
+
+state = {"r":0, "c":0, "t":0}
+que = []
+    
+sys.stdin = open("input.txt", "r")
+
+T = int(sys.stdin.readline().strip("\n"))
+
+for test_case in range(1, T+1):
+    h = sys.stdin.readline().strip("\n").split(" ")
+    N, M, R, C, L = int(h[0]), int(h[1]), int(h[2]), int(h[3]), int(h[4])
+    
+    maps = [[0]*M for _ in range(N)]
+    visited = [[0]*M for _ in range(N)]
+    for row in range(N):
+        l = sys.stdin.readline().strip("\n").split(" ")
+        for col in range(M):
+            maps[row][col] = int(l[col])
+
+    count = 1
+    state["r"], state["c"], state["t"] = R, C, 1
+    que.append(state)
+    visited[R][C] = 1
+    while len(que) > 0:
+        curr_state = que.pop(0)
+        curr_r, curr_c, curr_t = curr_state["r"], curr_state["c"], curr_state["t"]
+        if curr_t >= L:
+            continue
+        for h, v in direction[maps[curr_r][curr_c]]:
+            next_r, next_c, next_t = curr_r+h, curr_c+v, curr_t+1
+
+            can_move = (next_r < N) and (next_r >= 0) and (next_c < M) and (next_c >= 0)
+            if (can_move == True):
+                is_open = False
+                for h, v in direction[maps[next_r][next_c]]:
+                    tmp_r, tmp_c = next_r+h, next_c+v
+                    if (tmp_r==curr_r) and (tmp_c==curr_c):
+                        is_open = True
+                if (visited[next_r][next_c] < 1) and (is_open==True):
+                    new_state = {"r":next_r, "c":next_c, "t":curr_t + 1}
+                    que.append(new_state)
+                    visited[next_r][next_c] = 1
+                    count += 1
+    print("#%d %d" %(test_case, count))

python/Samsung/2112.py

@@ -0,0 +1,65 @@
+import sys
+sys.stdin = open("input.txt", "r")
+
+D,W,K,ret = 0,0,0,0
+
+def check():
+    global D,W,K
+    for w in range(W):
+        aflag = 0
+        bflag = 0
+        flag = False
+        for i in range(D):
+            if (arr[w]>>i)&1:
+                aflag+=1
+                bflag = 0
+            else:
+                bflag+=1
+                aflag = 0
+            if aflag==K or bflag==K: 
+                flag = True
+                break
+        if not flag:
+            return False
+    return True
+
+def sol(idx,k):
+    global D,W,K,ret
+    if k>K: return K
+    if k and check():
+        return k
+    if idx==D:
+        return 100
+    ret = min(ret,sol(idx+1,k))
+    temp = 0
+    #1로 통합
+    for w in range(W):
+        temp<<=1
+        temp|=((arr[w]>>idx)&1)
+        arr[w] |= (1<<idx)
+    ret = min(ret,sol(idx+1,k+1))
+    x = (1<<D)-(1<<idx|1)
+    #0으로 통합
+    for w in range(W):
+        arr[w] &= x
+    ret = min(ret,sol(idx+1,k+1))
+    #복구
+    for w in range(W-1,-1,-1):
+        arr[w] |= (temp&1)<<idx
+        temp>>=1
+    return ret
+
+T = int(input())
+# 여러개의 테스트 케이스가 주어지므로, 각각을 처리합니다.
+for test_case in range(1, T + 1):
+    D, W, K = map(int,input().split())
+    ret = K
+    arr = [0]*W
+    for d in range(D):
+        for idx,x in enumerate(list(map(int,input().split()))):
+            arr[idx]<<=1
+            arr[idx] = arr[idx]|x
+    ans = 0
+    if not check():
+        ans = sol(0,0)
+    print("#"+str(test_case),ans)

python/Samsung/2382.py

@@ -0,0 +1,48 @@
+import sys
+sys.stdin = open("input.txt", "r")
+
+#상하좌우 y,x
+d = [(-1,0),(1,0),(0,-1),(0,1)]
+
+T = int(input())
+# 여러개의 테스트 케이스가 주어지므로, 각각을 처리합니다.
+for test_case in range(1, T + 1):
+    N, M, K = map(int,input().split())
+    st = {}
+    for _ in range(K):
+        y,x,cnt,dir = map(int,input().split())
+        st[(y,x)]=(cnt,dir-1)
+    for t in range(M):
+        new_st = {}
+        for key,value in st.items():
+            y,x = key
+            cnt,dir = value
+            dy,dx = d[dir]
+            ny,nx = y+dy,x+dx
+            if ny==0 or ny==N-1 or nx==0 or nx==N-1:
+                cnt>>=1
+                dir^=1
+                if cnt:
+                    new_st[(ny,nx)]=[(cnt,dir)]
+            else:
+                if (ny,nx) in new_st:
+                    new_st[(ny,nx)].append((cnt,dir))
+                else:
+                    new_st[(ny,nx)]=[(cnt,dir)]
+        st = {}
+        for key,value in new_st.items():
+            if len(value)>1:
+                nCnt,nDir = 0,0
+                sumCnt = 0
+                for c,dir in value:
+                    if c>nCnt:
+                        nDir = dir
+                        nCnt = c
+                    sumCnt+=c
+                st[key]=(sumCnt,nDir)
+            else:
+                st[key]=value[0]
+    ans = 0
+    for v in st.values():
+        ans+=v[0]
+    print("#"+str(test_case),ans)

python/Samsung/2383.py

@@ -0,0 +1,70 @@
+import sys
+sys.stdin = open("input.txt", "r")
+
+def getTime(stair,t):
+    # sorted stair
+    inStair = []
+    idx = 0
+    ret = 0
+    while idx<len(stair):
+        nowP = stair[idx]
+        if len(inStair)<3:
+            inStair.append(nowP+t)
+            ret = nowP+t
+        else:
+            if inStair[0]<=nowP:
+                inStair.pop(0)
+                inStair.append(nowP+t)
+                ret = nowP+t
+            else:
+                tmp = inStair.pop(0)
+                inStair.append(tmp+t)
+                ret = tmp+t
+        idx+=1
+    return ret
+
+def distanse(py,px,num):
+    y,x = stairs[num]
+    return abs(py-y)+abs(px-x)
+
+def check():
+    global bit,L
+    ch = [[],[]]
+    for idx in range(L):
+        py,px = p[idx]
+        c = (bit>>idx)&1
+        dis = distanse(py,px,c)
+        ch[c].append(dis+1)    
+    return max(getTime(sorted(ch[0]),time[0]),getTime(sorted(ch[1]),time[1]))
+
+def sol(idx):
+    global L, bit
+    if idx==L:
+        return check()
+    ret = 1e10
+    temp = bit
+    ret = min(sol(idx+1),ret)
+    bit |= 1<<idx
+    ret = min(sol(idx+1),ret)
+    bit = temp
+    return ret
+
+T = int(input())
+# 여러개의 테스트 케이스가 주어지므로, 각각을 처리합니다.
+for test_case in range(1, T + 1):
+    N = int(input())
+    p = []
+    stairs = []
+    time = []
+    arr = [list(map(int,input().split())) for _ in range(N)]
+    for y in range(N):
+        for x in range(N):
+            if arr[y][x]:
+                if arr[y][x]>1:
+                    stairs.append((y,x))
+                    time.append(arr[y][x])
+                else:
+                    p.append((y,x))
+    L = len(p)
+    bit = 0
+    print("#"+str(test_case),sol(0))

python/gold1/1285.py

@@ -0,0 +1,38 @@
+import sys
+import copy
+input = sys.stdin.readline
+
+N = int(input())
+arr = [[0]*N for _ in range(N)]
+ans = N*N
+for y in range(N):
+    for idx,ch in enumerate(input().strip()):
+        if ch=="H":
+            arr[y][idx]=1
+
+def check():
+    global ans,N
+    sum = 0
+    for y in range(N):
+        tail = 0
+        for x in range(N):
+            if arr[x][y]:
+                tail+=1
+        sum+=min(tail,N-tail)
+        if sum>ans:
+            return sys.maxsize
+    return sum
+
+def sol(idx):
+    if idx==N:
+        return check()
+    ret = sys.maxsize
+    ret = min(sol(idx+1),ret)
+    for y in range(N):
+        arr[idx][y]^=1
+    ret = min(sol(idx+1),ret)
+    for y in range(N):
+        arr[idx][y]^=1
+    return ret
+
+print(sol(0))