프로그래머스 - 타겟 넘버

문제 설명

n개의 음이 아닌 정수들이 있습니다. 이 정수들을 순서를 바꾸지 않고 적절히 더하거나 빼서 타겟 넘버를 만들려고 합니다.

예를 들어 [1, 1, 1, 1, 1]로 숫자 3을 만들려면 다음 다섯 방법을 쓸 수 있습니다.

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

사용할 수 있는 숫자가 담긴 배열 numbers, 타겟 넘버 target이 매개변수로 주어질 때 숫자를 적절히 더하고 빼서 타겟 넘버를 만드는 방법의 수를 return 하도록 solution 함수를 작성해주세요.

제한사항

• 주어지는 숫자의 개수는 2개 이상 20개 이하입니다.
• 각 숫자는 1 이상 50 이하인 자연수입니다.
• 타겟 넘버는 1 이상 1000 이하인 자연수입니다.

내 풀이

각 숫자마다 더하거나 빼는 두 가지 선택지가 있으므로, 재귀 DFS로 모든 경우를 탐색했다.

dfs(idx, current)는 idx번째 숫자를 선택할 차례이고, 지금까지의 합이 current인 상태를 의미한다. 숫자를 더하는 방향과 빼는 방향으로 각각 재귀 호출해 트리 전체를 탐색하고, 마지막 숫자까지 선택했을 때 합이 target이면 카운트를 1 증가시킨다.

#include <string>
#include <vector>

using namespace std;

int count = 0;
vector<int> Numbers;
int Target;

void dfs(int idx, int current)
{
    if(idx == Numbers.size())
    {
        if(current == Target) count++;
        return;
    }
    
    dfs(idx + 1, current + Numbers[idx]);
    dfs(idx + 1, current - Numbers[idx]);
}

int solution(vector<int> numbers, int target) {
    count = 0;
    Numbers = numbers;
    Target = target;
    
    dfs(0, 0);
    
    
    return count;
}

시간복잡도 분석

각 숫자마다 + / - 두 가지 선택을 하므로, 숫자가 n개일 때 총 경우의 수는 2^n이다.

제한사항에서 N ≤ 20이므로 2^20 = 약 100만 연산으로 충분히 통과 가능하다.

오답노트

오류: Segmentation Fault

// 수정 전
dfs(idx + 1, current + Numbers[idx]);
dfs(idx - 1, current - Numbers[idx]);  // ← idx - 1이 잘못됨

// 수정 후
dfs(idx + 1, current + Numbers[idx]);
dfs(idx + 1, current - Numbers[idx]);  // 방향(+/-)과 인덱스 이동은 별개

빼는 방향(-) 선택이어도 다음 숫자로 이동해야 한다. idx - 1로 작성하면 인덱스가 음수로 내려가며 무한 재귀 → 스택 오버플로우가 발생한다.

후기

문제를 이해하는 건 어렵지 않았지만, 처음에 코드로 옮기는 작업이 조금 어려웠다. 이런 문제들을 좀 많이 풀면서, 생각한 로직을 코드로 옮기는 것에 익숙해져야겠다.

프로그래머스 - 게임 맵 최단거리

문제 설명

ROR 게임에서 당신은 상대 팀 진영을 공격하기 위해 지금 제일 빠른 길을 찾아야 합니다.

지도는 n×m 크기의 2차원 배열입니다. 0은 벽으로 막힌 공간, 1은 이동할 수 있는 공간입니다. 캐릭터는 좌, 우, 위, 아래 네 방향으로만 이동할 수 있습니다.

캐릭터가 처음 놓인 칸 (1, 1)에서 상대 팀 진영인 (n, m)까지 최단거리로 이동하면 몇 칸을 지나야 하는지 구해주세요. 이동할 수 없는 경우 -1을 반환합니다.

제한사항

• maps는 n × m 크기의 게임 맵의 상태가 들어있는 2차원 배열로, n과 m은 각각 1 이상 100 이하의 자연수입니다.
• n과 m은 서로 같을 수도, 다를 수도 있지만, n과 m이 모두 1인 경우는 입력으로 주어지지 않습니다.
• maps는 0과 1로만 이루어져 있으며, 0은 벽이 있는 자리, 1은 벽이 없는 자리를 나타냅니다.
• 처음에 캐릭터는 게임 맵의 좌측 상단인 (1, 1) 위치에 있으며, 상대방 진영은 게임 맵의 우측 하단인 (n, m) 위치에 있습니다.

내 풀이

2D 격자를 그래프로 보고 BFS로 최단거리를 탐색했다.

dist 배열을 -1로 초기화해 미방문 표시와 visited 역할을 겸하게 했다. 시작점 (0, 0)에서 출발해 상하좌우 4방향으로 이동하며, 이동할 때마다 dist[nx][ny] = dist[x][y] + 1로 거리를 누적한다. 목적지 (N-1, M-1)에 도달하면 dist[x][y] + 1을 반환하고, 큐가 빌 때까지 도달하지 못하면 -1을 반환한다.

#include <vector>
#include <queue>
using namespace std;

int N = 0, M = 0;
vector<vector<int>> Maps;

int Dx[] = { 0,  0, +1, -1};
int Dy[] = {+1, -1,  0,  0};

int bfs(int start_x, int start_y)
{
    queue<pair<int, int>> q;
    vector<vector<int>> dist(N, vector<int>(M, -1));
    
    q.push({start_x, start_y});
    dist[start_x][start_y] = 0;
    
    while(!q.empty())
    {
        auto [x, y] = q.front();
        q.pop();
        
        if(x == N-1 && y == M-1) return dist[x][y] + 1;
        
        for(int d = 0; d < 4; d++)
        {
            int nx = x + Dx[d];
            int ny = y + Dy[d];
            
            if(nx < 0 || nx >= N || ny < 0 || ny >= M) continue;
            
            if(Maps[nx][ny] == 0) continue;
            if(dist[nx][ny] != -1) continue;
            
            dist[nx][ny] = dist[x][y] + 1;
            q.push({nx, ny});
        }
    }
    
    return -1;
}


int solution(vector<vector<int> > maps)
{
    Maps = maps;
    N = (int)maps.size();
    M = (int)maps[0].size();
    
    return bfs(0,0);
}

시간복잡도 분석

N×M 격자의 모든 칸을 최대 한 번씩만 방문하므로 전체 시간복잡도는 O(N × M)이다.

제한사항에서 N, M ≤ 100이므로 최대 10,000 연산으로 충분히 통과 가능하다.

오답노트

오류: 이동 횟수와 칸의 수 혼동

// 수정 전
if(x == N-1 && y == M-1) return dist[x][y];    // 이동 횟수(엣지 수) 반환

// 수정 후
if(x == N-1 && y == M-1) return dist[x][y] + 1; // 칸의 수(노드 수) 반환

dist[0][0] = 0으로 시작하면 목적지의 dist 값은 이동 횟수(엣지 수)다. 문제가 요구하는 건 “몇 칸을 지나야 하는지” — 시작 칸을 포함한 칸의 수(노드 수)이므로 +1이 필요하다.

(0,0) → (1,0) → ... → (N-1,M-1)
dist:  0      1           10      → 반환값: 10 + 1 = 11칸

후기

이 문제도 어떻게 풀어야 하는지를 잘 몰라서 처음에 많이 헤매다가 공부를 다시 하고 풀어봤다. 이렇게 푸는거구나 라는 흐름을 익히고 나중에 한 번 더 도전해보는 것도 좋을 것 같다.

• 탐욕법 = 매 순간 현재 시점에서 가장 좋은 선택만 하는 전략
• 적용 조건 두 가지: 탐욕 선택 속성 (현재 최선이 미래 최선을 보장) + 최적 부분 구조 (부분 최적이 모여 전체 최적)
• 반례가 하나라도 있으면 탐욕 불가 → DP로 전환
• 패턴 1 — 정렬 후 앞에서 순서대로 선택 (과자 나눠주기)
• 패턴 2 — 정렬 후 양끝 포인터로 최적 쌍 선택 (구명보트/짐 싣기)
• 시간복잡도: 정렬이 병목 → 전체 O(N log N)

DFS / BFS란?

지금까지 배운 정렬, 해시, 완전탐색, 탐욕은 주로 1차원 배열에서 동작했다. 하지만 게임에서는 미로 경로 찾기, 연결된 구역 세기, 최단 이동 거리 계산 같은 문제들이 자주 등장한다. 이런 문제들은 그래프 형태로 모델링되고, 이를 탐색하는 두 가지 핵심 방법이 DFS와 BFS다.

• DFS (Depth-First Search): 한 방향으로 갈 수 있는 한 최대한 깊이 들어가고, 더 이상 못 가면 돌아와서 다른 방향 탐색
• BFS (Breadth-First Search): 가장 가까운 노드부터 먼저 탐색, 거리(레벨) 순서대로 퍼져나감

그래프 표현 방법

그래프는 노드(정점)와 간선(연결)으로 구성된다. 코딩테스트에서는 주로 인접 리스트를 사용한다.

int n = 5; // 노드 수
vector<vector<int>> adj(n);

// 0-1, 0-2, 1-3, 1-4 연결
adj[0] = {1, 2};
adj[1] = {0, 3, 4};
adj[2] = {0};
adj[3] = {1};
adj[4] = {1};

인접 행렬은 O(N²) 공간을 사용하므로 N이 작을 때 (≤ 1,000) 쓰고, 인접 리스트는 O(N + E) 공간으로 N이 클 때 (≤ 100,000) 적합하다. 코테에서는 대부분 인접 리스트를 쓴다.

DFS (깊이 우선 탐색)

0 방문 → 1 방문 → 3 방문 → 막힘 → 되돌아와 4 방문 → 막힘 → 되돌아와 → 2 방문

재귀로 구현하는 게 가장 자연스럽다.

vector<vector<int>> adj;
vector<bool> visited;

void dfs(int node) {
    visited[node] = true;
    cout << node << " ";

    for (int next : adj[node]) {
        if (!visited[next])
            dfs(next);
    }
}

// 사용
int n = 5;
adj.resize(n);
visited.assign(n, false);
// ... 간선 추가 ...
dfs(0); // 0 1 3 4 2

visited 배열 없이 탐색하면 0→1→0→1→… 무한루프에 빠진다. 이미 간 곳은 다시 가지 않는다는 표시가 필수다.

BFS (너비 우선 탐색)

0 방문 → 1, 2 방문 (거리 1) → 3, 4 방문 (거리 2)

BFS는 반드시 큐로 구현한다.

void bfs(int start) {
    queue<int> q;
    q.push(start);
    visited[start] = true;

    while (!q.empty()) {
        int node = q.front(); q.pop();
        cout << node << " ";

        for (int next : adj[node]) {
            if (!visited[next]) {
                visited[next] = true;
                q.push(next);
            }
        }
    }
}

// 0 1 2 3 4

visited 체크를 pop할 때 하면 같은 노드가 큐에 여러 번 들어갈 수 있다. push할 때 즉시 visited = true로 설정하는 게 올바른 패턴이다.

최단 거리 — BFS 활용

BFS는 가중치 없는 그래프에서 최단 거리를 보장한다. 레벨 순서로 탐색하기 때문에, 처음 도달했을 때가 항상 최단 거리다.

vector<int> dist(n, -1); // -1 = 미방문

void bfs_dist(int start) {
    queue<int> q;
    q.push(start);
    dist[start] = 0;

    while (!q.empty()) {
        int node = q.front(); q.pop();

        for (int next : adj[node]) {
            if (dist[next] == -1) {
                dist[next] = dist[node] + 1; // 거리 1씩 증가
                q.push(next);
            }
        }
    }
}

dist 배열이 -1이면 미방문이므로, visited 배열을 따로 쓰지 않아도 된다.

2D 격자 탐색 패턴

맵 문제(미로, 섬 세기 등)는 2D 배열을 그래프처럼 탐색한다. 상하좌우 4방향 이동이 “인접 노드” 역할을 한다.

int n, m; // 행, 열
vector<string> grid;

int dx[] = {0, 0, 1, -1}; // 상하좌우 x 변화량
int dy[] = {1, -1, 0, 0}; // 상하좌우 y 변화량

// BFS로 (sx, sy)에서 출발해 (ex, ey)까지 최단 거리
int bfs_grid(int sx, int sy, int ex, int ey) {
    queue<pair<int,int>> q;
    vector<vector<int>> dist(n, vector<int>(m, -1));

    q.push({sx, sy});
    dist[sx][sy] = 0;

    while (!q.empty()) {
        auto [x, y] = q.front(); q.pop();

        if (x == ex && y == ey) return dist[x][y];

        for (int d = 0; d < 4; d++) {
            int nx = x + dx[d];
            int ny = y + dy[d];

            // 범위 체크 + 벽 체크 + 미방문 체크
            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
            if (grid[nx][ny] == '1') continue; // '1'이 벽
            if (dist[nx][ny] != -1) continue;

            dist[nx][ny] = dist[x][y] + 1;
            q.push({nx, ny});
        }
    }
    return -1; // 도달 불가
}

dx/dy 배열 패턴은 2D 탐색 문제에서 거의 매번 등장한다. 외워두는 게 좋다.

DFS vs BFS 비교

판단 기준

• “최단 거리/최소 횟수”가 나오면 → BFS
• “경로 존재 여부”, “연결된 영역 세기” → DFS or BFS 모두 가능
• “모든 경우 탐색” (완전탐색과 혼합) → DFS

시간복잡도

DFS와 BFS 모두 모든 노드와 간선을 한 번씩 방문하므로 시간복잡도는 동일하다.

프로그래머스 - 구명보트

문제 설명

무인도에 갇힌 사람들을 구명보트를 이용하여 구출하려고 합니다. 구명보트는 작아서 한 번에 최대 2명씩 밖에 탈 수 없고, 무게 제한도 있습니다.

예를 들어, 사람들의 몸무게가 [70, 50, 80, 50]이고 구명보트의 무게 제한이 100kg이라면 2번째 사람과 4번째 사람은 같이 탈 수 있지만 1번째 사람과 3번째 사람의 무게의 합은 150kg이므로 구명보트의 무게 제한을 초과하여 같이 탈 수 없습니다.

구명보트를 최대한 적게 사용하여 모든 사람을 구출하려고 합니다.

사람들의 몸무게를 담은 배열 people과 구명보트의 무게 제한 limit가 매개변수로 주어질 때, 모든 사람을 구출하기 위해 필요한 구명보트 개수의 최솟값을 return 하도록 solution 함수를 작성해주세요.

제한사항

• 무인도에 갇힌 사람은 1명 이상 50,000명 이하입니다.
• 각 사람의 몸무게는 40 kg 이상 240 kg 이하입니다.
• 구명보트의 무게 제한은 40 kg 이상 240 kg 이하입니다.
• 구명보트의 무게 제한은 항상 사람들의 몸무게 중 최댓값보다 크므로, 모든 사람을 구출할 수 있습니다.

내 풀이

오름차순 정렬 후 양 끝 포인터(low, high)를 이용했다.

high는 현재 가장 무거운 사람, low는 가장 가벼운 사람을 가리킨다. 둘의 합이 limit 이하면 같이 탈 수 있으므로 low++로 가벼운 쪽을 한 명 처리한다. 합이 limit를 초과하면 무거운 사람은 혼자 탄다. 어느 경우든 high--와 boats++는 항상 실행된다.

low > high가 되면 모든 사람을 처리한 것이므로 종료하고 boats를 반환한다.

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int solution(vector<int> people, int limit) {
    sort(people.begin(), people.end());
    
    int low = 0, high = (int)people.size() - 1;
    int boats = 0;
    
    while(low <= high)
    {
        if(people[high] + people[low] <= limit) low++;
        
        high--;
        boats++;
    }
    
    return boats;
}

시간복잡도 분석

• 정렬: O(N log N)
• while 루프: high는 매 반복마다 1씩 감소, low는 최대 N번 증가 → O(N)
• 전체: O(N log N)

제한사항에서 N ≤ 50,000이므로 50,000 × log(50,000) ≈ 80만 연산으로 충분히 통과 가능하다.

후기

오늘 같이 풀었던 체육복 문제보다 오히려 구명보트 문제가 더 쉬웠던 것 같다. 레벨 1도 레벨 1 나름이고, 레벨 2도 레벨 2 나름인 것 같다.

프로그래머스 - 체육복

문제 설명

점심시간에 도둑이 들어, 일부 학생이 체육복을 도난당했습니다. 다행히 여벌 체육복이 있는 학생이 이들에게 체육복을 빌려주려 합니다. 학생들의 번호는 체격 순으로 매겨져 있어, 바로 앞번호의 학생이나 바로 뒷번호의 학생에게만 체육복을 빌려줄 수 있습니다.

체육복이 없으면 체육수업을 들을 수 없어서 체육복을 적절히 빌려 최대한 많은 학생이 체육수업을 들어야 합니다.

전체 학생의 수 n, 체육복을 도난당한 학생들의 번호가 담긴 배열 lost, 여벌의 체육복을 가져온 학생들의 번호가 담긴 배열 reserve가 매개변수로 주어질 때, 체육수업을 들을 수 있는 학생의 최댓값을 return 하도록 solution 함수를 작성해주세요.

제한사항

• 전체 학생의 수는 2명 이상 30명 이하입니다.
• 체육복을 도난당한 학생의 수는 1명 이상 n명 이하이고 중복되는 번호는 없습니다.
• 여벌의 체육복을 가져온 학생의 수는 1명 이상 n명 이하이고 중복되는 번호는 없습니다.
• 여벌 체육복이 있는 학생만 다른 학생에게 체육복을 빌려줄 수 있습니다.
• 여벌 체육복을 가져온 학생이 체육복을 도난당했을 수도 있습니다. 이 때 이 학생은 체육복을 하나밖에 없으므로 다른 학생에게는 체육복을 빌려줄 수 없습니다.

내 풀이

전처리 단계와 대여 단계로 나눠서 풀었다.

전처리 단계: reserve를 순회하며 lost에 같은 번호가 있으면 해당 학생은 자기 여벌을 직접 쓰는 것으로 처리해 lost에서 제거한다. 이 학생은 다른 사람에게 빌려줄 수 없으므로 filtered_reserve에 추가하지 않는다. lost에 없는 학생만 filtered_reserve에 추가해 순수하게 빌려줄 수 있는 학생 목록을 만든다.

대여 단계: filtered_reserve의 각 학생이 번호 ±1인 학생에게 빌려줄 수 있는지 확인한다. 앞번호(r-1) 우선으로 찾고, 없으면 뒷번호(r+1)를 찾아 lost에서 제거한다.

최종적으로 n - lost.size()를 반환하면 체육복이 있는 학생 수가 된다.

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int solution(int n, vector<int> lost, vector<int> reserve) {
    sort(lost.begin(), lost.end());
    sort(reserve.begin(), reserve.end());
    
    vector<int> filtered_reserve;
    
    for(int r : reserve)
    {
        auto it = find(lost.begin(), lost.end(), r);
        if(it != lost.end())
            lost.erase(it);
        else
            filtered_reserve.push_back(r);
    }
    
    reserve = filtered_reserve;
    
    for(int r : reserve)
    {
        auto it = find(lost.begin(), lost.end(), r - 1);
        if(it == lost.end())
            it = find(lost.begin(), lost.end(), r + 1);
        if(it != lost.end())
            lost.erase(it);
    }
    
    return n - (int)lost.size();
}

시간복잡도 분석

• 정렬: O(L log L + R log R) — L = lost 크기, R = reserve 크기
• 전처리 루프: reserve 각 원소마다 find(O(L)) → O(R × L)
• 대여 루프: reserve 각 원소마다 find 최대 2회(O(L)) → O(R × L)
• 전체: O(R × L)

제한사항에서 n ≤ 30이므로 L, R ≤ 30. 최악의 경우 30 × 30 = 900번 연산으로 충분히 통과 가능하다.

오답노트

처음 제출 시 83.3%가 나왔다.

원인은 lost와 reserve에 동시에 존재하는 학생을 처리하지 않은 것이었다. 예를 들어 lost=[2,4], reserve=[2,3]일 때, 2번 학생은 도난당했지만 여벌도 있으므로 자기 것을 쓰면 된다. 그런데 이 처리 없이 그냥 진행하면 3번 학생이 2번에게 빌려주게 되고, 정작 4번 학생은 아무도 빌려주지 못하는 문제가 생겼다.

수정하는 과정에서도 실수가 있었다. for(int r : reserve) 루프 안에서 reserve.erase(it)를 시도했는데, it가 lost의 이터레이터였고, 순회 중인 컨테이너를 직접 수정하면 UB가 발생한다. filtered_reserve를 별도로 만들어 순회 중 수정 없이 처리하는 방식으로 해결했다.

후기

탐욕법을 들어만 봤지, 제대로 공부하고 응용해본 것은 오늘이 처음이었다. 사실 아직까지는 어떤 문제가 탐욕이 적용 가능한지 구별해낼 자신은 없지만, 하다보면 늘 거라고 생각한다.

• 완전탐색은 모든 경우를 다 시도해 정답을 보장하는 전략 — “무식한 방법”이 아닌 “보장된 정답”
• next_permutation: 반드시 오름차순 정렬 후 사용해야 모든 순열을 얻을 수 있음
• 조합 재귀에서 start 파라미터로 중복을 막음 — i+1을 넘겨 항상 앞에서 뒤 방향으로만 선택
• 비트마스크 부분집합: mask & (1 << i)로 i번째 원소 선택 여부 판단, 경우의 수 2^N
• 시간복잡도 기준: 순열 N ≤ 8, 부분집합 N ≤ 20, 이중반복문 N ≤ 10,000

탐욕법이란?

완전 탐색은 모든 경우를 다 보는 방법이지만 n이 커지면 시간초과가 발생한다.
반면, 탐욕법은 매 순간 현재 시점에서 가장 최선의 선택을 하는 방법이다.

탐욕법을 사용하면 전체 경우를 다 보지 않더라도 최적해에 도달할 수 있다.

탐욕법의 적용 조건

1. 탐욕 선택 속성 -> 현재의 최선의 선택이 미래에도 최선을 보장하는 경우

• 예시 (보트 타기) : 가장 무거운 사람과 가장 가벼운 사람을 보트에 태움 -> 이 선택이 나중의 선택에도 여전히 최선

• 반례 (최소 동전 개수) : 1원, 4원, 6원 동전이 있고 8원을 만들어야 할 때. -> 큰 숫자를 만들기 위한 최선의 선택은 큰 숫자를 고르는 것. 하지만, 6원을 고르면 1원 2개를 골라야 해서 3개의 동전이 필요하다. 4원을 2개 고르는 것이 최선의 선택.

1. 최적 부분 구조 -> 부분 문제의 최적해가 모여 전체 최적해를 이루는 경우

• 예시 (짐 싣기) : n개의 짐을 싣는데 필요한 최소 트럭 수 = (첫 번째 짝 선택) + (나머지 n-2개 짐의 최소 트럭 수). 이처럼 작은 문제(n-2개)의 최적해가 전체 최적해에 기여하는 경우.

위 조건들이 성립하지 않으면 탐욕은 오답을 낼 수 있음.

패턴 1 — 정렬 후 순서대로 선택

가장 흔한 탐욕 패턴이다. 기준에 따라 정렬한 뒤 앞에서부터 차례로 선택한다.

예시) 과자 나눠주기 각각 원하는 최소 과자 크기가 있는 어린이들이 있고, 크기 별로 과자가 존재. 이 때 최대 몇 명을 만족시킬 수 있는지를 해결하는 문제.

int assignCookies(vector<int> children, vector<int> cookies) {
    sort(children.begin(), children.end());
    sort(cookies.begin(), cookies.end());

    int child = 0, cookie = 0;
    while (child < (int)children.size() && cookie < (int)cookies.size()) {
        if (cookies[cookie] >= children[child])
            child++;   // 만족 → 다음 어린이로
        cookie++;      // 과자는 무조건 다음으로
    }
    return child;
}

패턴 2 — 양쪽에서 좁혀오기

정렬을 한 후 양 끝 포인터를 이용해 최적 쌍을 선택하는 방법

예시) 한 번에 짐을 최대 두 개까지 싣는 것이 가능한 수레가 있다. 두 짐의 무게 합은 limit을 넘지 않아야 할 때, 필요한 최소 수레의 수는?

int loadWagon(vector<int> weights, int limit) {
    sort(weights.begin(), weights.end());

    int lo = 0, hi = (int)weights.size() - 1;
    int wagons = 0;

    while (lo <= hi) {
        // 가장 가벼운 짐 + 가장 무거운 짐을 같이 실을 수 있으면 같이 싣는다
        if (weights[lo] + weights[hi] <= limit)
            lo++;
        hi--;      // 가장 무거운 짐은 항상 수레 1대 소모
        wagons++;
    }

    return wagons;
}

탐욕 vs 완전탐색 판단법

판단하는 순서

1. n이 크면 완전탐색은 불가능 -> 탐욕 or DP를 고려
2. 정렬 후 순서대로 선택하면 최적인가를 직관적으로 판단
3. 반례를 하나라도 찾으면 탐욕 불가능 -> DP

시간복잡도

탐욕법 자체는 O(N)이지만, 정렬이 필요하면 O(N log N) 이 된다.

프로그래머스 - 최소직사각형

문제 설명

명함 지갑을 만드는 회사에서 지갑의 크기를 정하려고 합니다. 다양한 모양과 크기의 명함들을 모두 수납할 수 있으면서, 작아서 들고 다니기 편한 지갑을 만들어야 합니다.

각 명함의 가로 길이와 세로 길이를 나타내는 2차원 배열 sizes가 매개변수로 주어집니다. 모든 명함을 수납할 수 있는 가장 작은 지갑을 만들 때, 지갑의 크기를 return 하도록 solution 함수를 완성해주세요.

제한사항

• sizes의 길이는 1 이상 10,000 이하입니다.
• sizes의 각 원소는 [w, h] 형식입니다.
• w는 명함의 가로 길이를 나타냅니다.
• h는 명함의 세로 길이를 나타냅니다.
• w와 h는 1 이상 1,000 이하인 자연수입니다.

내 풀이

모든 명함을 긴 쪽이 가로(card[0]), 짧은 쪽이 세로(card[1])가 되도록 방향을 통일한다. 그 후 모든 명함의 가로 최댓값과 세로 최댓값을 구해 곱하면 최소 지갑 크기가 된다.

#include <string>
#include <vector>

using namespace std;

int solution(vector<vector<int>> sizes) {
    int w = 0;
    int h = 0;
    
    for(auto& card : sizes)
    {
        if(card[0] < card[1])
            swap(card[0], card[1]);
    }
    
    for(auto& card : sizes)
    {
        if(w < card[0]) w = card[0];
        if(h < card[1]) h = card[1];
    }
    
    return w * h;
}

시간복잡도 분석

• 방향 통일 반복문: O(N)
• 최댓값 탐색 반복문: O(N)
• 전체: O(N), N = sizes 크기 (최대 10,000)

N ≤ 10,000이므로 충분히 통과 가능하다.

오답노트

처음에는 어떻게 접근해야 할지 감이 잡히지 않았다.

핵심 아이디어는 모든 명함의 방향을 통일하는 것이다. 명함은 회전이 가능하므로, 긴 쪽을 항상 가로로 맞추면 지갑의 가로 = 모든 명함 가로의 최댓값, 세로 = 모든 명함 세로의 최댓값으로 단순화된다.

방향을 통일하지 않고 그냥 최댓값을 구하면 불필요하게 큰 지갑이 나오게 된다.

후기

프로그래머스 - 약수의 개수와 덧셈

문제 설명

두 정수 left와 right가 매개변수로 주어집니다. left부터 right까지의 모든 수들 중에서, 약수의 개수가 짝수인 수는 더하고, 약수의 개수가 홀수인 수는 빼려고 합니다. 그 결과를 return 하도록 solution 함수를 완성해주세요.

제한사항

• 1 ≤ left ≤ right ≤ 1,000

내 풀이

left부터 right까지 각 수를 순회하며, 1부터 해당 수까지 나누어 약수의 개수를 센다. 약수 개수가 짝수면 answer에 더하고, 홀수면 뺀다.

#include <string>
#include <vector>

using namespace std;

int solution(int left, int right) {
    int answer = 0;

    for(int i = left; i <= right; i++)
    {
        int count = 0;
        for(int j = 1; j <= i; j++)
        {
            if(i % j == 0) count++;
        }
        
        if(count % 2 == 0)
        {
            answer += i;
        }
        else
        {
            answer -= i;
        }
    }
    
    return answer;
}

시간복잡도 분석

• 외부 루프: O(right - left + 1) ≤ O(1,000)
• 내부 루프 (약수 탐색): O(i) ≤ O(1,000)
• 전체: O(N²), N = right - left + 1 (최대 1,000)

최대 약 1,000,000번 연산 → 충분히 통과 가능하다.

후기

프로그래머스 - 문자열 내 p와 y의 개수

문제 설명

대문자와 소문자가 섞여있는 문자열 s가 주어집니다. s에 ‘p’의 개수와 ‘y’의 개수를 비교해 같으면 True, 다르면 False를 return 하는 solution를 완성하세요. ‘p’, ‘y’ 모두 하나도 없는 경우는 같은 개수로 처리합니다.

단, 개수를 비교할 때 대문자와 소문자는 구별하지 않습니다.

제한사항

• 문자열 s의 길이 : 50 이하의 자연수
• 문자열 s는 알파벳으로만 이루어져 있습니다.

내 풀이

문자열을 순회하며 p/P와 y/Y의 개수를 각각 카운트한다. 두 개수가 같으면 true, 다르면 false를 반환한다.

#include <string>
#include <iostream>
using namespace std;

bool solution(string s)
{
    int count_p = 0;
    int count_y = 0;

    for(char c : s)
    {
        if(c == 'p' || c == 'P') count_p++;
        else if(c == 'y' || c == 'Y') count_y++;
    }

    return count_p == count_y;
}

시간복잡도 분석

• 문자열 순회: O(N), N = 문자열 길이 (최대 50)
• 전체: O(N)

N ≤ 50이므로 사실상 제한 없이 통과 가능하다.

후기

이건 너무 쉬운 문제를 고른 것 같다… 이 문제는 약간 레벨 0 느낌..?

• std::sort: 평균 O(N log N) 인트로소트 (퀵소트+힙소트+삽입소트 하이브리드)
• 커스텀 비교 함수 작성 시 Strict Weak Ordering 준수 — 같은 원소끼리는 반드시 false 반환
• 다중 정렬 기준: if (a.x != b.x) return ...; return ...; 패턴
• stable_sort: 동일 원소의 원래 순서 보장, O(N log² N)

완전탐색이란?

가능한 모든 경우의 수를 다 시도해서 정답을 찾는 방법이다.

복잡한 최적화를 거치지 않아도 정답을 보장하며, 입력 크기가 작은 경우에는 항상 유효한 선택지가 된다.

시간복잡도를 계산해서 통과가 가능하다면 다른 복잡한 알고리즘을 쓰는 것보다 완전탐색으로 풀 수 있는지 확인하는 전략을 취하는 것이 좋다.

기본 반복문 완전탐색

배열에서 두 수의 합이 target인 쌍을 찾는 방법을 예시로 들었다.

int n = v.size();
for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
        if (v[i] + v[j] == target) {
            // 찾음
        }
    }
}

이 경우, 시간복잡도는 O(n²)이며, n이 10,000이하인 경우 1초 안에 통과가 가능하다.

순열 — next_permutation

#include <algorithm>
#include <vector>
using namespace std;

vector<int> v = {1, 2, 3};

// 반드시 오름차순 정렬 후 시작해야 모든 순열을 얻을 수 있다.
sort(v.begin(), v.end());

do {
    for (int x : v) cout << x << " ";
    cout << "\n";
} while (next_permutation(v.begin(), v.end()));

경우의 수는 n!이다.

이 경우에는 시간복잡도가 O(n * n!)이므로, n이 8~9 이하인 경우에만 통과가 가능하다.

조합 — 재귀 구현

void combination(vector<int>& nums, int r, int start) {
    if ((int)chosen.size() == r) {
        for (int x : chosen) cout << x << " ";
        cout << "\n";
        return;
    }

    for (int i = start; i < (int)nums.size(); i++) {
        chosen.push_back(nums[i]);
        combination(nums, r, i + 1);
        chosen.pop_back();
    }
}

start 파라미터에 i+1이 전달되면서 항상 현재 선택한 원소보다 뒤에 있는 원소만을 선택 가능하게 한다. 이 덕분에 다른 중복 조합이 생기지 않는다.

부분집합 — 비트마스크

n개의 원소로 만들 수 있는 모든 부분집합을 열거하는 방식이다.

vector<int> v = {1, 2, 3};
int n = v.size();

for (int mask = 0; mask < (1 << n); mask++) {
    cout << "{ ";
    for (int i = 0; i < n; i++) {
        if (mask & (1 << i)) { //i번째 비트가 1이면
            cout << v[i] << " ";
        }
    }
    cout << "}\n";
}

이 경우에는 O(n * 2^n)정도의 시간복잡도를 가지기 때문에 n이 20이하인 경우에는 안전하게 통과가 가능하다.

시간복잡도 정리

완전탐색 풀이 전략

1. n의 크기를 먼저 확인한다.(시간복잡도 계산)
2. 유형을 분류한다
   • 순서O -> 순열
   • 순서X -> 조합(재귀)
   • 선택/미선택 -> 부분집합(비트마스크)
   • 격자 탐색 -> DFS/BFS
3. Pruning(불필요한 탐색 조기 종료)