#include <string>
#include <vector>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <map>
using namespace std;
 
char Map[110][110];
int row, col;
 
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
 
int safe(int x, int y)
{
    if(0 <= x && x < row && 0 <= y && y < col)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
 
bool solve(int x, int y)
{        
    char Find = Map[x][y];
    
    for(int i = 0; i < 4; i++)
    {
        int xpos = x + dx[i];
        int ypos = y + dy[i];
        
        while(safe(xpos, ypos) == 1 && (Map[xpos][ypos] == '.' || Map[xpos][ypos] == Find))
        {
            if(Map[xpos][ypos] == Find)
            {
                Map[x][y] = '.';
                Map[xpos][ypos] = '.';
                return true;
            }
            
            for(int j = 0; j < 4; j++)
            {
                if(i == j || (i == 0 && j == 1) || (i == 1 && j == 0) || (i == 2 && j == 3) || (i == 3 && j == 2))
                {
                    continue;
                }
 
                int nx = xpos + dx[j];
                int ny = ypos + dy[j];
               
                while(safe(nx, ny) == 1 && (Map[nx][ny] == '.' || Map[nx][ny] == Find))
                {
                    if(Map[nx][ny] == Find)
                    {
                        Map[x][y] = '.';
                        Map[nx][ny] = '.';
                        return true;
                    }
                    
                    nx += dx[j];
                    ny += dy[j];
                }
            }
 
            xpos += dx[i];
            ypos += dy[i];
        }   
    }
    
    return false;
}
 
// 전역 변수를 정의할 경우 함수 내에 초기화 코드를 꼭 작성해주세요.
string solution(int m, int n, vector<string> board) 
{
    string answer = "";
    row = m;
    col = n;
    
    vector<pair<char, pair<int, int>>> reserve;   
    map<char, int> alphabet_check;  
    
    for(int i = 0; i < m; i++)
    {
        for(int j = 0; j < n; j++)
        {
            Map[i][j] = board[i][j];
            
            if('A' <= Map[i][j] && Map[i][j] <= 'Z' && alphabet_check[Map[i][j]] == 0)
            {
                alphabet_check[Map[i][j]] = 1;
                reserve.push_back({Map[i][j], {i, j}});
            }
        }
    }
    sort(reserve.begin(), reserve.end());
    
    bool Flag = true;
    while(Flag)
    {
        Flag = false;
        
        for(int i = 0; i < reserve.size(); i++)
        {
            Flag = solve(reserve[i].second.first, reserve[i].second.second);
            
            if(Flag == true)
            {
                answer += reserve[i].first;
                reserve.erase(reserve.begin()+i);
                
                break;
            }
        }
    }
 
    if(reserve.size() != 0)
    {
        answer = "IMPOSSIBLE";
    }
    
    return answer;
}
cs
저작자표시 (새창열림)

'Programmers > Level 3' 카테고리의 다른 글

[프로그래머스 3] 블록 이동하기 (C/C++) (★★)  (0) 2020.03.11
[프로그래머스 3] GPS (C/C++) (★★★★)  (0) 2020.03.11
[프로그래머스 3] 방문 길이 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 숫자 게임 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 멀리 뛰기 (C/C++)  (0) 2020.03.09
#include <string>
#include <iostream>
using namespace std;
 
int solution(string dirs) 
{
    int answer = 0;
    int visited[11][11][4] = {0}; // 상, 하, 좌, 우
    int x = 5;
    int y = 5;
    
    for(int i = 0; i < dirs.size(); i++)
    {
        if(dirs[i] == 'U')
        {
            if(y+1 > 10)
            {
                continue;
            }
            
            if(visited[x][y][0] == 0 && visited[x][y+1][1] == 0)
            {
                visited[x][y][0] = 1;
                visited[x][y+1][1] = 1;
                answer++;
            }
            
            y++;
        }
        else if(dirs[i] == 'D')
        {
            if(y-1 < 0)
            {
                continue;
            }
            
            if(visited[x][y][1] == 0 && visited[x][y-1][0] == 0)
            {
                visited[x][y][1] = 1;
                visited[x][y-1][0] = 1;
                answer++;
            }
            
            y--;
        }
        else if(dirs[i] == 'L')
        {
            if(x-1 < 0)
            {
                continue;
            }
            
            if(visited[x][y][2] == 0 && visited[x-1][y][3] == 0)
            {
                visited[x][y][2] = 1;
                visited[x-1][y][3] = 1;
                answer++;
            }
            
            x--;
        }
        else if(dirs[i] == 'R')
        {
            if(x+1 > 10)
            {
                continue;
            }
            
            if(visited[x][y][3] == 0 && visited[x+1][y][2] == 0)
            {
                visited[x][y][3] = 1;
                visited[x+1][y][2] = 1;
                answer++;
            }
           
            x++;
        }
    }
    
   return answer;
}
cs
저작자표시 (새창열림)

'Programmers > Level 3' 카테고리의 다른 글

[프로그래머스 3] GPS (C/C++) (★★★★)  (0) 2020.03.11
[프로그래머스 3] 리틀 프렌즈 사천성 (C/C++) (★★)  (0) 2020.03.10
[프로그래머스 3] 숫자 게임 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 멀리 뛰기 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 야근 지수 (C/C++)  (0) 2020.03.09
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
 
int solution(vector<int> A, vector<int> B) 
{
    int answer = 0;
    
    sort(A.begin(), A.end());  
    sort(B.begin(), B.end());
    
    for(int i = A.size()-1; i >= 0; i--)
    {
        int left = 0;
        int right = B.size()-1;
        
        while(left <= right)
        {
            int mid = (left + right) / 2;
            
            if(B[mid] > A[i])
            {
                B.erase(B.begin()+mid);
                answer++;
                
                break;
            }
            else if(B[mid] <= A[i])
            {
                left = mid+1;
            }
        }
    }    
    
    return answer;
}
cs
저작자표시 (새창열림)

'Programmers > Level 3' 카테고리의 다른 글

[프로그래머스 3] 리틀 프렌즈 사천성 (C/C++) (★★)  (0) 2020.03.10
[프로그래머스 3] 방문 길이 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 멀리 뛰기 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 야근 지수 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 최고의 집합 (C/C++)  (0) 2020.03.09
#include <string>
#include <vector>
using namespace std;
 
long long dp[2010];
 
long long solve(int n)
{
    if(n == 0)
    {
        return 1;
    }
    else if(n < 0)
    {
        return 0;
    }
    
    if(dp[n] != 0)
    {
        return dp[n];
    }
    
    dp[n] = (solve(n-1) + solve(n-2)) % 1234567;
 
    return dp[n] % 1234567;
}
 
long long solution(int n) 
{
    long long answer = solve(n);
    
    return answer;
}
cs
저작자표시 (새창열림)

'Programmers > Level 3' 카테고리의 다른 글

[프로그래머스 3] 방문 길이 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 숫자 게임 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 야근 지수 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 최고의 집합 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 배달 (C/C++)  (0) 2020.03.09
#include <string>
#include <vector>
#include <iostream>
#include <queue>
using namespace std;
 
long long solution(int n, vector<int> works) 
{
    long long answer = 0;
    
    priority_queue<int> pq;
    
    for(int i = 0; i < works.size(); i++)
    {
        pq.push(works[i]);
    }
    
    for(int i = 1; i <= n; i++)
    {
        int value = pq.top();
        pq.pop();
        
        if(value == 0)
        {
            break;
        }
        
        value--;
        pq.push(value);
    }
    
    for(int i = 0; i < works.size(); i++)
    {
        long long value = pq.top();
        pq.pop();
        
        answer += value * value;
    }
    
    return answer;
}
cs
저작자표시 (새창열림)

'Programmers > Level 3' 카테고리의 다른 글

[프로그래머스 3] 숫자 게임 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 멀리 뛰기 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 최고의 집합 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 배달 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 자물쇠와 열쇠 (C/C++) (★★★)  (0) 2020.03.09
#include <string>
#include <vector>
using namespace std;
 
vector<int> solution(int n, int s) 
{
    vector<int> answer;
    
    if(n > s)
    {
        answer.push_back(-1);
        
        return answer;
    }
    else
    {
        if(s % n == 0)
        {
            int element = s / n;
            
            for(int i = 1; i <= n; i++)
            {
                answer.push_back(element);
            }
        }
        else
        {
            // 반복횟수
            int cnt = s % n;
            
            // 나머지를 가지고 1씩 분배해서 나눠가지면 최대 곱
            int element = s / n + 1;
            
            for(int i = 1; i <= n-cnt; i++)
            {
                answer.push_back(element-1);
            }
            
            for(int i = 1; i <= cnt; i++) 
            {
                answer.push_back(element);
            }
        }
        
        return answer;
    }
}
cs
저작자표시 (새창열림)

'Programmers > Level 3' 카테고리의 다른 글

[프로그래머스 3] 멀리 뛰기 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 야근 지수 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 배달 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 자물쇠와 열쇠 (C/C++) (★★★)  (0) 2020.03.09
[프로그래머스 3] 기둥과 보 (C/C++) (★★★)  (0) 2020.03.08
#include <iostream>
#include <vector>
using namespace std;
 
int d[55][55];
 
void floyd(int N)
{
    for(int k = 1; k <= N; k++)
    {
        for(int i = 1; i <= N; i++)
        {
            for(int j = 1; j <= N; j++)
            {
                if(d[i][k] + d[k][j] < d[i][j])
                {
                    if(i == j)
                    {
                        continue;
                    }
                    
                    d[i][j] = d[i][k] + d[k][j];
                }
            }
        }
    }
    
}
 
int solution(int N, vector<vector<int>> road, int K) 
{
    int answer = 0;
    
    for(int i = 1; i <= N; i++)
    {
        for(int j = 1; j <= N; j++)
        {
            if(i == j)
            {
                d[i][j] = 0;
            }
            else
            {
                d[i][j] = 99999999;   
            }
        }
    }
 
    for(int i = 0; i < road.size(); i++)
    {
        // 전에 나온 도로 -> 최소면 갱신
        if(d[road[i][0]][road[i][1]] != 99999999)
        {
            if(road[i][2] < d[road[i][0]][road[i][1]])
            {
                d[road[i][0]][road[i][1]] = road[i][2];
                d[road[i][1]][road[i][0]] = road[i][2];
            }
        }
        // 처음 나온 도로 -> 바로 갱신
        else
        {
            d[road[i][0]][road[i][1]] = road[i][2];
            d[road[i][1]][road[i][0]] = road[i][2];
        }
    }
    
    floyd(N);
    
    for(int i = 1; i <= N; i++)
    {
        if(d[1][i] <= K)
        {
            answer++;
        }
    }
 
    return answer;
}
cs
저작자표시 (새창열림)

'Programmers > Level 3' 카테고리의 다른 글

[프로그래머스 3] 야근 지수 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 최고의 집합 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 자물쇠와 열쇠 (C/C++) (★★★)  (0) 2020.03.09
[프로그래머스 3] 기둥과 보 (C/C++) (★★★)  (0) 2020.03.08
[프로그래머스 3] 거스름돈 (C/C++) (★)  (0) 2020.03.07
#include <string>
#include <vector>
#include <iostream>
using namespace std;
 
void rotate(vector<vector<int>> &key)
{
    vector<vector<int>> temp = key;
    
    for(int i = 0; i < key.size(); i++)
    {
        for(int j = 0; j < key.size(); j++)
        {
             temp[i][j] = key[j][key.size()-1-i];
        }
    }
    
    key = temp;
}
 
bool solution(vector<vector<int>> key, vector<vector<int>> lock) 
{
    int m = key.size();
    int n = lock.size();
    int hom = 0;
    
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            if(lock[i][j] == 0)
            {
                hom++;
            }
        }
    }
    
    for(int r = 1; r <= 4; r++)
    {   
        for(int i = -n; i <= n; i++)
        {
            for(int j = -n; j <= n; j++)
            {
                bool fail = true;
                int cnt = 0;
 
                for(int x = 0; x < m; x++)
                {
                    for(int y = 0; y < m; y++)
                    {       
                        int nx = i + x;
                        int ny = j + y;
                        
                        if(0 <= nx && nx < n && 0 <= ny && ny < n) 
                        {
                            //  열쇠의 돌기 부분과 자물쇠의 홈 부분이 정확히 일치해야 하며
                            if(lock[nx][ny] == 0 && key[x][y] == 1)
                            {
                                cnt++;
                            }
                            // 열쇠의 돌기와 자물쇠의 돌기가 만나서는 안됩니다.
                            else if(lock[nx][ny] == 1 && key[x][y] == 1)
                            {
                                fail = false;
                            }
                        }
                    }
                }
                
                if(hom == cnt && fail == true)
                {
                    return true;
                }
            }
        }
        
        rotate(key);
    }
    
    return false;
}
cs
저작자표시 (새창열림)

'Programmers > Level 3' 카테고리의 다른 글

[프로그래머스 3] 최고의 집합 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 배달 (C/C++)  (0) 2020.03.09
[프로그래머스 3] 기둥과 보 (C/C++) (★★★)  (0) 2020.03.08
[프로그래머스 3] 거스름돈 (C/C++) (★)  (0) 2020.03.07
[프로그래머스 3] 보행자 천국 (C/C++)  (0) 2020.03.07

+ Recent posts

티스토리툴바