#include <string>
#include <vector>
using namespace std;
 
int visited[210= {0};
 
void DFS(int start, vector<vector<int>> computers)
{
    visited[start] = 1;
    
    for(int i = 0; i < computers.size(); i++)
    {
        if(start == i)
        {
            continue;
        }
        
        if(visited[i] == 0 && computers[start][i] == 1)
        {
            visited[i] = 1;
            DFS(i, computers);
        }
    }  
}
 
int solution(int n, vector<vector<int>> computers) 
{
    int answer = 0;
    
    for(int i = 0; i < n; i++)
    {
        if(visited[i] == 1)
        {
            continue;
        }
        else
        {
            DFS(i, computers);
            answer++;
        }
    }
    
    return answer;
}
cs
#include <string>
#include <vector>
#include <queue>
#include <algorithm>
#include <iostream>
using namespace std;
 
vector<int> solution(vector<string> operations) 
{
    vector<int> answer;
    vector<int> q;
    
    for(int i = 0; i < operations.size(); i++)
    {
        if(operations[i][0== 'I')
        {
            string num = operations[i].substr(2, operations.size()-2);
            q.push_back(stoi(num));
        }
        else if(operations[i][0== 'D')
        {
            if(q.size() == 0)
            {
                continue;
            }
            
            if(operations[i][2== '1')
            {
                // 오름차순
                sort(q.begin(), q.end());
                q.pop_back();
            }
            else if(operations[i][2== '-')
            {
                // 내림차순
                sort(q.begin(), q.end(), greater<int>());
                q.pop_back();
            }
        }  ;
    }
    
    if(q.size() == 0)
    {
        answer.push_back(0);
        answer.push_back(0);
    }
    else
    {
        // 오름차순
        sort(q.begin(), q.end());
        answer.push_back(q[q.size()-1]);
        answer.push_back(q[0]);
    }
    
    return answer;
}
cs
#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <iostream>
using namespace std;
 
bool cmp(pair<intint> a, pair<intint> b)
{
    if(a.first > b.first)
    {
        return true;
    }
    else if(a.first == b.first)
    {
        if(a.second < b.second)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    else
    {
        return false;
    }
}
 
vector<int> solution(vector<string> genres, vector<int> plays) 
{
    vector<int> answer;
    vector<string> gName;
    map<stringint> gVisited;
    
    // 1. 속한 노래가 많이 재생된 장르를 먼저 수록합니다.
    for(int i = 0; i < genres.size(); i++)
    {
        if(gVisited[genres[i]] == 0)
        {
            gName.push_back(genres[i]);
        }
        
        gVisited[genres[i]] += plays[i];
    }
    
    vector<pair<intstring>> gRank;
    for(int i = 0; i < gName.size(); i++)
    {
        gRank.push_back({gVisited[gName[i]], gName[i]});
    }
    // 장르 순서 정렬(오름차순)
    sort(gRank.begin(), gRank.end(), greater<pair<intstring>>());
    
 
    // 2. 장르 내에서 많이 재생된 노래를 먼저 수록합니다.
    // 3. 장르 내에서 재생 횟수가 같은 노래 중에서는 고유 번호가 낮은 노래를 먼저 수록합니다.
    for(int i = 0; i < gRank.size(); i++)
    {
        // 노래 재생횟수 저장
        vector<pair<intint>> reserve;
        
        for(int j = 0; j < genres.size(); j++)
        {
            if(gRank[i].second == genres[j])
            {
                reserve.push_back({plays[j], j});
            }
        }
        
        // 노래 순서 정렬(cmp)
        sort(reserve.begin(), reserve.end(), cmp);
        
        if(reserve.size() == 1)
        {
            answer.push_back(reserve[0].second);
        }
        else
        {
            answer.push_back(reserve[0].second);
            answer.push_back(reserve[1].second);
        }
    }
    
    return answer;
}
cs
#include <string>
#include <vector>
using namespace std;
 
vector<vector<int>> answer;
 
void hanoi(int num, int from, int by, int to)
{
    // 1번판(마지막 원판) -> 3번판
    if(num == 1)
    {
        vector<int> temp;
        temp.push_back(from);
        temp.push_back(to);
        answer.push_back(temp);
        
        return;
    }
    
    // 1번판 -> 2번판
    hanoi(num-1, from, to, by);
    
    // 1번판 -> 3번판
    vector<int> temp;
    temp.push_back(from);
    temp.push_back(to);
    answer.push_back(temp);
    
    // 2번판 -> 3번판
    hanoi(num-1, by, from, to);
}
 
vector<vector<int>> solution(int n) 
{
    hanoi(n, 123);
    
    return answer;
}
cs

+ Recent posts