Merge pull request #779 from sAp00n/master

외발뛰기, 와일드 카드,  삼각형 위의 최대 경로

Author: sangmandu

알고스팟/삼각형 위의 최대 경로/삼각형 위의 최대 경로.py

@@ -0,0 +1,55 @@
+from sys import stdin
+
+
+def compute_sum(location):
+    global triang_list
+    global memo
+
+    line, number = location
+
+    if line == len(triang_list) - 1:
+        if location in memo:
+            return memo[location]
+        return_val = triang_list[line][number]
+        memo[location] = return_val
+        # print(f'return: {return_val}')
+        return return_val
+
+    if number == len(triang_list[line]):
+        if (line + 1, number) in memo:
+            return triang_list[line][number] + memo[(line + 1, number)]
+        return_val = compute_sum((line + 1, number))
+        memo[line + 1, number] = return_val
+        # print(f'return: {return_val}')
+        return triang_list[line][number] + return_val
+
+    if (line + 1, number) in memo:
+        left_sum = memo[(line + 1, number)]
+    else:
+        left_sum = compute_sum((line + 1, number))
+        memo[(line + 1, number)] = left_sum
+    if (line + 1, number + 1) in memo:
+        right_sum = memo[(line + 1, number + 1)]
+    else:
+        right_sum = compute_sum((line + 1, number + 1))
+        memo[(line + 1, number + 1)] = right_sum
+    return_val = triang_list[line][number] + max(left_sum, right_sum)
+    # print(f'return: {return_val}')
+    return return_val
+
+
+def sol():
+    C = int(stdin.readline())
+    for _ in range(C):
+        n = int(stdin.readline())
+        global triang_list
+        global memo
+        triang_list = []
+        memo = {}
+        for __ in range(n):
+            triang_list.append(list(map(int, stdin.readline().split())))
+        print(compute_sum((0, 0)))
+        # print(memo)
+
+
+sol()

알고스팟/와일드카드/와일드카드.py

@@ -0,0 +1,59 @@
+from sys import stdin
+
+
+def match(w_idx, s_idx):
+    global w
+    global s
+    global memo
+    w_start_idx = w_idx
+    s_start_idx = s_idx
+    # print(f'input_list -> {w[w_start_idx:]} matching : {s[s_start_idx:]}')
+
+    if (w_start_idx, s_start_idx) in memo:
+        # print(f'in memo\nreturn_value ->{memo[(w_start_idx, s_start_idx)]}')
+        return memo[(w_start_idx, s_start_idx)]
+    idx = 0
+    # print(f'start_matching at {idx} < {len(w[w_start_idx:]) - 1} or {idx} < {len(s[s_start_idx:]) - 1}')
+    while idx < len(w[w_start_idx:]) and idx < len(s[s_start_idx:]):
+        if w[w_start_idx + idx] == s[s_start_idx + idx] or w[w_start_idx + idx] == '?':
+            idx += 1
+            # print(f'    list: {w[w_start_idx + idx:]} matching: {s[s_start_idx + idx:]}')
+            continue
+        break
+
+    if w_start_idx + idx == len(w) and s_start_idx + idx == len(s):
+        memo[(w_start_idx, s_start_idx)] = True
+        # print(f'        case {w[w_start_idx + idx:]} -> {s[s_start_idx + idx:]} is True')
+        return True
+
+    if len(w[w_start_idx + idx:]) >= 1 and w[w_start_idx + idx] == '*':
+        # print(f'fst letter is "*"')
+        for jdx in range(0, len(s[s_start_idx:]) - idx + 1):
+            # print(f'match( {w[w_start_idx + idx + 1:]} , {s[s_start_idx + idx + jdx:]} ) ')
+            if match(w_start_idx + idx + 1, s_start_idx + idx + jdx):
+                memo[(w_start_idx + idx + 1, s_start_idx + idx + jdx)] = True
+                return True
+    memo[(w_start_idx, s_start_idx)] = False
+    return False
+
+
+def sol():
+    global w
+    global s
+    global memo
+    w = stdin.readline().strip('\n')
+    n = int(stdin.readline())
+    return_li = []
+    for __ in range(n):
+        s = stdin.readline().strip('\n')
+        memo = {}
+        if match(0, 0):
+            return_li.append(s)
+        # print(f'memo: {memo}\n\n')
+    return_li.sort()
+    for li in return_li:
+        print(li)
+
+C = int(stdin.readline())
+for _ in range(C):
+    sol()

알고스팟/외발뛰기/외발뛰기.py

@@ -0,0 +1,40 @@
+from sys import stdin
+
+
+def recursive_jump(mat, location):
+    # print(f'cache : {cache}')
+    if mat[location[0]][location[1]] == 0:
+        return True
+    if location in cache:
+        return cache[location]
+    current_num = mat[location[0]][location[1]]
+    case_01, case_02 = False, False
+    if location[0] + current_num <= len(mat) - 1:
+        case_01 = recursive_jump(mat, (location[0] + current_num, location[1]))
+        cache[(location[0] + current_num, location[1])] = case_01
+    if location[1] + current_num <= len(mat) - 1:
+        case_02 = recursive_jump(mat, (location[0], location[1] + current_num))
+        cache[location[0], location[1] + current_num] = case_02
+    if case_01 or case_02:
+        return True
+    else:
+        return False
+
+
+def sol():
+    n = int(stdin.readline())
+    mat = [list(map(int, stdin.readline().split())) for _ in range(n)]
+    '''for line in mat:
+        print(line)'''
+
+    if recursive_jump(mat, (0, 0)):
+        print('YES')
+    else:
+        print('NO')
+
+
+C = int(stdin.readline())
+
+for _ in range(C):
+    cache = {}
+    sol()