[c++] ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค 42579 :: "๋ฒ ์ŠคํŠธ ์•จ๋ฒ”" ํ’€์ด ๋ฐ ์ฝ”๋“œ

๋ฌธ์ œ

๋ฒ ์ŠคํŠธ ์•จ๋ฒ” ๋ฌธ์ œ ๋ฐ”๋กœ๊ฐ€๊ธฐ

 

์ฝ”๋”ฉํ…Œ์ŠคํŠธ ์—ฐ์Šต - ๋ฒ ์ŠคํŠธ์•จ๋ฒ”

์ŠคํŠธ๋ฆฌ๋ฐ ์‚ฌ์ดํŠธ์—์„œ ์žฅ๋ฅด ๋ณ„๋กœ ๊ฐ€์žฅ ๋งŽ์ด ์žฌ์ƒ๋œ ๋…ธ๋ž˜๋ฅผ ๋‘ ๊ฐœ์”ฉ ๋ชจ์•„ ๋ฒ ์ŠคํŠธ ์•จ๋ฒ”์„ ์ถœ์‹œํ•˜๋ ค ํ•ฉ๋‹ˆ๋‹ค. ๋…ธ๋ž˜๋Š” ๊ณ ์œ  ๋ฒˆํ˜ธ๋กœ ๊ตฌ๋ถ„ํ•˜๋ฉฐ, ๋…ธ๋ž˜๋ฅผ ์ˆ˜๋กํ•˜๋Š” ๊ธฐ์ค€์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค. ์†ํ•œ ๋…ธ๋ž˜๊ฐ€

programmers.co.kr

 

ํ’€์ด

์šฐ์„  ์•Œ์•„๋‚ด์•ผ ํ•  ๊ฒƒ์€ ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

  • ์žฅ๋ฅด์˜ ์ด ์žฌ์ƒ ํšŸ์ˆ˜ -> ์žฅ๋ฅด ์ˆœ์œ„ ์ •ํ•˜๊ธฐ
  • ๊ฐ ์žฅ๋ฅด์˜ ๊ฐœ๋ณ„ ๊ณก ์žฌ์ƒ ํšŸ์ˆ˜ -> ๊ณก ์ˆœ์œ„ ์ •ํ•˜๊ธฐ

์ด๊ฑธ ํ•œ ๋ฒˆ์— ์•Œ์•„๋‚ด๋ ค๊ณ  ํ•˜๋ฉด ์žฅ๋ฅด๋ฅผ key๋กœ ๋‘๊ณ  ์žˆ๋Š” map์— value๋กœ (์ด ์žฌ์ƒ ํšŸ์ˆ˜, index๋งˆ๋‹ค์˜ ์žฌ์ƒํšŸ์ˆ˜)์„ ์ €์žฅํ•ด๋‘์–ด์•ผ ํ•˜๊ณ  ์ด๋Ÿฌ๋ฉด ์žฅ๋ฅด์˜ ์ˆœ์œ„๋ฅผ ์•Œ์•„๋‚ด๊ธฐ ํž˜๋“ค ๋ฟ๋งŒ ์•„๋‹ˆ๋ผ ๊ณก ์ˆœ์œ„๋„ ์ถ”์ถœํ•ด์„œ ๋‚˜ํƒ€๋‚ด์•ผ ํ•œ๋‹ค. ๋”ฐ๋ผ์„œ map์„ ๋‘๊ฐœ๋กœ ๋‚˜๋ˆ„์—ˆ๋‹ค.

1๋ฒˆ map์€ { key : ์žฅ๋ฅด, value : ์ด ์žฌ์ƒ ํšŸ์ˆ˜ } ๋ฅผ ๋‚˜ํƒ€๋‚ด๊ณ ,

2๋ฒˆ map์€ { key : ์žฅ๋ฅด, value : { key : ์žฅ๋ฅด/index , value : ์žฌ์ƒ ํšŸ์ˆ˜ }} ๋ฅผ ๋‚˜ํƒ€๋‚ธ๋‹ค.

 

์œ„์™€ ๊ฐ™์ด map์œผ๋กœ ๋‹ค ์ €์žฅํ•œ ํ›„ 1๋ฒˆ map์„ ์ •๋ ฌํ•ด์„œ ์žฅ๋ฅด์˜ ์ˆœ์œ„๋ฅผ ์ •ํ•˜๊ณ ,

์ˆœ์œ„ ๋ณ„๋กœ 2๋ฒˆ map์—์„œ value ๊ฐ’์ธ map์„ ๊บผ๋‚ด์„œ ์ •๋ ฌํ•˜๋ฉด 1, 2 ์ˆœ์œ„ ๊ณก์˜ index๋ฅผ ์•Œ ์ˆ˜ ์žˆ๋‹ค.

 

๊ทธ๋Ÿฐ๋ฐ map์„ ์–ด๋–ป๊ฒŒ value ๊ฐ’ ๊ธฐ์ค€์œผ๋กœ ์ •๋ ฌํ• ๊นŒ? map์€ ๊ธฐ์กด์— key ๊ฐ’์„ ๊ธฐ์ค€์œผ๋กœ ์ •๋ ฌํ•˜๋„๋ก ๋˜์–ด์žˆ๋‹ค.

์•„๋ž˜์™€ ๊ฐ™์ด vector๋กœ ๋งŒ๋“ค์–ด ์ค€ ํ›„์— sort ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด์ฃผ๋ฉด ๋œ๋‹ค.

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

bool compare (pair<string, int>&a, pair<string, int>&b) {
	return a.second > b.second;
}

map<string, int> sortMap;
vector<pair<string,int>> sortVec(sortMap.begin(), sortMap.end());
sort(sortVec.begin(), sortVec.end(), compare);

 

 

์ฝ”๋“œ

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

using namespace std;

bool compare(const pair<string,int>& a, const pair<string,int>& b) {
	return a.second > b.second;
}

vector<int> solution(vector<string> genres, vector<int> plays) {
    vector<int> answer;
    
    map<string, int> genreMap; // ์žฅ๋ฅด -> ์ด ์žฌ์ƒํšŸ์ˆ˜
    map<string, map<string, int>> genreIndexMap; // ์žฅ๋ฅด -> ์žฅ๋ฅด+index -> ์žฌ์ƒํšŸ์ˆ˜
    
    for(int i=0; i<genres.size(); i++){
        string genre = genres[i];
        int play = plays[i];
        if (genreMap[genre]) {
            genreMap[genre] += play;
        } else {
            genreMap[genre] = play;
        }
        genreIndexMap[genre][genre.append("/"+to_string(i))] = play; // "/"๋กœ split ํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•˜๊ธฐ
    }
    
    // map์„ vector๋กœ ๋ฐ”๊พธ์–ด value ๊ธฐ์ค€ ์ •๋ ฌ
    vector<pair<string,int>> genreVec(genreMap.begin(), genreMap.end());
    sort(genreVec.begin(), genreVec.end(), compare);
    
    for(auto iter = genreVec.begin(); iter != genreVec.end(); iter++) {
        string nowGenre = iter->first;
        auto indexMap = genreIndexMap[nowGenre];
        
        vector<pair<string, int>> indexVec(indexMap.begin(), indexMap.end());
        sort(indexVec.begin(), indexVec.end(), compare);
        
        int maxNum = 2; // ํ•œ ์žฅ๋ฅด์—์„œ ์ตœ๋Œ€ 2๊ณก
        
        for(int i=0; i<maxNum && i<indexVec.size(); i++) {
            int idx = indexVec[i].first.find("/");
            answer.push_back(stoi(indexVec[i].first.substr(idx+1))); // "/" ์ดํ›„์˜ ์ˆซ์ž๋งŒ ์ถ”์ถœ
        }
    }
    
    
    return answer;
}

 

 

๊ฒฐ๊ณผ

๋ฐ˜์‘ํ˜•