2. Google Colaboratory 시작

시작하기 - 더보기 - Google Colaboratory

3. 런타임 유형 변경

런타임 - 런타임 유형 변경 - GPU 선택 - 저장

4. Mount 시키기

from google.colab import drive
drive.mount('/content/drive')

본 코드로 본인이 원하는 곳에 Mount 시킨다.

5. 원하는 코드 작성해서 사용하기!😊

git lfs 이용

1. https://git-lfs.github.com/ 사이트에 들어가서 download 먼저 해줍니다.

2. 해당 Repository에 아래 명령 적용

git lfs install

3. 이전 git add 기록이 있다면 지워줌

git rm -r --cached "*"

4. git add .gitattributes

lfs는 .gitattributes를 통해 관리되기 때문에 꼭!

git add .gitattributes

5. git에 원하는 파일 add

git add (파일명)
git commit -m "Add design file"
git push origin (브런치명)

1번 문제 풀이 코드(BFS 이용)

import sys
from collections import deque

def bfs(x, y):
    deq = deque()
    deq.append((x, y))

    # 상좌하우 방향 설정
    dx = [0, -1, 0, 1]
    dy = [1, 0, -1, 0]

    while deq:
        x, y = deq.popleft()
        # 방향 탐색
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            if nx < 0 or ny < 0 or nx == n or ny == m:
                continue
            # 벽이면 계속 진행
            if matrix[nx][ny] == 0:
                continue

            if matrix[nx][ny] == 1:
                matrix[nx][ny] = matrix[x][y] + 1
                deq.append((nx, ny))

    # 최단거리
    return matrix[n-1][m-1]

# 테스트 케이스
n, m = map(int, sys.stdin.readline().rstrip().split())
# n개의 줄에 m개의 정수들 입력
matrix = [list(map(int, sys.stdin.readline().rstrip())) for _ in range(n)]

print(bfs(0, 0))    

=======================================================

DFS를 이용해서 풀려고 하다가 시간만 잡아먹었다.... 본 문제는 최단거리를 구해야 하는 문제로서 BFS를 이용해서 푸는것이 효율적이다.

참고

https://loosie.tistory.com/151 http://blog.slarea.com/algorithm/techniques/dfs-bfs

본 유기농 배추 배열에는 최소 흰지렁이는 5마리 필요함

1-1번 문제 풀이 코드(DFS 이용)

import sys
# 파이썬의 기본 재귀는 1000으로 한정되어 있다.
# 재귀를 하다 에러가 난다면 아래와 같은 코드를 사용해서 해결한다.
sys.setrecursionlimit(10 ** 6)

def dfs(x, y):
    # 상좌하우의 방향
    dx = [0, -1, 0, 1]
    dy = [1, 0, -1, 0]

    # 방향 탐색
    for i in range(4):
        nx = x + dx[i]
        ny = y + dy[i]
        if (0 <= nx < m) and (0 <= ny < n):
            if matrix[ny][nx] == 1:
                # 상하좌우에 값이 있으면 값을 0으로 변경한다.
                matrix[ny][nx] = 0
                dfs(nx, ny)
    return

# 테스트 케이스
t = int(sys.stdin.readline())

for _ in range(t):
    m, n, k = map(int, sys.stdin.readline().split())
    # 배추 위치쌍을 2차원 배열로 받기
    matrix = [[0] * m for _ in range(n)]
    # 흰지렁이수를 세기 위함
    count = 0

    # 배추 위치에 1삽입
    for i in range(k):
        x, y = map(int, sys.stdin.readline().split())
        matrix[y][x] = 1

    # 각 행과 열에서 값을 확인한다.
    # 그리고 dfs 함수가 모두 끝나면 흰지렁이 수를 계산한다.
    for i in range(m):
        for j in range(n):
            if matrix[j][i] == 1:
                dfs(i, j)
                count += 1

    print(count)

=======================================================

1-2번 문제 풀이 코드(BFS 이용)

import sys
from collections import deque

def bfs(x, y):
    deq = deque()
    deq.append((x, y))
    # 상좌하우의 방향
    dx = [0, -1, 0, 1]
    dy = [1, 0, -1, 0]
    while deq:
        x, y = deq.popleft()
        # 방향 탐색
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            if (0 <= nx < m) and (0 <= ny < n):
                if matrix[ny][nx] == 1:
                    deq.append((nx, ny))
                    # 상하좌우에 값이 있으면 값을 0으로 변경한다.
                    matrix[ny][nx] = 0
    return


# 테스트 케이스
t = int(sys.stdin.readline())

for _ in range(t):
    m, n, k = map(int, sys.stdin.readline().split())
    # 배추 위치쌍을 2차원 배열로 받기
    matrix = [[0] * m for _ in range(n)]
    # 흰지렁이수를 세기 위함
    count = 0

    # 배추 위치에 1삽입
    for i in range(k):
        x, y = map(int, sys.stdin.readline().split())
        matrix[y][x] = 1

    # 각 행과 열에서 값을 확인한다.
    # 그리고 dfs 함수가 모두 끝나면 흰지렁이 수를 계산한다.
    for i in range(m):
        for j in range(n):
            if matrix[j][i] == 1:
                bfs(i, j)
                count += 1

    print(count)

======================================================= 본 방법에서 순서를 따로 지정한 것이 아니기에, dfs나 bfs 모든 방법으로 풀 수 있다.

컴퓨터 연결 상황 그림

1-1번 문제 풀이 코드(DFS 이용)

import sys

# 바이러스에 걸린 컴퓨터수 셀 리스트
count = []
def dfs(v):
    # 방문했던 곳에 1 삽입
    visited[v] = 1
    #재귀 함수 선언
    for i in range(1, n + 1):
        if visited[i] == 0 and matrix[v][i] == 1:
            # 리스트에 해당하는 값을 따로 담아줌
            count.append(i)
            dfs(i)
    # 그 값의 길이를 리턴
    return len(count)

# 컴퓨터수 n, 네트워크상 연결된 컴퓨터쌍 수 m
n = int(sys.stdin.readline())
m = int(sys.stdin.readline())
# 컴퓨터의 번호쌍을 2차원 배열로 받기
matrix = [[0] * (n + 1) for _ in range(n + 1)]
# 방문했던 곳 확인을 위한 배열
visited = [0] * (n + 1)

# 간선 갯수 확인을 위한 반복문
for i in range(m):
    a, b = map(int, sys.stdin.readline().split())
    matrix[a][b] = matrix[b][a] = 1

# 값의 길이를 출력
print(dfs(1))

=======================================================

1-2번 문제 풀이 코드(BFS 이용)

import sys
from collections import deque

# bfs 함수
count = []
def bfs(v):
    # 방문할 곳을 넣을 덱
    deq = deque()
    deq.append(v)
    # 방문한 곳에 1을 삽입
    visited[v] = 1
    # 덱 안에 데이터가 없어질때까지 반복문 실행
    while deq:
        v = deq.popleft()
        for i in range(1, n + 1):
            if visited[i] == 0 and matrix[v][i] == 1:
                deq.append(i)
                count.append(i)
                visited[i] = 1
    return len(count)

# 컴퓨터수 n, 네트워크상 연결된 컴퓨터쌍 수 m
n = int(sys.stdin.readline())
m = int(sys.stdin.readline())
# 컴퓨터의 번호쌍을 2차원 배열로 받기
matrix = [[0] * (n + 1) for _ in range(n + 1)]
# 방문했던 곳 확인을 위한 배열
visited = [0] * (n + 1)

# 간선 갯수 확인을 위한 반복문
for i in range(m):
    a, b = map(int, sys.stdin.readline().split())
    matrix[a][b] = matrix[b][a] = 1

print(bfs(1))

=======================================================

본 방법에서 순서를 따로 지정한 것이 아니기에, dfs나 bfs 모든 방법으로 풀 수 있다.

그림을 통해서 어떤 모양인지 확인한다. ----------------- 예제 1 fig ------------------------------------- 예제 2 fig ----------------

1번 문제 풀이 코드

import sys
from collections import deque

# dfs 함수
def dfs(v):
    # 방문한 곳에 1을 삽입
    visited1[v] = 1
    print(v, end=' ')
    # 재귀 함수 선언
    for i in range(1, n + 1):
        if visited1[i] == 0 and matrix[v][i] == 1:
            dfs(i)

# bfs 함수
def bfs(v):
    # 방문할 곳을 넣을 덱
    deq = deque()
    deq.append(v)
    # 방문한 곳에 1을 삽입
    visited2[v] = 1
    # 덱 안에 데이터가 없어질때까지 반복문 실행
    while deq:
        v = deq.popleft()
        print(v, end=' ')
        for i in range(1, n + 1):
            if visited2[i] == 0 and matrix[v][i] == 1:
                deq.append(i)
                visited2[i] = 1

# n: 정점 갯수, m: 간선 갯수, v: 탐색을 시작할 정점 번호 입력 받기
n, m, v = map(int, sys.stdin.readline().rstrip().split())

# 배열은 0부터 시작하므로 n개의 수에 1을 더해 값들의 위치를 입력 받은 그대로 생각한다.
# n개의 숫자들 사이의 인접하는 0행렬을 생성
matrix = [[0] * (n + 1) for _ in range(n + 1)]
# 방문한 곳 확인을 위한 배열 생성
visited1 = [0] * (n + 1)
visited2 = [0] * (n + 1)

# 간선 갯수에 맞춰 두 개의 숫자들 입력 받기
for _ in range(m):
    a, b = map(int, sys.stdin.readline().rstrip().split())
    # 입력 받은 두 값의 위치 체크를 위해 위치에 맞게 1 삽입
    matrix[a][b] = matrix[b][a] = 1

dfs(v)
print()
bfs(v)

======================================================= 아직 많이 부족하다... dfs bfs를 잘 모르기 때문에 아예 개념부터 다시 공부해야 했다.. 이 파트는 특히 많은 문제를 풀어봐야 할 필요가 있다. 오늘은 여기까지.

1번 문제 풀이 코드

import sys

n, m = map(int, sys.stdin.readline().rstrip().split())
# 값들을 담아줄 리스트
list = []

def dfs():
    # 리스트의 길이가 m인 숫자들을 출력한다.
    if len(list) == m:
        # 리스트 값이 '1', '2' ... 이런 형식이므로 join을 이용해 1 2 형식으로 바꿔줌
        print(' '.join(map(str, list)))
        return

    # 1부터 n까지의 숫자들로 반복문 실행
    for i in range(1, n+1):
        # 리스트에 i값을 넣어주고
        list.append(i)
        # 리스트 안의 숫자들을 출력해줌
        dfs()
        # 출력된 값들은 제거한다.
        list.pop()

dfs()

=======================================================

2번 문제. https://www.acmicpc.net/problem/15652 -> N과 M(4)

2번 문제 풀이 코드

import sys

n, m = map(int, sys.stdin.readline().rstrip().split())
# 값들을 담아줄 리스트
list = []

# 시작 값의 변화를 통해 비내림순열을 만든다.
def dfs(start):
    # 리스트의 길이가 m인 숫자들을 출력한다.
    if len(list) == m:
        # 리스트 값이 '1', '2' ... 이런 형식이므로 join을 이용해 1 2 형식으로 바꿔줌
        print(' '.join(map(str, list)))
        return

    # start 값부터 n까지의 숫자들로 반복문 실행
    for i in range(start, n+1):
        # 리스트에 값 넣기
        list.append(i)
        # 함수에 숫자를 하나씩 올리면서 값을 출력
        dfs(i)
        # 출력된 값은 제거
        list.pop()

# 1부터 시작
dfs(1)

======================================================= 백트래킹을 사용해서 문제를 푸는건 정말 많이 헷갈린다... 되게 단순한 것도.ㅎ

step1

https://github.com/naver/d2codingfont 로 들어가서 다운 받고, 압축 풀어주세요. 요거 풀어주시고, D2CodingAll 파일 열어서 D2Coding-Ver1.3.2-20180524-all.ttc 더블 클릭 설치 눌러서 설치해줍니다.

step2

C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Administrative Tools 혹은 윈도우 검색에서 '레지스트리 편집기'를 관리자권한으로 실행해주세요

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Command Processor 이걸 이렇게 붙여넣어주세요. 그리고 빈 공간에 마우스 오른쪽 버튼 눌러서 새로 만들기 -> 문자열 값을 눌러줍니다. 그리고 이름은 AutoRun 이라 하고, 그 위에 커서를 두고 마우스 오른쪽 버튼을 눌러 수정해줍니다. 위의 사진처럼 값 데이터에 chcp 65001을 누르고 확인을 눌러줍니다.

step3

제어판 -> 시스템 -> 고급 시스템 설정

환경변수 -> Path -> 편집 -> 새로 만들기 -> C:\Program Files\MySQL\MySQL Server 8.0\bin 이걸 붙여주고 확인 누릅니다.

아래 시스템 변수 -> Path -> 편집 -> 새로 만들기 -> C:\Program Files\MySQL\MySQL Server 8.0\bin 이걸 붙여주고 확인 누릅니다.

step4

vscode로 들어가서 setting으로 가줍니다. (단축키 : ctrl+, ) Text Editor -> Font -> Font Family에서 D2Coding 하고 저장합니다.

Step5

터미널에서

mysqldump --set-gtid-purged=OFF -h "<본인의 엔드포인트주소>" -P 3306 -u <user name> -p <database name > <backup file name>.sql

하고 본인의 비밀번호를 눌러서 저장해줍니다.

Result

원래는 한글이 다 깨져서 쀍숋샳 이런 식의 형태였는데, 지금 보이는 것처럼 한글이 잘 나오고 문제 없이 저장 되었습니다!😆

이 외의 문제 발생

혹시 이 외에 다른 문제가 발생한다면 아래와 같은 명령어를 이용해서 접속해주세요! insert문 입력시 만약 한글이 깨진다면?

mysql -h "<본인의 엔드포인트 주소>" -P 3306 -u <user name> -p --default-character-set=utf8;

이유는 시스템 환경변수에서 path에서 없어서 생기는 일... 제어판 > 시스템 및 보안 > 시스템 C:\Program Files\MySQL\MySQL Server 8.0\bin 값을 넣어주고, cmd 다시 시작해서 원하는대로 명령어를 넣으면 된다.

1번 문제 풀이 코드

import sys
from itertools import permutations

# 순열을 이용하면 쉽게 해결할 수 있다.
n, m = map(int, sys.stdin.readline().rstrip().split())
nums = [i for i in range(1, n+1)]
for a in list(permutations(nums, m)):
    print(*a)

=======================================================

2번 문제. https://www.acmicpc.net/problem/15650 -> N과 M(2)

2번 문제 풀이 코드

import sys
from itertools import combinations

# 조합을 이용해서 풀면 쉽게 풀린다.
n, m = map(int, sys.stdin.readline().rstrip().split())
nums = [i for i in range(1, n+1)]
for a in list(combinations(nums, m)):
    print(*a)

======================================================= 이 문제가 알고리즘에서 백트래킹 문제이기도 하므로, 백트레킹을 이용해서 이 문제를 풀어보는것도 좋은 방법이다.

1번 문제 풀이 코드

import sys
import heapq

# 연산 갯수 입력
n = int(sys.stdin.readline().rstrip())
# 자연수들을 넣은 배열
num_list = []

for _ in range(n):
    # x 값을 하나씩 입력 받음
    x = int(sys.stdin.readline().rstrip())

    # 만약 x 값이 1보다 크거나 같다면(자연수)
    if x >= 1:
        heapq.heappush(num_list, -(x))
        print(num_list)
    # 그렇지 않고,
    else:
        # 자연수 배열이 1개 이상 존재할 때
        if len(num_list) >= 1:
            print(-1 * heapq.heappop(num_list))
        # 비어있을 때 0을 출력
        else:
            print(0)

=======================================================

2번 문제. https://www.acmicpc.net/problem/1927 -> 최소 힙

2번 문제 풀이 코드

import heapq
import sys

n = int(sys.stdin.readline().rstrip())
num_list = []

for _ in range(n):
    x = int(sys.stdin.readline().rstrip())

    if x >= 1:
        heapq.heappush(num_list, x)
    else:
        if len(num_list) >= 1:
            print(heapq.heappop(num_list))
        else:
            print(0)

=======================================================

3번 문제. https://www.acmicpc.net/problem/11286 -> 절댓값 힙

3번 문제 풀이 코드

import heapq
import sys

n = int(sys.stdin.readline().rstrip())
num_list = []

for _ in range(n):
    x = int(sys.stdin.readline().rstrip())

    if x != 0:
        heapq.heappush(num_list, (abs(x), x))
    else:
        if len(num_list) >= 1:
            print(heapq.heappop(num_list)[1])
        else:
            print(0)

======================================================= 오늘은 여기까지

1-1번 문제 풀이 코드 (메모리 초과)

import sys
from collections import deque

n = int(sys.stdin.readline())
nums = deque()

for _ in range(n):
    nums.append(deque(map(int, sys.stdin.readline().rstrip().split())))

list = []
for i in range(n):
    for j in range(n):
        list.append(nums[i][j])
list.sort(reverse=True)

print(list[n-1])

======================================================= 메모리 초과!!! 다른 블로그들을 찾아보니, 힙큐를 사용해서 푸는 것을 추천한다. 우선순위 큐과 힙

1-2번 문제 풀이 코드(정답)

import sys
import heapq

# nxn 보드 입력
n = int(sys.stdin.readline())
# 힙 숫자들의 리스트
num_list = []
for _ in range(n):
    # n번 숫자들을 입력 받음
    numbers = list(map(int, sys.stdin.readline().rstrip().split()))

    # 저장할 리스트에 값이 없으면
    if not num_list:
        # 입력 받은 숫자들을 하나씩
        for num in numbers:
            # num_list에 숫자(num)를 넣는다.
            # heappush를 이용해서 리스트에 최솟값부터 담긴다.
            heapq.heappush(num_list, num)
            # print(num_list)

    else:
        for num in numbers:
            # 만약 리스트 내에서 최솟값이 입력 받은 수보다 작으면
            if num_list[0] < num:
                # 입력 받은 수를 num_list에 넣어준다.
                heapq.heappush(num_list, num)
                # print(num_list)
                # 그리고 최솟값(num_list[0])을 하나씩 제거
                heapq.heappop(num_list)
                # print(num_list)
# print(num_list) -> 최솟값들을 하나씩 제거하고나면, num_list에는 가장 큰 수 n개가 순서대로 남아 있다.
print(num_list[0])

[12] [7, 12] [7, 12, 9] [7, 12, 9, 15] [5, 7, 9, 15, 12] 그 다음에 13이 온다. [5, 7, 9, 15, 12, 13] [7, 12, 9, 15, 13] 최솟값 5 제거 후 그 다음 최솟값이 앞에 채워짐 [7, 12, 8, 15, 13, 9] [8, 12, 9, 15, 13] [8, 12, 9, 15, 13, 11] [9, 12, 11, 15, 13] [9, 12, 11, 15, 13, 19] [11, 12, 19, 15, 13] [11, 12, 19, 15, 13, 21] [12, 13, 19, 15, 21] [12, 13, 19, 15, 21, 26] [13, 15, 19, 26, 21] [13, 15, 19, 26, 21, 31] [15, 21, 19, 26, 31] [15, 21, 16, 26, 31, 19] [16, 21, 19, 26, 31] [16, 21, 19, 26, 31, 48] [19, 21, 48, 26, 31] [19, 21, 28, 26, 31, 48] [21, 26, 28, 48, 31] [21, 26, 28, 48, 31, 35] [26, 31, 28, 48, 35] [26, 31, 28, 48, 35, 52] [28, 31, 52, 48, 35] [28, 31, 32, 48, 35, 52] [31, 35, 32, 48, 52] [31, 35, 32, 48, 52, 41] [32, 35, 41, 48, 52] [32, 35, 41, 48, 52, 49] [35, 48, 41, 49, 52]

======================================================= 힙큐 문제들을 몇 번 더 풀어봐야 할 듯 하다.

큐가 FIFO(First In, First Out)구조인 것을 안다. 우선순위 큐는 들어가는 순서와 관계없이 우선순위가 높은 데이터를 먼저 출력한다. 우선순위 큐는 힙 자료구조를 이용해서 구현한다.

힙(Heap)

• 힙(Heap)은 우선순위 큐를 위해 고안된 완전이진트리 형태의 자료구조이다.
• 이진탐색트리(BST)와 달리 중복된 값이 허용된다.
• 힙 종류

  최대힙 -> 부모노드 ≥ 자식노드 최소힙 -> 부모노드 ≤ 자식노드

** 빅오 표기법으로 나타낸 시간 복잡도 **

최대힙, 최소힙, 절댓값힙 문제 적용

* 참고 https://aerocode.net/193 * * 참고 https://suyeon96.tistory.com/31 *

1-1번 문제 풀이 코드 (틀림)

import sys

while True:
    sentence = sys.stdin.readline().rstrip()
    bracket = []
    true_flag = 1

    for i in sentence:
        if i == '(' or i == '[':
            bracket.append(i)
        elif i == ']':
            if len(bracket) != 0 and bracket[-1] == '[':
                bracket.pop()
            else:
                true_flag = 0
                break
        elif i == ')':
            if len(bracket) != 0 and bracket[-1] == '(':
                bracket.pop()
            else:
                true_flag = 0
                break

    if sentence == '.':
        break

    if true_flag == 1:
        print('yes')
    else:
        print('no')

=======================================================

1-2번 문제 풀이 코드(정답)

import sys

while True:
    # 문장들을 원하는 만큼 입력 받기
    sentence = sys.stdin.readline().rstrip()
    # 괄호를 체크할 리스트
    bracket = []
    # 맞으면 1, 틀리면 0
    true_flag = 1

    for i in sentence:
        # 만약 문장에서 '(' 이나 '['이 있으면 bracket리스트에 추가
        if i == '(' or i == '[':
            bracket.append(i)
        # 만약 ']' 가 보이면,
        elif i == ']':
            # bracket 리스트가 비어있지 않고, 여는 괄호가 ']'와 짝이 맞다면,
            if len(bracket) != 0 and bracket[-1] == '[':
                bracket.pop() # 맞는 것은 1, 그리고 결국엔 bracket안에 아무것도 남지 않음
            else:
                true_flag = 0 # 틀렸으면 0 그리고 멈춤
                break
        # 만약 ')' 가 보이면,
        elif i == ')':
            # bracket 리스트가 비어있지 않고, 여는 괄호가 ')'와 짝이 맞다면,
            if len(bracket) != 0 and bracket[-1] == '(':
                bracket.pop() # 맞는 것은 1, 그리고 결국엔 bracket안에 아무것도 남지 않음
            else:
                true_flag = 0 # 틀렸으면 0 그리고 멈춤
                break
    # 만약 '.'이면 종료한다.
    if sentence == '.':
        break

    # 만약 bracket 안에 아무것도 없고, true_flag가 1이면 yes 아니면 no 출력
    if true_flag == 1 and len(bracket) == 0:
        print('yes')
    else:
        print('no')

======================================================= 진짜 괜히 다른 곳에서 찾을게 아니라 조건을 어떻게 줬는지를 잘 생각해볼 것 오늘은 여기까지.

1번 문제 풀이 코드

import sys

# 테스트 케이스 입력
t = int(sys.stdin.readline())
# 이동 및 방향을 리스트에 담기
move = []
# 북서남동 -> 북(0, 1), 서(-1, 0), 남(0, -1), 동(1, 0)
dx = [0, -1, 0, 1]
dy = [1, 0, -1, 0]

# 이동 및 방향 하나씩 입력 받기
for _ in range(t):
    move.append(list(map(str, sys.stdin.readline().strip())))

# move 리스트에서 리스트 하나씩 꺼내기
for idx in move:
    # 각 리스트의 x, y값들을 초기화
    x, y = 0, 0
    # 최대, 최소 값을 초기화
    max_x, max_y = 0, 0
    min_x, min_y = 0, 0
    # 방향 지시를 위함 - > 북0, 서1, 남2, 동3
    direction = 0
    # 리스트를 하나씩 뜯어서 생각하기
    for i in idx:
        # 만약 리스트 값들 중에 "F"가 있다면, 방향 지시에 맞춰 1칸 앞으로 이동
        if i == "F":
            x += dx[direction]
            y += dy[direction]

        # 만약 리스트 값들 중에 "B"가 있다면, 방향 지시에 맞춰 1칸 뒤로 이동
        elif i == "B":
            x -= dx[direction]
            y -= dy[direction]

        # 만약 리스트 값들 중에 "L"이 있다면, 방향을 하나씩 더해줌
        # 내가 방향을 북서남동 즉, 반시계 방향으로 설정했기 때문
        elif i == "L":
            if direction == 3:
                direction = 0
            else:
                direction += 1

        # 만약 리스트 값들 중에 "R"이 있다면, 방향을 하나씩 빼줌
        # 오른쪽으로 계속 방향을 바꾸면 시계방향임
        elif i == "R":
            if direction == 3:
                direction = 0
            else:
                direction -= 1

        # x, y의 최소값, 최대값을 각각 구함
        min_x = min(min_x, x)
        min_y = min(min_y, y)
        max_x = max(max_x, x)
        max_y = max(max_y, y)

    # 두번째 for문에서 빠져나와서 계산
    # 최대값과 최소값의 차이가 (-)가 될 수 있기 때문에 절대값을 씌워줌
    print(abs(max_x - min_x) * abs(max_y - min_y))

======================================================= 오늘은 여기까지

1번 문제 풀이 코드

import sys

# nxn 보드 크기 입력
n = int(sys.stdin.readline())
# 사탕 집어넣을 리스트
candies = []
# 먹을 사탕 갯수 값 초기화
candy_cnt = 1

# 사탕 색별 리스트에 담기
for _ in range(n):
    candies.append(list(map(str, sys.stdin.readline())))

# 행의 사탕들 확인
def row_check():
    global candy_cnt
    # 2차원 리스트 안의 값을 하나하나 비교
    for i in range(n):
        row_count = 1 # 행 사탕 갯수 세기
        for j in range(n-1):
            # 행 값들을 비교
            if candies[i][j] == candies[i][j+1]:
                row_count += 1
                # 상근이가 먹을 사탕 갯수는 최대 갯수
                candy_cnt = max(row_count, candy_cnt)
            else:
                row_count = 1 # 이거 안하면 틀림.....

# 열의 사탕들 확인
def col_check():
    global candy_cnt
    # 2차원 리스트 안의 값을 하나하나 비교
    for i in range(n):
        col_count = 1 # 열 사탕 갯수 세기
        for j in range(n-1):
            # 열 값들을 비교
            if candies[j][i] == candies[j+1][i]:
                col_count += 1
                # 상근이가 먹을 사탕 갯수는 최대 갯수
                candy_cnt = max(col_count, candy_cnt)
            else:
                col_count = 1 # 이거 안하면 틀림.....

# 사탕 근접 위치 이동
for i in range(n):
    for j in range(n-1):
        # 만약 행 사이에서 근접 사탕 색이 다르다면
        if candies[i][j] != candies[i][j+1]:
            # 행 근접 위치 교환
            candies[i][j], candies[i][j+1] = candies[i][j + 1], candies[i][j]
            # 행 체크 -> 갯수 세고
            row_check()
            # 열 체크 -> 갯수 세고
            col_check()
            # 다시 제자리로 돌려놓음 -> 다시 안돌려놓으면 안됨!!
            candies[i][j+1], candies[i][j] = candies[i][j], candies[i][j+1]

        # 만약 열 사이에서 근접 사탕 색이 다르다면
        if candies[j][i] != candies[j+1][i]:
            # 행 근접 위치 교환
            candies[j][i], candies[j+1][i] = candies[j+1][i], candies[j][i]
            # 행 체크 -> 갯수 세고
            row_check()
            # 열 체크 -> 갯수 세고
            col_check()
            # 다시 제자리로 돌려놓음 -> 다시 안돌려놓으면 안됨!!
            candies[j+1][i], candies[j][i] = candies[j][i], candies[j+1][i]

print(candy_cnt)

======================================================= 6번 틀림.... 겨우 겨우 블로그들 보면서 내 문제 해결 이중 for문을 볼 때 순서를 잘 파악할 것!!

1번 문제 풀이 코드

import sys

# nxn 보드를 위해 입력
n = int(sys.stdin.readline())
# 보드 내에서 얻고자 하는 숫자
m = int(sys.stdin.readline())
# nxn 보드판 만들기
board = [[0 for _ in range(n)]for _ in range(n)]

# 방향전환용 
# 상우하좌
dr = [0, 1, 0, -1]
dc = [1, 0, -1, 0]

# 홀수 보드
row = n//2
col = n//2
# 시작 숫자
num = 1
# 이동할 길이
len = 0
# 보드 좌표에서의 숫자
board[row][col] = num

while True:
    # 방향에대한 for문
    for i in range(4):
        # 한칸씩 이동해서 숫자입력
        for _ in range(len):
            row += dr[i]
            col += dc[i]
            num += 1
            board[row][col] = num
            # 찾을 숫자의 인덱스 저장
            if num == m:
                result = [row+1, col+1]

    if row == 0 and y == 0:
        break
    row -= 1
    col -= 1
    len += 2

for i in range(n):
    print(*board[i])
print(*result)

======================================================= 1491번 나선 문제를 풀다가 이런 문제들이 달팽이 배열이라는 것을 깨달았다. 그래서 달팽이 문제들을 풀어보며 다음에 1491을 풀어보면 좋을 것 같아 1913번 문제를 풀게 되었다. 그러나.. 런타임 에러,,,,? 잘만 나오는데 뭐가 문제인지 ㅋ

1번 문제 풀이 코드

import sys
from collections import deque

# 괄호 입력
# 앞에서부터 빼주며 비교하기 위해
bracket = deque(sys.stdin.readline().strip())
# print(bracket)

# 괄호 안의 요소들을 하나씩 비교
def cal(start):
    # 값을 더해줄 변수 설정
    br_result = 0
    while bracket:
        # 괄호들에서 왼쪽부터 하나씩 빼서 반환할 변수
        # 하나씩 빼서 나열한 값들이 존재한다.
        after_pop = bracket.popleft()

        # 시작하는 괄호과 뺀 괄호가 각각 모두 존재한다면,
        if start == '(' and after_pop == ')':
            # 만약 둘 다 존재한다면, 1보다 큰 수일 것이고, 그 큰 수에 2를 곱한 값을 반환
            # 아니면 1 값을 최대값으로 반환하여 더하는 값을 2로 반환한다.
            br_result = 2 * max(1, br_result)
            return br_result
        elif start == '[' and after_pop == ']':
            br_result = 3 * max(1, br_result)
            return br_result
        # 만약 여는 괄호가 ( 거나 [ 둘 중에 하나면, 재귀함수를 통해 다시 함수를 돌린다.
        elif after_pop == '(' or after_pop == '[':
            br_result += cal(after_pop)
    # 잘못된 괄호일 경우에 0을 내보낸다.
    print(0)
    # 파이썬의 코드를 끝나는 즉시 중단
    sys.exit()

# 최종값을 더해줄 변수
result = 0
# 괄호가 존재하지 않을때까지 반복문을 돌려준다.
while bracket:
    # 최종값에 반환된 값들을 각각 더해준다.
    result += cal(bracket.popleft())

print(result)

======================================================= 처음에 잘 모르겠어서 다른 사람들의 코드들을 많이 참고했다. 대부분이 스택을 이용해서 풀었는데, 솔직히 너무 복잡해보여서 좀 보기 싫게 생겼다... 사실 자료구조에 많이 약하다.. 그래서 재귀 함수를 이용해서 푸는 방법들을 참고했다.

1-1번 문제 풀이 코드

import sys

# 후보자수 등록
n = int(sys.stdin.readline())
# 후보자별 득표수 입력
votes = []
# 매수할 인간수
count = 0

# 후보자가 다솜 혼자면 당연히 당선되므로
if n <= 1:
    print(0)
else:
    # 나머지 후보자들의 득표수
    for _ in range(n):
        votes.append(int(sys.stdin.readline().strip()))
    dasom = votes[0]
    while dasom <= max(votes):
        # 다솜이 아닌 최대득표수를 가지는 후보자의 인덱스 값을 확인
        max_others = votes.index(max(votes))
        # 그 인덱스의 후보자의 투표자를 한명씩 매수
        votes[max_others] -= 1
        dasom += 1
        count += 1
    print(count)

======================================================= 모든 예제 답은 나오는데, 틀렸다. 하지만, 3 99 1 1 을 입력하면 0이 나와야 하는데 1이 나와버린다. 즉, 다솜이도 max(votes)에 들어갈 수 있다는 이야기!

1-2번 문제 풀이 코드

import sys

# 후보자수 등록
n = int(sys.stdin.readline())
# 후보자별 득표수 입력
votes = []
# 매수할 인간수
count = 0

# 후보자가 다솜 혼자면 당연히 당선되므로
if n <= 1:
    print(0)
else:
    # 나머지 후보자들의 득표수
    for _ in range(n):
        votes.append(int(sys.stdin.readline().strip()))
    dasom = votes[0]
    while dasom <= max(votes):
        # 다솜이 아닌 최대득표수를 가지는 후보자의 인덱스 값을 확인
        # 다솜이를 제외하고 그 수에서 최대값을 구해야한다.
        max_others = votes.index(max(votes[1:]))
        # 그 인덱스의 후보자의 투표자를 한명씩 매수
        votes[max_others] -= 1
        dasom += 1
        count += 1
    print(count)

======================================================= 오늘은 여기까지

1-1번 문제 풀이 코드

import sys
# N x M 값 입력
n, m = map(int, sys.stdin.readline().split())
# 사각형 꼭짓점들의 값 입력
rect = [list(map(int, sys.stdin.readline().strip())) for _ in range(n)]
# N과 M 값에서 최솟값을 기준으로 정사각형이 최대가 될 수 있음
d = min(n, m)
# 정사각형의 최대값은 1부터 시작
max_size = 1

# i번째에서
for i in range(n):
    # j번째에서
    for j in range(m):
        # n, m 최솟값 중 최대 크기의 정사각형을 찾기 위해
        for k in range(d):
            # 만약 [i][j]번째의 값과 [i-k][j]번째 값과 
            #[i][j-k]번째 값과 [i-k][j-k]값이 같다면
            # 가장 큰 정사각형을 찾을 수 있다.
            if rect[i][j] == rect[i-k][j] == rect[i][j-k] == rect[i-k][j-k]:
                # k 값으로 생각했더니, 값이 전부 1씩 작게 나옴..
                max_size = max(max_size, (k+1)**2)

print(max_size)

======================================================= 답이... 나오는데 틀림

1-2번 문제 풀이 코드

import sys
# N x M 값 입력
n, m = map(int, sys.stdin.readline().split())
# 사각형 꼭짓점들의 값 입력
rect = [list(map(int, sys.stdin.readline().strip())) for _ in range(n)]
# N과 M 값에서 최솟값을 기준으로 정사각형이 최대가 될 수 있음
d = min(n, m)
# 정사각형의 최대값은 1부터 시작
max_size = 1

# i번째에서
for i in range(n):
    # j번째에서
    for j in range(m):
        # n, m 최솟값 중 최대 크기의 정사각형을 찾기 위해
        for k in range(d):
            # 만약 [i][j]번째의 값과 [i+k][j]번째 값과 
            #[i][j+k]번째 값과 [i+k][j+k]값이 같다면
            # 가장 큰 정사각형을 찾을 수 있다.
            if ((i + k) < n) and ((j + k) < m) and
            (rect[i][j] == rect[i][j + k] == rect[i + k][j] == rect[i + k][j + k]):
                # k 값으로 생각했더니, 값이 전부 1씩 작게 나옴..
                max_size = max(max_size, (k+1)**2)

print(max_size)

======================================================= 그냥 변경했더니... 된다..... 이유는 다음에 찾는걸로 오늘은 여기까지