33-kangrae-jo

[kangrae-jo]

🔗 문제 링크

[카드 게임]

✔️ 소요된 시간

55m
(빠르게 답 봤습니다.)

✨ 수도 코드

유니온 파인드의 응용 알고리즘을 들고와봤습니다.
저희가 이전에 유니온 파인드 문제를 다뤘는지는 기억이 안나는데, 체감상 거의 처음 만나보는 유형인 것 같네요.

저는 이 문제를 읽고 처음에 다음과 같이 접근 했어요.

1. blues 정렬
2. upper_bound로 red를 넘는 수 중 가장 작은 수 찾기
3. erase로 해당 인덱스 지우기

시간 초과가 날 것 같았지만 구현이 쉬운 편이라 빠르게 제출을 한 번 해봤습니다.
역시나 시간초과더라구요.

upper_bound 는 이진 탐색으로 O(log M) 이지만, erase가 O(M) 이기 때문이에요. (배열 뒤에것을 다 당겨오기 때문)
그리고 질의가 최대 K개 있으니.... O(K * (log M + M)) 이네요.
M최대가 4,000,000 이고 K 최대가 10,000이니 약 4 * 10^10이네요.. (로그 무시하고 계산)

유니온 파인드를 활용하면 시간 초과를 해결할 수 있습니다.
원래 유니온 파인드는 서로소의 집합을 관리하는 알고리즘이라고 하는데요, 여기서 활용이 가능합니다.

각 인덱스가 자기자신이고, 값이 부모(연결)인 배열형 자료구조로 '현재 선택한 카드보다 바로 위'의 카드를 가져올 수 있게 할 수 있어요.
말이 좀 어렵네요..

이진 탐색으로 blues에서 red보다 큰 카드를 고르고,
그 카드를 찾고, 사용했다는 표시를 하는 것이죠. (부모 노드와 이어줌으로써 표시가 가능)

차근차근 흐름을 따라가보시면 이해가 될 겁니다.
생각을 잘 해놓는다면 구현을 꽤나 쉬울 것 같네요.

참고로 저기서 red가 1을 한 번 더 낸다면 blue는 뭘 내야할까요??
...

이렇게 p[4] = 4 까지 타고 올라간 다음 ,
blues[4]인 7을 출력하고,
p[4] = 5 로 바꾸어 주게 될 것 입니다.

📚 새롭게 알게된 내용

오랜만에 c++새로운 문법을 배웠습니다.
numeric에 있는 iota() 함수 입니다.

iota(begin, end, startValue) 이렇게 사용하면 해당 벡터의 시작 부터 끝까지 startValue부터 시작하여 1씩 증가하는 값을 넣을 수 있어요.

startValue == 0이라면 ->> 인덱스 = 값이 되겠죠.
근데 iota를 몰라도 for(int i = 0; i < n; i++) p[i] = i; 이러면 될 것 같네요.

[9kyo-hwang]

아 C++의 set(Java의 TreeSet) 자료구조를 사용하면 스근하게 풀리겠다~ 했는데 Set의 내부 구현이 매우 느려서 통과가 안되네요 ㅎ... 날먹 실패!

Set 코드

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int N, M, K; cin >> N >> M >> K;
    
    vector<int> cardList(M);
    for(int& card : cardList) {
        cin >> card;
    }
    
    set<int> cards(cardList.begin(), cardList.end());
    
    while(K--) {
        int card; cin >> card;
        auto it = cards.upper_bound(card);
        cout << *it << endl;
        cards.erase(it);
    }

    return 0;
}

결국 배열을 정렬하고 이진탐색을 돌려야 하는데, 철수가 낸 카드보다 큰 카드 중 가장 작은 것(upper_bound)을 찾아내는 것은 좋은데 사용된 카드를 어떻게 처리하는 지가 고민이었습니다.

감이 안잡혀서 알고리즘 카테고리를 봤는데, Disjoint Set이 있길래 "이게 대체 어떻게 쓰란 거지...?" 싶어서 한참 끙끙 댔네요. 그래도 약간 시뮬레이션을 해보니까 감을 잡았습니다.

주어진 카드를 정렬하면 아래와 같습니다.

2 3 4 5 7 8 9

첫 번째로 카드 4를 제시합니다. 우리는 이보다 큰 카드인 [5 7 8 9] 중 가장 작은 5를 내야 합니다. 5를 내고, 5 바로 다음으로 큰 카드와 묶습니다

2 3 4 7 8 9
      5

다음으로 카드 1을 제시합니다. 우리는 2를 내야 합니다. 2를 내고, 2 바로 다음으로 큰 카드 3과 묶습니다.

3 4 7 8 9
2   5

다시 카드 1을 제시합니다. 우리는 3을 내야 합니다. FInd를 통해 최상단 부모인 3을 내고, 3 바로 다음으로 큰 카드 4와 묶습니다.

4 7 8 9
3 5
2

다음은 카드 3을 제시합니다. 우리는 4를 내야 합니다. FInd를 통해 4르 내고, 4 바로 다음으로 큰 카드 7과 묶습니다.

7 8 9
5
4
3
2

마지막으로 카드 8을 제시합니다. 우리는 9를 제시합니다. 9는 주어진 카드의 마지막 카드이므로, 별도로 Union을 진행하지 않습니다.

이러한 로직을 통해, 사용 가능한 카드 중 upper_bound 카드의 바로 다음 카드를 빠르게 뽑아낼 수 있도록 합니다.

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int N, M, K; cin >> N >> M >> K;
    
    vector<int> cards(M);
    for(int& card : cards) {
        cin >> card;
    }
    
    sort(cards.begin(), cards.end());
    
    vector<int> parents(M + 1);
    iota(parents.begin(), parents.end(), 0);
    
    auto Find = [&](int x) {
        while(x != parents[x]) {
            parents[x] = parents[parents[x]];
            x = parents[x];
        }
        
        return parents[x];
    };
    
    auto Union = [&](int u, int v) {
        u = Find(u);
        v = Find(v);
        
        if(u == v) {
            return false;
        }
        
        parents[u] = v;
        return true;
    };

    while(K--) {
        int card; cin >> card;
        
        int index = Find(upper_bound(cards.begin(), cards.end(), card) - cards.begin());
        cout << cards[index] << "\n";
        
        if(index + 1 < M) {
            Union(index, index + 1);
        }
    }

    return 0;
}

사실 인덱스를 기준으로 Union-Find 해야 하는데, 값 기준으로 해버린 건 안 비밀... ㅎ

[g0rnn]

정말 어렵군요.. 구글에 관련 레퍼런스를 검색해보니 예전엔 플레티넘 문제였나봅니다 허허

처음엔 사실 PriorityQueue를 사용해서 날먹 하려 했으나 57퍼에서 실패하더군요. 철수의 카드보다 큰 카드 중 가장 작은 카드만을 찾으려는 실수 때문이었습니다.

Fail 57%

import java.util.*;
import java.io.*;

public class Main {
    static int n, m, k;
    static int[] answer;
    static PriorityQueue<Integer> minsu = new PriorityQueue<>();
    static PriorityQueue<int[]> chulsu = new PriorityQueue<>((a, b) -> {
        if (a[0] == b[0]) return Integer.compare(a[1], b[1]);
        return Integer.compare(a[0], b[0]);
    });

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());
        k = Integer.parseInt(st.nextToken());

        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < m; i++) {
            minsu.add(Integer.parseInt(st.nextToken()));
        }

        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < k; i++) {
            int card = Integer.parseInt(st.nextToken());
            chulsu.add(new int[]{card, i});
        }
        br.close();

        answer = new int[k];
        while (!chulsu.isEmpty()) {
            int blue = minsu.poll();
            int red = chulsu.peek()[0];
            int index = chulsu.poll()[1];

            while (red >= blue) { // 민수가 낼 카드가 철수보다 더 커질 때까지 카드를 찾음
                blue = minsu.poll();
            }

            answer[index] = blue;
        }

        for (int i = 0; i < k; i++) {
            System.out.println(answer[i]);
        }
    }
}

이건 다음 테스트 케이스에서 실패합니다. 민수가 낼 카드가 철수가 낸 카드보다 전부 크다면 문제가 생깁니다.

100 4 3
30 40 50 60
29 1 24
out:
30
40
50

그래서 풀이를 봤습니다. 유니온 파인드라는 약간 생소한 개념을 사용하는 문제였습니다. 예전에 누가 친구 찾는 문제를 올렸었는데 그 때 사용했었던거 같아요. 너무 옛날이라 기억이 잘 안나지만..

근데 너무 와닿지 않아서 좀 고민해봤습니다.
유니온 파인드란 원래 두 집합이 서로소인지를 판별할 때 일반적으로 사용됩니다. 그래서 두 네트워크 간 연결지점이 있는지 확인할 때 사용되죠.

하지만 이 문제는 유니온 파인드를 풀 때 사용되는 개념을 약간 응용해야 하네요. 집합을 구성할 때 서로 연결되어 있음을 증명하는 DSU는 자신의 부모 노드를 가리키는데 이걸 따라다가 보면 각 집합의 대표 노드를 확인할 수 있어요. 이 때 대표노드를 아직 사용되지 않은 나보다 큰 녀석으로 설정합니다.

find라는 메서드로는 이 대표노드를 찾는 것이고, use는 해당 인덱스는 사용했으니 대표노드를 설정할 수 있게 하는 메서드죠. (단, DSU를 초기화할 땐 자기 자신을 대표노드로 설정)

재미난 문제 감사합니도

package beakjoon;

import java.util.*;
import java.io.*;

public class Sol16566 {
    static int n, m, k;
    static int[] cards;
    static int[] parent;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());
        k = Integer.parseInt(st.nextToken());

        st = new StringTokenizer(br.readLine());
        cards = new int[m];
        for (int i = 0; i < m; i++) {
            cards[i] = Integer.parseInt(st.nextToken());
        }
        Arrays.sort(cards);

        // DSU: 서로 겹치지 않는 집합
        parent = new int[m + 1];
        for (int i = 0; i <= m ; i++) {
            parent[i] = i;
        }

        st = new StringTokenizer(br.readLine());
        StringBuilder sb = new StringBuilder();
        while(st.hasMoreTokens()) {
            int x = Integer.parseInt(st.nextToken());

            int idx = upperBound(cards, x);
            int p = find(idx);
            sb.append(cards[p]).append('\n');
            use(p);
        }
        System.out.println(sb);
    }

    private static int upperBound(int[] cards, int x) {
        int l = 0, r = cards.length;
        while (l < r) {
            int mid = (l + r) / 2;
            if (cards[mid] <= x) l = mid + 1;
            else r = mid;
        }
        return l;
    }

    private static int find(int x) {
        if (parent[x] == x) return x;
        return parent[x] = find(parent[x]);
    }

    private static void use(int idx) {
        parent[idx] = find(idx + 1);
    }
}

[kokeunho]

풀이법은 쉽게 떠올릴 수 있었습니다.
근데 upperBound, lowerBound 구현이 아직 미숙해서
구현은 좀 참고를 했습니다.

제가 떠올린 풀이법은
upperBound으로 민수는 덱에서 target보다 큰 수 중 첫 번째 카드를 냅니다.
그리고 M이 최대 4,000,000, K는 최대 10,000라 사용한 카드를 배열에서 제거하는 것은 부담이 될 것이라고 생각했습니다.
하지만 재활용을 방지해야 하니 사용했다는 표시를 visited[]로 해주었습니다.
(그래프 탐색에서 하도 visited로 사용하니 배열명을 습관대로 적었네요.)

기존의 upperBound 코드에서 결정된 인덱스의 카드가 이미 사용된 카드라면
그 다음 사용되지 않은 카드들 중 가장 작은 수의 카드를 사용하도록 수정해주었습니다.

이런 유형의 풀이를 유니온 파인드라고 하는군요.
강래님의 PR 참고해서 더 공부해보도록 하겠습니다.

수고하셨습니다!

(리뷰를 작성하고 보니 다른 분들은 많이 고민한 것 같네요.
저는 단순하게 떠올린 풀이를 그대로 구현했는데 풀렸습니다.
혹시 그냥 운이 좋았던 것일까요...? 불안하네요)

Details

import java.util.*;
import java.io.*;

public class Main {
    static int N, M, K;
    static int[] minsuDecks, cheolsuCards;
    static boolean[] visited;

    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        K = Integer.parseInt(st.nextToken());

        st = new StringTokenizer(br.readLine());
        minsuDecks = new int[M];
        for (int i = 0; i < M; i++) {
            minsuDecks[i] = Integer.parseInt(st.nextToken());
        }
        Arrays.sort(minsuDecks);

        st = new StringTokenizer(br.readLine());
        cheolsuCards = new int[K];
        for (int i = 0; i < K; i++) {
            cheolsuCards[i] = Integer.parseInt(st.nextToken());
        }

        visited = new boolean[M];
        StringBuilder sb = new StringBuilder();
        for (int card : cheolsuCards) {
            sb.append(minsuDecks[upperBound(card)]).append("\n");
        }

        System.out.print(sb);
    }

    static int upperBound(int target) {
        int left = 0, right = minsuDecks.length;

        while (left < right) {
            int mid = (left + right) / 2;
            if (minsuDecks[mid] <= target) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }

        while (left < minsuDecks.length && visited[left]) {
            left++;
        }
        visited[left] = true;
        
        return left;
    }
}

[kangrae-jo]

@kokeunho 저는 오히려 그런 접근이 좋다고 생각합니다.
이 문제는 무슨 알고리즘을 사용하고, 어떤 로직을 사용하고 그런걸 아는 것 보다
진짜 순수한 자신의 힘으로 정답과 유사한 알고리즘을 구현해내는게 더 어렵다고 생각해요.

뭔가 visited 배열을 사용 하는 것과 left를 ++ 시켜서 사용하지 않은 것 중에 answer인 녀석을 찾는 과정이
유니온 파인드와 비슷하군요.

저는 풀이는 떠오르지 않았어서 바로 답을 봤던 것 같네요. 반성합니다!!!

그런데 최악의 케이스에서는 시간초과가 떠야할 것같은데....
k번은 최대 1만번이어서 괜찮은 걸까요.

질문 게시판을 보니 근호님과 비슷한 고민을 하는 사람들이 있네요.