Merge branch 'main' of https://github.com/zaqquum/Hongjoo_algorithm_study

Author: zaqquum

YoonYn9915/Graph/2024-12-14-[백준]-#17070-파이프 옮기기 1.py

@@ -0,0 +1,49 @@
+N = int(input())
+
+# 가로, 세로, 대각선 순
+dx = [0, 1, 1]
+dy = [1, 0, 1]
+
+
+def dfs(x, y, dir):
+    # 이미 방문한 상태라면 결과를 반환
+    if memo[x][y][dir] != -1:
+        return memo[x][y][dir]
+
+    # 종료 조건: 목표에 도달하면 경로 1개 추가
+    if x == N - 1 and y == N - 1:
+        return 1
+
+    # 경로 수
+    paths = 0
+
+    for dir_idx in range(3):
+        # 현재 방향에서 이동 불가능한 방향 건너뛰기
+        if (dir == 0 and dir_idx == 1) or (dir == 1 and dir_idx == 0):
+            continue
+
+        newX = x + dx[dir_idx]
+        newY = y + dy[dir_idx]
+
+        # 이동 가능한지 검사
+        if 0 <= newX < N and 0 <= newY < N and arr[newX][newY] == 0:
+            if dir_idx == 2:  # 대각선
+                if arr[newX - 1][newY] == 1 or arr[newX][newY - 1] == 1:
+                    continue
+
+            # DFS 탐색
+            paths += dfs(newX, newY, dir_idx)
+
+    # 결과를 메모이제이션에 저장
+    memo[x][y][dir] = paths
+    return paths
+
+
+# 입력
+arr = [list(map(int, input().split())) for _ in range(N)]
+
+# 메모이제이션 초기화: -1로 채움
+memo = [[[-1] * 3 for _ in range(N)] for _ in range(N)]
+
+# DFS 시작
+print(dfs(0, 1, 0))

YoonYn9915/implementation/2024-12-14-[백준]-#14500-테트로미노.py

@@ -0,0 +1,49 @@
+'''
+1. 완전 탐색으로 진행
+    1.1 문제 요건에 따라 최악의 경우는
+        500 * 500 * 5(테트로미노 종류) * 4(90도 회전 경우의 수) * 4(대칭한 후 90도 회전 경우의 수).
+        N(1억)이 1초라고 가정한다면 2초면 충분하다고 판단.
+2. 테트로미노의 종류별로, 회전과 대칭의 경우의 수를 모두 고려하여 모양 리스트를 만든다.
+3. 이중 반복문에서 모든 칸을 순회하며 모든 모양 리스트를 검사하여 최댓값을 찾는다.
+
+'''
+
+N, M = map(int, input().split())
+
+arr = [list(map(int, input().split())) for _ in range(N)]
+
+# 가능한 모든 테트로미노 모양, 시작점을 기준으로 더해야 할 dx, dy임.
+shape = [[(0, 1), (0, 2), (0, 3)], [(1, 0), (2, 0), (3, 0)],
+         [(0, 1), (1, 0), (1, 1)],
+         [(1, 0), (1, 1), (2, 1)], [(0, -1), (1, -1), (1, -2)],
+         [(1, 0), (1, -1), (2, -1)], [(0, 1), (1, 1), (1, 2)],
+         [(1, 0), (2, 0), (2, 1)], [(0, 1), (0, 2), (1, 0)],
+         [(0, 1), (1, 1), (2, 1)], [(0, 1), (0, 2), (-1, 2)],
+         [(1, 0), (2, 0), (2, -1)], [(0, 1), (0, 2), (1, 2)],
+         [(1, 0), (2, 0), (0, 1)], [(1, 0), (1, 1), (1, 2)],
+         [(1, 0), (1, 1), (1, -1)], [(1, 0), (1, 1), (2, 0)],
+         [(0, -1), (1, 0), (0, 1)], [(0, 1), (-1, 1), (1, 1)]
+         ]
+
+
+def calc(i, j, tet):
+    sum = arr[i][j]
+    for dx, dy in tet:
+        newX = i + dx
+        newY = j + dy
+        #종이의 범위를 넘지 않았다면 종이 칸의 수 더하기
+        if 0 <= newX < N and 0 <= newY < M:
+            sum += arr[newX][newY]
+        else:
+            return 0
+    return sum
+
+
+ans = 0
+for i in range(N):
+    for j in range(M):
+        for tet in shape:
+            temp = calc(i, j, tet)  # 현재 위치에서 가능한 모든 모양의 합 계산
+            ans = max(temp, ans)
+
+print(ans)

learntosurf/Implementation/2024-12-14-[BOJ]-#14500-테크로미노.py

@@ -0,0 +1,51 @@
+import sys
+input = sys.stdin.readline
+
+# 테트로미노의 전체 경우의 수를 저장
+tets = [
+    # 1x4 막대
+    [(0, 1), (0, 2), (0, 3)], [(1, 0), (2, 0), (3, 0)],
+    # 2x2 정사각형
+    [(0, 1), (1, 0), (1, 1)],
+    # ㄹ자 모양
+    [(1, 0), (1, 1), (2, 1)], [(0, 1), (1, 0), (1, -1)],
+    # ㄹ자 대칭
+    [(1, 0), (1, -1), (2, -1)], [(0, 1), (1, 1), (1, 2)],
+    # ㄴ자 모양 (회전 포함)
+    [(1, 0), (2, 0), (2, 1)], [(0, 1), (0, 2), (1, 0)],
+    [(0, 1), (1, 1), (2, 1)], [(0, 1), (0, 2), (-1, 2)],
+    [(1, 0), (2, 0), (2, -1)], [(0, 1), (0, 2), (1, 2)],
+    # ㄴ자 대칭 (회전 포함)
+    [(1, 0), (2, 0), (0, 1)], [(1, 0), (1, 1), (1, 2)],
+    [(1, 0), (1, 1), (1, -1)], [(1, 0), (1, 1), (2, 0)],
+    # ㅗ자 모양 (회전 포함)
+    [(0, -1), (0, 1), (1, 0)], [(0, 1), (-1, 1), (1, 1)],
+    [(0, -1), (0, 1), (-1, 0)], [(1, 0), (0, 1), (-1, 0)],
+]
+
+# 주어진 좌표에서 특정 테트로미노를 배치했을 때의 합 계산
+def calc(i, j, tet):
+    total = arr[i][j]  # 시작 좌표의 값
+    for di, dj in tet:
+        ni, nj = i + di, j + dj
+        # 범위를 벗어나면 무효
+        if 0 <= ni < N and 0 <= nj < M:
+            total += arr[ni][nj]
+        else:
+            return 0
+    return total
+
+# 모든 위치에서 가능한 테트로미노를 배치해 최대값 계산
+def max_tetromino_sum():
+    max_sum = 0
+    for i in range(N):
+        for j in range(M):
+            for tet in tets:
+                max_sum = max(max_sum, calc(i, j, tet))
+    return max_sum
+
+
+N, M = map(int, input().split())
+arr = [list(map(int, input().split())) for _ in range(N)]
+
+print(max_tetromino_sum())

minjeong/DynamicProgramming/2024-12-14-[백준]-#10844-쉬운계단수.py

@@ -0,0 +1,16 @@
+n = int(input())
+
+num = [[0]*10 for _ in range(n+1)]
+num[0] = [1,1,1,1,1,1,1,1,0] #0행에 들어가는 값들을 계단수의 경우의수로 초기화
+
+for i in range(1,n+1):
+    for j in range(10): #0일때, 9일때, 나머지인 경우를 점화식을 토대로 코드 작성
+        if j == 0:
+            num[i][j] = num[i-1][1]
+        elif j == 9:
+            num[i][j] = num[i-1][8]
+        else:
+            num[i][j] = num[i-1][j-1] + num[i-1][j]
+
+answer = sum(num[n]) % 100000000
+print(answer)

minjeong/DynamicProgramming/2024-12-14-[백준]-#1914-하노이탑.py

@@ -0,0 +1,16 @@
+# 하노이 함수
+def hanoi_f(one, three, n):
+    if n == 1:
+        print(one, three)
+        return
+
+    hanoi_f(one, 6 - one - three, n - 1)  # 1단계 (1->2)
+    print(one, three)  # 2단계 (마지막원반 1->3)
+    hanoi_f(6 - one - three, three, n - 1)  # 3단계 (2->3)
+
+
+# 메인
+n = int(input())
+print(2 ** n - 1)
+if n <= 20:
+    hanoi_f(1, 3, n)

minjeong/PrefixSum/2024-12-10-[백준]-#11660-구간합구하기5.py

@@ -0,0 +1,33 @@
+import sys
+input = sys.stdin.readline
+
+# 누적합 테이블 계산
+def get_prefix_sum(grid, N):
+    prefix_sum = [[0] * (N+1) for _ in range(N+1)]
+    for i in range(1, N+1):
+        for j in range(1, N+1):
+            prefix_sum[i][j] = (
+                grid[i-1][j-1]
+                + prefix_sum[i-1][j]
+                + prefix_sum[i][j-1]
+                - prefix_sum[i-1][j-1]
+            )
+    return prefix_sum
+
+# 입력
+N, M = map(int, input().split())
+grid = [list(map(int, input().split())) for _ in range(N)]
+
+# 누적합
+prefix_sum = get_prefix_sum(grid, N)
+
+# 범위 합 계산
+for _ in range(M):
+    x1, y1, x2, y2 = map(int, input().split())
+    answer = (
+        prefix_sum[x2][y2]
+        - prefix_sum[x1-1][y2]
+        - prefix_sum[x2][y1-1]
+        + prefix_sum[x1-1][y1-1]
+    )
+    print(answer)

minjeong/Simulation/2024-12-14-[백준]-#14500-테트로미노.py

@@ -0,0 +1,57 @@
+n, m = map(int, input().split())
+graph = [list(map(int, input().split())) for _ in range(n)]
+visited = [[False] * m for _ in range(n)]
+
+# 방향 설정 (상, 하, 좌, 우)
+dx = [-1, 1, 0, 0]
+dy = [0, 0, -1, 1]
+
+# 최댓값 저장 변수
+max_value = 0
+
+
+# DFS 탐색 (ㅗ 모양 제외)
+def dfs(x, y, count, total):
+    global max_value
+    # 테트로미노 4칸 채웠을 경우
+    if count == 4:
+        max_value = max(max_value, total)
+        return
+
+    # 상하좌우 탐색
+    for i in range(4):
+        nx, ny = x + dx[i], y + dy[i]
+        # 범위 내에 있고, 방문하지 않은 경우
+        if 0 <= nx < n and 0 <= ny < m and not visited[nx][ny]:
+            visited[nx][ny] = True
+            dfs(nx, ny, count + 1, total + graph[nx][ny])
+            visited[nx][ny] = False  # 백트래킹
+
+
+# ㅗ 모양 탐색
+def check_t_shape(x, y):
+    global max_value
+    # 중심 기준 4방향 중 3개를 선택 (ㅗ, ㅜ, ㅏ, ㅓ)
+    for i in range(4):
+        total = graph[x][y]
+        for j in range(3):  # 현재 제외한 3방향 탐색
+            k = (i + j) % 4
+            nx, ny = x + dx[k], y + dy[k]
+            if 0 <= nx < n and 0 <= ny < m:
+                total += graph[nx][ny]
+            else:  # 범위를 벗어나면 ㅗ 모양이 성립하지 않음
+                break
+        else:  # 모든 3방향 탐색이 유효한 경우
+            max_value = max(max_value, total)
+
+
+# 모든 좌표에서 테트로미노 탐색
+for i in range(n):
+    for j in range(m):
+        visited[i][j] = True
+        dfs(i, j, 1, graph[i][j])  # DFS 시작
+        visited[i][j] = False
+        check_t_shape(i, j)  # ㅗ 모양 탐색
+
+# 결과 출력
+print(max_value)