• arr이란 리스트에 2차원배열로 회의 시작시간과 끝나는시간을 저장해 준 다음 회의가 끝나는 시간을 오름차순으로 정렬하였고, 만약 끝나는 시간이 같다면 시작시간을 오름차순으로 정렬하였다.

arr = []
now,cnt = 0,0 # now (현재 시간) , cnt (회의 
N = int(input())

for i in range(N):
    st,ed = map(int,input().split())
    arr.append([st,ed]) # 2차원 배열에 시작,끝나는 시간 저장

arr = sorted(arr, key=lambda x: (x[1], x[0])) # 인덱스1을 기준으로 오름차순 정렬
						# 만약 인덱스1 의 값이 같다면 인덱스 0값을 기준으로 오름차순 정렬

for i in range(N):
    if now <= arr[i][0]: # 현재시간이 시작시간과 같거나 적으면
        now = arr[i][1] # 현재시간을 회의가 끝나는 시간으로 변경
        cnt += 1
print(cnt)

• 중복되지않는 수열을 구하기 위해 used배열을 이용했고
• 1,2와 2,1 같은 순서가 다른 중복된 값을 뽑지 않기 위해 for문 시작배열을 설정해주었다.

N,M = map(int,input().split())
used = [0] * (N+1)
path = [0] * M

def dfs(st,level):

    if level == M: 
        print(*path,end =' ')
        print()
        return

    for i in range(st,N+1):
        if used[i] == 0:
            used[i] = 1
            path[level] = i
            dfs(i+1,level+1)
            used[i] = 0

dfs(1,0)

• 중복 순열을 구하기위해 dfs를 이용하여 구현하였다

N,M = map(int,input().split())

path = [''] * M

def dfs(level):

    if level == M: # dfs의 level이 M이 된다면 path에 저장된값을 출력하고 return
        print(*path)
        return

    for i in range(1,N+1):
        path[level] = i
        dfs(level+1)

dfs(0)

import sys
input = sys.stdin.readline # 시간초과를 방지하기 위한 코드

N = int(input())
stack = []
for i in range(N):
    tmp = int(input())
    if tmp == 0: # 0이 입력된다면 stack의 마지막부분을 제거
        stack.pop()
    else:
        stack.append(tmp)

print(sum(stack)) # for문이 끝나면 남아있는 stack의 합을 구함

• push를 구현하기위해 append를 사용했고
• pop을 구현하기위해선 pop함수,
• size와 empty를 구현하기위해서는 len함수를 사용했다.
• 예외 사항들은 try, except 구문을 이용해 구현하였다

import sys
input = sys.stdin.readline # 시간단축을 위한 코드

N = int(input())
stack = []

for i in range(N):
    command = list(input().split())
    if command[0] == 'push':
        stack.append(command[1])
        
    elif command[0] == 'pop':
        try:
            print(stack.pop())
        except:
            print('-1')
            
    elif command[0] == 'size':
        print(len(stack))
        
    elif command[0] == 'empty':
        if len(stack):
            print('0')
        else:
            print('1')
            
    elif command[0] == 'top':
        try:
            print(stack[-1])
        except:
            print('-1')

• dfs를 이용한 중복순열로 해결하였다.

TC = int(input())

for tc in range(1,TC+1):
    N = int(input())
    cnt = 0
    
    def dfs(level):
        global cnt
        if level > N: # level의 값이 목표값을 넘어가면 리턴
            return

        if level == N: # 목표값이 되었을 때, cnt + 1
            cnt += 1
            return

        for i in range(1,4): # 1~3 까지의 수의 중복순열 구하기
            dfs(level+i)

    dfs(0)
    print(cnt)

• 수열을 구하기 위해 dfs를 사용하였다
• 중복수열이 아니기 때문에 중복값이 나오지 않도록 used를 사용하여 방문체크를 했다

N,M = map(int,input().split())
path = [''] * M
used = [0] * N
def dfs(level):

    if level == M:
        for i in range(M):
            print(path[i], end = ' ')
        print()
        return

    for j in range(N):
        if used[j] == 0: # 사용하지 않은 수라면
            used[j] = 1
            path[level] = j+1 # path에 값 저장
            dfs(level+1)
            used[j] = 0

dfs(0)

• BFS를 이용하여 풀었다.

import copy
from collections import deque

N = int(input())

arr = [list(map(int,input().split())) for _ in range(N)]
acc = copy.deepcopy(arr)
directy = [-1,1,0,0]
directx = [0,0,-1,1]
result = []

def bfs(y,x): # 인접해있는 지역을 모두 False로 바꿈
    q = deque([(y,x)])
    arr[y][x] = False

    while q:
        y,x = q.popleft()

        for k in range(4):
            dy = directy[k] + y
            dx = directx[k] + x

            if dy >= N or dy < 0 or dx >= N or dx < 0: # 배열을 벗어난다면 continue
                continue
            if arr[dy][dx] != False: # 목표좌표가 False이 아니라면 False로 바꿔줌
                arr[dy][dx] = False
                q.append([dy,dx])


for l in range(101): # 높이가 최대 100이므로 100까지 증가하는 for 문
    arr = copy.deepcopy(acc) # for문을 돌 때마다 arr배열과 cnt(안전영역) 초기화
    cnt = 0

    for j in range(N):
        for i in range(N):
            if arr[j][i] <= l: # 비의 양보다 낮으면 해당 좌표를 False로 만들어줌
                arr[j][i] = False

    for j in range(N):
        for i in range(N):
            if arr[j][i] != False: # False이 아니라면 bfs 함수 호출하고 cnt += 1
                bfs(j,i) 
                cnt += 1

    result.append(cnt) # 안전영역을 result에 추가

    if cnt == 0: # 모든지역이 물에 잠긴다면 그 이후는 의미 없으므로 break
        break

print(max(result))

• BFS를 이용하여 풀었다.

from collections import deque
TC = int(input())

for tc in range(TC):
    N = int(input())
    used = [[0]*N for _ in range(N)] # 방문체크를 위한 used 배열
    arr = [[-1]*N for _ in range(N)]
    y,x = map(int,input().split()) 
    used[y][x] = 1
    arr[y][x] = 0 # 시작위치는 0부터 시작
    q = deque([(y,x)])
    j,i = map(int,input().split())
    arr[j][i] = 'ed' 
    directy = [-1,-2,-2,-1,1,2,2,1]
    directx = [-2,-1,1,2,-2,-1,1,2]
    result = 0

    def bfs():
        global result,q
        while q:
            y,x = q.popleft()

            for k in range(8):

                dy = directy[k] + y
                dx = directx[k] + x

                if dy >= N or dy < 0 or dx >= N or dx < 0: # 배열을 벗어나면 continue
                    continue
                if arr[dy][dx] == 'ed': # 도착점에 도착하면 result에 값 저장하고 종료
                    result = arr[y][x] + 1
                    q=[]
                    break
                if used[dy][dx] == 0: # 방문하지 않은곳만 방문
                    used[dy][dx] = 1
                    arr[dy][dx] = arr[y][x] + 1
                    q.append([dy,dx])


    if j == y and i == x: # 시작점과 도착점이 같다면 0출력
        print("0")
    else:
        bfs()
        print(result)

• BFS를 이용하여 풀었다.
• 물이 차있는 지역이 없을 수 도있고 여러개인 경우를 고려하지 못해서 처음엔 런타임에러가 떴다.
• 도착점을 제외하고는 고슴도치는 물이 찰 예정인 칸으로 갈 수 없으므로 목표좌표에 고슴도치부터 이동시키고 물과 고슴도치가 만난다면 물로 표시했다

from collections import deque

N,M = map(int,input().split())
arr = [list(input()) for _ in range(N)]
used = [[0] * M for _ in range(N)] # 물의 방문체크
used2 = [[0] * M for _ in range(N)] # 고슴도치의 방문체크
directy = [-1,1,0,0]
directx = [0,0,-1,1]
q = deque()
tmp1,tmp2 = [],[]
result,flag = 0,0
for j in range(N):
    for i in range(M):
        if arr[j][i] == 'S':
            tmp1 = [j,i,'S'] # 고슴도치의 위치
            arr[j][i] = 0
            used2[j][i] = 1
        if arr[j][i] == '*': # 물이 있는 좌표를 tmp2에 저장
            tmp2.append([j,i,'*'])
            used[j][i] = 1
            flag += 1
        if arr[j][i] == 'D':
            used[j][i] = 1 # 도착점에는 물이 도착할 수 없도록 used에 방문체크

q.append(tmp1) # 고슴도치부터 q에 추가
for i in range(flag):
    q.append(tmp2[i])

def bfs():
    global result,q

    while q:
        y,x,s = q.popleft()

        # for i in range(N):
        #     print(*arr[i])
        # print(result, q)
        for k in range(4):

            dy = directy[k] + y
            dx = directx[k] + x
            if dy >= N or dy < 0 or dx >= M or dx < 0 or arr[dy][dx] == 'X': # 배열을 벗어나거나 벽이라면 continue
                continue
            if s == 'S': # 고슴도치
                if arr[dy][dx] == 'D' and used[y][x] == 0: # 목적지에 도착했다면 result에 이동거리 저장
                    result = arr[y][x] + 1
                    q = []
                    break
                if used2[dy][dx] == 0 and used[dy][dx] == 0 and used[y][x] == 0: # 고슴도치가 방문하지 않았고, 목표지점과 현재위치가 물이 없다면 이동
                    used2[dy][dx] = 1
                    arr[dy][dx] = arr[y][x] + 1
                    q.append([dy,dx,'S'])
            if s == '*': # 물
                if used[dy][dx] == 0: # 방문안한곳 방문
                    used[dy][dx] = 1
                    arr[dy][dx] = '*'
                    q.append([dy,dx,'*'])

bfs()

if result == 0: # 도착하지못하면 KAKTUS 출력
    print("KAKTUS")
else:
    print(result)

• BFS를 3차원배열을 이용하여 풀었다

from collections import deque

M,N,H = map(int,input().split())
tomato = []
q = deque()
directy = [-1,1,0,0,0,0]
directx = [0,0,1,-1,0,0]
directk = [0,0,0,0,-1,1]
mmax,flag = 0,0
used = [[[0] * M for _ in range(N)] for _ in range(H)] # 방문체크

for j in range(H): # tomato라는 변수에 3차원 정보 저장
    arr = []
    for i in range(N):
        tmp = list(map(int,input().split()))
        arr.append(tmp)
    tomato.append(arr)

for k in range(H): # 완전탐색을 통해 초기 토마토 위치를 q에 저장
    for j in range(N):
        for i in range(M):
            if tomato[k][j][i] == 1:
                used[k][j][i] = 1
                q.append([k,j,i])

def bfs():
    global mmax,cnt

    while q:
        k,y,x = q.popleft()

        for l in range(6):
            dy = directy[l] + y
            dx = directx[l] + x
            dk = directk[l] + k

            if dy >= N or dy < 0 or dx >= M or dx < 0 or dk >= H or dk < 0: # 배열 벗어나면 continue
                continue
            if tomato[dk][dy][dx] == -1: # 토마토가 없는 곳이라면 continue
                continue
            if used[dk][dy][dx] == 0: # 방문하지 않았던 곳이라면
                used[dk][dy][dx] = 1 # 방문 체크 하고
                tomato[dk][dy][dx] = tomato[k][y][x] + 1
                if mmax < tomato[dk][dy][dx]:
                    mmax = tomato[dk][dy][dx]
                q.append([dk,dy,dx]) # q에 추가


bfs()

for k in range(H): # bfs를 호출하고 난 후 다시 완전탐색으로 안익은 토마토 확인
    for j in range(N):
        for i in range(M):
            if tomato[k][j][i] == 0: 
                flag = 1

if flag: # 안익은 토마토가 있다면 
    print(-1)
else:
    if mmax == 0: # 처음부터 익은 토마토 밖에 없는 경우
        print(0)
    else:
        print(mmax-1)

import copy

N,M = map(int,input().split())
arr = [-1] * 101
tmp = [-1] * 101
acc = [False] * 101
arr[1] = 0
cnt = 0

for _ in range(N+M):
    a,b = map(int,input().split())
    acc[a] = b # acc배열에 도착하면 (사다리 or 뱀) 이동할 위치 저장

while True:
    if arr[100] != -1: # 목적지에 도착하면 cnt 출력
        print(cnt)
        break

    cnt += 1

    for j in range(101):
        if arr[j] == cnt-1:
            for i in range(1,7):
                if j+i > 100: # 배열을 벗어나면 break
                    break
                if acc[j+i] == False:
                    tmp[j+i] = cnt
                else:
                    tmp[acc[j+i]] = cnt

    arr = copy.deepcopy(tmp)
    tmp = [-1] * 101

• 출발점이 정해져 있어, 정점간의 최소합을 구하기 위해 다익스트라를 이용하였다.

import heapq,sys
input = sys.stdin.readline # 시간초과를 방지하기위한 코드
V,M = map(int,input().split())
start = int(input())

arr =[[]*V for _ in range(V)]

for i in range(M):
    a,b,c = map(int,input().split())

    arr[a-1].append((b-1,c))

result = [float('INF')] * V
heap = []

def dijkstra(start):
    heapq.heappush(heap,(0,start))
    result[start] = 0

    while heap:
        sk, k = heapq.heappop(heap)
        result[start] = 0

        if result[k] < sk:
            continue

        for i in arr[k]:
            cost = sk + i[1]
            if cost < result[i[0]]:
                result[i[0]] = cost
                heapq.heappush(heap,(cost,i[0]))

dijkstra(start-1)
for i in range(len(result)):
    if result[i] == float('inf'):
        print('INF')
    else:
        print(result[i])

• 출발점이 정해져있어, 다익스트라를 이용하면 각 정점에 대한 최소값을 쉽게 구할 수 있기 때문에 다익스트라를 이용해 풀었다.

import heapq,sys
input = sys.stdin.readline # 시간초과를 방지하기 위한 코드
V = int(input())
M = int(input())

arr =[[]*V for _ in range(V)]

for i in range(M):
    a,b,c = map(int,input().split())

    arr[a - 1].append((b - 1, c))
start,end = map(int,input().split())

result = [float('INF')] * V
heap = []

def dijkstra(start):
    heapq.heappush(heap,(0,start))
    result[start] = 0

    while heap:
        sk, k = heapq.heappop(heap)
        result[start] = 0

        if result[k] < sk:
            continue

        for i in arr[k]:
            cost = sk + i[1]
            if cost < result[i[0]]:
                result[i[0]] = cost
                heapq.heappush(heap,(cost,i[0]))

dijkstra(start-1)
print(result[end-1])

• BFS를 이용하여 풀었다.

from collections import deque

N,M = map(int,input().split())
used = [21e8] * 100001
result = []
def bfs(N,cnt):
    q = deque([(N,cnt)])

    while q:
        N,cnt = q.popleft()
        if 0 <= N < 100001:
            if cnt < used[N]: # used배열에 도착했을때 cnt의 최소값만 갱신
                used[N] = cnt 
            else:
                continue

            q.append([N-1,cnt+1])
            q.append([N+1,cnt+1])
            q.append([N*2,cnt])

bfs(N,0)
print(used[M]) # used 배열에는 시작점으로부터 각 1~100,000까지의 위치에 도착했을 때 
# 가장 시간이 적게 소요된 값만 있으므로 동생의 인덱스값을 출력해주면 된다.