51-9kyo-hwang

[9kyo-hwang]

🔗 문제 링크

21944 문제 추천 시스템 Version 2

✔️ 소요된 시간

1시간 반

✨ 수도 코드

1. 문제

21939 문제 추천 시스템 Version 1의 확장판이다.
각 문제마다 문제 번호, 난이도에 이에 "알고리즘 분류" 정보가 추가되었다.
이를 기반으로, 다음과 같은 5가지 명령어를 지원하는 문제 추천 시스템을 작성하라.

명령어	설명
recommend 𝐺 𝑥	𝑥가 1인 경우 추천 문제 리스트에서 알고리즘 분류가 𝐺인 문제 중 가장 어려운 문제 번호를 출력한다. 조건을 만족하는 문제가 여러 개라면 그 중 문제 번호가 큰 것으로 출력한다.  𝑥가 -1인 경우 추천 문제 리스트에서 알고리즘 분류가 𝐺인 문제 중 가장 쉬운 문제 번호를 출력한다. 조건을 만족하는 문제가 여러 개라면 그 중 문제 번호가 작은 것으로 출력한다. 해당 명령어는 해당 그룹 𝐺에 문제 번호가 한 개 이상이 있을 경우에만 주어진다.
recommend2 𝑥	𝑥가 1인 경우 추천 문제 리스트에서 알고리즘 분류 상관없이 가장 어려운 문제 번호를 출력한다. 조건을 만족하는 문제가 여러 개라면 그 중 문제 번호가 큰 것으로 출력한다.  𝑥가 -1인 경우 추천 문제 리스트에서 알고리즘 분류 상관없이 가장 쉬운 문제 번호를 출력한다. 조건을 만족하는 문제가 여러 개라면 그 중 문제 번호가 작은 것으로 출력한다.
recommend3 𝑥 𝐿	𝑥가 1인 경우 추천 문제 리스트에서 알고리즘 분류 상관없이 난이도 𝐿보다 크거나 같은 문제 중 가장 쉬운 문제 번호를 출력한다. 조건을 만족하는 문제가 여러 개라면 그 중 문제 번호가 작은 것으로 출력한다. 만약 조건을 만족하는 문제 번호가 없다면 -1을 출력한다.  𝑥가 -1인 경우 추천 문제 리스트에서 알고리즘 분류 상관없이 난이도 𝐿보다 작은 문제 중 가장 어려운 문제 번호를 출력한다. 조건을 만족하는 문제가 여러 개라면 그 중 문제 번호가 큰 것으로 출력한다. 만약 조건을 만족하는 문제 번호가 없다면 -1을 출력한다.
add 𝑃 𝐿 𝐺	추천 문제 리스트에 난이도가 𝐿이고 알고리즘 분류가 𝐺인 문제 번호 𝑃를 추가한다. (추천 문제 리스트에 없는 문제 번호 𝑃만 입력으로 주어진다. 이전에 추천 문제 리스트에 있던 문제 번호가 다른 난이도와 다른 알고리즘 분류로 다시 들어 올 수 있다.)
solved 𝑃	추천 문제 리스트에서 문제 번호 𝑃를 제거한다. (추천 문제 리스트에 있는 문제 번호 𝑃만 입력으로 주어진다.)

제한

• $1 \le N, P \le 100,000$ 
• $1 \le M \le 10,000$ 
• $1 \le L, G \le 100$, $L$와 $G$은 자연수
• $x = \pm 1$ 

2. 풀이

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    Database* DB = new Database();
    
    int N; cin >> N;
    while(N--)
    {
        int P, L, G; cin >> P >> L >> G;
        DB->Add(P, L, G);
    }
    
    int M; cin >> M;
    while(M--)
    {
        string Command; cin >> Command;
        if(Command == "recommend")  // find Max/Min in Category G
        {
            int G, x; cin >> G >> x;
            cout << DB->Recommend1(G, x) << "\n";
        }
        else if(Command == "recommend2")  // find Max/Min any Category
        {
            int x; cin >> x;
            cout << DB->Recommend2(x) << "\n";
        }
        else if(Command == "recommend3")  // find lower bound
        {
            int x, L; cin >> x >> L;
            cout << DB->Recommend3(x, L) << "\n";
        }
        else if(Command == "add")
        {
            int P, L, G; cin >> P >> L >> G;
            DB->Add(P, L, G);
        }
        else if(Command == "solved")
        {
            int P; cin >> P;
            DB->Solved(P);
        }
    }
    
    delete DB;
    
    return 0;
}

Database라는 이름의 커스텀 클래스를 정의해 사용한다.
해당 클래스에는 Recommend1(), Recommend2(), Recommend3(), Add(), Solved() 메서드가 존재해 각각의 Command에 대응한다.
주어지는 N개의 기본 데이터들을 Add()를 통해 저장한 뒤, M개의 명령어를 각각의 커맨드에 맞게 호출한다.

class Database
{
public:
    ...
private:
    set<int> ProblemByLevel[101];
    set<int> ProblemByLevelAndGroup[101][101];
    pair<int, int> Problems[100001];

    ...
};

기본적으로 Database 클래스는 3개의 자료구조를 갖는다.

• 레벨 별로 그룹핑해서 문제 번호들을 저장하는 ProblemByLevel set
• 레벨 정보와 분류 정보를 가지고 문제 번호들을 저장하는 ProblemByLevelAndGroup set
• 문제 번호마다 {난이도, 알고리즘 분류} 정보를 저장하는 Problems 배열

참고로 set을 사용한 이유는 각각의 명령어들이 "최대/최소 문제 번호", "가장 어려운/쉬운 난이도" 등을 지속적으로 요구하기 때문이다.
c++에서 set은 "이진 검색 트리"를 기반으로 하기 때문에 정렬된 상태를 유지한다.

class Database
{
public:
    ...
    void Add(int P, int L, int G)
    {
        ProblemByLevel[L].emplace(P);
        ProblemByLevelAndGroup[L][G].emplace(P);
        Problems[P] = {L, G};
    }
    
    void Solved(int P)
    {
        ProblemByLevel[Problems[P].first].erase(P);  // Problems의 first는 난이도 L
        ProblemByLevelAndGroup[Problems[P].first][Problems[P].second].erase(P);  // second는 알고리즘 분류 G
    }

private:
    ...
}

Add() 메서드는 문제 번호 P, 문제 난이도 L, 알고리즘 분류 G 정보를 넘겨받아 각각의 자료구조에 맞게 저장한다.
Solved() 메서드는 문제 번호 P를 넘겨받아 ProblemByLevel set, ProblemByLevelAndGroup set에 저장된 문제 정보를 제거한다.

public:
    int Recommend1(int G, int x)
    {
        if(x == 1)
        {
            return Recommend1P(G);
        }
        else if(x == -1)
        {
            return Recommend1N(G);
        }
    }

private:
    int Recommend1P(int G)
    {
        for(int L = 100; L >= 1; --L)
        {
            if(!ProblemByLevelAndGroup[L][G].empty())
            {
                return *(--ProblemByLevelAndGroup[L][G].end());
            }
        }
    }
    
    int Recommend1N(int G)
    {
        for(int L = 1; L <= 100; ++L)
        {
            if(!ProblemByLevelAndGroup[L][G].empty())
            {
                return *ProblemByLevelAndGroup[L][G].begin();
            }
        }
    }

주어진 알고리즘 분류 G에서 가장 어려운/쉬운 문제 번호를 반환하는 함수이다.
x가 1이면 Recommend1P() 메서드를 호출한 결과를 반환하고, -1이면 Recommend1N() 메서드를 호출한 결과를 반환한다.

• P() 메서드는 난이도 최대값인 100부터 하나씩 낮춰보며 해당 분류 G에서 처음으로 문제가 존재하는 난이도 L을 발견하면, 그 난이도에 속하는 문제들 중에서 가장 큰 번호(end())를 반환한다.
• N() 메서드는 난이도 최소값인 1부터 하나씩 올려보며 해당 분류 G에서 처음으로 문제가 존재하는 난이도 L을 발견하면, 그 난이도에 속하는 문제들 중에서 가장 작은 번호(begin())를 반환한다.

public:
    int Recommend2(int x)
    {
        if(x == 1)
        {
            return Recommend2P();
        }
        else if(x == -1)
        {
            return Recommend2N();
        }
    }

private:
    int Recommend2P()
    {
        for(int L = 100; L >= 1; --L)
        {
            if(!ProblemByLevel[L].empty())
            {
                return *(--ProblemByLevel[L].end());
            }
        }
    }
    
    int Recommend2N()
    {
        for(int L = 1; L <= 100; ++L)
        {
            if(!ProblemByLevel[L].empty())
            {
                return *ProblemByLevel[L].begin();
            }
        }
    }

모든 문제에 대해서 가장 어려운/쉬운 문제 번호를 반환하는 함수이다. 위와 동일하게 x == 1이면 P, -1이면 N을 호출한다.

• P() 메서드는 L = 100부터 시작해 하나씩 낮춰보며 처음으로 문제가 존재하는 난이도를 발견하면, 그 난이도에 속하는 문제들 중 가장 큰 번호(end())를 반환한다.
• N() 메서드는 L = 1부터 시작해 하나씩 높여보며 처음으로 문제가 존재하는 난이도를 발견하면, 그 난이도에 속하는 문제들 중 가장 작은 번호(begin())를 반환한다.

public:
    int Recommend3(int x, int L)
    {
        if(x == 1)
        {
            return Recommend3P(L);
        }
        else if(x == -1)
        {
            return Recommend3N(L);
        }
    }

private:
    int Recommend3P(int L)
    {
        for(; L <= 100; ++L)
        {
            if(!ProblemByLevel[L].empty())
            {
                return *ProblemByLevel[L].begin();
            }
        }
        return -1;
    }
    
    int Recommend3N(int L)
    {
        for(L -= 1; L >= 1; --L)
        {
            if(!ProblemByLevel[L].empty())
            {
                return *(--ProblemByLevel[L].end());
            }
        }
        return -1;
    }

주어진 난이도 L보다 크거나 같은/작은 문제들 중에서 가장 작은/큰 문제 번호를 반환하는 함수이다.

• P() 메서드는 주어진 난이도 L부터 100까지 하나씩 올려보며 처음으로 문제가 존재하는 난이도를 발견하면, 그 난이도에 속하는 문제들 중 가장 작은 번호(begin())를 반환한다.
• N() 메서드는 주어진 난이도 L - 1부터 1까지 하나씩 낮처보며 처음으로 문제가 존재하는 난이도를 발견하면, 그 난이도에 속하는 문제들 중 가장 큰 번호(end())를 반환한다.

전체 코드

C++

#include <iostream>
#include <set>

using namespace std;

class Database
{
public:
    int Recommend1(int G, int x)
    {
        if(x == 1)
        {
            return Recommend1P(G);
        }
        else if(x == -1)
        {
            return Recommend1N(G);
        }
    }
    
    int Recommend2(int x)
    {
        if(x == 1)
        {
            return Recommend2P();
        }
        else if(x == -1)
        {
            return Recommend2N();
        }
    }
    
    int Recommend3(int x, int L)
    {
        if(x == 1)
        {
            return Recommend3P(L);
        }
        else if(x == -1)
        {
            return Recommend3N(L);
        }
    }

    void Add(int P, int L, int G)
    {
        ProblemByLevel[L].emplace(P);
        ProblemByLevelAndGroup[L][G].emplace(P);
        Problems[P] = {L, G};
    }
    
    void Solved(int P)
    {
        ProblemByLevel[Problems[P].first].erase(P);
        ProblemByLevelAndGroup[Problems[P].first][Problems[P].second].erase(P);
    }
    
private:
    set<int> ProblemByLevel[101];
    set<int> ProblemByLevelAndGroup[101][101];
    pair<int, int> Problems[100001];
    
    int Recommend1P(int G)
    {
        for(int L = 100; L >= 1; --L)
        {
            if(!ProblemByLevelAndGroup[L][G].empty())
            {
                return *(--ProblemByLevelAndGroup[L][G].end());
            }
        }
    }
    
    int Recommend1N(int G)
    {
        for(int L = 1; L <= 100; ++L)
        {
            if(!ProblemByLevelAndGroup[L][G].empty())
            {
                return *ProblemByLevelAndGroup[L][G].begin();
            }
        }
    }
    
    int Recommend2P()
    {
        for(int L = 100; L >= 1; --L)
        {
            if(!ProblemByLevel[L].empty())
            {
                return *(--ProblemByLevel[L].end());
            }
        }
    }
    
    int Recommend2N()
    {
        for(int L = 1; L <= 100; ++L)
        {
            if(!ProblemByLevel[L].empty())
            {
                return *ProblemByLevel[L].begin();
            }
        }
    }
    
    int Recommend3P(int L)
    {
        for(; L <= 100; ++L)
        {
            if(!ProblemByLevel[L].empty())
            {
                return *ProblemByLevel[L].begin();
            }
        }
        return -1;
    }
    
    int Recommend3N(int L)
    {
        for(L -= 1; L >= 1; --L)
        {
            if(!ProblemByLevel[L].empty())
            {
                return *(--ProblemByLevel[L].end());
            }
        }
        return -1;
    }
};

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    Database* DB = new Database();
    
    int N; cin >> N;
    while(N--)
    {
        int P, L, G; cin >> P >> L >> G;
        DB->Add(P, L, G);
    }
    
    int M; cin >> M;
    while(M--)
    {
        string Command; cin >> Command;
        if(Command == "recommend")  // find Max/Min in Category G
        {
            int G, x; cin >> G >> x;
            cout << DB->Recommend1(G, x) << "\n";
        }
        else if(Command == "recommend2")  // find Max/Min any Category
        {
            int x; cin >> x;
            cout << DB->Recommend2(x) << "\n";
        }
        else if(Command == "recommend3")  // find lower bound
        {
            int x, L; cin >> x >> L;
            cout << DB->Recommend3(x, L) << "\n";
        }
        else if(Command == "add")
        {
            int P, L, G; cin >> P >> L >> G;
            DB->Add(P, L, G);
        }
        else if(Command == "solved")
        {
            int P; cin >> P;
            DB->Solved(P);
        }
    }
    
    delete DB;
    
    return 0;
}

📚 새롭게 알게된 내용

지난 49번 PR의 약간 확장된 버전이라 수월하게 풀 수 있을 것 같았으나... 괜히 속도 빠르게 해보겠다고 복잡하게 접근했다가 된통 시간 날리고 처음부터 갈아엎는 것만 몇 번 했는지 모르겠따...

심지어 처리를 어떻게 해야하나 싶은 것들도 찾아보니 단순하게 반복문으로 슈루룩 하면 해결되는 거 보고 좀 허탈해짐... ㅋㅋ

[xxubin04]

Version 1에서 알고리즘 분류가 더해져서 어떻게 구현해야 하는지 감이 잘 안잡혔네요...
3개의 자료구조에 정보들을 저장해서 필요한 정보를 찾아 뽑아내도록 구현하셨군요!

앞의 Version 1에서는 recommend에서 1과 -1를 구분하기 위해 max, min_heap 을 사용하셨었는데 이번에는 P(), N() 메소드로 구현하셨네요!
그 이유가 recommend1~3으로 늘어나면서 메소드로 처리하는게 훤씬 편하기 때문인지 궁금합니다!

코드 하나하나씩 읽어보면서 궁금한 건 물어보려고 했는데, PR이 완벽 그 자체여서 물어볼 게 없습니다... 역시 갓👍🏻

[mjj111]

해당 백준 문제에서 N과 M에 대한 크기가 커서 자료구조를 고민해야했는데영

정렬, 삭제, 추가가 빨라야 하는데 정렬된 Set 자료구조가 필요하더군요 ㅋㅋㅋ ㅠ
그래서 TreeSet 학습해서 풀었습니다.

문제가 특정한 자료구조를 요구하니 신박하네요ㅎㅅㅎ

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {

    public static void main(String[] args) throws IOException {
        StringBuilder sb = new StringBuilder();
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());

        TreeSet<Problem> tree = new TreeSet<>();
        List<TreeSet<Problem>> subtrees = new ArrayList<>();
        for (int i = 0; i <= 100; i++) {
            subtrees.add(new TreeSet<>());
        }

        HashMap<Integer, int[]> hMap = new HashMap<>();

        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int no = Integer.parseInt(st.nextToken());
            int level = Integer.parseInt(st.nextToken());
            int group = Integer.parseInt(st.nextToken());

            Problem p = new Problem(no, level, group);
            subtrees.get(group).add(p);
            tree.add(p);
            hMap.put(no, new int[]{level, group});
        }

        int M = Integer.parseInt(br.readLine());
        for (int i = 0; i < M; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            String command = st.nextToken();

            if (command.equals("recommend")) {
                int group = Integer.parseInt(st.nextToken());
                int x = Integer.parseInt(st.nextToken());
                if (x == 1) {
                    sb.append(subtrees.get(group).last().no).append("\n");
                } else {
                    sb.append(subtrees.get(group).first().no).append("\n");
                }
            } else if (command.equals("recommend2")) {
                int x = Integer.parseInt(st.nextToken());
                if (x == 1) {
                    sb.append(tree.last().no).append("\n");
                } else {
                    sb.append(tree.first().no).append("\n");
                }
            } else if (command.equals("recommend3")) {
                int x = Integer.parseInt(st.nextToken());
                int level = Integer.parseInt(st.nextToken());
                if (x == 1) {
                    Problem p = tree.ceiling(new Problem(0, level, 0));
                    sb.append(p == null ? -1 : p.no).append("\n");
                } else {
                    Problem p = tree.lower(new Problem(0, level, 0));
                    sb.append(p == null ? -1 : p.no).append("\n");
                }
            } else if (command.equals("add")) {
                int no = Integer.parseInt(st.nextToken());
                int level = Integer.parseInt(st.nextToken());
                int group = Integer.parseInt(st.nextToken());

                Problem p = new Problem(no, level, group);
                subtrees.get(group).add(p);
                tree.add(p);
                hMap.put(no, new int[]{level, group});
            } else if (command.equals("solved")) {
                int no = Integer.parseInt(st.nextToken());
                if (!hMap.containsKey(no)) continue;

                int[] info = hMap.get(no);
                int level = info[0];
                int group = info[1];

                Problem p = new Problem(no, level, group);
                hMap.remove(no);
                tree.remove(p);
                subtrees.get(group).remove(p);
            }
        }

        System.out.println(sb.toString());
    }

    static class Problem implements Comparable<Problem> {
        int no;
        int level;
        int group;

        public Problem(int no, int level, int group) {
            this.no = no;
            this.level = level;
            this.group = group;
        }

        @Override
        public int compareTo(Problem o) {
            if (level == o.level) {
                return Integer.compare(no, o.no);
            }
            return Integer.compare(level, o.level);
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null || getClass() != obj.getClass()) return false;

            Problem other = (Problem) obj;
            return no == other.no && level == other.level && group == other.group;
        }

        @Override
        public int hashCode() {
            return Objects.hash(no, level, group);
        }
    }
}