esssun.log

[프로그래머스] 쿼드 압축 후 개수 세기 (파이썬)

_은선_ — Sun, 12 Jul 2026 16:19:12 +0900

분할 정복 문제

https://school.programmers.co.kr/learn/courses/30/lessons/68936

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

풀이코드 (성공)

def solution(arr):
    # answer[0]은 0의 개수, answer[1]은 1의 개수
    answer = [0, 0]
    
    def solve(size, r, c):
        # 1. 현재 영역이 모두 같은 숫자인지 체크
        first_val = arr[r][c]
        is_same = True
        
        for i in range(r, r + size):
            for j in range(c, c + size):
                if arr[i][j] != first_val:
                    is_same = False
                    break
            if not is_same:
                break
        
        # 2. 모두 같은 숫자라면 압축 가능! 해당 숫자 카운트를 1 증가시키고 종료
        if is_same:
            answer[first_val] += 1
            return
        
        # 3. 다른 숫자가 섞여 있다면 4분할하여 재귀 호출
        half = size // 2
        solve(half, r, c)                  # 왼쪽 위
        solve(half, r, c + half)           # 오른쪽 위
        solve(half, r + half, c)           # 왼쪽 아래
        solve(half, r + half, c + half)    # 오른쪽 아래

    # 전체 배열 크기부터 시작
    solve(len(arr), 0, 0)
    
    return answer

[백준] 17090 : 미로 탈출하기 (파이썬)

_은선_ — Sun, 19 Apr 2026 18:31:05 +0900

Memorization 문제

https://www.acmicpc.net/problem/17090

17090번: 미로 탈출하기

크기가 N×M인 미로가 있고, 미로는 크기가 1×1인 칸으로 나누어져 있다. 미로의 각 칸에는 문자가 하나 적혀있는데, 적혀있는 문자에 따라서 다른 칸으로 이동할 수 있다. 어떤 칸(r, c)에 적힌 문

www.acmicpc.net

풀이코드 (성공)

import sys
sys.setrecursionlimit(10**6)

r, c = map(int, sys.stdin.readline().split())
graph = [list(sys.stdin.readline().strip()) for _ in range(r)]

# -1: 아직 방문 안 함
# 0: 탈출 불가
# 1: 탈출 가능
memo = [[-1] * c for _ in range(r)]
visited = [[False] * c for _ in range(r)]  # 현재 dfs 경로에서 방문 중인지 체크

def dfs(y, x):
    # 격자 밖으로 나가면 탈출 성공
    if not (0 <= y < r and 0 <= x < c):
        return 1

    # 이미 결과를 구한 칸이면 그대로 반환
    if memo[y][x] != -1:
        return memo[y][x]

    # 현재 탐색 경로에서 다시 만났다면 사이클 → 탈출 불가
    if visited[y][x]: # 방향 그래프에서 사이클 처리
        return 0

    visited[y][x] = True

    if graph[y][x] == 'D':
        ny, nx = y + 1, x
    elif graph[y][x] == 'U':
        ny, nx = y - 1, x
    elif graph[y][x] == 'L':
        ny, nx = y, x - 1
    else:  # 'R'
        ny, nx = y, x + 1

    memo[y][x] = dfs(ny, nx)
    visited[y][x] = False # 한번 방문한 노드라도 해당 재귀가 끝나면 재방문 가능해야함
    return memo[y][x]

answer = 0
for i in range(r):
    for j in range(c):
        answer += dfs(i, j)

print(answer)

[백준] 3055 : 탈출 (파이썬)

_은선_ — Sun, 5 Apr 2026 19:18:22 +0900

BFS 문제

https://www.acmicpc.net/problem/3055

풀이코드 (성공 - BFS)

'''
.: 비어있는곳 (물 O, 고슴도치 O)
*: 물 (물 O, 고슴도치 X)
X: 돌 (물 X, 고슴도치 X)
D: 비버의 굴 (물 X, 고슴도치 O)
S: 고슴도치 위치 (물 O, 고슴도치 O)
'''

# 9:30 ~
import sys 
from collections import deque
r, c = map(int, sys.stdin.readline().split())
visited = [[False] * c for _ in range(r)]
visitedW = [[False] * c for _ in range(r)]
graph = []
S = None # 2) 좌표 사용 시 튜플 처음 선언
D = None
water = deque()

dy = [0, 1, 0, -1]
dx = [1, 0, -1, 0]

for i in range(r):
    l = list(map(str, sys.stdin.readline().strip())) # 1) split: 공백기준 / strip: 문자열 양쪽 공백 제거
    for j, s in enumerate(l):
        if s == 'S':
            S = (i, j)
        elif s == 'D':
            D = (i, j)
        elif s == '*':
            water.append((i, j))
    graph.append(l)


def water_spread():
    global water
    size = len(water)

    for i in range(size):
        wy, wx = water.popleft()

        for j in range(4):
            ny = wy + dy[j]
            nx = wx + dx[j]

            if 0 <= ny < r and 0 <= nx < c:
                if visitedW[ny][nx] == False:
                    visitedW[ny][nx] = True

                    if graph[ny][nx] == ".":
                        water.append((ny, nx))
                        graph[ny][nx] = "*"     
        
def bfs():
    global r, c, S

    is_possible = False
    queue = deque()
    cnt = 1
    queue.append((S[0], S[1], cnt))
    last = 0
    while queue:
        y, x, cnt = queue.popleft()

        if last != cnt:
            last = cnt
            water_spread() # 물 먼저 확장

        for i in range(4):
            ny = y + dy[i]
            nx = x + dx[i]
    
            if 0 <= ny < r and 0 <= nx < c:
                if visited[ny][nx] == False:
                    visited[ny][nx] = True
                    if graph[ny][nx] == ".":
                        queue.append((ny, nx, cnt + 1))
                    elif graph[ny][nx] == "D":
                        is_possible = True
                        print(cnt)

    if is_possible == False:
        print("KAKTUS")
        return
        

bfs()

주요 로직

1. 물을 먼저 상, 하, 좌, 우로 확장시키기

이때, for문을 현재 queue의 크기만큼 돈다. (현재 시간에 존재하는 물의 갯수만큼)

만약 다음에 이동할 칸이 빈칸이라면 graph의 칸이 물임을 기록해준다.

2. 고슴도치 이동시키기

만약 다음에 이동할 칸이 빈칸이라면 고슴도치를 이동시킨다.

만약 다음에 이동할 칸이 물이라면 리턴시키는 코드는 작성할 필요가 없다.

만약 현재 분에 고슴도치가 상, 하, 좌, 우로 이동시키려는 칸이 전부 물이라면 리턴시키는 코드는 작성할 필요가 없다.
어차피, queue에 좌표를 못넣으므로 while queue:문이 종료될 것이기 때문이다.

또한, 매분마다 물처럼 고슴도치의 좌표를 graph에 기록하며 이동시킬 필요도 없다. (pop, add 등으로)

이때, 물을 확장시키는 함수를 매번 호출하지 않고, 분이 지났으면 확장시킨다.

즉, cnt을 통해 현재 분을 판단한 후 물을 확장시키는 함수는 매 분마다 한번만 호출한다.

[백준] 1593 : 문자 해독 (파이썬)

_은선_ — Sun, 23 Nov 2025 18:51:33 +0900

슬라이딩 윈도우 문제

https://www.acmicpc.net/problem/1593

풀이코드 (성공 - 슬라이딩 윈도우)

import sys

lenW, lenS = map(int, sys.stdin.readline().split())
w = list(str(sys.stdin.readline().strip()))
s = str(sys.stdin.readline().strip())

wl = [0] * 58
sl = [0] * 58

answer = 0

for i in w:
    wl[ord(i)-65] += 1


def solution():
    global answer 
    length = 0

    for i in range(lenS):
        sl[ord(s[i])-65] += 1
        length += 1

        if length == lenW:
            if wl == sl:
                answer += 1

            length -= 1
            sl[ord(s[i+1-lenW])-65] -= 1


solution()
print(answer)

[프로그래머스] Level2 : 주차 요금 계산 (파이썬, C++)

_은선_ — Sun, 19 Oct 2025 20:37:18 +0900

구현, 해시 문제

https://school.programmers.co.kr/learn/courses/30/lessons/92341

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

풀이코드 (성공 - Python)

import heapq
import math

def solution(fees, records):
    answer = []
    
    # 기본시간(분), 기본요금(원), 단위시간(분), 단위요금(원)
    
    bTime = fees[0]
    bFee = fees[1]
    pTime = fees[2]
    pFee = fees[3]
    
    dic = {}
    
    for str in records:
        arr = str.split(' ')
        time = arr[0].split(':')
        time = int(time[0]) * 60 + int(time[1])
        
        if arr[1] not in dic:
            dic[arr[1]] = [time, 0]
        else:
            if arr[2] == "IN":
                dic[arr[1]][0] = time
            else:
                dic[arr[1]][1] += (time - dic[arr[1]][0])
                dic[arr[1]][0] = -1
    print(dic)
    
    heap = []
    for k, (enter, time) in dic.items():
        if enter != -1:
            time = (60 * 23) + 59
            dic[k][1] += (time - dic[k][0])
            dic[k][0] = -1
            
        if dic[k][1] < bTime:
            heapq.heappush(heap, (k, bFee))
        else:
            tmp = 0
            dic[k][1] -= bTime
            tmp += bFee
            tmp += math.ceil(dic[k][1] / pTime) * pFee
            
            heapq.heappush(heap, (k, tmp))
    print(heap)
    
    while heap:
        car, fee = heapq.heappop(heap)
        answer.append(fee)
            
    return answer

풀이코드 (성공 - C++)

#include <cmath>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <tuple>
#include <map>

using namespace std;

vector<int> solution(vector<int> fees, vector<string> records) {
    vector<int> answer;
    map<string, pair<int,int>> dic;
    
    
    for (auto &s : records){
        stringstream ss(s);
        string token;
        vector<string> result;
        
        string time;
        int minute;
        string car;
        string inout;
        
        
        while (getline(ss, token, ' ')) // stringstream ss을 이용해 : 기준으로 split해 token에 저장
        {
            result.push_back(token);
        }
        
        time = result[0];
        car = result[1];
        inout = result[2];
        
        minute = stoi(time.substr(0, 2)) * 60 + stoi(time.substr(3, 2));
        
        // cout << minute <<" " << car << " " << inout;
        
        
        if (dic.find(car) != dic.end()){
            if(inout == "IN")
            {
                dic[car].first = minute;
            }
            else{
                dic[car].second += (minute - dic[car].first);
                dic[car].first = -1;
            }
        }
        else{
            dic[car] = {minute, 0};
        }        
        
    }
    
    
    priority_queue<pair<string, int>, vector<pair<string, int>>, greater<pair<string, int>>> heap;


    for (auto &d : dic) {
        if (d.second.first != -1){
            d.second.second += (23 * 60 + 59) - d.second.first;
            d.second.first = -1;
        }
        
        int tmp = 0;
        cout << d.first << " " << d.second.first << " " << d.second.second << endl;
        if (d.second.second <= fees[0]){
            heap.push({d.first, fees[1]});
        } 
        else{
            d.second.second -= fees[0];
            tmp = fees[1];
            
            tmp += (ceil((double)d.second.second / fees[2])) * fees[3]; // double로 캐스팅한 후 계산
            heap.push({d.first, tmp});
        }
    }
    
   while (heap.empty() == false){
       auto [c, sums] = heap.top();
       heap.pop();
       
       answer.push_back(sums);
      
   }
    
    for (auto& a : answer){
        cout << a << endl;
    }
        
    return answer;
}

[프로그래머스] Level3 : 섬 연결하기 (파이썬)

_은선_ — Sun, 19 Oct 2025 02:06:56 +0900

MST 문제

https://school.programmers.co.kr/learn/courses/30/lessons/42861

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

풀이코드 (성공 - MST Kruskal)

def solution(n, costs):
    answer = []
    graph = []
    ans = 0
    
    for n1, n2, w in costs:
        graph.append((w, n1, n2))
    parent = [0] * (n + 1)
    
    def init():
        for i in range(1, n + 1):
            parent[i] = i
    
    def find(i):
        while parent[i] != i:
            parent[i] = parent[parent[i]]
            i = parent[i]
        return i
    
    def merge(i, j):
        ii = find(i)
        jj = find(j)
        
        if ii != jj:
            parent[ii] = jj
    
    graph.sort()
    
    init()
    for w, u, v in graph:
        p = find(u)
        q = find(v)
        
        if find(p) != find(q):
            merge(p, q)
            answer.append(w)
    
    ans = sum(answer[:n-1]) # 노드의 갯수 : n-1
    print(answer)
    print(ans)
    
    
    return ans

풀이코드 (성공 - MST Prim)

import heapq

def solution(n, costs):
    answer = 0
    
    graph = [[] for _ in range(n)]
    
    for u, v, w in costs:
        graph[u].append((v, w))
        graph[v].append((u, w))
    
    visited = [False] * n
    print(visited)
    heap = []
    heapq.heappush(heap, (0, 0))
    ans = []
    
    while heap:
        w, u = heapq.heappop(heap)
        
        if visited[u] == False:
            visited[u] = True
            ans.append(w)
        
            for i, weight in graph[u]:
                if visited[i] == False:
                    heapq.heappush(heap, (weight, i))
    answer=  sum(ans)
        
        
        
    
    
    return answer

[프로그래머스] Level3 : 양과 늑대(파이썬)

_은선_ — Sun, 19 Oct 2025 00:41:50 +0900

백트래킹 문제

https://school.programmers.co.kr/learn/courses/30/lessons/92343

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

풀이코드1(Python 성공-DFS)

양방향 그래프일 필요 X

단방향 그래프를 통하여, 재귀호출을 구현할 수 있는 방법을 찾을 필요가 존재합니다.
바로 그 답은, 다음 차례에 이동 가능한 정점을 따로 담아서 재귀호출을 하는 것입니다.

def dfs(idx, sheep, wolf, possible):
    global g_info, answer, graph
    print(idx, possible, sheep)
    
    if g_info[idx] == 0:
        sheep += 1
        answer = max(answer, sheep)
    else:
        wolf += 1
    if wolf >= sheep:
        return 
    
    possible.extend(graph[idx])
    for p in possible:
        dfs(p, sheep, wolf, [i for i in possible if i != p])

def solution(info, edges):
    global answer, g_info, visited, graph
    answer = 0
    g_info = info
    n = len(info)
    graph = [[] for _ in range(n)]
    
    for a, b in edges:
        graph[a].append(b)
    
    dfs(0, 0, 0, [])
    return answer

풀이코드2(Python 성공-DFS)

def solution(info, edges):
    answer = []
    visited = [False] * len(info)
    
    
    def dfs(sheeps, wolves):
        if sheeps > wolves:
            answer.append(sheeps)
        else:
            return
        
        for p, c in edges:
            # 부모는 방문하였지만 자식은 방문 안한 경우만 진행
            if visited[p] and not visited[c]:
                visited[c] = True
                if info[c] == 0:
                    dfs(sheeps + 1, wolves)
                else:
                    dfs(sheeps, wolves + 1)
                # 만약 다른 곳을 들렸다 방문 시 조건에 충족할 수 있어 false 처리
                visited[c] = False
                
    visited[0] = True
    dfs(1, 0)
    
    return max(answer)

풀이코드(Python 실패-DFS)

def solution(info, edges):
    global sheep, wolf
    answer = 0
    graph = [[] for _ in range(len(info))]
    
    for a,b in edges:
        graph[a].append(b)
        
    
    sheep = 1
    wolf = 0
    def dfs(n, s, w):
        global sheep, wolf
        
        visited[n] = True
        
        if all(visited) or 0 not in info:
            return
        
        for i in graph[n]:
            if info[i] == 0:
                
                if sheep + 1 > w:
                    info[i] = 2 # 데려옴
                    sheep += 1
                    wolf = w
                    dfs(i, s+1, w)
            
            elif info[i] == 2:
                if sheep > w:
                    dfs(i, s, w)
            else:
                if sheep > w + 1:
                    dfs(i, s, w+1)
        return w
                    


    visited = [False for _ in range(len(info))]
    
    while True:
        if all(visited) or 0 not in info:
            break
        
        dfs(0, sheep, wolf)
    
    dfs(0, 1, 0)
    answer = sheep
        
    return answer

https://school.programmers.co.kr/questions/25736?question=25736

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

https://tight-sleep.tistory.com/34

[프로그래머스] 양과 늑대 - python

문제 링크: https://school.programmers.co.kr/learn/courses/30/lessons/92343 프로그래머스 코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁

tight-sleep.tistory.com

https://talktato.tistory.com/62

[programmers] 양과 늑대 (python)

https://school.programmers.co.kr/learn/courses/30/lessons/92343 프로그래머스코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는

talktato.tistory.com

[백준] 1987 : 알파벳 (파이썬)

_은선_ — Sat, 11 Oct 2025 23:40:14 +0900

그리디, 백트래킹 문제

https://www.acmicpc.net/problem/1987

접근 방식

백트래킹

풀이코드 (Pypy3 성공 - DFS)

import sys 
r, c = map(int, sys.stdin.readline().split())
graph = []
dy = [1, 0, -1, 0]
dx = [0, 1, 0, -1]
visited= [[False] * c for _ in range(r)]
ans = 0
alpha = set()

# print(visited)

for _ in range(r):
    l = list(map(str, sys.stdin.readline().strip())) # 문자열 하나하나씩 저장
    alpha.update(l) # ['H', 'M', 'C', 'H', 'H']를 한번에 각각의 요소별로 set에 추가
    graph.append(l)

# used = [graph[0][0]] # (0,0)은 시작좌표이므로 무조건 지남
used = set()
used.add(graph[0][0])

def dfs(level, x, y):
    global used, ans
    
    ans = max(ans, level)

    if level == len(alpha):
        return
    
    for i in range(4):
        ny = y + dy[i]
        nx = x + dx[i]

        if 0 <= ny < r and 0 <= nx < c:
            if visited[ny][nx] == False:
                # if graph[ny][nx] not in used:
                #     visited[ny][nx] = True
                #     used.append(graph[ny][nx])
                #     dfs(level + 1, nx, ny)
                #     used.pop()
                #     visited[ny][nx] = False
                if graph[ny][nx] not in used:
                    visited[ny][nx] = True
                    used.add(graph[ny][nx])
                    dfs(level + 1, nx, ny)
                    used.remove(graph[ny][nx])
                    visited[ny][nx] = False

dfs(1, 0, 0)
print(ans)

위의 코드에서 주석을 풀고, 주석 아래 코드를 주석하면 시간초과가 발생한다.

즉, 알파벳을 썼는지를 기록하는 used를 set이 아닌 list 자료구조를 쓰면 시간초과가 발생한다.

그러므로, dfs나 알고리즘 문제를 풀 때 해당 원소를 썼는지/안썼는지를 확인하기 위한 자료구조로는 왠만하면 set을 사용하자.

참고문헌

https://codinghejow.tistory.com/215

[Python] 백준 1987번 : 알파벳

https://www.acmicpc.net/problem/1987 1987번: 알파벳 세로 R칸, 가로 C칸으로 된 표 모양의 보드가 있다. 보드의 각 칸에는 대문자 알파벳이 하나씩 적혀 있고, 좌측 상단 칸 (1행 1열) 에는 말이 놓여 있다.

codinghejow.tistory.com

[프로그래머스] Lv.2 충돌위험 방지 (파이썬)

_은선_ — Thu, 30 Jan 2025 15:38:45 +0900

구현, 시뮬레이션 문제

https://school.programmers.co.kr/learn/courses/30/lessons/340211

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

문제 설명

routes = []에 몇번 point가 몇번 point로 이동할 것인지의 정보가 주어진다.
우리는 routes의 정보를 가지고, point -> point로 이동할 때 최단 경로만을 사용해서 이동하고 싶다.
이때, r좌표의 이동을 c좌표의 이동보다 우선시한다.
최종적으로는 routes에 있는 point -> point로 동시에 이동시킬 때, 몇 번 충돌하는지 알고 싶다.

접근 방식

초기

BFS를 통해 각각의 point에서 목표 point로 이동하는 최단경로를 싹 구한다.

이때, BFS를 돌리는 과정에서 queue에 이동한 현재 좌표를 리스트에 추가함으로써 이동 경로를 기록한다.

BFS를 다 돌린 후에는 zip, Counter를 활용해 i번째 초에서 각각 몇번 겹쳤는지를 기록한다.

변경 후

BFS를 돌릴 필요가 없다 !!!

(우리는 보통 그래프에서 벽으로 막혀져있거나, 지나갈 수 없는 한계상황을 피해 최단경로를 구하기 위해 BFS를 사용했다.)

그 이유는 좌표 -> 좌표로 이동하는 최단경로를 구하는 것이므로, 단순히 while문만 돌려주면 된다.

또, 굳이 4방향을 돌면서 BFS의 queue에 다음 좌표를 추가해줄 필요 없이, 현재 좌표에서 목표 좌표로 가기 위한 중간 좌표값만 기록해주면 된다. (r, c 우선순위도 정해져있음)

✏️ 짚고 넘어갈 Point

1. BFS에서 지나온 경로 기록하기

while queue:
	if (nx, ny) not in visited:
    	   queue.append((nx, ny, path + [(x, y)]))

2. zip, zip_longest

for pair in zip_longest(*pairs, fillvalue=None):

fillvalue를 사용하면 비교할 리스트의 길이가 짧을 경우, 해당 요소를 원하는 값으로 채울 수 있다.
*pairs는 pairs(이중 리스트)에 들어간 리스트들을 비교하기 위해 *를 사용했다.

사용 예시

import itertools

students = ['한민서', '황지민', '이영철', '이광수', '김승민']
rewards = ['사탕', '초컬릿', '젤리']

result = itertools.zip_longest(students, rewards, fillvalue='None')
print(list(result))

'''
출력 결과:
[('한민서', '사탕'), 
('황지민', '초콜릿'), 
('이영철', '젤리'), 
('이광수', 'None'), 
('김승민', 'None')]
'''

3. Counter 모듈 사용

cnt = Counter(filtered_pair)

for k, v in cnt.items():
	...

counter에서 각각의 key와 value에 접근하기 위해선 items()를 사용하면 된다.

사용 예시

Counter(["hi", "hey", "hi", "hi", "hello", "hey"])
Counter({'hi': 3, 'hey': 2, 'hello': 1})

풀이코드 (시간초과 - BFS)

from collections import deque, Counter
from itertools import zip_longest

dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

pairs = []

def solution(points, routes):
    answer = 0

    def bfs(startX, startY, targetX, targetY, path):
        queue = deque()
        queue.append((startX, startY, path))
        visited = set()
        visited.add((startX, startY))
        
        while queue:
            x, y, path = queue.popleft()
            
            # new_path = path + [(x, y)]  
            
            if x == targetX and y == targetY:
                return path
            
            for ii in range(4):
                ny = dy[ii] + y
                nx = dx[ii] + x
                
                if (nx, ny) not in visited:
                    visited.add((nx, ny))
                    queue.append((nx, ny, path + [(x, y)]))
        return [] 

    for r in routes:
        j = deque(r)
        
        path = []
        
        while len(j) >= 2:
            s = j.popleft()
            n = j[0]
            
            startX = points[s-1][0]-1
            startY = points[s-1][1]-1
           
            targetX = points[n-1][0]-1
            targetY = points[n-1][1]-1

            path = bfs(startX, startY, targetX, targetY, path)       
            
        path = path + [(points[j[0]-1][0]-1, points[j[0]-1][1]-1)]
            
        if path:  
            pairs.append(path)
    

    for pair in zip_longest(*pairs, fillvalue=None):
        filtered_pair = [p for p in pair if p is not None] 
        cnt = Counter(filtered_pair)

        for k, v in cnt.items():
            if v > 1:
                answer += 1

    return answer

시간 복잡도

1. bfs 함수의 시간 복잡도

bfs(startX, startY, targetX, targetY, path)

BFS의 최악의 경우는 2차원 격자(100x100)에서 모든 칸을 탐색하는 경우이다.
최악의 경우 O(R x C) = O(100 x 100) = O(10000)
하지만 BFS는 시작점에서 최단 거리만 탐색하므로, 평균적으로 O(D) (목표 지점까지의 거리) 정도만 탐색된다.
최악의 경우, D는 격자의 크기만큼(100) 될 수 있어 O(100) = O(10²).

2. bfs 함수 호출 횟수

routes의 최대 길이 = 100

routes[i]의 최대 길이 = 100

for r in routes:
    j = deque(r)

    while len(j) >= 2:
        ...
        path = bfs(startX, startY, targetX, targetY, path)

총합 = O(100 ~ 10000) X O(100) X O(100) = O(1000000) ~ O(100000000)

즉, BFS 함수의 시간 복잡도에 따라 최소 백만번 ~ 억번 실행될 수 있다. -> 시간 초과

고친 코드

routes = [[2, 3, 4, 5], [1, 3, 4, 5]]처럼 시작점이 끝점까지 도달하는 과정에서 거쳐야 하는 점들이 여러 개 있는 경우도 있다.

위의 예로 들면 2번 point에서 5번 point로 도달하는 과정에서 3번 point와 4번 point도 거쳐가야 하는 것이다.

이를 위해 처음에는 아래와 같이 구현했다.

하지만, 아래처럼 구현할 경우에는 시작점(2)에서 끝점(5)로 가는 최단 경로를 구해버린다.

(혹은 시작점(2)에서 중간점(3) / 중간점(4)로 각각 가는 최단 경로를 구해버린다.)

시작점(2)에서 중간점(3, 4)를 거쳐 끝점(5)로 가는 경로가 아니다.

if x == points[tarList[0]-1][0]-1 and y == points[tarList[0]-1][1]-1:
    print(tarList, points[tarList[0]-1][0]-1, points[tarList[0]-1][0]-1)
    tarList.pop(0)
    print(new_path)
    if len(tarList) == 0:
        return new_path  # 최단 경로 반환

풀이코드 (성공- 시뮬레이션)

# bfs 돌릴 필요가 없음 (장애물이 있는 것도 아니고, 최단 거리만 찾으면 됨 (r, c) 조건에 따라 )

from collections import deque, Counter
from itertools import zip_longest

pairs = []

def solution(points, routes):
    answer = 0

    def sol(startX, startY, targetX, targetY, path):
    
        while startX != targetX:
            if startX < targetX:
                startX += 1
            else:
                startX -= 1
            path.append((startX, startY))
        
            
        while startY != targetY:
            if startY < targetY:
                startY += 1
            else:
                startY -= 1
            path.append((startX, startY))
        
        return path 

    for r in routes:
        j = deque(r)
        
        path = []
        path = path + [(points[j[0]-1][0]-1, points[j[0]-1][1]-1)]
        
        while len(j) >= 2:
            s = j.popleft()
            n = j[0]
            
            startX = points[s-1][0]-1
            startY = points[s-1][1]-1
            
            targetX = points[n-1][0]-1
            targetY = points[n-1][1]-1

            path = sol(startX, startY, targetX, targetY, path)
            
        pairs.append(path)
    
    for pair in zip_longest(*pairs, fillvalue=None):
        cnt = Counter(pair)

        for k, v in cnt.items():
            if v > 1 and k != None:
                answer += 1

    return answer

주요 로직

현재 x좌표와 목표 x좌표를 비교해서 x좌표가 가까워질수 있도록 좌표값을 1씩 증가 / 감소해준다.
그리고, 이동 경로를 기록하기 위해 현재 x좌표와 y좌표를 path 리스트에 추가해준다.
현재 y좌표와 목표 y좌표를 비교해서 y좌표가 가까워질수 있도록 좌표값을 1씩 증가 / 감소해준다.
그리고, 이동 경로를 기록하기 위해 현재 x좌표와 y좌표를 path 리스트에 추가해준다.

while startX != targetX:
    if startX < targetX:
        startX += 1
    else:
        startX -= 1
    path.append((startX, startY))


while startY != targetY:
    if startY < targetY:
        startY += 1
    else:
        startY -= 1
    path.append((startX, startY))

* 참고문헌

https://windy7271.tistory.com/entry/PythonLV2-PCCP-%EA%B8%B0%EC%B6%9C%EB%AC%B8%EC%A0%9C-3%EB%B2%88-%EC%B6%A9%EB%8F%8C%EC%9C%84%ED%97%98-%EC%B0%BE%EA%B8%B0

(Python/LV2) [PCCP 기출문제] 3번 / 충돌위험 찾기

어떤 물류 센터는 로봇을 이용한 자동 운송 시스템을 운영합니다. 운송 시스템이 작동하는 규칙은 다음과 같습니다. 물류 센터에는 (r, c)와 같이 2차원 좌표로 나타낼 수 있는

windy7271.tistory.com

[프로그래머스] Lv.1 최소 직사각형 (파이썬)

_은선_ — Wed, 29 Jan 2025 15:50:38 +0900

완전 탐색 문제

https://school.programmers.co.kr/learn/courses/30/lessons/86491

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

풀이코드 (실패 - 시간초과)

import sys
sys.setrecursionlimit(10000000)

result = sys.maxsize

def solution(sizes):
    
    def dfs(idx, w_max, h_max):
        global result
        
        if idx == len(sizes):
            result = min(result, w_max * h_max)
            return
        
        for i in range(2):
            n_w_max = max(w_max, sizes[idx][i]) # 0, 1
            n_h_max = max(h_max, sizes[idx][1-i]) # 1, 0
            
            if n_w_max * n_h_max < result:
                dfs(idx + 1, n_w_max, n_h_max)
    dfs(0, 0, 0)
    answer = result
        
    return answer

시간 복잡도

시간 복잡도 계산 (카세르트의 곱)

각각의 명함 번호에서 2가지(1. w, h 2. h, w) 의 경우의 수를 만들 수 있고, 이러한 명함 번호를 조합하여 모든 경우의 수를 찾는다.

따라서, 최악의 경우 N = 10,000일 때, 호출 횟수는 O(2**10000)이 되므로 시간 초과가 발생한다.

풀이코드 (실패)

def solution(sizes):
    answer = 0
    
    arr = [x for s in sizes for x in s]
    arr.sort(reverse=True)
    answer = arr[0] * arr[len(arr) // 2]
    return answer

명함 번호	가로 길이	세로 길이
1	60	50
2	30	70
3	60	30
4	80	70

위의 예시에서 4번 명함의 세로 길이에 있는 70이 두번째로 큰 수 이지만, 가로 길이로 바꿀 수가 없다 (80이 더 크므로)

따라서, 이러한 경우로 인해 오답이 발생한다.

잘못된 답 : arr = [80, 70, 70, 60, 60, 50, 30, 30] -> 4800

올바른 답 : 가로 = [60, 70, 60, 80] 세로 = [50, 30, 30, 70] -> 5600

풀이코드 (성공)

def solution(sizes):
    answer = 0
    
    w_max = max(sizes, key = lambda x: x[0])[0]
    h_max = max(sizes, key = lambda x: x[1])[1]

    if max(w_max, h_max) == w_max: 
        for i in range(len(sizes)):
            if sizes[i][0] < sizes[i][1]:
                sizes[i][1] = sizes[i][0]
        h_max = max(sizes, key = lambda x: x[1])[1]
    else:
        for i in range(len(sizes)):
            if sizes[i][0] > sizes[i][1]:
                sizes[i][0] = sizes[i][1]
        w_max = max(sizes, key = lambda x: x[0])[0]
        
    answer = w_max * h_max
                
        
    return answer

느낀점

시간복잡도를 미리 계산하고 문제를 풀자 ..!