32-wnsmir

[wnsmir]

🔗 문제 링크

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

✔️ 소요된 시간

40min

✨ 수도 코드

쿼리와 학생정보를 미리 파싱해두고 각 쿼리를 학생리스트에 대조해보면서 정답리스트에 수를 채워나가는 그냥 구현으로 20분만에 풀었다가...
바로 시간초과나서 GPT와함께 문제를 풀어보았습니다 ㅎ..

def solution(info, query):
    # 학생 정보 파싱
    students = [s.split() for s in info]
    for s in students:
        s[4] = int(s[4])  # 점수를 int로

    # 쿼리 파싱
    querys = []
    for q in query:
        parts = q.split(" and ")
        last_part = parts[-1].split()
        parts[-1] = last_part[0]
        parts.append(int(last_part[1]))
        querys.append(parts)

    # 쿼리 개수만큼 결과 배열
    result = [0] * len(querys)

    # 각 쿼리별로 학생 대조
    for qi, que in enumerate(querys):
        cnt = 0
        for student in students:
            Flag = True

            # 언어
            if not (que[0] == student[0] or que[0] == '-'):
                Flag = False
            # 직군
            if not (que[1] == student[1] or que[1] == '-'):
                Flag = False
            # 경력
            if not (que[2] == student[2] or que[2] == '-'):
                Flag = False
            # 소울푸드
            if not (que[3] == student[3] or que[3] == '-'):
                Flag = False
            # 점수 (학생 점수 >= 쿼리 최소 점수)
            if not (student[4] >= que[4]):
                Flag = False

            if Flag:
                cnt += 1

        result[qi] = cnt

    return result

이렇게 풀게되면 일종의 브루트포스방식으로 시간복잡도가 N*Q가 됩니다.
따라서 지피티5는 전처리 + 이분탐색을 활용하라고 가르쳐주었습니다..

• 4개 필드 각각이 **값 또는 -**일 뿐 → 총 2⁴=16 가지 키 조합
• 각 지원자에 대해 16개의 모든 키를 만들어 해당 키의 점수 리스트에 푸시
• 쿼리는 4필드의 정확한 키(와 -)로 해당 리스트만 조회 → 이분 탐색으로 “최소 점수 이상”의 개수를 O(log L)에 계산

16가지의 키는 각 속성의 값들이 아니라 -인지 값인지 의 경우의 수입니다.
이부분에 처음에 햇갈렸는데 각 쿼리는 와일드카드 아니면 어떤 값이 주어지고, 와일드카드라면 해당조건을 무시해도 됩니다.

즉 info: python backend junior pizza 150에서 생기는 키들은
•("python","backend","junior","pizza") ← 정확 일치용
•("python","backend","junior","-")
•("python","-","junior","pizza")
•("-","backend","junior","pizza")
•("-","-","-","-")
… (총 16개) 가 됩니다.

따라서 전처리 O(N log N) + 쿼리당 O(log L) 는 효율성검사도 통과합니다!

from collections import defaultdict
from itertools import combinations
from bisect import bisect_left

def solution(info, query):
    # 전처리: 16개 키에 점수 적재
    db = defaultdict(list)
    for s in info:
        lang, job, career, food, score = s.split()
        score = int(score)
        fields = [lang, job, career, food]

        # 4개의 필드에서 0~4개를 '-'로 치환한 모든 조합(2^4=16)
        for r in range(5):
            for idxs in combinations(range(4), r):
                key = fields[:]  # 복사
                for i in idxs:
                    key[i] = '-'
                db[tuple(key)].append(score)

    # 각 키의 점수 리스트 정렬(이분 탐색)
    for k in db:
        db[k].sort()

    # 쿼리 처리: 키 만들고, lower_bound로 개수 계산
    answer = []
    for que in query:
        # "java and backend and junior and pizza 100" -> ["java","backend","junior","pizza","100"]
        que = que.replace(" and ", " ")
        a, b, c, d, min_score = que.split()
        key = (a, b, c, d)
        scores = db.get(key, [])
        # 점수 >= min_score 인 원소 개수 = 전체 - 첫 위치
        idx = bisect_left(scores, int(min_score))
        answer.append(len(scores) - idx)

    return answer

[kangrae-jo]

16개 조합을 만드는 부분이 예술이네요.
저는 16개 하드코딩 했습니다.
몸이 조금 고생한다는 마인드..;;

[kangrae-jo]

처음에는 map의 map의 map의.... 로 저장해서
인덱스 접근을해서 각 쿼리에 해당하는 답을 구했습니다.

저도 한 20분 걸렸는데 시간초과가 났습니다.

그래서 map의 map의 map의... 를 쓰지 않기 위해서 string으로 합해서 그걸 key로 썼습니다.
그래도 시간초과더라구요.

그래서 저도 gpt 에게 물어봤는데, query를 해결할 때 이분탐색을 써야한다고 하더라구요...
info 개수가 5만개 밖에 되지 않는데 효율성 테스트에는 극악의 테케가 있나봐요.

그래서 이분탐색으로 바꾸어줬더니 정답이었습니다.

준용님 말씀대로 이 문제 핵심은

1. 적절한 자료구조를 사용한 저장
2. 이분탐색을 통해 query 풀기

가 되겠네요.
좋은 문제 감사합니다.

#include <string>
#include <vector>
#include <unordered_map>
#include <sstream>
#include <algorithm>

using namespace std;

const string ANY = "-";

unordered_map<string, vector<int>> um;

string key(const string& a, const string& b, const string& c, const string& d) {
    return a + b + c + d;
}

vector<int> solution(vector<string> info, vector<string> query) {
    for (const string& str : info) {
        string lang, pos, year, food;
        int score;

        stringstream ss(str);
        ss >> lang >> pos >> year >> food >> score;

        um[key(lang, pos, year, food)].push_back(score);

        um[key(ANY,  pos, year, food)].push_back(score);
        um[key(lang, ANY, year, food)].push_back(score);
        um[key(lang, pos, ANY,  food)].push_back(score);
        um[key(lang, pos, year, ANY )].push_back(score);

        um[key(ANY,  ANY, year, food)].push_back(score);
        um[key(ANY,  pos, ANY,  food)].push_back(score);
        um[key(ANY,  pos, year, ANY )].push_back(score);
        um[key(lang, ANY, ANY,  food)].push_back(score);
        um[key(lang, ANY, year, ANY )].push_back(score);
        um[key(lang, pos, ANY,  ANY )].push_back(score);

        um[key(ANY,  ANY, ANY,  food)].push_back(score);
        um[key(ANY,  ANY, year, ANY )].push_back(score);
        um[key(ANY,  pos, ANY,  ANY )].push_back(score);
        um[key(lang, ANY, ANY,  ANY )].push_back(score);

        um[key(ANY,  ANY, ANY,  ANY )].push_back(score);
    }

    // socre 기준 정렬
    for (auto& entry : um) sort(entry.second.begin(), entry.second.end());

    vector<int> answer(query.size(), 0);
    for (int i = 0; i < query.size(); i++) {
        string lang, pos, year, food, ands;
        int score;

        stringstream ss(query[i]);
        ss >> lang >> ands >> pos >> ands >> year >> ands >> food >> score;

        auto it = um.find(key(lang, pos, year, food));
        if (it == um.end()) {
            answer[i] = 0; 
            continue;
        }

        // v는 정렬했으니 이분탐색
        vector<int> v = it->second;
        answer[i] = (v.end() - lower_bound(v.begin(), v.end(), score));
    }

    return answer;
}

[9kyo-hwang]

C++에서는 그냥 무식하게 각 카테고리 별 점수 리스트 테이블을 매 질의마다 순회해도 통과하길래 파이썬도 똑같이 되는 줄 알고 딸깍 했는데... 이진 탐색을 써야 효율성을 통과하는군요...

#include <vector>
#include <string>
#include <unordered_map>
#include <sstream>

using namespace std;

vector<int> solution(vector<string> info, vector<string> query) 
{
    unordered_map<string, int> cat = 
    {
        {"cpp", 0}, {"java", 1}, {"python", 2},
        {"backend", 0}, {"frontend", 1},
        {"junior", 0}, {"senior", 1},
        {"chicken", 0}, {"pizza", 1},
    };

    vector<int> table[3][2][2][2];

    for (const auto &str : info) 
    {
        istringstream ss(str); string buffer;
        vector<string> v;

        while (getline(ss, buffer, ' ')) 
            v.emplace_back(buffer);

        table[cat[v[0]]][cat[v[1]]][cat[v[2]]][cat[v[3]]].emplace_back(stoi(v[4]));
    }

    vector<int> result;
    for (const auto &q : query) 
    {
        istringstream ss(q); string buffer;
        vector<string> v;
        
        while (getline(ss, buffer, ' '))
            v.emplace_back(buffer);

        int score = stoi(v[7]);
        int cnt = 0;

        vector<int> range[4];
        if (v[0] == "-") range[0] = {0, 1, 2};
        else range[0] = {cat[v[0]]};

        if (v[2] == "-") range[1] = {0, 1};
        else range[1] = {cat[v[2]]};

        if (v[4] == "-") range[2] = {0, 1};
        else range[2] = {cat[v[4]]};

        if (v[6] == "-") range[3] = {0, 1};
        else range[3] = {cat[v[6]]};

        for (const auto &i : range[0]) 
            for (const auto &j : range[1]) 
                for (const auto &k : range[2]) 
                    for (const auto &l : range[3]) 
                        for (const auto &s : table[i][j][k][l]) 
                            if (s >= score) cnt++;

        result.emplace_back(cnt);
    }
    
    return result;
}

[kokeunho]

저도 지선생이랑 결국 같이 풀었습니다.

이런 풀이는 도저히 스스로 생각해낼 수가 없었네요...
효율성 검사를 위해 이분 탐색도 사용해야했고, 여러모로 재밌는 문제였습니다.

근데 전처리에 O(N log N)이 든다고 하셨는데
info마다 key값 만들어서 list에 저장 후 score 기준으로 정렬해서 O(N log N)인걸까요?

Details

import java.util.*;

class Solution {
    public int[] solution(String[] info, String[] query) {
        String[] languages = {"cpp", "java", "python", "-"};
        String[] jobs = {"backend", "frontend", "-"};
        String[] careers = {"junior", "senior", "-"};
        String[] foods = {"chicken", "pizza", "-"};

        Map<String, List<Integer>> map = new HashMap<>();
        for (String l : languages) {
            for (String j : jobs) {
                for (String c : careers) {
                    for (String f : foods) {
                        String key = l + j + c + f;
                        map.put(key, new ArrayList<>());
                    }
                }
            }
        }

        for (String detail : info) {
            String[] parts = detail.split(" ");
            String l = parts[0], j = parts[1], career = parts[2], food = parts[3];
            int score = Integer.parseInt(parts[4]);

            String[] ls = {l, "-"};
            String[] js = {j, "-"};
            String[] cs = {career, "-"};
            String[] fs = {food, "-"};

            for (String a : ls) {
                for (String b : js) {
                    for (String c : cs) {
                        for (String f : fs) {
                            String key = a + b + c + f;
                            map.get(key).add(score);
                        }
                    }
                }
            }
        }

        for (List<Integer> list : map.values()) {
            Collections.sort(list);
        }

        int n = query.length;
        int[] answer = new int[n];
        for (int i = 0; i < n; i++) {
            String q = query[i].replaceAll(" and ", " ");
            String[] parts = q.split(" ");
            String key = parts[0] + parts[1] + parts[2] + parts[3];
            int score = Integer.parseInt(parts[4]);

            List<Integer> list = map.get(key);
            if (list == null || list.isEmpty()) {
                answer[i] = 0;
                continue;
            }

            int low = 0, high = list.size();
            while (low < high) {
                int mid = (low + high) / 2;
                if (list.get(mid) < score) low = mid + 1;
                else high = mid;
            }
            answer[i] = list.size() - low;
        }
        return answer;
    }
}

[g0rnn]

어렵네요..key-value로 map을 구상해내는 과정이 왜 이렇게 생각나지 않는지.. 아쉬움이 많은 문제입니다.

어려워서 풀다가 다른 분들의 코드를 봤고, 그러다보니 코드가 많이 비슷해졌네요..

미리 key-value로 구성된 map을 전부 만들고, info로부터 가능한 모든 키 조합에 값을 삽입하였습니다.

재밌는 문제 감사합니다 :)

import java.util.*;

class Solution {
    public int[] solution(String[] info, String[] query) {
        int[] answer = new int[query.length];
        Map<String, List<Integer>> map = makeWithAllKey();
        
        for (String data : info) {
            StringTokenizer st = new StringTokenizer(data);
            String lang = st.nextToken();
            String job = st.nextToken();
            String career = st.nextToken();
            String food = st.nextToken();
            Integer score = Integer.parseInt(st.nextToken());
            
            for (String l : new String[]{lang, "-"}) {
                for (String j : new String[]{job, "-"}) {
                    for (String c : new String[]{career, "-"}) {
                        for (String f : new String[]{food, "-"}) {
                            String key = l + j + c + f;
                            map.get(key).add(score);
                        }
                    }
                }
            }
        }
        
        for (List<Integer> score : map.values()) {
            score.sort(Comparator.naturalOrder());
        }
        
        for (int i = 0; i < query.length; i++) {
            String q = query[i].replaceAll(" and ", " ");
            String[] qs = q.split(" ");
            String key = qs[0] + qs[1] + qs[2] + qs[3];
            Integer target = Integer.parseInt(qs[4]);
            
            List<Integer> score = map.get(key);
            int s = 0, e = score.size();
            while (s < e) {
                int mid = (s + e) / 2;
                if (score.get(mid) < target) s = mid + 1;
                else e = mid;
            }
            answer[i] = score.size() - s;
        }
        
        return answer;
    }
    
    private Map<String, List<Integer>> makeWithAllKey() {
        String[] lang = {"cpp", "java", "python", "-"};
        String[] jobs = {"backend", "frontend", "-"};
        String[] career = {"junior", "senior", "-"};
        String[] foods = {"chicken", "pizza", "-"};
        Map<String, List<Integer>> m = new HashMap<>();
        
        for (String l : lang) {
            for (String j : jobs) {
                for (String c : career) {
                    for (String f : foods) {
                        String key = l + j + c + f;
                        m.put(key, new ArrayList<>());
                    }
                }
            }
        }
        return m;
    }
}