나의 개발일지

[C++][백준][알고리즘] 브루트 포스

bonnate — Sun, 3 Mar 2024 20:10:05 +0900

브루트 포스는 모든 경우의 수를 다 해보는 것이다.

예를 들어, 비밀번호가 4자리이고, 숫자로만 이루어져 있다고 한다면 0000부터 9999까지 다 입력해보면 된다.
비밀번호 4자리의 경우의 수는 10,000가지 이다.

브루트 포스로 문제를 풀기 위해서는 다음과 같은 3가지 단계를 생각해볼 수 있다.
1. 문제의 가능한 경우의 수를 계산해본다.
2. 가능한 모든 방법을 다 만들어본다.
3. 각각의 방법을 이용해 답을 구해본다

경우의 수

N명의 사람이 한 줄로 서는 경우의 수 → N × (N-1) × … × 1 = N!
N명의 사람 중에서 대표 두 명을 뽑는 경우의 수 → N × (N-1) / 2
N명의 사람 중에서 대표 세 명을 뽑는 경우의 수 → N × (N-1) × (N-2) / 3!
N명의 사람 중에서 반장 1명과 부반장 1명을 뽑는 경우의 수 → N × (N-1)
N명의 사람이 있을 때, 각 사람이 영화를 볼지, 보지 않을지 결정한다. 가능한 조합의 수 → 2N

2309번

2309번: 일곱 난쟁이

아홉 개의 줄에 걸쳐 난쟁이들의 키가 주어진다. 주어지는 키는 100을 넘지 않는 자연수이며, 아홉 난쟁이의 키는 모두 다르며, 가능한 정답이 여러 가지인 경우에는 아무거나 출력한다.

www.acmicpc.net

아홉명 중에 일곱 명을 고르는 것은, 아홉 명 중에 두 명을 고르는 것과 같은 문제입니다. 고르는 개수의 차이만 있을 뿐 접근하는 방식은 동일합니다.

// Online C++ compiler to run C++ program online
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

bool ch[9];
int arr[9];
int sel[9];
bool isFinish = false;

void dfs(int s, int p)
{
    if(isFinish)
        return;
    
    if(p == 7)
    {
        int sum = 0;
        for(int i = 0; i < 7; ++i)
            sum += arr[sel[i]];
            
        if(sum == 100)
        {
            vector<int> res;
            for(int i = 0; i < 7; ++i)
                res.push_back(arr[sel[i]]);
            sort(res.begin(), res.end());
            for(int i = 0; i < 7; ++i)
                printf("%d\n", res[i]);
            isFinish = true;
        }

    }
    else
    {
        for(int i = 0; i < 9; ++i)
        {
            if(!ch[i])
            {
                ch[i] = true;
                sel[p] = i;
                dfs(s + 1, p + 1);
                ch[i] = false;
            }
        }
    }
}

int main() {
    for(int i = 0; i < 9; ++i)
        scanf("%d", &arr[i]);
        
    dfs(0, 0);

    return 0;
}

DFS를 이용하여 9개 중 7개를 선택하는 조합을 구하는 알고리즘을 사용하여 문제를 해결하였습니다. 7개를 골랐다면, 그 요소들의 합이 100인지 검사하여 마무리합니다.

3085번

3085번: 사탕 게임

예제 3의 경우 4번 행의 Y와 C를 바꾸면 사탕 네 개를 먹을 수 있다.

www.acmicpc.net

N^2크기의 배열에서 상하좌우 원소를 서로 swap하여 가장 긴 행, 열의 크기를 리턴하는 문제입니다.

// Online C++ compiler to run C++ program online
#include <iostream>
#include <cmath>
#include <climits>
using namespace std;

char board[50][50];
int N;
int ans = INT_MIN;

int dx[4] { -1, +1, 0 ,0 };
int dy[4] { 0, 0, -1, +1 };

void check() {
	char c;
	
	// 행 계산
	for (int i = 0; i < N; i++) 
	{
		int count = 1; // 1개부터 시작
		c = board[i][0]; // 시작은 행의 첫번째 원소부터
		for (int j = 1; j < N; j++) 
		{
		    // c와 같은 char라면, 연속된 길이
			if ((board[i][j] == c))
				++count;
			else 
			    count = 1;
		    
		    // 연속에 상관 없이 다음 c는 현재 위치의 char
			c = board[i][j];
			
			// 개수 갱신
			ans = max(ans, count);
		}
	}

	// 열 계산
	for (int i = 0; i < N; i++) 
	{
		int count = 1; // 1개부터 시작
		c = board[0][i];
		for (int j = 1; j < N; j++) 
		{
			if ((board[j][i] == c))
				++count;
			else 
			    count = 1;
			    
			c = board[j][i];
			
			ans = max(ans, count);
		}
	}
}

int main() {
    cin >> N;
    for(int i = 0; i < N; ++i)
        for(int j = 0; j < N; ++j)
            cin >> board[i][j];
            
    for(int y = 0; y < N; ++y) // col
        for(int x = 0; x < N; ++x) // row
            for(int k = 0; k < 4; ++k) // 4 path
            {
                // 각 방향을 구하기
                int ddy = y + dy[k];
                int ddx = x + dx[k];
                
                // 벗어난경우 무시
                if(ddy < 0 || ddx < 0 || ddy == N || ddx == N)
                    continue;
                    
                // swap 후 개수를 계산한 후 다시 되돌리기
                swap(board[y][x], board[ddy][ddx]);
                check();
                swap(board[y][x], board[ddy][ddx]);
            }
            
    printf("%d", ans);

    return 0;
}

dx, dy를 이용하여 네 방향에 swap을 하고, check를 통해 연속된 가장 긴 길이를 리턴합니다.
swap을 한 후에는 다시 swap을 하여 원상태를 유지합니다.

1476번

1476번: 날짜 계산

준규가 사는 나라는 우리가 사용하는 연도와 다른 방식을 이용한다. 준규가 사는 나라에서는 수 3개를 이용해서 연도를 나타낸다. 각각의 수는 지구, 태양, 그리고 달을 나타낸다. 지구를 나타

www.acmicpc.net

#include <iostream>
using namespace std;

int main() {

    int year = 1;
    
    int E, S, M;
    cin >> E >> S >> M;
    
    int e = 1, s = 1, m = 1;

    for(int i = 1; i <= 7980; ++i)
    {
        if(e == E && s == S && m == M)
        {
            printf("%d", i);
            break;
        }
        
        ++e;
        ++s;
        ++m;
        
        if(e == 16)
            e = 1;
        if(s == 29)
            s = 1;
        if(m == 20)
            m = 1;
    }

    return 0;
}

이 문제는 총 경우의 수를 파악하는것이 중요한 문제입니다.
가능한 총 경우의 수는 15 * 28 *19로 7980에 해당합니다. e가 15, s가 28, m이 19에 해당할 때 마지막 값이 됩니다.
1부터 7890까지 반복하여 조건에 따라 e, s, m을 변경해주어 입력값과 일치해지면 정답을 출력합니다.

1107번

1107번: 리모컨

첫째 줄에 수빈이가 이동하려고 하는 채널 N (0 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 고장난 버튼의 개수 M (0 ≤ M ≤ 10)이 주어진다. 고장난 버튼이 있는 경우에는 셋째 줄에는 고장난 버튼이

www.acmicpc.net

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cmath>
#include <climits>
using namespace std;

// 선택 가능한 모든 버튼
vector<int> numbers { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

// DFS에서 선택한 원소의 번호
int sel[10] { 0, };

// 입력
int N = 0, M = 0;

// 정답
int answer = INT_MAX;

void dfs(int s, int length)
{
    // length만큼 골랐다면?
    if(s == length)
    {
        int num = 0;
       
       // 앞에서부터 조립하여 숫자 생성 
        for(int i = 0; i < length; ++i)
            num += (pow(10, length - i - 1) * numbers[sel[i]]);
            
        // 최소값 갱신
        answer = min(answer, length + abs(N - num));
    }
    else
    {
        // 0부터 중복하여 선택
        for(int i = 0; i < numbers.size(); ++i)
        {
            sel[s] = i;
            dfs(s + 1, length);
        }
    }
}

int main() {
    int input;

    cin >> N >> M;
    
    for(int i = 0; i < M; ++i)
    {
        cin >> input;
        numbers.erase(find(numbers.begin(), numbers.end(), input));
    }
    
    // 모든 버튼이 망가진경우?
    if(M == 10)
    {
        cout << abs(100 - N);
        return 0;
    }
    
    // 모든 버튼이 망가지지 않은경우?
    if(M == 0)
    {
        cout << min((int)to_string(N).size(), abs(100 - N));
        return 0;
    }    

    int length = to_string(N).size();
    
    // 요구 자리 수 - 1
    if(length > 1)
        dfs(0, length - 1);
    
    // 요구 자리 수    
    dfs(0, length);
    
    // 요구 자리 수 + 1
    dfs(0, length + 1);

    cout << min(answer, abs(100 - N));

    return 0;
}

DFS를 활용하여 문제를 해결하였습니다. 선택 가능한 버튼에서 M개를 제외한 나머지 중 N의 자리수만큼 중복을 허용하여 선택을 합니다.
선택된 값에서 N을 빼어 최소값을 갱신할 수 있습니다.
문제 자체는 간단하다고 생각하였으나, 내부적으로 고려해야 할 다양하고 복잡한 조건이 있어 실수가 있었습니다.

글 읽기 - ****리모컨 질문게시판에있는 모든 반례 모음****

댓글을 작성하려면 로그인해야 합니다.

www.acmicpc.net

#include <iostream>
using namespace std;
bool broken[10];
int possible(int c) {
    if (c == 0) {
        if (broken[0]) {
            return 0;
        } else {
            return 1;
        }
    }
    int len = 0;
    while (c > 0) {
        if (broken[c % 10]) {
            return 0;
        }
        len += 1;
        c /= 10;
    }
    return len;
}
int main() {
    int n;
    cin >> n;
    int m;
    cin >> m;
    for (int i = 0; i < m; i++) {
        int x;
        cin >> x;
        broken[x] = true;
    }
    int ans = n - 100;
    if (ans < 0) {
        ans = -ans;
    }
    for (int i = 0; i <= 1000000; i++) {
        int c = i;
        int len = possible(c);
        if (len > 0) {
            int press = c - n;
            if (press < 0) {
                press = -press;
            }
            if (ans > len + press) {
                ans = len + press;
            }
        }
    }
    printf("%d\n", ans);
    return 0;
}

더욱 효율적인 코드로, DFS를 사용하지 않고, 0부터 1000000까지 반복하여 해당 i에 고장난 버튼이 포함되어있는지 검사하여 나아가는 방법입니다.

14500번

14500번: 테트로미노

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다. 정사각형은 서로 겹치면 안 된다. 도형은 모두 연결되어 있어야 한다. 정사각형의 변

www.acmicpc.net

#include <iostream>

int main() {
    
    int N, M;
    int arr[500][500];
    
    scanf("%d %d", &N, &M);
    for(int i = 0; i < N; ++i)
        for(int j = 0; j < M; ++j)
            scanf("%d", &arr[i][j]);
            
    int ans = 0;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            /*
                 
            */
            if (j+3 < M) {
                int temp = arr[i][j] + arr[i][j+1] + arr[i][j+2] + arr[i][j+3];
                if (ans < temp) ans = temp;
            }
            /*
                 
                 
                 
                 
            */
            if (i+3 < N) {
                int temp = arr[i][j] + arr[i+1][j] + arr[i+2][j] + arr[i+3][j];
                if (ans < temp) ans = temp;
            }
            /*
                 
                 
            */
            if (i+1 < N && j+2 < M) {
                int temp = arr[i][j] + arr[i+1][j] + arr[i+1][j+1] + arr[i+1][j+2];
                if (ans < temp) ans = temp;
            }
            /*
                 
                 
                 
            */            
            if (i+2 < N && j+1 < M) {
                int temp = arr[i][j] + arr[i][j+1] + arr[i+1][j] + arr[i+2][j];
                if (ans < temp) ans = temp;
            }
            /*
                 
                     
                
            */               
            if (i+1 < N && j+2 < M) {
                int temp = arr[i][j] + arr[i][j+1] + arr[i][j+2] + arr[i+1][j+2];
                if (ans < temp) ans = temp;
            }
            /*
                   
                   
                 
            */             
            if (i+2 < N && j-1 >= 0) {
                int temp = arr[i][j] + arr[i+1][j] + arr[i+2][j] + arr[i+2][j-1];
                if (ans < temp) ans = temp;
            }
            /*
                     
                 
            */              
            if (i-1 >= 0 && j+2 < M) {
                int temp = arr[i][j] + arr[i][j+1] + arr[i][j+2] + arr[i-1][j+2];
                if (ans < temp) ans = temp;
            }
            /*
                 
                 
                 
            */               
            if (i+2 < N && j+1 < M) {
                int temp = arr[i][j] + arr[i+1][j] + arr[i+2][j] + arr[i+2][j+1];
                if (ans < temp) ans = temp;
            }
            /*
                 
                 
            */               
            if (i+1 < N && j+2 < M) {
                int temp = arr[i][j] + arr[i][j+1] + arr[i][j+2] + arr[i+1][j];
                if (ans < temp) ans = temp;
            }
            /*
                 
                   
                   
            */              
            if (i+2 < N && j+1 < M) {
                int temp = arr[i][j] + arr[i][j+1] + arr[i+1][j+1] + arr[i+2][j+1];
                if (ans < temp) ans = temp;
            }
            /*
                 
                 
            */                 
            if (i+1 < N && j+1 < M) {
                int temp = arr[i][j] + arr[i][j+1] + arr[i+1][j] + arr[i+1][j+1];
                if (ans < temp) ans = temp;
            }
            /*
                   
                 
            */               
            if (i-1 >= 0 && j+2 < M) {
                int temp = arr[i][j] + arr[i][j+1] + arr[i-1][j+1] + arr[i-1][j+2];
                if (ans < temp) ans = temp;
            }
            /*
                 
                 
                   
            */               
            if (i+2 < N && j+1 < M) {
                int temp = arr[i][j] + arr[i+1][j] + arr[i+1][j+1] + arr[i+2][j+1];
                if (ans < temp) ans = temp;
            }
            /*
                 
                   
            */              
            if (i+1 < N && j+2 < M) {
                int temp = arr[i][j] + arr[i][j+1] + arr[i+1][j+1] + arr[i+1][j+2];
                if (ans < temp) ans = temp;
            }
            /*
                   
                 
                 
            */              
            if (i+2 < N && j-1 >= 0) {
                int temp = arr[i][j] + arr[i+1][j] + arr[i+1][j-1] + arr[i+2][j-1];
                if (ans < temp) ans = temp;
            }
            /*
                   
                 
                
                 
                   
            */ 
            if (j+2 < M) {
                int temp = arr[i][j] + arr[i][j+1] + arr[i][j+2];
                if (i-1 >= 0) {
                    int temp2 = temp + arr[i-1][j+1];
                    if (ans < temp2) ans = temp2;
                }
                if (i+1 < N) {
                    int temp2 = temp + arr[i+1][j+1];
                    if (ans < temp2) ans = temp2;
                }
            }
            /*
                   
                 
                   
                  
                 
                 
                 
            */             
            if (i+2 < N) {
                int temp = arr[i][j] + arr[i+1][j] + arr[i+2][j];
                if (j+1 < M) {
                    int temp2 = temp + arr[i+1][j+1];
                    if (ans < temp2) ans = temp2;
                }
                if (j-1 >= 0) {
                    int temp2 = temp + arr[i+1][j-1];
                    if (ans < temp2) ans = temp2;
                }
            }
        }
    }
    
    printf("%d", ans);
    return 0;
}

N*M만큼 반복하여 해당 위치에 가능한 모든 모양의 테트로미노에 해당하는 위치에서 값을 계산하여 최고값을 갱신합니다.
문제 자체는 간단하지만, 19개의 테트로미노 모양에 대한 조건식을 정확하게 써야 오류가 나지 않습니다.
- 실수를 한 경우에 디버깅이 어렵습니다.

#include <iostream>
using namespace std;
int a[500][500];
int block[19][3][2] = {
    {{0,1}, {0,2}, {0,3}},
    {{1,0}, {2,0}, {3,0}},
    {{1,0}, {1,1}, {1,2}},
    {{0,1}, {1,0}, {2,0}},
    {{0,1}, {0,2}, {1,2}},
    {{1,0}, {2,0}, {2,-1}},
    {{0,1}, {0,2}, {-1,2}},
    {{1,0}, {2,0}, {2,1}},
    {{0,1}, {0,2}, {1,0}},
    {{0,1}, {1,1}, {2,1}},
    {{0,1}, {1,0}, {1,1}},
    {{0,1}, {-1,1}, {-1,2}},
    {{1,0}, {1,1}, {2,1}},
    {{0,1}, {1,1}, {1,2}},
    {{1,0}, {1,-1}, {2,-1}},
    {{0,1}, {0,2}, {-1,1}},
    {{0,1}, {0,2}, {1,1}},
    {{1,0}, {2,0}, {1,1}},
    {{1,0}, {2,0}, {1,-1}},
};
int main() {
    int n, m;
    cin >> n >> m;
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            cin >> a[i][j];
        }
    }
    int ans = 0;
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            for (int k=0; k<19; k++) {
                bool ok = true;
                int sum = a[i][j];
                for (int l=0; l<3; l++) {
                    int x = i+block[k][l][0];
                    int y = j+block[k][l][1];
                    if (0 <= x && x < n && 0 <= y && y < m) {
                        sum += a[x][y];
                    } else {
                        ok = false;
                        break;
                    }
                }
                if (ok && ans < sum) {
                    ans = sum;
                }
            }
        }
    }
    cout << ans << '\n';
    return 0;
}

위 정답보다 보다 개선된 형태로, 3차원 배열에 0,0을 기준으로하여 상대적인 위치에 나머지 세개의 블록을 두는 방식으로 구현한 방식입니다.

6064번

6064번: 카잉 달력

입력 데이터는 표준 입력을 사용한다. 입력은 T개의 테스트 데이터로 구성된다. 입력의 첫 번째 줄에는 입력 데이터의 수를 나타내는 정수 T가 주어진다. 각 테스트 데이터는 한 줄로 구성된다.

www.acmicpc.net

#include <iostream>
using namespace std;
int main() {
    int T;
    cin >> T;
    for(int i = 0; i < T; ++i)
    {
        int M, N, X, Y;
        cin >> M >> N >> X >> Y;
        
        --X, --Y;
        // 1씩 빼면 나머지를 활용하여 문제를 해결할 수 있음
        // X와 Y중 하나를 고정하여 문제를 해결하기
        // X를 고정한다고 가정했을 때, Y의 값을 찾아 정답을 구하기
        
        /*
            1을 빼지 않았을 때
            • 1: <1,1>
            • 2: <2,2>
            • 3: <3,3>
            • 4: <4,4>
            • 5: <5,5>
            • 6: <1,6>
            • 7: <2,7>
            • 8: <3,1>
            • 9: <4,2>
            • 10: <5,3>
            
            1을 빼면 X, Y중 하나를 고정하여 해결 가능
            0부터 X, Y는 차례대로 루프로 고정됨
            • 0: <0,0>
            • 1: <1,1>
            • 2: <2,2>
            • 3: <3,3>
            • 4: <4,4> (첫 사이클 동안은 값이 동일함)
            • 5: <0,5>
            • 6: <1,6>
            • 7: <2,0>
            • 8: <3,1>
            • 9: <4,2>
            • 10: <0,3>
        */
        
        // 조합을 찾았는가?
        bool ok = false;
        
        // int k = X를 하는 이유는 첫 X의 값과 Y는 동일하기 때문
        // 
        // k += M을 하는 이유는 M을 더하면 X축이 고정되는 원리
        // k += M을 하여 고정된 축에서 k % M == Y라면, 해당 조합을 찾은 것
        for (int k = X; k < (N * M); k += M) 
        {
            if (k % N == Y) 
            {
                cout << k + 1 << '\n';
                ok = true;
                break;
            }
        }
        if (!ok)
            cout << -1 << '\n';

    }
    return 0;
}

1씩 빼면 나머지를 활용하여 문제를 해결할 수 있습니다. 이는 날짜계산 문제와 비슷합니다.

1748번

1748번: 수 이어 쓰기 1

첫째 줄에 N(1 ≤ N ≤ 100,000,000)이 주어진다.

www.acmicpc.net

#include <iostream>
#include <cmath>

int sizes[9] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

int main() {
    long long int answer = 0;
    int N;
    scanf("%d", &N);
    
    int digit = 1;
    for(; digit <= 10; ++digit)
    {
        if(!(N / (int)pow(10, digit - 1)))
        {
            --digit;
            break;
        }
    }
    
    for(int i = 1; i < digit; ++i)
        answer += (pow(10, i) - pow(10, i - 1)) * i;

    answer += (N - (int)pow(10, digit - 1) + 1) * sizes[digit - 1];
       
    printf("%lld", answer);
}

digit를 구하여 자리수-1까지 9 * 10^n만큼 더합니다.
- 한자리는 9, 두자리는 90, 세자리는 900...으로 증가합니다.
마지막 digit는 꽉 차있지 않기 때문에 pow(10, digit - 1)를 빼주어 해당 자리수의 크기만큼 곱하여 정답을 리턴합니다.

[C++][백준][알고리즘] 최대공약수, 최소공배수, 소수

bonnate — Thu, 29 Feb 2024 18:28:59 +0900

최대 공약수는 Greatest Common Divisor으로 GCD라고 씁니다.
최소 공배수는 Least Common Multiple으로 LCM으로 씁니다.

2609번

2609번: 최대공약수와 최소공배수

첫째 줄에는 입력으로 주어진 두 수의 최대공약수를, 둘째 줄에는 입력으로 주어진 두 수의 최소 공배수를 출력한다.

www.acmicpc.net

#include <iostream>

/*
    [최대 공약수]
    유클리드 호제법 알고리즘
    
    1. 작은 수로 큰 수를 나눕니다.
    2. 나머지가 0이 될 때까지 계속 나눕니다.
    3. 나머지가 0이 되면, 해당 나누는 수가 두 수의 최대공약수가 됩니다.
    
    // 입력: 18, 24
    먼저 24를 18로 나눕니다.
    24 ÷ 18 = 1 ... 6
    나머지가 0이 아니므로, 이제 18을 나머지로, 6을 나눕니다.
    18 ÷ 6 = 3 ... 0
    나머지가 0이 되었으므로, 이 때의 나누는 수인 6이 18과 24의 최대공약수입니다. 따라서 최대공약수(GCD)는 6입니다.
*/

/*
    [최소 공배수]
    두 수의 곱을 그들의 최대공약수로 나누는 것으로 구할 수 있습니다.
    
    // 입력: 18, 24
    18과 24의 최대공약수는 6입니다.
    18 * 24 / 6은 72입니다.
*/

int gcd(int x, int y)
{
    if(y == 0)
        return x;
    else return gcd(y, x % y);
}

int main() {
    int a, b;
    scanf("%d %d", &a, &b);
    
    int g = gcd(a, b);
    
    printf("%d\n%d", g, a * b / g);

    return 0;
}

최대 공약수는 다음과 같이 계산합니다.

작은 수로 큰 수를 나눕니다.
나머지가 0이 될 때까지 계속 나눕니다.
나머지가 0이 되면, 해당 나누는 수가 두 수의 최대공약수가 됩니다.

최소 공배수는 다음과 같이 계산합니다.

두 수의 곱을 그들의 최대공약수로 나누는 것으로 구할 수 있습니다.

1978번

1978번: 소수 찾기

첫 줄에 수의 개수 N이 주어진다. N은 100이하이다. 다음으로 N개의 수가 주어지는데 수는 1,000 이하의 자연수이다.

www.acmicpc.net

#include <iostream>
#include <cmath>

int main() {
    int N, input;
    int answer = 0;
    scanf("%d", &N);

    for(int i = 0; i < N; ++i)
    {
        scanf("%d", &input);    
        bool isPrime = true;
        
        for(int i = 2; i <= sqrt(input); ++i)
            if( input % i == 0)
            {
                
                isPrime = false;
                break;
            }   
        
        if(input != 1 && isPrime)
            ++answer;
    }

    printf("%d", answer);

    return 0;
}

최대 100개의 테스트 케이스가 소수인지 검사하여 소수의 개수를 리턴합니다.
약수의 성질을 활용하여 sqrt(input)까지 검사하여 i로 나누어 떨어지지 않는다면 소수로 볼 수 있습니다.
에라토스테네스의 체를 활용하여 매우 큰 범위의 소수를 더욱 빠르게 구할 수 있습니다.

[C++] 소수의 개수 (에라토스테네스의 체)

문제 자연수 N이 입력되면 1부터 N까지의 소수의 개수를 출력하는 프로그램을 작성하세요. 만약 20이 입력되면 1부터 20까지의 소수는 2, 3, 5, 7, 11, 13, 17, 19로 총 8개입니다. ℹ️ 조건 제한시간

bonnate.tistory.com

9020번

9020번: 골드바흐의 추측

1보다 큰 자연수 중에서 1과 자기 자신을 제외한 약수가 없는 자연수를 소수라고 한다. 예를 들어, 5는 1과 5를 제외한 약수가 없기 때문에 소수이다. 하지만, 6은 6 = 2 × 3 이기 때문에 소수가 아

www.acmicpc.net

#include <iostream>
#include <vector>
using namespace std;

vector<bool> isPrime(10001, true);

int main() {
    // 에라토스테네스의 체
    isPrime[0] = isPrime[1] = false;
    for(int i = 2; i < 10001; ++i)
        if(isPrime[i])
            for(int j = i * 2; j <= 10001; j += i)
                isPrime[j] = false;
            
    int T, n;
    scanf("%d", &T);
    for(int i = 0; i < T; ++i)
    {
        scanf("%d", &n);
        
        // 중간부터 시작하기
        int left = n / 2;
        while(true)
        {
            // 에라토스테네스의 체 배열에서 left, right가 모두 소수라면?
            if(isPrime[left] && isPrime[n - left])
            {
                // 출력 후 종료
                printf("%d %d\n", left, n - left);
                break;
            }
    
            --left;
        }
    }
    
    return 0;
}

에라토스테네스의 체를 기반으로 소수를 효울적으로 찾은 후 테스트케이스에 접근합니다.
각 테스트케이스의 입력에서 중간값부터 시작하여 left, right의 값이 모두 소수인지 확인하여 소수라면, 정답을 출력하고 마무리합니다.

[C++][백준][알고리즘] 약수

bonnate — Thu, 29 Feb 2024 17:49:39 +0900

1037번

1037번: 약수

첫째 줄에 N의 진짜 약수의 개수가 주어진다. 이 개수는 50보다 작거나 같은 자연수이다. 둘째 줄에는 N의 진짜 약수가 주어진다. 1,000,000보다 작거나 같고, 2보다 크거나 같은 자연수이고, 중복되

www.acmicpc.net

양수 A는 진짜약수(1과 자기 자신을 제외)한 값 중에서 최소값과 최대값을 서로 곱하면 자기 자신이 나옵니다.

17427번

17427번: 약수의 합 2

두 자연수 A와 B가 있을 때, A = BC를 만족하는 자연수 C를 A의 약수라고 한다. 예를 들어, 2의 약수는 1, 2가 있고, 24의 약수는 1, 2, 3, 4, 6, 8, 12, 24가 있다. 자연수 A의 약수의 합은 A의 모든 약수를 더

www.acmicpc.net

틀린 코드

#include <iostream>
#include <climits>
#include <cmath>

using namespace std;

int main() {
	int N;
	int answer = 0;
	scanf("%d", &N);
	
	for(int i = 1; i <= N; ++i)
	    for(int j = 1; j <= sqrt(i); ++j)
	        if(i % j == 0)
	        {
	            int temp = i / j;
	            if(temp != j)
	                answer += temp;
	        
	            answer += j;
	        }

    printf("%d", answer);
	return 0;
}

sqrt를 사용하여 n * √n으로 계산할 수 있습니다. 하지만 이 방법은 제한 시간 0.5초를 벗어난 크기입니다.
1,000,000 * 1,000은 1,000,000,000(10억)으로, 10초정도 소요되는 풀이 방법으로 해결할 수 없습니다.

맞은 코드

#include <iostream>
#include <climits>
#include <cmath>

using namespace std;

int main() {
	int N;
	long long answer = 0; // 수는 매우 커질 수 있기에 long long int로 선언
	scanf("%d", &N);
	
	/*
	    N이하 자연수 중 3을 약수로 갖는 수의 개수는 N / 3개!
	    그 이유는, 3의 배수로 이루어진 수는 N으로 나누어 떨어질 때 무조건 
	    그 수를 약수로 포함하기 때문!
	    
	    N이하의 자연수 중에서 1을 약수로 갖는 수의 개수는 ⌊N/1⌋개
        N이하의 자연수 중에서 2를 약수로 갖는 수의 개수는 ⌊N/2⌋개
        N이하의 자연수 중에서 3을 약수로 갖는 수의 개수는 ⌊N/3⌋개
        ...
        N이하의 자연수 중에서 i를 약수로 갖는 수의 개수는 ⌊N/i⌋개
	*/
	for(int i = 1; i <= N; ++i)
	{
	    int cnt = N / i;
	    answer += cnt * i;
	}

    // lld: long long int 출력
    printf("%lld", answer);
	return 0;
}

배수를 활용한 방식으로 문제를 해결하였습니다.
N이하의 자연수 중에서 1을 약수로 갖는 수의 개수는 ⌊N/1⌋개로 볼 수 있습니다. 그 이유는 1의 배수로 이루어진 수는 해당 수가 모두 1을 약수로 가지기 때문입니다.
예를 들어 9 이하의 자연수 중 3을 약수로 가지는 개수는 9/3으로 계산하여 3이 나옵니다.
- 3, 6, 9는 3의 배수이며, 이 수들은 모두 3을 약수로 가지게 됩니다.
이런 방식으로 접근하여 1~N까지의 모든 약수의 합을 구하려면 N번 반복하면 문제를 해결할 수 있습니다.

17425번

17425번: 약수의 합

www.acmicpc.net

#include <iostream>
#include <vector>
using namespace std;

const int MAX = 1000000;

int main() {
    vector<long long> dp(MAX + 1, 1);
    vector<long long> s(MAX + 1, 0);
    
    // 인덱스 번호에 해당하는 배수를 누적하여 저장
    // i의 배수가 가리키는 값은 i를 항상 약수로 가지는 성질
    for (int i = 2; i <= MAX; ++i) 
        for (int j = 1; i * j <= MAX; ++j) 
            dp[i * j] += i;

    // 인덱스 번호의 약수 합을 누적하여 차례대로 저장
    for (int i = 1; i <= MAX; ++i)
        s[i] = s[i - 1] + dp[i];

    int T, N;
    scanf("%d", &T);
    
    for(int i = 0; i < T; ++i)
    {
        scanf("%d", &N);
        printf("%lld\n", s[N]);
    }

    return 0;
}

17427번과 같은 문제이지만, 테스트케이스가 추가되어 각 테스트케이스를 각각 구하게 된다면 시간초과하는 문제입니다.
이 문제는 dp를 이용하여 MAX까지의 값을 일단 구하고, g(n)을 s라는 벡터에 미리 저장하여 모든 테스트 케이스에 대비하여 출력을 마지막에 하는 방식으로 해결하였습니다.

[C++][백준][알고리즘] 나머지 연산

bonnate — Thu, 29 Feb 2024 15:54:53 +0900

10430번

10430번: 나머지

첫째 줄에 A, B, C가 순서대로 주어진다. (2 ≤ A, B, C ≤ 10000)

www.acmicpc.net

덧셈, 곱셉, 뺄셈에서는 다음과 같은 식을 성립합니다. (나머지는 불가능)

(A+B) mod M = ((A mod M) + (B mod M)) mod M
- (4 + 7) % 3 = 11 % 3 = 2
- (4 % 3 + 7 % 3) = (1 + 1) % 3 = 2
(A×B) mod M = ((A mod M) × (B mod M)) mod M
- (4 * 7) % 3 = 28 % 3 = 1
- (4 % 3 * 7 % 3) = (1 * 1) % 3= 1
(A-B) mod M = ((A mod M) - (B mod M)) mod M
- (7 - 3) % 3 = 4 % 3 = 1
- (7 % 3 - 3 % 3) = (1 - 0) % 3 = 1
단, 뺄셈에서는 프로그래밍 언어에 따라 부호가 다르게 나옵니다. C++은 음수를 지원합니다.
- (6 % 3 ‒ 5 % 3) % 3 = (0 ‒ 2) % 3 = -2 % 3 = -2?

4375번

4375번: 1

2와 5로 나누어 떨어지지 않는 정수 n(1 ≤ n ≤ 10000)가 주어졌을 때, 각 자릿수가 모두 1로만 이루어진 n의 배수를 찾는 프로그램을 작성하시오.

www.acmicpc.net

나머지 연산이 포함된 문제는 다음과 같은 고려할 사항이 있습니다.

수의 크기가 int,longlong의 범위를 넘어갈 수 있기 때문에, 수를 실제로 만들 수 없다.
Java의 BigInteger,Python은 수의 범위 제한이 없어서 수를 실제로 만들 수 있지만, 수의 크기가 커지면 나누는데 걸리는 시간도 매우 오래 걸린다.

틀린 코드

#include <iostream>

int main() {
    int n;
    
    while(scanf("%d", &n) != EOF)
    {
        int digit = 1;
        long long value = 1;
        
        while(true)
        {
            value *= 10;
            value += 1;
            ++digit;
            
            if(value % n == 0)
            {
                printf("%d\n", digit);
                break;
            }
        }
    }

    return 0;
}

가장 먼저 생각할 수 있는 방법으로, 단순히 실제 value의 값을 1111111... 처럼 늘려 mod 연산이 0이 나올때까지 반복하여 계산할 수 있습니다. 하지만 이 방법은 시간 초과가 나 더 효율적인 방법을 찾아야 했습니다.

정답 코드

#include <iostream>

int main() {
    int n;
    
    while(scanf("%d", &n) != EOF)
    {
        int digit = 0; // 자리 수
        int remains = 1 % n; // 나머지
        
        while(true)
        {
            /*
                1 % 3 = 1
                11 % 3 = (1 * 10 + 1) % 3 = ({1 % 3} * 10 + 1) % 3
                111 % 3 = (11 * 10 + 1) % 3 = ({11 % 3} * 10 + 1) % 3
                1111 % 3 = (111 * 10 + 1) % 3 = ({111 % 3} * 10 + 1) % 3
                
                규칙: 이전 계산 값의 나머지 값을 활용하면 수가 무수히
                커지지 않고 계산할 수 있음!
            */
            
            // 나머지 연산의 성질을 이용한 식
            int remains = (remains * 10 + 1) % n;
            ++digit;
            
            if(remains == 0)
            {
                printf("%d\n", digit);
                break;
            }
        }
    }

    return 0;
}

나머지 연산자의 성질을 이용한 방법으로 해결하였습니다.
- 1 % 3 = 1
- 11 % 3 = (1 * 10 + 1) % 3 = ({1 % 3} * 10 + 1) % 3
- 111 % 3 = (11 * 10 + 1) % 3 = ({11 % 3} * 10 + 1) % 3
- 1111 % 3 = (111 * 10 + 1) % 3 = ({111 % 3} * 10 + 1) % 3
위 식과 같이 식을 분해하면 이전 값을 활용하여 수가 커지지 않고 계산을 이어나갈 수 있습니다.
예를 들어, 1이 10000자리인 매우 큰 수의 나머지가 3이라고 하였을때, 10001자리는 다음과 같이 구할 수 있습니다.
- (3 * 10 + 1) % N

[C++][백준 15649번] N과 M (1) ⭐

bonnate — Wed, 28 Feb 2024 17:38:23 +0900

15649번: N과 M (1)

한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다. 중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다. 수열은 사전 순으로 증가하는 순서로 출력해

www.acmicpc.net

문제

자연수 N과 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오.

1부터 N까지 자연수 중에서 중복 없이 M개를 고른 수열

풀이

순열을 구하는 문제입니다.
N개의 자연수 중 M개를 선택하여 모든 가능한 순서대로 배열하여 만들어야 합니다.
- ch는 인덱스 번호에 삽입한 자연수입니다.
- used는 해당 인덱스 번호를 사용하였는지 검사하기 위해 사용합니다.
{1, 2}와 {2, 1}은 서로 다른 순열입니다. 이는 조합과 다릅니다.
Permutations 함수에서 s가 M(선택할 개수)와 같다면 해당 함수는 종료됩니다.
- s는 현재 선택한 개수를 뜻합니다.
0부터 N까지 반복하여 used[i]가 false인 경우에만 ch에 저장한 후, s + 1을 하여 다음 DFS로 넘어갑니다.

// Online C++ compiler to run C++ program online
#include <iostream>

int N, M;

int ch[8];
int used[8];

void Permutations(int s)
{
	if (s == M)
	{
		for (int i = 0; i < M; ++i)
			printf("%d ", ch[i] + 1);
		printf("\n");
	}
	else
	{
		for (int i = 0; i < N; ++i)
			if (!used[i])
			{
				used[i] = true;
				ch[s] = i;
				Permutations(s + 1);
				used[i] = false;
			}
	}
}

int main() 
{
    scanf("%d %d", &N, &M);
    
    Permutations(0);

    return 0;
}

[C++][프로그래머스] 양과 늑대

bonnate — Wed, 28 Feb 2024 17:08:09 +0900

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

문제

2진 트리 모양 초원의 각 노드에 늑대와 양이 한 마리씩 놓여 있습니다. 이 초원의 루트 노드에서 출발하여 각 노드를 돌아다니며 양을 모으려 합니다. 각 노드를 방문할 때 마다 해당 노드에 있던 양과 늑대가 당신을 따라오게 됩니다. 이때, 늑대는 양을 잡아먹을 기회를 노리고 있으며, 당신이 모은 양의 수보다 늑대의 수가 같거나 더 많아지면 바로 모든 양을 잡아먹어 버립니다. 당신은 중간에 양이 늑대에게 잡아먹히지 않도록 하면서 최대한 많은 수의 양을 모아서 다시 루트 노드로 돌아오려 합니다.

예를 들어, 위 그림의 경우(루트 노드에는 항상 양이 있습니다) 0번 노드(루트 노드)에서 출발하면 양을 한마리 모을 수 있습니다. 다음으로 1번 노드로 이동하면 당신이 모은 양은 두 마리가 됩니다. 이때, 바로 4번 노드로 이동하면 늑대 한 마리가 당신을 따라오게 됩니다. 아직은 양 2마리, 늑대 1마리로 양이 잡아먹히지 않지만, 이후에 갈 수 있는 아직 방문하지 않은 모든 노드(2, 3, 6, 8번)에는 늑대가 있습니다. 이어서 늑대가 있는 노드로 이동한다면(예를 들어 바로 6번 노드로 이동한다면) 양 2마리, 늑대 2마리가 되어 양이 모두 잡아먹힙니다. 여기서는 0번, 1번 노드를 방문하여 양을 2마리 모은 후, 8번 노드로 이동한 후(양 2마리 늑대 1마리) 이어서 7번, 9번 노드를 방문하면 양 4마리 늑대 1마리가 됩니다. 이제 4번, 6번 노드로 이동하면 양 4마리, 늑대 3마리가 되며, 이제 5번 노드로 이동할 수 있게 됩니다. 따라서 양을 최대 5마리 모을 수 있습니다.

각 노드에 있는 양 또는 늑대에 대한 정보가 담긴 배열 info, 2진 트리의 각 노드들의 연결 관계를 담은 2차원 배열 edges가 매개변수로 주어질 때, 문제에 제시된 조건에 따라 각 노드를 방문하면서 모을 수 있는 양은 최대 몇 마리인지 return 하도록 solution 함수를 완성해주세요.

❗️ 제한사항

2 ≤ info의 길이 ≤ 17
- info의 원소는 0 또는 1 입니다.
- info[i]는 i번 노드에 있는 양 또는 늑대를 나타냅니다.
- 0은 양, 1은 늑대를 의미합니다.
- info[0]의 값은 항상 0입니다. 즉, 0번 노드(루트 노드)에는 항상 양이 있습니다.
edges의 세로(행) 길이 = info의 길이 - 1
- edges의 가로(열) 길이 = 2
- edges의 각 행은 [부모 노드 번호, 자식 노드 번호] 형태로, 서로 연결된 두 노드를 나타냅니다.
- 동일한 간선에 대한 정보가 중복해서 주어지지 않습니다.
- 항상 하나의 이진 트리 형태로 입력이 주어지며, 잘못된 데이터가 주어지는 경우는 없습니다.
- 0번 노드는 항상 루트 노드입니다.

풀이

스스로 해결하지 못해 아래의 글을 참고하여 문제를 이해하였습니다.

[C++] Programmers 양과 늑대 (2022 KAKAO Blind Recruitment)

https://programmers.co.kr/learn/courses/30/lessons/92343 코딩테스트 연습 - 양과 늑대 [0,0,1,1,1,0,1,0,1,0,1,1] [[0,1],[1,2],[1,4],[0,8],[8,7],[9,10],[9,11],[4,3],[6,5],[4,6],[8,9]] 5 [0,1,0,1,1,0,1,0,0,1,0] [[0,1],[0,2],[1,3],[1,4],[2,5],[2,6],[

korini.tistory.com

· 틀린 코드 (72.2점)

DFS를 이용하여 각 노드를 방문 시 연결된 모든 노드와, 방문했던 노드를 돌아가는 코드를 추가하여 모든 경우의 수를 검사하려했으나, 중복된 노드를 방문 시 wolf, sheep을 늘리는 문제와 복잡도가 증가하여 해결할 수 없었습니다.

#include <string>
#include <vector>
#include <climits>

using namespace std;

vector<bool> visit;
vector<bool> backed;
vector<vector<int>> graph;
vector<vector<int>> backing;
int answer = INT_MIN;

void dfs(int sheep, int wolf, int node, vector<int> info) {
    if(sheep == wolf)
    {
        printf("종료\n");
        return;
    }
        
    answer = max(answer, sheep);
    
    printf("[%d] %d, %d\n", node, sheep, wolf);
    
    if(node != 0)
    {
        printf("뒤로가기: [%d]->", node);
        backed[node] = true;
        dfs(sheep, wolf, backing[node][0], info);
        backed[node] = false;
    }
    
    for(int i = 0; i < graph[node].size(); ++i) {
        int next = graph[node][i];
        
        if(backed[next])
        {
            dfs(sheep, wolf + 1, next, info);
            continue;
        }
        
        if(visit[next] || next == node)
            continue;
        
        visit[next] = true;
        
        printf("[%d]->", node);
        
        if(info[next])
            dfs(sheep, wolf + 1, next, info);
        else
            dfs(sheep + 1, wolf, next, info);
        
        visit[next] = false;
    }
}

int solution(vector<int> info, vector<vector<int>> edges) {
    visit = vector<bool>(info.size(), false);
    backed = vector<bool>(info.size(), false);
    backing = vector<vector<int>>(edges.size() + 1, vector<int>());
    graph = vector<vector<int>>(edges.size() + 1, vector<int>());
    
    for(vector<int> edge : edges)
    {
        graph[edge[0]].push_back(edge[1]);
        graph[edge[1]].push_back(edge[0]);
    }
    
    for(vector<int> edge : edges)
        backing[edge[1]].push_back(edge[0]);
    
    visit[0] = true;
    dfs(1, 0, 0, info);
    
    return answer;
}

· 정답 코드

DFS와 BFS를 결합하여 접근한 방식입니다.
큐를 활용하여 현재 노드에서 갈 수 있는 모든 노드를 삽입하여 이를 순서대로 방문합니다.
만약, wolf >= sheep인 경우, 더 나아갈 수 없기때문에 현재 위치를 큐에 삽입합니다.
- ⭐ 현재 위치를 큐에 삽입하면, 다른 경로에서 sheep을 더 가져올 수 있습니다. 이를 통해 직전에 통과하지 못한 구간을 통과할 수 있게 됩니다.

// https://korini.tistory.com/40

#include <string>
#include <vector>
#include <algorithm>
#include <queue>

using namespace std;

vector<vector<int>> graph;
vector<int> _info;

int ans = 0;

void DFS(int cur, int sheep, int wolf, queue<int> q) 
{
    printf("%d\n", cur);
    
    // 현재 노드에 있는 양, 늑대를 계산
    if (_info[cur] == 0)
        sheep++;
    else
        wolf++;
    
    // 늑대가 더 많다면, 진행할 수 없음!
    if (wolf >= sheep)
        return;
    
    // 최대값 갱신
    ans = max(ans, sheep);
    
    // 현재 노드에서 갈 수 있는 모든 노드 삽입
    for (int i = 0; i < graph[cur].size(); i++) 
        q.push(graph[cur][i]);
    
    // 큐에 삽입된 순서대로 방문하기
    for (int i = 0; i < q.size(); i++) 
    {
        // 방문할 노드 가져오기
        int next = q.front();
        q.pop();
        
        // DFS 호출
        DFS(next, sheep, wolf, q);
        
        // DFS가 끝난 경우에 추후에 돌아오기 위해 대상 위치를 큐에 삽입
        // 삽입 전 queue의 다른 원소들을 방문하여 재시도 할 수 있음!
        q.push(next);
    }
}

int solution(vector<int> info, vector<vector<int>> edges) 
{
    // 단방향 그래프
    graph = vector<vector<int>>(info.size());
    
    // 전역 변수로 설정
    _info.assign(info.begin(), info.end());
    
    // 간선 정보 삽입
    for (int i = 0; i < info.size() - 1; i++)
        graph[edges[i][0]].push_back(edges[i][1]);
    
    queue<int> q;
    DFS(0, 0, 0, q);
    return ans;
}

[C++][프로그래머스] 최고의 집합

bonnate — Tue, 27 Feb 2024 15:35:36 +0900

프로그래머스

programmers.co.kr

문제

자연수 n 개로 이루어진 중복 집합(multi set, 편의상 이후에는 "집합"으로 통칭) 중에 다음 두 조건을 만족하는 집합을 최고의 집합이라고 합니다.

각 원소의 합이 S가 되는 수의 집합
위 조건을 만족하면서 각 원소의 곱 이 최대가 되는 집합

예를 들어서 자연수 2개로 이루어진 집합 중 합이 9가 되는 집합은 다음과 같이 4개가 있습니다.
{ 1, 8 }, { 2, 7 }, { 3, 6 }, { 4, 5 }
그중 각 원소의 곱이 최대인 { 4, 5 }가 최고의 집합입니다.

집합의 원소의 개수 n과 모든 원소들의 합 s가 매개변수로 주어질 때, 최고의 집합을 return 하는 solution 함수를 완성해주세요.

❗️ 제한사항

최고의 집합은 오름차순으로 정렬된 1차원 배열(list, vector) 로 return 해주세요.
만약 최고의 집합이 존재하지 않는 경우에 크기가 1인 1차원 배열(list, vector) 에 -1 을 채워서 return 해주세요.
자연수의 개수 n은 1 이상 10,000 이하의 자연수입니다.
모든 원소들의 합 s는 1 이상, 100,000,000 이하의 자연수입니다.

풀이

특정 알고리즘을 사용하기보다는 문제 해결을 위한 접근 방식의 접근이 중요한 문제라고 생각합니다.
다음과 같이 접근하여 해결하였습니다.
- 중복이 가능한 n개로 이루어진 집합을 구성할 때, 각 원소가 큰 숫자일수록 곱이 커집니다.
- 예를들어 n이 3, s가 10일경우 3, 3, 4의 조합으로 구성한것이 가장 큽니다.
- 이를 계산하기 위해 s / n을 max값으로 구성하고, s % n을 remain으로하여 remain의 개수만큼은 max + 1의 값으로 채웁니다.

#include <string>
#include <vector>

using namespace std;

vector<int> solution(int n, int s) {
    
    // 만약 합이 자연수 개수보다 작다면 불가능한 조합!
    if(n > s)
        return {-1};
    
    vector<int> answer;
    
    int max = s / n; // 몫 위주로 채우기
    int remains = s % n; // 나누어 떨어지지 않는경우, 몫+1 값으로 채우기
    
    // 나머지 개수가 아닌 만큼 목 위주로 채우기(낮은 값 우선)
    for(int i = 0; i < n - remains; ++i)
        answer.push_back(max);

    // 나머지 개수만큼은 몫+1 값으로 채우기
    for(int i = 0; i < remains; ++i)
        answer.push_back(max + 1);
    
    return answer;
}

[C++][프로그래머스] 네트워크(Union-Find)

bonnate — Mon, 26 Feb 2024 21:14:37 +0900

문제

네트워크란 컴퓨터 상호 간에 정보를 교환할 수 있도록 연결된 형태를 의미합니다. 예를 들어, 컴퓨터 A와 컴퓨터 B가 직접적으로 연결되어있고, 컴퓨터 B와 컴퓨터 C가 직접적으로 연결되어 있을 때 컴퓨터 A와 컴퓨터 C도 간접적으로 연결되어 정보를 교환할 수 있습니다. 따라서 컴퓨터 A, B, C는 모두 같은 네트워크 상에 있다고 할 수 있습니다.

컴퓨터의 개수 n, 연결에 대한 정보가 담긴 2차원 배열 computers가 매개변수로 주어질 때, 네트워크의 개수를 return 하도록 solution 함수를 작성하시오.

❗️ 제한사항

컴퓨터의 개수 n은 1 이상 200 이하인 자연수입니다.
각 컴퓨터는 0부터 n-1인 정수로 표현합니다.
i번 컴퓨터와 j번 컴퓨터가 연결되어 있으면 computers[i][j]를 1로 표현합니다.
computer[i][i]는 항상 1입니다.

풀이

union-find를 이용하여 문제를 해결합니다.
n의 크기에 해당하는 arr를 생성한 후 각 i로 초기화합니다.
그 후에 2중 for문을 통해 연결된 모든 네트워크를 union합니다.
마지막으로 모든 arr의 원소를 find하여 그룹 번호를 정리한 후, set에 중복되지 않는 개수를 리턴하여 정답을 구해냅니다.

#include <string>
#include <vector>
#include <map>
#include <queue>
#include <set>

using namespace std;

vector<int> arr;

// Find
int Find(int n) {
    if (n == arr[n]) return n; // n번째 그룹에 바로 속해있는경우 리턴
    else return arr[n] = Find(arr[n]); // n번째 그룹에 바로 속하지 않은경우, DFS로 실제 속한 그룹을 찾기
}

// Union
void Union(int a, int b) {
    arr[Find(a)] = Find(b); // arr[a]는 이제부터 b그룹에 속함
    arr[Find(b)] = Find(a); // arr[a]는 이제부터 b그룹에 속함
}

int solution(int n, vector<vector<int>> computers) {
    
    arr = vector<int>(n);
    
    // 집합 정보 초기화
    for (int i = 0; i < n; ++i)
        arr[i] = i;    
    
    for(int i = 0; i < n; ++i)
        for(int j = 0; j < n; ++j)
            if(computers[i][j])
                Union(i, j);
    
    set<int> s;
    for(int i = 0; i < n; ++i)
        s.insert(Find(i));
    
    return s.size();
}

[C++][프로그래머스] 단어 변환

bonnate — Mon, 26 Feb 2024 16:18:26 +0900

프로그래머스

programmers.co.kr

문제

두 개의 단어 begin, target과 단어의 집합 words가 있습니다. 아래와 같은 규칙을 이용하여 begin에서 target으로 변환하는 가장 짧은 변환 과정을 찾으려고 합니다.

1. 한 번에 한 개의 알파벳만 바꿀 수 있습니다.
2. words에 있는 단어로만 변환할 수 있습니다.

예를 들어 begin이 "hit", target가 "cog", words가 ["hot","dot","dog","lot","log","cog"]라면 "hit" -> "hot" -> "dot" -> "dog" -> "cog"와 같이 4단계를 거쳐 변환할 수 있습니다.

두 개의 단어 begin, target과 단어의 집합 words가 매개변수로 주어질 때, 최소 몇 단계의 과정을 거쳐 begin을 target으로 변환할 수 있는지 return 하도록 solution 함수를 작성해주세요.

❗️ 제한사항

각 단어는 알파벳 소문자로만 이루어져 있습니다.
각 단어의 길이는 3 이상 10 이하이며 모든 단어의 길이는 같습니다.
words에는 3개 이상 50개 이하의 단어가 있으며 중복되는 단어는 없습니다.
begin과 target은 같지 않습니다.
변환할 수 없는 경우에는 0를 return 합니다.

풀이

문제를 이해하는데 시간이 걸렸습니다.

words 배열에 target이 없으면 변환 자체가 불가능합니다.
words 배열에서 하나씩 선택하여 target을 만들면 됩니다.
- begin을 변경하되, 한 글자만 변경이 가능하며 이는 words 배열의 원소이어야 합니다.
words 배열에서 순서는 의미가 없습니다.

다음과 같은 방법으로 접근하여 해결하였습니다.

dfs를 이용하여 begin부터 시작하여 words 배열을 모두 검사하여 한글자씩 변경이 가능한 단어인경우, 해당 단어로 변경하여 target까지 변환을 시도하여 answer의 최소값을 구합니다.
bool sel[51]을 통해 중복선택을 피하여 최적의 값을 구할 수 있도록 합니다.

#include <string>
#include <vector>
#include <climits>
#include <set>
#include <algorithm>

using namespace std;

bool sel[51]; // words 속 해당 단어를 사용하였는가?
int answer = INT_MAX; // 정답 최소값을 갱신

bool check(string begin, string word)
{
    int cnt = 0;
    for(int i = 0; i < begin.size(); ++i)
        if(begin[i] != word[i])
            ++cnt;

    return cnt == 1;
}

void dfs(string word, string target, vector<string> words, int cnt)
{
    // 현재 생성된 단어가 target과 동일하다면 더 이상 진행하지 않고 최소값 갱신
    if(word == target)
    {
        answer = min(answer, cnt);
        return;        
    }
    
    // 모든 words를 검사하여 변환 가능하다면 뻗어나가기
    for(int i = 0; i < words.size(); ++i)
    {
        // 선택하지 않은 단어이면서, 글자가 한개만 차이가 난다면?
        if(!sel[i] && check(word, words[i]))
        {
            // 선택 완료 후 해당 문자열로 뻗어나가기
            sel[i] = true;
            dfs(words[i], target, words, cnt + 1);
            // 함수가 종료되면 다시 복구
            sel[i] = false;
        }
    }
}

int solution(string begin, string target, vector<string> words) {

    // words에 target이 없다면 변환 자체가 불가능!
    if(find(words.begin(), words.end(), target) == words.end())
        return 0;
    
    // dfs 탐색
    dfs(begin, target, words, 0);
    
    // 탐색 후 answer가 한번도 갱신되지 않았다면 0 리턴
    return answer == INT_MAX ? 0 : answer;
}

[C++][프로그래머스] 정수 삼각형

bonnate — Mon, 26 Feb 2024 15:26:53 +0900

프로그래머스

programmers.co.kr

문제

위와 같은 삼각형의 꼭대기에서 바닥까지 이어지는 경로 중, 거쳐간 숫자의 합이 가장 큰 경우를 찾아보려고 합니다. 아래 칸으로 이동할 때는 대각선 방향으로 한 칸 오른쪽 또는 왼쪽으로만 이동 가능합니다. 예를 들어 3에서는 그 아래칸의 8 또는 1로만 이동이 가능합니다.
삼각형의 정보가 담긴 배열 triangle이 매개변수로 주어질 때, 거쳐간 숫자의 최댓값을 return 하도록 solution 함수를 완성하세요.

ℹ️ 조건

삼각형의 높이는 1 이상 500 이하입니다.
삼각형을 이루고 있는 숫자는 0 이상 9,999 이하의 정수입니다.

풀이

bottom-up 방식으로 접근하여 문제를 해결하였습니다.
검사는 현재 노드에서 대각선 왼쪽과 오른쪽의 각 합을 검사하여 큰 값을 현재 노드에 저장하여 올라가는 방식으로 접근합니다.
- 맨 아래 배열의 한칸 위 "triangle.size() - 2" 부터 시작하여 0까지 올라갑니다.
- i의 값 + 1까지 검사하여 현재 행의 모든 노드를 검사합니다.
  - 현재 노드에서 triangle[i + 1][j]와 triangle[i + 1][j + 1]의 합 중 더 큰 값을 현재 노드에 저장하여 검사합니다.
마지막 리턴은 triangle[0][0]입니다.

#include <vector>

using namespace std;

int solution(vector<vector<int>> triangle) {

    // bottom-up 방식
    // 맨 아래의 한칸 위 {2, 7, 4, 4} 부터 시작하여 맨 위까지 검사
    for(int i = triangle.size() - 2; i >= 0; --i)
        // 현재 칸에서 한칸 아래의 개수(+1)만큼 검사
        for(int j = 0; j < i + 1; ++j)
            // 현재 칸의 값은 현재칸 + 대각선 왼쪽, 대각선 아래쪽의 합 중 큰 값을 저장
            triangle[i][j] += max(triangle[i + 1][j], triangle[i + 1][j + 1]);
    
    return triangle[0][0];
}

[유니티] Connect It

bonnate — Tue, 20 Feb 2024 19:35:54 +0900

Connect It은 학창시절 공책 또는 태블릿에 그림을 그리며 시간을 떼웠던 기억을 떠올려 '필기' 컨셉으로 제작한 게임입니다. 이 게임은 타일에서 다양한 색상의 원을 인접한 같은 색상으로 연결지어 정해진 시도 횟수 안에 높은 점수를 기록하는것이 목표입니다. 글로벌 랭킹 시스템을 도입하여 자신의 실력을 확인하고, 동기를 부여하도록 디자인 하였습니다.

게임 소개

게임 이름	플랫폼	개발 기간	개발 도구
Connect It (가제)	Windows, MacOS, iOS, Android	2024.02.20 ~ 개발 중	Unity

미리 보기

기타 정보

· 개발 중

현재 Connect It은 개발 중 게임입니다.
미리보기 영상은 24.02.20 기준이며, 디자인과 컨셉이 변경될 예정입니다.

[유니티] Rolling Orb

bonnate — Wed, 7 Feb 2024 16:32:16 +0900

Rolling Orb는 작은 오브를 좌우로 이동시켜 아래에서 빠르게 올라오는 장애물을 피해 오랫동안 버티는 게임입니다. 휴대폰 화면의 좌우를 터치 또는 키보드의 방향키로 조작하는 매우 쉬운 게임이지만, 오브는 점점 빨라지며, 더욱 복잡한 형태의 모양이 나오게 됩니다. 개인 최고 기록을 갱신하여, 다른 친구들과 경쟁하세요.

게임 소개

게임 이름	플랫폼	개발 기간	개발 도구
Rolling Orb	Windows, MacOS, iOS, Android	2024.02 (약 2주)	Unity

미리보기

기타 정보

· itch.io

itch.io에서 데스크톱 버전(MacOS, Windows)의 게임을 즐길 수 있습니다.

Rolling Orb by Bonnate(PARK SEUNG GEUN)

Rolling the orb to avoid obstacles and survive as long as you can!

bonnate.itch.io

[유니티] Persist it

bonnate — Wed, 7 Feb 2024 16:16:43 +0900

Persist it은 휴대폰을 기울여 공을 꾸준히 이동시키는 게임입니다. 공을 떨어뜨리기위해 폭탄, 바람, 레이저 등 다양한 방해 요소가 시간이 지남에따라 강력해지며 플레이어의 공을 위협합니다. 플레이어는 이러한 방해를 공을 움직여 버티며 오랫동안 살아남아 세계 기록을 세우는것이 목표입니다. 공을 굴려 오래 버티세요!

게임 소개

게임 이름	플랫폼	개발 기간	개발 도구
Persist it	Android, iOS	7일	Unity

미리 보기

작고 귀여운 축구공이 잔디밭에서 떨어지지 않을 것이라고 확신하시나요? 그렇다면, Persist It이 당신에게 딱 맞는 도전일지도 모릅니다! Persist It은 축구공을 잔디밭 위에서 떨어뜨리기 위해 다양한 방해를 해올 것입니다.

Persist It은 휴대폰을 기울여 공을 꾸준히 이동시키는 것을 요구하여, 그 과정에서 여러 가지 방해 요소를 마주하게 됩니다. 게임이 진행될수록 도전의 난이도는 상승하며, 여러 가지 예기치 못한 상황들이 발생할 것입니다. 공이 떨어지지 않도록 끊임없이 노력하며, 도전의 흥미로운 순간들을 만끽하세요!

[단순하지만 어려운 게임]
Persist It은 매우 단순한 게임이지만, 그 단순함이 게임의 어려움을 감출 만큼 충분합니다. 휴대폰을 기울여 공을 굴리는 것만으로 게임을 즐길 수 있습니다. 어떠한 복잡한 조작도 필요 없습니다. 그러나 이 작은 축구공을 계속해서 떨어뜨리지 않고 굴리는 것은 예상보다 어려울 수 있습니다!

[게임 러닝타임]
게임의 러닝타임은 평균적으로 3분을 넘지 않아 빠르게 진행됩니다. 하지만, 이 작은 게임에 숨겨진 어려움을 깨닫게 될 것입니다. 그렇게 간단해 보이지만, 얼마나 오랫동안 축구공을 떨어뜨리지 않고 굴릴 수 있을지 도전해보세요!

[글로벌 랭킹 시스템]
Persist It은 국가와 닉네임을 활용하여 버틴 시간을 자동으로 랭킹에 등록합니다. 여러분의 우수한 실력을 세계에 자랑하고, 다른 플레이어들과 경쟁하세요! 자신을 당당히 랭킹에 올려, 엄청난 플레이를 인정받으세요!

기타 정보

· 출시 예정

Persist it은 모바일 게임으로 PlayStore, AppStore에서 서비스 할 예정입니다. 현재는 심사를 받고 있습니다.

[유니티] Morph!

bonnate — Wed, 7 Feb 2024 15:32:15 +0900

Morph!는 게임 속 월드에서 수많은 오브젝트들로 변신하여 서로 추격하거나, 조용히 숨는 등 자신만의 플레이 스타일을 통해 즐길 수 있는 캐주얼 게임입니다. 대학교 4학년에 C# 소켓 서버를 개발 후 온라인 게임을 위해 제작한 프로젝트로, 크로스플랫폼을 지원하여 Steam, AppStore, PlayStore에서 온라인으로 플레이가 가능합니다. 현재 스토어에서 심사를 받아 출시 대기중입니다.

게임 소개

게임 이름	플랫폼	개발 기간	개발 도구
Morph!	Windows, MacOS, Android, iOS	2023.07 ~ 2024.02	Unity

미리 보기

"Morph"는 여러 가지 플레이 스타일을 구축하여 즐기는 캐주얼 인디 게임으로, 주어진 세계에서 100개가 넘는 다양한 객체를 '소유'하여 다른 플레이어를 찾아 쫓거나 조용히 숨을 수 있습니다.

다른 객체로 자신을 소유하세요!
다양한 객체로 소유하여 주변과 완벽하게 조화되어 존재를 숨기고 전략적으로 전술적 우위를 차지하세요.

다른 플레이어를 찾으세요!
다른 플레이어를 찾아 쫓고 처치하세요.

자연스럽게 숨으세요!
소유한 객체를 주변과 완벽하게 조화되도록 숨겨보세요.

스킬을 활용하세요!
다양한 스킬을 조합하여 고유한 플레이 스타일을 만들어 게임을 즐기세요.

다양한 맵에서 플레이하세요!
다양한 컨셉의 맵에서 다양한 객체를 활용해 게임을 즐겨보세요.

기타 정보

· Steam

Morph! on Steam

Morph is a casual game in which you can transform into a bunch of objects in the world of the game, chasing each other, or hiding quietly, and so on.

store.steampowered.com

Steam에서 해당 게임을 다운로드 받아 플레이 할 수 있습니다. 현재는 모든 심사가 완료되어 출시 대기중입니다.

· 트레일러 영상

· 스토어 이미지

· 요약 분석서

· 기타 문서

Morph 게임 플레이 팁 | Notion

Morph는 게임 속 월드에서 수많은 오브젝트들로 변신하여 서로 추격하거나, 조용히 숨는 등 자신만의 플레이 스타일을 통해 즐길 수 있는 캐주얼 게임입니다. 일반적으로 모든 플레이어를 처치하

thunder-puma-0c3.notion.site

개인정보 처리방침

morph-privacy.super.site

· 도움을 준 사람

에제이엘/
- Morph!의 메인 디자이너로서, Morph 대부분의 UI 디자인을 맡아주었습니다. 바쁜 시간에도 불구하고 적극적으로 다양한 디자인과 의견을 제공해주어 Morph가 자연스러운 UI를 가지도록 큰 도움을 주었습니다.
pencils57
- 큰 조력자로서, 많은 고민 사항을 시원하게 해결해 주었습니다. 게이머 친화적으로 다양한 부분에서 게임의 재미를 위해 의견을 제시하여 주었습니다.

[유니티] Mate

bonnate — Wed, 7 Feb 2024 15:08:03 +0900

Mate는 대학교 3학년에 스토리가 완결되는 게임을 제작하고자 시작한 프로젝트입니다. 이 게임은 주인공인 학교폭력의 가해자가 피해자의 실종으로 자신이 저지른 잘못에 대해 극도의 불안감을 느껴 정신적으로 고통을 받으며 지내는것을 그린 게임입니다. 플레이어는 각종 환각과 악몽을 꾸며 더욱 지쳐가며 여러분은 학교폭력의 가해자인 주인공을 조종하며 게임을 이어 나갑니다. 생애 첫 스토리 완결 게임으로, Steam에 무료로 업로드를 하여 서비스하고 있습니다.

게임 소개

게임 이름	플랫폼	개발 기간	개발 도구
Mate	Windows, MacOS	2022.03 ~ 2022.07	Unity

미리 보기

기타 정보

· Steam

Mate on Steam

Mate is a third-person story-based game with a multi-ending game with puzzles and physical controls.The protagonist, the perpetrator of school violence, is anxious that his actions will be revealed to others, which leads to psychological hallucinations and

store.steampowered.com

이 게임은 Steam에서 서비스중인 무료게임입니다. Steam을 통해 다운로드 받아 플레이할 수 있습니다.

· 프로젝트에 대하여

Mate는 4개월간 사운드의 일부를 제외한 에셋 제작, 기획을 포함하여 모든것을 직접 제작한 의미 있는 게임입니다.
생애 첫 Steam에 업로드하여 개발자로서 게임을 글로벌로 첫 출시한 게임입니다.

[유니티] Sky & Shoe

bonnate — Wed, 7 Feb 2024 14:57:33 +0900

Sky & Shoe는 ‘소라피리’ 기업에서 출판한 동화책 ‘배가 된 꽃신’의 원화을 활용하여 게임 제작 외주를 통해 개발한 게임입니다. 원화 이미지를 유니티의 쉐이더를 활용하여 2D 이미지 기반으로 구성된 3D 월드 컨셉으로 제작을 하였습니다. 이미지의 그림자와 심도가 표현되도록 개발하였으며, 동화책의 스토리를 재구성한 게임입니다.

게임 소개

게임 이름	플랫폼	개발 기간	개발 도구
Sky & Shoe	Windows, MacOS, Android, iOS	2022.09 ~ 2023.01	Unity

미리 보기

기타 정보

· 프로젝트에 대하여

이 게임은 '배가 된 꽃신' 동화책의 원화를 이용하여 제작한 게임입니다.
프로젝트 매니저 2명, 게임 원화가 2명, 개발 1명으로 구성되었으며 게임 기획 및 클라이언트 개발을 담당하였습니다.

[유니티] Dragon Quest

bonnate — Wed, 7 Feb 2024 14:46:27 +0900

Dragon Quest는 RPG 장르의 게임으로, 유니티 엔진을 사용하여 개발하였습니다. 플레이어가 다양한 환경에서 다양한 적과 싸우며 성장해나가는 모험을 담고 있습니다. 이 포트폴리오 게임에는 일반적인 RPG 게임에서 볼 수 있는 여러 요소들을 직접 구현하고 적용하였습니다.

게임 소개

게임 이름	플랫폼	개발 기간	개발 도구
Dragon Quest	Windows, MacOS	2022.08 ~ 2023.04	Unity

미리 보기

기타 정보

· 다운로드

[Portfolio] Dragon Quest by Bonnate(PARK SEUNG GEUN)

RPG game portfolio made using Unity.

bonnate.itch.io

이 게임은 itch.io의 별도로 지원을 받아 다운로드 받아 플레이할 수 있습니다.

· 상세 설명 영상

· 기획 및 개발분석안

[유니티] ZombieRun

bonnate — Wed, 7 Feb 2024 14:28:16 +0900

ZombieRun은 대학교 3학년 2학기에 '게임엔진응용실습' 수업에서 진행한 게임 프로젝트입니다. 어두운 산 속에서 길을 잃은 당신은 도움을 청하기 위해 산 정상에 올라가야 합니다. 길을 따라가며 죽지 않고 이동하세요. 총을 사용하여 좀비를 죽이고 자신을 보호하세요. 주변을 탐색하여 총알을 획득하여 전투하거나, 좀비를 살펴 피해다닐 수 있습니다.

게임 소개

게임 이름	플랫폼	개발 시간	개발 도구
ZombieRun	Windows, MacOS	12시간	Unity

미리 보기

기타 정보

· 다운로드

ZombieRun by Bonnate(PARK SEUNG GEUN)

It is a simple FPS game where you use a gun and avoid zombies to reach your destination.

bonnate.itch.io

itch.io에서 게임을 다운로드하여 플레이할 수 있습니다. Windows와 MacOS를 지원합니다.

[유니티] Tower Defense

bonnate — Wed, 7 Feb 2024 14:13:19 +0900

Tower Defense는 대학교 3학년 2학기에 '게임엔진응용실습' 수업에서 진행한 게임 프로젝트입니다. 다가오는 적들이 미리 정해진 경로를 따라 목적지에 도달하기 전에 처치해야 하는 게임입니다. 적을 처치하여 돈을 벌고, 세 가지 유형의 타워를 구매하여 설치해 적을 공격할 수 있습니다. 점점 더 어려워지는 난이도속에서 오래 살아남으세요. 생명력이 0이 되면 게임이 종료됩니다.

게임 소개

게임 이름	플랫폼	개발 시간	개발 도구
Tower Defense	Windows, MacOS, Android	4시간	Unity

미리 보기

기타 정보

· 다운로드

Tower Defense by Bonnate(PARK SEUNG GEUN)

Simple Tower Defense Game! Windows and Android Support.

bonnate.itch.io

itch.io에서 게임을 다운로드하여 플레이할 수 있습니다. Windows와 Android를 지원합니다.

· 타워 종류

전략적으로 타워를 배치하고 업그레이드하여 적의 공격을 막고 영토를 보호하세요.

화살 타워: 범위 내의 적 1명에게 유도 화살을 발사합니다.
석궁 타워 : 경로 끝을 향해 직선으로 화살을 발사합니다.
버프 타워: 주변 타워의 공격 속도를 향상시킵니다.

[유니티] Space Invader

bonnate — Wed, 7 Feb 2024 13:51:28 +0900

Space Invader는 대학교 3학년 2학기에 '게임엔진응용실습' 수업에서 진행한 게임 프로젝트입니다. 지정된 경로를 따라 전진하는 우주선을 조종하는 게임입니다. 마우스를 사용하여 총알을 발사하여 로켓과 적 항공기를 파괴하고, 장애물과 충돌하지 않고 목표 지점에 도달하는 것입니다. 적의 우주선이 공격할 기회를 갖기 전에 전략적으로 제거해야 합니다.

게임 소개

게임 이름	플랫폼	개발 시간	개발 도구
Space Invader	Windows	8시간	Unity

미리 보기

기타 정보

· 다운로드

Space Invader by Bonnate(PARK SEUNG GEUN)

Destroy rockets and enemy aircraft by firing bullets using your mouse!

bonnate.itch.io

itch.io에서 게임을 다운로드하여 플레이할 수 있습니다. MacOS를 지원합니다.

[유니티] Space Flight

bonnate — Wed, 7 Feb 2024 13:25:37 +0900

'Space Flight'는 대학교 3학년 2학기에 '게임엔진응용실습' 수업에서 진행한 게임 프로젝트입니다. 이 게임은 우주선을 파괴하는 소행성의 충돌을 피하고, 위협적인 직선 로켓도 피해야 합니다. 더 오래 생존하고 더 멀리 여행할수록 점수가 높아집니다.

게임 정보

게임 이름	플랫폼	개발 시간	개발 도구
Space Flight	MacOS	4시간	유니티

미리 보기

기타 정보

· 다운로드

Space Flight by Bonnate(PARK SEUNG GEUN)

Avoid collisions with asteroids!

bonnate.itch.io

itch.io에서 게임을 다운로드하여 플레이할 수 있습니다. Windows를 지원합니다.

[C# 서버] 소켓 서버 문서

bonnate — Sun, 28 Jan 2024 15:04:42 +0900

C# 기반으로 제작한 소켓 서버의 문서입니다.
이 서버는 Unity 엔진을 위해 제작되었으며, 온라인 게임을 포함하여 시뮬레이션, 하드웨어 제어 등 다양한 분야에서 사용될 수 있습니다.

[C#] MySqlConnector를 통해 DB와 통신하기

bonnate — Sun, 28 Jan 2024 13:10:34 +0900

MySqlConnector 패키지를 이용하여 DB와 통신할 수 있습니다. static 메서드를 통해 별도의 인스턴스 없이 편리하게 접근하여 DB 쿼리를 작성할 수 있도록 구현합니다.

미리 보기

서론

'미리보기'에 나오는 영상은 Morph! 게임에서 사용자의 로그인을 하는 과정입니다.
작성한 'MySqlManager' 클래스는 서버에 구현되어있으며, 클라이언트는 서버를 통해 DB에 접근하는 방식입니다.
이렇게 구현한 이유는 MySQL에 접근하기위한 접속쿼리가 클라이언트 코드에 노출되지 않게 하기 위함입니다.
- 클라이언트의 디컴파일을 통해 리터럴이 노출되면 DB 자체가 공격을 받을 수 있기 때문입니다.

구현 내용

MySqlManager에서는 Insert, Update 등을 수행할 수 있는 'Command' 메서드와 데이터를 읽기 위한 'Select' 메서드를 구현하였습니다.

⚒️ 구현

· 구현 내용

using MySqlConnector;
using Server.Game;
using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

/// <summary>
/// MySQL 쿼리 매니저
/// </summary>
public class MySqlManager
{
    private static ThreadLocal<MySqlConnection> _Connection = new ThreadLocal<MySqlConnection>(); // SQL Connection

    private static string _SqlConnection = null; //SQL 접속 명령인자

    static MySqlManager()
    {
        // 접속 명령인자 생성
        StringBuilder builder = new StringBuilder();

        builder.AppendFormat("Server={0};", "192.168.0.1"); // DB가 설치된 ID
        builder.AppendFormat("Port={0};", "1234"); // DB의 포트 번호
        builder.AppendFormat("Database={0};", "sampleDB"); // 데이터베이스 이름
        builder.AppendFormat("Uid={0};", "sampleUser"); // 사용자 이름
        builder.AppendFormat("Pwd={0}", "samplePassword"); // 사용자의 비밀번호

        _SqlConnection = builder.ToString();
    }

    private static void MySqlConnect()
    {
        try
        {
            _Connection.Value = new MySqlConnection(_SqlConnection);
            _Connection.Value.Open();

            if (_Connection.Value.State != ConnectionState.Open)
            {
                throw new InvalidOperationException("Connection failed to open.");
            }
        }
        catch (Exception ex)
        {
            Logger.Log(ex.Message);
        }
    }

    private static void MySqlDisconnect()
    {
        if (_Connection.Value != null && _Connection.Value.State != ConnectionState.Closed)
        {
            _Connection.Value.Close();
            _Connection.Value = null;
        }
    }

    public static MySqlErrorCode Command(string command)
    {
        Logger.Log($"[SELECT]: {command}");

        MySqlConnect(); // 접속

        try
        {
            MySqlCommand dbcmd = new MySqlCommand(command, _Connection.Value); // 명령어를 커맨드에 입력
            dbcmd.ExecuteNonQuery(); // 명령어를 SQL에 보냄

            return MySqlErrorCode.None;
        }
        catch (MySqlException e) // SQL 오류
        {
            Logger.Log(e.ToString());

            return e.ErrorCode;
        }
        finally
        {
            MySqlDisconnect(); // 접속 해제
        }
    }

    public static DataTableReader Select(string command)
    {
        Logger.Log($"[SELECT]: {command}");

        MySqlConnect(); // 접속

        try
        {
            MySqlDataAdapter adapter = new MySqlDataAdapter(command, _Connection.Value);
            DataTable table = new DataTable(); // 테이블 생성
            adapter.Fill(table); // 데이터 테이블 채우기

            return table.CreateDataReader(); // 성공적으로 select를 했다면, 데이터 리더를 생성
        }
        catch (MySqlException e) // SQL 오류 발생
        {
            Logger.Log(e.ToString());

            return null;
        }
        finally
        {
            MySqlDisconnect(); // 접속 해제
        }
    }
}

builder.AppendFormat("Server={0};", "192.168.0.1"); // DB가 설치된 ID
builder.AppendFormat("Port={0};", "1234"); // DB의 포트 번호
builder.AppendFormat("Database={0};", "sampleDB"); // 데이터베이스 이름
builder.AppendFormat("Uid={0};", "sampleUser"); // 사용자 이름
builder.AppendFormat("Pwd={0}", "samplePassword"); // 사용자의 비밀번호

이곳에서 접속할 데이터베이스의 접속인자를 정의합니다. 이 코드에서는 임시로 채워넣었습니다.

public static MySqlErrorCode Command(string command)

Command 메서드는 테이블을 읽지 않는 쿼리를 요청할때 사용할 수 있습니다.
MySqlErrorCode를 리턴하여 성공적으로 Command를 수행했는지 확인할 수 있습니다.

public static DataTableReader Select(string command)

Select 메서드는 테이블을 읽고, 이를 리턴하기위해 사용할 수 있습니다.
사용자의 로그인, 회원가입 읽기 등 다양한 부분에서 사용합니다.

✅ 적용

· Command

public static void AddCoin(int playerUniqueId, int amount)
{
    DataTableReader balanceInfo = MySqlManager.Select($"select coins from balance where user_id = {playerUniqueId}");
    if (balanceInfo.Read())
    {
        MySqlManager.Command($"update balance set coins = {balanceInfo.GetInt32(0) + amount} where user_id = {playerUniqueId};");
    }
    else
    {
        Logger.Log($"[ERROR EXCEPTION] No {playerUniqueId} Level Column from DB!");
    }
}

다음과 같이 Command를 사용할 수 있습니다.
Command는 UPDATE문 등 테이블을 읽지 않는 쿼리를 사용하기 위한 메서드입니다.

· Select

/// <summary>
/// 플레이어의 현재 인벤토리 정보를 전송
/// </summary>
/// <param name="clientSession"></param>
public static void SendPlayerInventory(ClientSession clientSession)
{
    int PlayerUniqueId = clientSession.MyPlayer.PlayerInfo.PlayerUniqueId;
    S_RespondPlayerGameData s_RespondPlayerGameData = new S_RespondPlayerGameData();

    // 인벤토리 정보 가져오기
    DataTableReader inventoryInfo = MySqlManager.Select($"select item_id, amount from inventory where user_id = {PlayerUniqueId}");
    while (inventoryInfo.Read())
    {
        int item_id = Convert.ToInt32(inventoryInfo["item_id"]); // item_id 열 값 가져오기
        int amount = Convert.ToInt32(inventoryInfo["amount"]);   // amount 열 값 가져오기

        // DbItemData 객체 생성 및 값 할당
        DbItemData itemData = new DbItemData()
        {
            EntityCode = item_id,
            Count = amount,
        };

        // DbItemDatas 추가
        s_RespondPlayerGameData.InventoryInfo.Add(itemData);
    }

    DataTableReader expInfo = MySqlManager.Select($"select exp, lv from level where user_id = {PlayerUniqueId}");
    if (expInfo.Read())
    {
        s_RespondPlayerGameData.Exp = expInfo.GetInt32(0);
        s_RespondPlayerGameData.Level = expInfo.GetInt32(1);
    }
    else
        Logger.Log($"uniqueId {PlayerUniqueId} is null from DB!");

    DataTableReader coinInfo = MySqlManager.Select($"select coins, skill_point from balance where user_id = {PlayerUniqueId}");
    if (coinInfo.Read())
    {
        s_RespondPlayerGameData.Coins = coinInfo.GetInt32(0);
        s_RespondPlayerGameData.SkillPoint = coinInfo.GetInt32(1);
    }
    else
        Logger.Log($"uniqueId {PlayerUniqueId} is null from DB!");

    // 데이터 전송
    clientSession.Send(s_RespondPlayerGameData);

    // 할당 인벤토리 데이터 전송
    SendAllocatedInventorySelf(clientSession);
}

위 코드는 플레이어의 인벤토리 정보를 전달하기 위한 메서드입니다.
Select 쿼리를 사용하여 DB에서 정보를 읽고, 이를 추출하여 패킷에 담아 보냅니다.

️ Unity Affiliate

Unity Affiliate Program 파트너로서 아래의 배너를 통해 접속하신 경우 수수료를 받을 수 있습니다.
아래 배너의 에셋들은 '실시간 무료 에셋 랭킹'을 나타냅니다.

[유니티] Graphics device is null. 오류 해결

bonnate — Thu, 18 Jan 2024 10:28:26 +0900

에디터에서는 괜찮지만, 빌드 후 실행 시 "Graphics device is null." 오류가 나타날 수 있습니다. 이 오류의 원인은 다양하지만, TMP를 서브스레드에서 제어할 경우 나타날 수 있습니다. 이를 해결하기위해 메인스레드에서 제어할 수 있도록 하는 기능을 구현하였습니다.

서론

유니티 빌드 프로그램이 크래시가 난 후 player.log를 살펴보면 다음과같이 stacktrace와 함께 오류가 난 부분이 나타납니다. 이 함수가 호출되는 위치를 메인스레드에서 호출할 수 있도록 구현한 기능을 이용합니다.

Graphics device is null.
TMPro.TextMeshProUGUI:Awake()
UiTab:ToggleLerp(Boolean, Single)
PacketHandler:S_EnterGameHandler(PacketSession, IMessage)
PacketManager:MakePacket(PacketSession, ArraySegment`1, UInt16)
ServerSession:OnRecvPacket(ArraySegment`1)
ServerCore.PacketSession:OnRecv(ArraySegment`1)
ServerCore.Session:OnRecvCompleted(Object, SocketAsyncEventArgs)
System.Net.Sockets.<>c:<.cctor>b__367_10(IAsyncResult)
System.Threading.ThreadPoolWorkQueue:Dispatch()

⚒️ 구현

싱글턴으로 Monobehavior을 상속받아 메인스레드에서 Upate를 호출하여 queue의 내용을 꺼내와 함수를 호출합니다.

using UnityEngine;
using System;
using System.Collections.Generic;

public class UnityMainThreadDispatcher : MonoBehaviour
{
    private static readonly Queue<Action> _executionQueue = new Queue<Action>();
    private static UnityMainThreadDispatcher _instance = null;

    public static UnityMainThreadDispatcher Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = FindObjectOfType<UnityMainThreadDispatcher>();

                if (_instance == null)
                {
                    GameObject go = new GameObject("UnityMainThreadDispatcher");
                    _instance = go.AddComponent<UnityMainThreadDispatcher>();
                }
            }

            return _instance;
        }
    }

    private void Awake() 
    {
        UnityMainThreadDispatcher.Instance.Enqueue(() => Debug.Log("UnityMainThreadDispatcher Active!"));
    }

    private void Update()
    {
        lock (_executionQueue)
        {
            while (_executionQueue.Count > 0)
            {
                _executionQueue.Dequeue().Invoke();
            }
        }
    }

    public void Enqueue(Action action)
    {
        lock (_executionQueue)
        {
            _executionQueue.Enqueue(action);
        }
    }
}

✅ 적용

매니저로서 역할을 수행할 수 있도록 Scene에 컴포넌트를 추가해줍니다.

오류가 난 부분이 메인스레드에서 호출될 수 있도록 Action타입으로 함수를 호출해줍니다.

/// <summary>
/// 서버에 접속하면 네트워크 매니저가 호출
/// </summary>
public void ConnectedFromServer()
{
    UnityMainThreadDispatcher.Instance.Enqueue(() => 
    {
        // Auth 매니저 활성화
        AuthManager.Instance.Init();

        // 로딩 탭 비활성화
        UiTabCtrl.Clear(1.0f);
    });
}

️ Unity Affiliate

Unity Affiliate Program 파트너로서 아래의 배너를 통해 접속하신 경우 수수료를 받을 수 있습니다.
아래 배너의 에셋들은 '실시간 무료 에셋 랭킹'을 나타냅니다.

[C++][백준 2579번] 계단오르기

bonnate — Mon, 11 Dec 2023 06:01:53 +0900

2579번: 계단 오르기

계단 오르기 게임은 계단 아래 시작점부터 계단 꼭대기에 위치한 도착점까지 가는 게임이다. <그림 1>과 같이 각각의 계단에는 일정한 점수가 쓰여 있는데 계단을 밟으면 그 계단에 쓰여 있는 점

www.acmicpc.net

문제

계단 오르기 게임은 계단 아래 시작점부터 계단 꼭대기에 위치한 도착점까지 가는 게임이다. <그림 1>과 같이 각각의 계단에는 일정한 점수가 쓰여 있는데 계단을 밟으면 그 계단에 쓰여 있는 점수를 얻게 된다.

<그림 1>

예를 들어 <그림 2>와 같이 시작점에서부터 첫 번째, 두 번째, 네 번째, 여섯 번째 계단을 밟아 도착점에 도달하면 총 점수는 10 + 20 + 25 + 20 = 75점이 된다.

<그림 2>

계단 오르는 데는 다음과 같은 규칙이 있다.

계단은 한 번에 한 계단씩 또는 두 계단씩 오를 수 있다. 즉, 한 계단을 밟으면서 이어서 다음 계단이나, 다음 다음 계단으로 오를 수 있다.
연속된 세 개의 계단을 모두 밟아서는 안 된다. 단, 시작점은 계단에 포함되지 않는다.
마지막 도착 계단은 반드시 밟아야 한다.
따라서 첫 번째 계단을 밟고 이어 두 번째 계단이나, 세 번째 계단으로 오를 수 있다. 하지만, 첫 번째 계단을 밟고 이어 네 번째 계단으로 올라가거나, 첫 번째, 두 번째, 세 번째 계단을 연속해서 모두 밟을 수는 없다.

각 계단에 쓰여 있는 점수가 주어질 때 이 게임에서 얻을 수 있는 총 점수의 최댓값을 구하는 프로그램을 작성하시오.

풀이

계단을 오르며 최대 점수를 누적하여 정답을 구해야합니다.
조건으로, 계단을 세개 연속으로 밟을 수 없기때문에 아래와 같이 고려해야합니다.
- 현재 위치(n)일 때, n-3의 누적 + n-1을 밟으면서 n을 밟은 경우
- n에서 n-2의 누적과 함께 n을 밟은 경우

#include <iostream>
#include <vector>
using namespace std;

vector<int> dp(301, -1);
int input[301];

//int func(int n)
//{
//	// 0보다 작다면 0리턴
//	if (n < 0)
//		return 0;
//
//	int& ret = dp[n];
//
//	// 해당 값이 이미 있다면, 즉시 리턴
//	if (ret != -1)
//		return ret;
//
//	ret = max(ret, func(n - 2) + input[n]); // case1: n-2 계단과 n번 계단을 함께 밟는 경우
//	ret = max(ret, func(n - 3) + input[n - 1] + input[n]); // case2: n-3 계단과 n-1, n번 계단을 함께 밟는 경우
//
//	return ret;
//}

int main()
{
	ios_base::sync_with_stdio(false);

	int N;
	cin >> N;

	for (int i = 1; i <= N; ++i)
		cin >> input[i];

	dp[0] = 0;
	dp[1] = input[1]; // 1번 계단까지의 최대값은 1번 계단
	dp[2] = input[1] + input[2]; // 2번 계단까지의 최대값은 1번 계단 + 2번 계단
	for (int i = 3; i <= N; ++i)
		dp[i] = max(dp[i - 3] + input[i - 1] + input[i], dp[i - 2] + input[i]);

	cout << dp[N];
}

dp를 통해 문제를 해결하며, top-down 과 bottom-up 방식을 모두 구현하였습니다.

[C++][백준 9095번] 1, 2, 3 더하기

bonnate — Mon, 11 Dec 2023 04:49:30 +0900

9095번: 1, 2, 3 더하기

각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 출력한다.

www.acmicpc.net

문제

정수 4를 1, 2, 3의 합으로 나타내는 방법은 총 7가지가 있다. 합을 나타낼 때는 수를 1개 이상 사용해야 한다.

1+1+1+1
1+1+2
1+2+1
2+1+1
2+2
1+3
3+1

정수 n이 주어졌을 때, n을 1, 2, 3의 합으로 나타내는 방법의 수를 구하는 프로그램을 작성하시오.

풀이

#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
	int dp[12];

	dp[1] = 1; // 1
	dp[2] = 2; // 1+1, 2
	dp[3] = 4; // 1+1+1, 1+2, 2+1, 3
	//dp[4] = 7; // 1+1+1+1, 1+1+2, 1+2+1, 2+1+1, 2+2, 1+3, 3+1

	int T, n;
	cin >> T;

	for (int i = 4; i < 12; ++i)
		dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];

	for (int i = 0; i < T; ++i)
	{
		cin >> n;
		cout << dp[n] << endl;
	}
}

dp를 이용하여 해결할 수 있습니다.bottom-up 방식으로 해결하였습니다.
dp[i]를 구할때엔 다음과 같이 점화식을 세울 수 있습니다.
- dp[i - 3]에서 3을 추가
- dp[i - 2]에서 2를 추가
- dp[i - 1]에서 1을 추가
위 세개를 모두 더하면 dp[i]가 나옵니다.

[C++][백준 1463번] 1로 만들기 ⭐

bonnate — Mon, 11 Dec 2023 04:26:28 +0900

1463번: 1로 만들기

첫째 줄에 1보다 크거나 같고, 106보다 작거나 같은 정수 N이 주어진다.

www.acmicpc.net

문제

정수 X에 사용할 수 있는 연산은 다음과 같이 세 가지 이다.

X가 3으로 나누어 떨어지면, 3으로 나눈다.
X가 2로 나누어 떨어지면, 2로 나눈다.
1을 뺀다.
정수 N이 주어졌을 때, 위와 같은 연산 세 개를 적절히 사용해서 1을 만들려고 한다. 연산을 사용하는 횟수의 최솟값을 출력하시오.

풀이

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> dp(1000001);

int main()
{
	int N;
	cin >> N;

	dp[1] = 0;

	// bottom-up
	for (int i = 2; i <= N; ++i)
	{
		// 1을 더해보기
		dp[i] = dp[i - 1] + 1;

		// 3으로 나누어 떨어진다면, 현재 값과, 3으로 나누고 + 1한 값 중 낮은 값을 사용
		if (i % 3 == 0)
			dp[i] = min(dp[i], dp[i / 3] + 1);

		// 2로 나누어 떨어진다면, 현재 값과, 2로 나누고 + 1한 값 중 낮은 값을 사용
		if (i % 2 == 0)
			dp[i] = min(dp[i], dp[i / 2] + 1);
	}

	cout << dp[N];
}

bottom-up 방식으로 문제를 해결합니다.
dp[1]은 0이므로, 2부터 시작하여 차례대로 최소값을 갱신하여 나아갑니다.
- 단순히 이전 값에서 1을 더하여 계산합니다.
- 만약 3으로 나누어 떨어진다면, 현재 값과 3으로 나누고 1을 더한 값 중 낮은 값을 사용합니다.
- 만약 2로 나누어 떨어진다면, 현재 값과 2로 나누고 1을 더한 값 중 낮은 값을 사용합니다.

[C++][프로그래머스] 코딩 테스트 연습

bonnate — Mon, 11 Dec 2023 00:02:42 +0900

프로그래머스

programmers.co.kr

문제

당신은 코딩 테스트를 준비하기 위해 공부하려고 합니다. 코딩 테스트 문제를 풀기 위해서는 알고리즘에 대한 지식과 코드를 구현하는 능력이 필요합니다.

알고리즘에 대한 지식은 알고력, 코드를 구현하는 능력은 코딩력이라고 표현합니다. 알고력과 코딩력은 0 이상의 정수로 표현됩니다.

문제를 풀기 위해서는 문제가 요구하는 일정 이상의 알고력과 코딩력이 필요합니다.

예를 들어, 당신의 현재 알고력이 15, 코딩력이 10이라고 가정해보겠습니다.

A라는 문제가 알고력 10, 코딩력 10을 요구한다면 A 문제를 풀 수 있습니다.
B라는 문제가 알고력 10, 코딩력 20을 요구한다면 코딩력이 부족하기 때문에 B 문제를 풀 수 없습니다.
풀 수 없는 문제를 해결하기 위해서는 알고력과 코딩력을 높여야 합니다. 알고력과 코딩력을 높이기 위한 다음과 같은 방법들이 있습니다.

알고력을 높이기 위해 알고리즘 공부를 합니다. 알고력 1을 높이기 위해서 1의 시간이 필요합니다.
코딩력을 높이기 위해 코딩 공부를 합니다. 코딩력 1을 높이기 위해서 1의 시간이 필요합니다.
현재 풀 수 있는 문제 중 하나를 풀어 알고력과 코딩력을 높입니다. 각 문제마다 문제를 풀면 올라가는 알고력과 코딩력이 정해져 있습니다.
문제를 하나 푸는 데는 문제가 요구하는 시간이 필요하며 같은 문제를 여러 번 푸는 것이 가능합니다.
당신은 주어진 모든 문제들을 풀 수 있는 알고력과 코딩력을 얻는 최단시간을 구하려 합니다.

초기의 알고력과 코딩력을 담은 정수 alp와 cop, 문제의 정보를 담은 2차원 정수 배열 problems가 매개변수로 주어졌을 때, 모든 문제들을 풀 수 있는 알고력과 코딩력을 얻는 최단시간을 return 하도록 solution 함수를 작성해주세요.

풀이

#include <string>
#include <vector>
#include <algorithm>
#define MAX_VALUE 1000000

using namespace std;

int solution(int alp, int cop, vector<vector<int>> problems) {
    
    // dp의 인덱스 번호는 현재 알고력과 코딩력의 누적 cost
    vector<vector<int>> dp(152, vector<int>(152, MAX_VALUE));
    
    // 요구하는 코딩력과 알고력을 구하기
    int maxAlp = alp, maxCop = cop;
    for(vector<int>& problem : problems)
    {
        maxAlp = max(maxAlp, problem[0]);
        maxCop = max(maxCop, problem[1]);
    }
    
    // 만약 alp와 cop가 요구하는 값 이상이라면 0 리턴
    if(alp >= maxAlp && cop >= maxCop)
        return 0;
    
    dp[alp][cop] = 0; // 시작 부분은 0
    for(int i = alp; i <= maxAlp; ++i)
    {
        for(int j = cop; j <= maxCop; ++j)
        {
            dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + 1); // 알고리즘 공부
            dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + 1); // 코딩 공부
            
            // 모든 문제를 검사
            for(vector<int>& problem : problems)
            {
                // 문제를 풀기위한 최소 알고력, 코딩력이 있다면?
                if(i >= problem[0] && j >= problem[1])
                {
                    // 기존 점수와 문제에서 얻은 점수의 합이 maxAlp, maxCop을 넘지 못하게 방지
                    // maxAlp + 1, 2..도 어차피 같은 경우로, [maxAlp][maxCop]에 값을 쓰고, 인덱스 번호를 추가로 사용하지 않도록 최적화
                    int alpIdx = min(maxAlp, problem[2] + i);
                    int copIdx = min(maxCop, problem[3] + j);
                    
                    // 문제를 풀었을 때, cost를 비교하여 낮은 값으로 갱신
                    dp[alpIdx][copIdx] = min(dp[alpIdx][copIdx], dp[i][j] + problem[4]);
                }
            }
        }
    }
    
    // 정답 리턴
    return dp[maxAlp][maxCop];
}

dp bottom-up 방식으로 문제를 해결합니다.
dp의 인덱스 번호를 현재 alp, cop의 누적 cost로 사용합니다. dp의 크기는 152, 152를 초과하지 않습니다.
- 그 이유는, 0 ≤ alp,cop ≤ 150 조건으로, alp, cop가 150을 초과하지 않게 clamp를 해줄 수 있기 때문입니다.
- alp + n을 alp로 간주하여 문제를 해결할 수 있습니다.
3중 for문을 이용하여 접근합니다.
- i와 j는 각각 alp, cop에서 시작하여 maxAlp, maxCop까지 반복합니다.
아래의 세가지 검사를 통해 dp를 갱신합니다.
- 알고리즘 공부를 통해 cost를 1추가하여 alp를 1 증가시킵니다.
- 코딩 공부를 통해 cost를 1추가하여 cop를 1 증가시킵니다.
- 모든 problems를 검사하여 cost를 추가하여 alp와 cop를 증가시킵니다. 단, 현재 alp와 cop인 i, j가 이상이어야합니다.
모든 반복을 마치면, 정답을 리턴합니다.

[C++][프로그래머스] 등산코스 정하기

bonnate — Sun, 10 Dec 2023 19:48:57 +0900

프로그래머스

programmers.co.kr

문제

XX산은 n개의 지점으로 이루어져 있습니다. 각 지점은 1부터 n까지 번호가 붙어있으며, 출입구, 쉼터, 혹은 산봉우리입니다. 각 지점은 양방향 통행이 가능한 등산로로 연결되어 있으며, 서로 다른 지점을 이동할 때 이 등산로를 이용해야 합니다. 이때, 등산로별로 이동하는데 일정 시간이 소요됩니다.

등산코스는 방문할 지점 번호들을 순서대로 나열하여 표현할 수 있습니다.
예를 들어 1-2-3-2-1 으로 표현하는 등산코스는 1번지점에서 출발하여 2번, 3번, 2번, 1번 지점을 순서대로 방문한다는 뜻입니다.
등산코스를 따라 이동하는 중 쉼터 혹은 산봉우리를 방문할 때마다 휴식을 취할 수 있으며, 휴식 없이 이동해야 하는 시간 중 가장 긴 시간을 해당 등산코스의 intensity라고 부르기로 합니다.

당신은 XX산의 출입구 중 한 곳에서 출발하여 산봉우리 중 한 곳만 방문한 뒤 다시 원래의 출입구로 돌아오는 등산코스를 정하려고 합니다. 다시 말해, 등산코스에서 출입구는 처음과 끝에 한 번씩, 산봉우리는 한 번만 포함되어야 합니다.
당신은 이러한 규칙을 지키면서 intensity가 최소가 되도록 등산코스를 정하려고 합니다.

다음은 XX산의 지점과 등산로를 그림으로 표현한 예시입니다.

위 그림에서 원에 적힌 숫자는 지점의 번호를 나타내며, 1, 3번 지점에 출입구, 5번 지점에 산봉우리가 있습니다. 각 선분은 등산로를 나타내며, 각 선분에 적힌 수는 이동 시간을 나타냅니다. 예를 들어 1번 지점에서 2번 지점으로 이동할 때는 3시간이 소요됩니다.

위의 예시에서 1-2-5-4-3 과 같은 등산코스는 처음 출발한 원래의 출입구로 돌아오지 않기 때문에 잘못된 등산코스입니다. 또한 1-2-5-6-4-3-2-1 과 같은 등산코스는 코스의 처음과 끝 외에 3번 출입구를 방문하기 때문에 잘못된 등산코스입니다.

등산코스를 3-2-5-4-3 과 같이 정했을 때의 이동경로를 그림으로 나타내면 아래와 같습니다.

이때, 휴식 없이 이동해야 하는 시간 중 가장 긴 시간은 5시간입니다. 따라서 이 등산코스의 intensity는 5입니다.

등산코스를 1-2-4-5-6-4-2-1 과 같이 정했을 때의 이동경로를 그림으로 나타내면 아래와 같습니다.

이때, 휴식 없이 이동해야 하는 시간 중 가장 긴 시간은 3시간입니다. 따라서 이 등산코스의 intensity는 3이며, 이 보다 intensity가 낮은 등산코스는 없습니다.

XX산의 지점 수 n, 각 등산로의 정보를 담은 2차원 정수 배열 paths, 출입구들의 번호가 담긴 정수 배열 gates, 산봉우리들의 번호가 담긴 정수 배열 summits가 매개변수로 주어집니다. 이때, intensity가 최소가 되는 등산코스에 포함된 산봉우리 번호와 intensity의 최솟값을 차례대로 정수 배열에 담아 return 하도록 solution 함수를 완성해주세요. intensity가 최소가 되는 등산코스가 여러 개라면 그중 산봉우리의 번호가 가장 낮은 등산코스를 선택합니다.

풀이

#include <iostream>
#include <vector>
#include <queue>
#include <climits>
#include <unordered_set>
#include <algorithm>
using namespace std;

// 간선 정보
struct Edge {
    int to, weight;
};

vector<int> solution(int n, vector<vector<int>> paths, vector<int> gates, vector<int> summits) {
    
    vector<vector<Edge>> graph(n + 1);
    
    // 정답을 구하기 위해 정렬
    sort(summits.begin(), summits.end());

    // 그래프 정보 초기화 (양방향)
    for (vector<int> r : paths) {
        int from = r[0];
        int to = r[1];
        int weight = r[2];
        graph[from].push_back({to, weight});
        graph[to].push_back({from, weight});
    }

    // summits의 ID를 빠르게 검색하기위한 set
    unordered_set<int> summitIds;
    for(int i = 0; i < summits.size(); ++i)
        summitIds.insert(summits[i]);
    
    // gates ID를 빠르게 검색하기위한 set
    unordered_set<int> gateIds;
    for(int i = 0; i < gates.size(); ++i)
        gateIds.insert(gates[i]);    
    
    vector<int> dp(summits.size(), INT_MAX);
    for(int i = 0; i < gates.size(); ++i)
    {    
        vector<int> dist(n + 1, INT_MAX);
        vector<int> maxValue(n + 1, INT_MAX);  

        // 우선순위 큐를 이용한 다익스트라 알고리즘
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;            

        dist[gates[i]] = 0; // 시작 노드의 거리는 0
        maxValue[gates[i]] = 0;
        pq.push({0, gates[i]}); // {거리, 노드} 쌍을 우선순위 큐에 삽입

        while (!pq.empty()) {
            int current_distance = pq.top().first;
            int current_node = pq.top().second;
            pq.pop();
            
            // 현재 노드에서 갈 수 있는 모든 노드들에 대해 최단 거리 갱신
            for (Edge& e : graph[current_node]) {
                int next_node = e.to;
                int weight = e.weight;

                // gate로의 이동은 금지
                if(gateIds.find(next_node) != gateIds.end())
                    continue;
                    
                // 가중치가 낮다면, 갱신
                if (dist[next_node] > weight) {
                    dist[next_node] = weight; // 해당 노드의 weight를 기록
                    maxValue[next_node] = max(maxValue[current_node], dist[next_node]); // 해당 노드까지의 최대 피로도를 계산
                    pq.push({dist[next_node], next_node});
                }
            }
            
            // 만약, 산봉우리에 도착하였다면 더 이상 계산할 필요가 없기에 while문 리턴
            if(summitIds.find(current_node) != summitIds.end())
                break;
        }  
        
        // 정답을 구할 dp에 모든 값을 최소값으로 갱신
        for(int j = 0; j < summits.size(); ++j)
            dp[j] = min(dp[j], maxValue[summits[j]]);
    }
    
    // 역방향으로 검사하여 최소값을 정답에 저장(정렬 필요)
    vector<int> answer{INT_MAX, INT_MAX};
    for(int i = summits.size() - 1; i >= 0; --i)
        if(answer[1] >= dp[i])
            answer = {summits[i], dp[i]};
    
    return answer;
}

다익스트라 알고리즘을 활용하여 문제를 해결합니다.
우선순위 큐를 통해 노드 탐색 시 가중치가 작은 순서대로 탐색합니다.
- 이 방법을 통해 현재 gates에서 시작하여 가장 가중치가 작은(intensity가 최소) 산봉우리 중 하나로 이동합니다.

각 gates로부터 가장 가까운 산봉우리로 검색을 합니다.

gates가 1, 3일때 intensity가 낮은 이동 방법

gates가 1, 3일때 산봉우리로 이동할 때 각각 intensity는 3, 4로 이동할 수 있습니다.
이러한 방법을 통해 gates는 1, intensity는 3으로 {1, 3}을 리턴하여야합니다.

문제를 안정적으로 해결하기 위해 아래의 조건을 만족시켜야합니다.
- gate로부터 산봉우리까지의 경로는 편도로만 검색한 후, 왕복은 편도의 경로를 그대로 이용한다고 가정합니다.
  - 이 방법은 우선순위큐를 통해 가중치를 계산하여 해당 경로까지 검색하기때문에 돌아오는 경로를 굳이 계산할 필요가 없습니다.
- 시작 gate를 제외하고 다른 gate로의 이동을 해서는 안됩니다. 이 이유는 특정 gate로 이동하여 굳이 계산을 할 필요가 없기 때문입니다.
- 특정 산봉우리에 도착하였다면, 해당 경로를 마지막으로 더 이상 계산할 필요가 없습니다.
  - 아래의 그림과 같이 7 -> 6 - >5로 이동하였다면, 추가 계산을 할 필요가 없이 즉시 break합니다.

모든 gate를 시작점으로 하여 intensity를 갱신하여 정답을 구해야합니다.

[C++][프로그래머스] 카운트 다운

bonnate — Sun, 10 Dec 2023 17:35:38 +0900

프로그래머스

programmers.co.kr

문제

프로그래머스 다트 협회에서는 매년마다 새로운 특수 룰으로 다트 대회를 개최합니다. 이번 대회의 룰은 "카운트 다운"으로 "제로원" 룰의 변형 룰입니다.
"카운트 다운"은 게임이 시작되면 무작위로 점수가 정해지고, 다트를 던지면서 점수를 깎아서 정확히 0점으로 만드는 게임입니다. 단, 남은 점수보다 큰 점수로 득점하면 버스트가 되며 실격 합니다.

다음 그림은 다트 과녁입니다.

다트 과녁에는 1 부터 20 까지의 수가 하나씩 있고 각 수마다 "싱글", "더블", "트리플" 칸이 있습니다. "싱글"을 맞히면 해당 수만큼 점수를 얻고 "더블"을 맞히면 해당 수의 두 배만큼 점수를 얻고 "트리플"을 맞히면 해당 수의 세 배만큼 점수를 얻습니다. 가운데에는 "불"과 "아우터 불"이 있는데 "카운트 다운" 게임에서는 구분 없이 50점을 얻습니다.

대회는 토너먼트로 진행되며 한 게임에는 두 선수가 참가하게 됩니다. 게임은 두 선수가 교대로 한 번씩 던지는 라운드 방식으로 진행됩니다. 가장 먼저 0점을 만든 선수가 승리하는데 만약 두 선수가 같은 라운드에 0점을 만들면 두 선수 중 "싱글" 또는 "불"을 더 많이 던진 선수가 승리하며 그마저도 같다면 선공인 선수가 승리합니다.

다트 실력에 자신 있던 종호는 이 대회에 출전하기로 하였습니다. 최소한의 다트로 0점을 만드는 게 가장 중요하고, 그러한 방법이 여러가지가 있다면 "싱글" 또는 "불"을 최대한 많이 던지는 방법을 선택해야 합니다.

목표 점수 target이 매개변수로 주어졌을 때 최선의 경우 던질 다트 수와 그 때의 "싱글" 또는 "불"을 맞춘 횟수(합)를 순서대로 배열에 담아 return 하도록 solution 함수를 완성해 주세요.

풀이

#include <string>
#include <vector>

using namespace std;

int dp[100001][2];

void check(int target) {
    // target - 60의 누적 개수와 target - 50의 누적 개수가 같다면?
    if (dp[target - 60][0] == dp[target - 50][0]) 
    {
        dp[target][0] = dp[target - 50][0] + 1; // 누적 개수 1 증가
        dp[target][1] = max(dp[target - 60][1], dp[target - 50][1] + 1); // max(target - 60의 값, target - 50의 값 + 1(불 사용))
    }
    // target - 60이 더 효율적이라면?
    else if (dp[target - 60][0] < dp[target - 50][0]) 
    {
        dp[target][0] = dp[target - 60][0] + 1;
        dp[target][1] = dp[target - 60][1];
    }
    else 
    {
        dp[target][0] = dp[target - 50][0] + 1;
        dp[target][1] = dp[target - 50][1] + 1;
    }
}

vector<int> solution(int target) {
    vector<int> answer(2, 0);

    for (int i = 1; i <= target; i++) {
        /* 한 번에 끝내기 */
        // 싱글(20이하) 또는 불(50)로 끝내는 경우
        if (i == 50 || i <= 20) 
        {
            dp[i][0] = 1;
            dp[i][1] = 1; // 값 증가
        }
        // 60 이하의 3의 배수인 경우는 트리플로 가능
        else if (i <= 60 && i % 3 == 0) 
        {
            dp[i][0] = 1;
            dp[i][1] = 0; // 싱글,불이 아님
        }
        // 40 이하의 2의 배수인 경우에는 더블로 가능
        else if (i <= 40 && i % 2 == 0) 
        {
            dp[i][0] = 1;
            dp[i][1] = 0; // 싱글, 불이 아님
        }
        /* 블+싱글 조합으로 두 번에 끝내기 */
        // 50보다 크고 70 이하라면 2번(불 + 싱글)로 가능
        else if (i > 50 && i <= 70) 
        {
            dp[i][0] = 2;
            dp[i][1] = 2; // 불 + 싱글의 조합으로 2 증가
        }
        /* 나머지 두 번에 끝내기 */
        // 70보다 작은 수인경우, 아래의 두 조건으로 나눌 수 있음
        else if (i < 70) 
        {
            // 40 보다 작은 수라면, 싱글 2개로 조합 가능
            if (i < 40) 
            {
                dp[i][0] = 2;
                dp[i][1] = 2; // 싱글 2개
            }
            // 아니라면, 싱글 + 더블 조합으로 가능
            else 
            {
                dp[i][0] = 2;
                dp[i][1] = 1; // 싱글 1개
            }
        }
        // 71부터는 저장된 값을 고려하여 최선의 선택을 구하기
        else 
        {
            check(i);
        }
    }

    answer[0] = dp[target][0];
    answer[1] = dp[target][1];

    return answer;
}

싱글 또는 불을 최대한 많이 맞추면서, 맞추는 개수는 최소로 하여 정답을 구해야합니다.
이 문제는 dp를 활용하여 해결하였으며, 다음과 같은 규칙으로 접근할 수 있습니다.
- dp를 [100001][2]로 선언하여 누적된 싱글 또는 불 / 다트의 개수를 저장합니다.
- target이 50이거나, 20이하인경우에는 싱글 또는 불로 한번에 해결할 수 있습니다. 이 경우 dp에 누적 다트와 싱글/불 개수를 1로 설정할 수 있습니다.
- target이 60 이하일 때, 3의 배수라면 1~20 값의 트리플로 해결할 수 있습니다. 이 경우 dp에 누적 다트는 1로, 싱글/불 개수는 0으로 합니다.
- target이 40 이하일 때, 2의 배수라면 1~20 값의 더블로 해결할 수 있습니다.
- 50보다 크고, 70 이하라면, 불 + 싱글의 조합 (50 + x)으로 해결할 수 있습니다. 이 경우에는 2, 2로 저장합니다.
- 위 조건이 모두 아닐경우 70보다 작다면, 두가지의 경우를 고려할 수 있습니다.
  - 40보다 작다면, 두개의 싱글로 조합이 가능합니다.
  - 그렇지 않다면, 싱글 + 더블의 조합으로 가능합니다.
- 위 모든 조건이 아니라면, 최선의 선택을 위해 함수를 통해 조건을 통해 값을 구합니다.
  - 60, 50을 사용하여 큰 값을 줄일 수 있습니다. 이 때, target-60의 횟수와 target-50의 누적 횟수가 같다면, 둘 중 불의 사용이 큰 개수를 [1]에 저장합니다.
  - target-60이 더 효율적이라면, 불을 사용하지 않고 누적 다트 수인 [0]에 저장합니다.
  - target-50이 더 효율적이라면, 불을 사용하여 누적 다트 수와 불 사용 수에 저장합니다.

[C++][프로그래머스] 고고학 최고의 발견

bonnate — Sun, 26 Nov 2023 19:33:17 +0900

프로그래머스

programmers.co.kr

문제

고고학자인 혜선은 오래전부터 성궤의 행방을 추적해왔습니다. 그동안 그의 연구는 주류 학자들로부터 인정받지 못했었지만, 혜선이는 포기하지 않고 조사를 계속했고 마침내 성궤의 행방을 알아내었습니다.

그러나 오래전 누군가로부터 봉인된 성궤는 특별한 잠금장치에 의해 보호되고 있었습니다. 잠금장치는 일종의 퍼즐과 연결되어 퍼즐을 해결하면 열리는 것으로 보입니다.

퍼즐은 시계들이 행렬을 이루는 구조물인데 하나의 시계에 시곗바늘은 하나씩만 있습니다. 각 시곗바늘은 시계방향으로만 돌릴 수 있고 한 번의 조작으로 90도씩 돌릴 수 있습니다. 시계들은 기계장치에 의해 연결되어 있어 어떤 시계의 시곗바늘을 돌리면 그 시계의 상하좌우로 인접한 시계들의 시곗바늘도 함께 돌아갑니다. 행렬의 모서리에 위치한 시계의 시곗바늘을 돌리는 경우에는 인접한 세 시계의 시곗바늘들이 함께 돌아가며, 꼭짓점에 위치한 시계의 시곗바늘을 돌리는 경우에는 인접한 두 시계의 시곗바늘들이 함께 돌아갑니다.

각 시계는 12시, 3시, 6시, 9시 방향 중의 한 방향을 가리키고 있습니다. 각 시계의 시곗바늘을 적절히 조작하여 모든 시곗바늘이 12시 방향을 가리키면 퍼즐이 해결되어 성궤를 봉인하고 있는 잠금장치가 열릴 것입니다.

노후화된 퍼즐 기계장치가 걱정되었던 혜선은 가능한 최소한의 조작으로 퍼즐을 해결하려고 합니다. 시곗바늘들의 행렬 clockHands가 매개변수로 주어질 때, 퍼즐을 해결하기 위한 최소한의 조작 횟수를 return 하도록 solution 함수를 완성해주세요.

풀이

DFS를 (0, 0)위치에서 부터 시작하여 clockHands의 모든 영역에 대하여 0, 1, 2, 3번씩 회전했을 때를 고려하여 clockHands의 현 상태가 모두 정렬이 되었다면, 해당 형상까지 총 몆번을 회전하였는지 검사할 수 있습니다.
- 하지만 이 방법대로 문제를 해결한다면 모든 경우의 수는 매우 커지므로, 시간 초과가 나 조금 더 효율적인 방법을 고려해야합니다.
아래의 규칙을 따라 더 효율적인 방식으로 문제를 해결할 수 있습니다.
- (0, 0)부터 회전을 시도하여 경우의 수를 늘려나갑니다.
- 현재 행에서 모든 열까지 회전을 한 후 , 행을 늘려나갑니다. (0, 0) -> (0, 1) -> ... -> (0, 3) -> (1, 0)
- 행이 1 이상인경우, 현재 위치(row, col)에서 0~3번의 회전을 하였을 때 row - 1의 값이 1이어서는 안됩니다. 그 이유는 위 규칙에 의해 검사는 (0, 0)위치로부터 차례대로 진행되며, 위 값이 0이 아니라면, 더 이상 해당 값을 되돌릴 수 없기 때문입니다.
  - 행이 1 이상인 상태에서, row - 1의 값이 0이라면, 해당 경우의 수는 모든 시계를 정렬할 수 있는 가능성이 있으므로 DFS를 누적하여 호출할 수 있습니다.
- 만약, check 함수가 true로 나온다면, 누적된 cnt의 값을 리턴합니다. row의 값이 size와 같아진다면, 영역을 초과할 때 까지 check에 성공하지 못한것으로, INT_MAX를 리턴하여 해당 값은 사용하지 않게합니다.

#include <string>
#include <vector>
#include <iostream>
#include <climits>

using namespace std;

int dy[5] { 0, 0, 0, 1, -1 };
int dx[5] { 0, -1, 1, 0, 0 };
int result = INT_MAX;

// 선택한 (y, x)의 위치를 isClockwise 방향으로 회전
void rotate(vector<vector<int>>& clockHands, int y, int x, int count, bool isClockwise = true)
{
    // 선택된 위치를 기준으로 5번의 반복(현재 위치, 좌, 우, 상, 하)
    for(int i = 0; i < 5; ++i)
    {
        int yy = y + dy[i];
        int xx = x + dx[i];
        
        // 영역 자체를 벗어났다면, 수행하지 않음
        if(yy == -1 || xx == -1 || yy == clockHands.size() || xx == clockHands.size())
            continue;
        
        // isClockwise(시계 방향)이라면, +count(시계방향) 아니라면 -count(시계반대방향)
        clockHands[yy][xx] = clockHands[yy][xx] + (isClockwise ? +count : -count);
        
        // -값이 되면 적절하게 수정
        if(clockHands[yy][xx] < 0)
            clockHands[yy][xx] += 4;

        // 3보다 커질 수 없기에 적절히 수정
        clockHands[yy][xx] %= 4;
    }
}

// 현재 형상이 모두 12시로 맞춰져 있는가?
bool check(vector<vector<int>>& clockHands)
{
    for(int i = 0; i < clockHands.size(); ++i)
        for(int j = 0; j < clockHands.size(); ++j)
            if(clockHands[i][j])
                return false;
    
    return true;
}

int DFS(vector<vector<int>>& clockHands, int row, int col, int cnt)
{
    // 모든 시계를 확인하고 최소 이동 횟수 업데이트
    if (check(clockHands))
        return cnt;
    
    // 마지막에 도달하였을 때, check가 안되었다면, 이 방법으로는 시계를 정렬할 수 없음
    if (row == clockHands.size())
        return INT_MAX;  
    
    // 만약 누적된 cnt가 result 이상이라면, 더 이상 검사할 필요가 없기에 리턴
    if (cnt >= result)
        return INT_MAX;
    
    // 해당 위치를 0~3번 돌려 경우의수를 확장
    for (int i = 0; i < 4; ++i) 
    {
        // i만큼 시계 방향으로 회전
        rotate(clockHands, row, col, i, true);
        
        // 현재 row가 1 이상이면서, 현재 위치 바로 위 값이 0이 아니라면? -> 누적된 이 방법으로는 시계를 맞출 수 없음
        if (row && clockHands[row - 1][col]) 
        {
            // 회전 전으로 복구(반시계 방향 회전)
            rotate(clockHands, row, col, i, false);
            continue;
        }
        
        // 다음 위치 계산
        int nextRow = (col + 1 == clockHands.size()) ? row + 1 : row; // col이 끝에 도달하였다면, row를 증가, 아니라면 유지
        int nextCol = (col + 1) % clockHands.size(); // 다음 col은 1씩 증가
        
        // cnt는 i만큼 더하기 (i만큼 회전한 것이기 때문)
        result = min(result, DFS(clockHands, nextRow, nextCol, cnt + i));
        
        // 재귀가 끝나면 원래 상태로 되돌리기
        rotate(clockHands, row, col, i, false);
    }
    
    return result;
}

int solution(vector<vector<int>> clockHands) {
    return DFS(clockHands, 0, 0, 0);
}

[C++][프로그래머스] 2차원 동전 뒤집기

bonnate — Sun, 26 Nov 2023 02:35:23 +0900

프로그래머스

programmers.co.kr

문제

한수는 직사각형 모양의 공간에 놓인 동전들을 뒤집는 놀이를 하고 있습니다. 모든 동전들은 앞과 뒤가 구분되어 있으며, 동전을 뒤집기 위해서는 같은 줄에 있는 모든 동전을 뒤집어야 합니다. 동전들의 초기 상태와 목표 상태가 주어졌을 때, 초기 상태에서 최소 몇 번의 동전을 뒤집어야 목표 상태가 되는지 알아봅시다.

예를 들어, 위 그림에서 맨 왼쪽이 초기 상태, 맨 오른쪽이 목표 상태인 경우에 대해 알아봅시다. 그림에서 검은색 원은 앞면인 동전, 흰색 원은 뒷면인 동전을 의미합니다. 초기 상태에서 2행과 4행의 돌들을 뒤집으면, 두 번째 그림이 됩니다. 그 후, 2열, 4열, 5열의 돌들을 순서대로 뒤집는 다면, 총 5번의 동전 뒤집기를 통해 목표 상태가 되며, 이 경우가 최소인 경우입니다.

직사각형 모양의 공간에 놓인 동전들의 초기 상태를 나타내는 2차원 정수 배열 beginning, 목표 상태를 나타내는 target이 주어졌을 때, 초기 상태에서 목표 상태로 만들기 위해 필요한 동전 뒤집기 횟수의 최솟값을 return 하는 solution 함수를 완성하세요. 단, 목표 상태를 만들지 못하는 경우에는 -1을 return 합니다.

풀이

오답 코드

두개의 반례를 찾아내지 못하여 결국 처음부터 다시 작성하기로 하였습니다.

#include <string>
#include <vector>
#include <iostream>

using namespace std;

void flip(vector<vector<int>>& map, int pos, bool isHorizontal)
{
    if(isHorizontal)
        for(int i = 0; i < map[0].size(); ++i)
            map[pos][i] = map[pos][i] ? 0 : 1;
    else
        for(int i = 0; i < map.size(); ++i)
            map[i][pos] = map[i][pos] ? 0 : 1;
}

bool print(vector<vector<int>>& map)
{
    for(int i = 0; i < map.size(); ++i)
    {
        for(int j = 0; j < map[0].size(); ++j)
            printf("%d ", map[i][j]);
        cout<<endl;
    }
    
    cout<<endl;
       
    return true;
}

bool compare(vector<vector<int>>& map, vector<vector<int>>& target)
{
    for(int i = 0; i < map.size(); ++i)
        for(int j = 0; j < map[0].size(); ++j)
            if(map[i][j] != target[i][j])
                return false;
       
    return true;
}

bool checkMap(vector<vector<int>> beginning, vector<vector<int>> target)
{
    int row = beginning.size();
    int col = beginning[0].size();
    
    if(row < 2 || col < 2)
        return false;
    
    bool checkCol = true;
    for(int i = 0; i < row; ++i)
        for(int j = 0; j < col - 1; ++j)
        {
            if(beginning[i][j] != beginning[i][j + 1] || target[i][j] != target[i][j + 1])
                checkCol = false;
        }
    
    bool checkRow = true;  
    for(int i = 0; i < col; ++i)
        for(int j = 0; j < row - 1; ++j)
        {
            if(beginning[j][i] != beginning[j + 1][i] || target[j][i] != target[j + 1][i])
                checkRow = false;
        }    
    
    if(checkCol || checkRow)
        printf("TRUE");
    
    return checkCol || checkRow;
}

int solution(vector<vector<int>> beginning, vector<vector<int>> target) {
    if(compare(beginning, target))
        return 0;

    vector<vector<int>> original = beginning;
    
    int row = beginning.size();
    int col = beginning[0].size();
    bool isSame = checkMap(beginning, target);
    
    if(min(row, col) == 1 || isSame)
    {
        if(isSame)
            row = row < col ? 1 : row;
        
        if(row == 1)
        {
            int diff = 0;
            for(int i = 0; i < col; ++i)
                if(beginning[0][i] != target[0][i])
                    ++diff;
            
            printf("ROW %d", diff);
            
            int answer = diff < col / 2 ? diff : col - diff + 1;
            if(isSame)
                answer += beginning.size() - 1;
            
            return answer;                 
        }
        else
        {
            int diff = 0;
            for(int i = 0; i < row; ++i)
                if(beginning[i][0] != target[i][0])
                    ++diff;
            
            printf("COL %d", diff);
            
            int answer = diff < row / 2 ? diff : row - diff + 1;
            if(isSame)
                answer += beginning[0].size() - 1;
            
            return answer;            
        }
    }
    
    int answer1 = 0;
    bool escape1 = false;
    bool success1 = false;
    for(int i = 0; i < row; ++i)
        if(beginning[i][0] != target[i][0])
        {
            ++answer1;
            flip(beginning, i, true);
            if(compare(beginning, target))
            {
                escape1 = true;
                success1 = true;
                break;   
            }
        }
    if(!escape1)
    for(int i = 0; i < col; ++i)
        if(beginning[0][i] != target[0][i])
        {
            ++answer1;
            flip(beginning, i, false);
            if(compare(beginning, target))
            {
                success1 = true;
                break;
            }
        }
    if(!success1)
        answer1 = -1;
    
    int answer2 = 0;
    bool escape2 = false;
    bool success2 = false;
    beginning = original;
    for(int i = 0; i < col; ++i)
        if(beginning[0][i] != target[0][i])
        {
            ++answer2;
            flip(beginning, i, false);
            if(compare(beginning, target))
            {
                escape2 = true;
                success2 = true;
                break;   
            }
        }      
    if(!escape2)
    for(int i = 0; i < row; ++i)
        if(beginning[i][0] != target[i][0])
        {
            ++answer2;
            flip(beginning, i, true);
            if(compare(beginning, target))
            {
                success2 = true;
                break;             
            }
        }
    if(!success2)
        answer2 = -1;
  
    return min(answer1, answer2);
}

정답 코드

#include <vector>
#include <algorithm>

using namespace std;

void flip(vector<vector<int>>& map, int pos, bool isHorizontal)
{
    if(isHorizontal)
        for(int i = 0; i < map[0].size(); ++i)
            map[pos][i] = map[pos][i] ? 0 : 1;
    else
        for(int i = 0; i < map.size(); ++i)
            map[i][pos] = map[i][pos] ? 0 : 1;
}

bool compare(vector<vector<int>>& map, vector<vector<int>>& target)
{
    for(int i = 0; i < map.size(); ++i)
        for(int j = 0; j < map[0].size(); ++j)
            if(map[i][j] != target[i][j])
                return false;
       
    return true;
}

int solution(vector<vector<int>> beginning, vector<vector<int>> target) {

    int row = beginning.size();
    int col = beginning[0].size();
    
    // 행 -> 열 순서에서 행이 다른경우? flip
    int answer1 = 0;
    bool escape1 = false;
    bool success1 = false;
    vector<vector<int>> ch = beginning;
    for(int i = 0; i < row; ++i)
        if(ch[i][0] != target[i][0])
        {
            ++answer1;
            flip(ch, i, true);
            if(compare(ch, target))
            {
                escape1 = true;
                success1 = true;
                break;   
            }
        }
    if(!escape1)
    for(int i = 0; i < col; ++i)
        if(ch[0][i] != target[0][i])
        {
            ++answer1;
            flip(ch, i, false);
            if(compare(ch, target))
            {
                success1 = true;
                break;
            }
        }
    if(!success1)
        answer1 = -1;
    
    // 열 -> 행 순서에서 열이 다른경우? flip
    int answer2 = 0;
    bool escape2 = false;
    bool success2 = false;
    ch = beginning;
    for(int i = 0; i < col; ++i)
        if(ch[0][i] != target[0][i])
        {
            ++answer2;
            flip(ch, i, false);
            if(compare(ch, target))
            {
                escape2 = true;
                success2 = true;
                break;   
            }
        }      
    if(!escape2)
    for(int i = 0; i < row; ++i)
        if(ch[i][0] != target[i][0])
        {
            ++answer2;
            flip(ch, i, true);
            if(compare(ch, target))
            {
                success2 = true;
                break;             
            }
        }
    if(!success2)
        answer2 = -1;
    
    // 행 -> 열 순서에서 행이 같은경우? flip
    int answer3 = 0;
    bool escape3 = false;
    bool success3 = false;
    ch = beginning;    
    for(int i = 0; i < row; ++i)
        if(ch[i][0] == target[i][0])
        {
            ++answer3;
            flip(ch, i, true);
            if(compare(ch, target))
            {
                escape3 = true;
                success3 = true;
                break;   
            }
        }
    if(!escape3)
    for(int i = 0; i < col; ++i)
        if(ch[0][i] != target[0][i])
        {
            ++answer3;
            flip(ch, i, false);
            if(compare(ch, target))
            {
                success3 = true;
                break;
            }
        }
    if(!success3)
        answer3 = -1;    
    
    // 열 -> 행 순서에서 열이 같은경우? flip
    int answer4 = 0;
    bool escape4 = false;
    bool success4 = false;
    ch = beginning;    
    for(int i = 0; i < col; ++i)
        if(ch[0][i] == target[0][i])
        {
            ++answer4;
            flip(ch, i, false);
            if(compare(ch, target))
            {
                escape4 = true;
                success4 = true;
                break;   
            }
        }   
    if(!escape4)
    for(int i = 0; i < row; ++i)
        if(ch[i][0] != target[i][0])
        {
            ++answer4;
            flip(ch, i, true);
            if(compare(ch, target))
            {
                success4 = true;
                break;             
            }
        }
    if(!success4)
        answer4 = -1;      
    
    return min({answer1, answer2, answer3, answer4});
}

네가지의 규칙을 적용하여 문제를 해결합니다.
- 행을 먼저 검사하여 행의 맨 앞의 값이 서로 다르다면 flip을 하고 열의 맨 앞 값이 다르다면 flip을 한 갯수
- 열을 먼저 검사하여 열의 맨 앞의 값이 서로 다르다면 flip을 하고 행의 맨 앞 값이 다르다면 flip을 한 갯수
- 행을 먼저 검사하여 행의 맨 앞의 값이 서로 같다면 flip을 하고 열의 맨 앞 값이 다르다면 flip을 한 갯수
- 열을 먼저 검사하여 열의 맨 앞의 값이 서로 같다면 flip을 하고 행의 맨 앞 값이 다르다면 flip을 한 갯수
위에서 구한 네가지의 정답(answer1, 2, 3, 4)의 최소값을 리턴합니다.

[C++][프로그래머스] 부대복귀

bonnate — Sun, 26 Nov 2023 00:02:02 +0900

프로그래머스

programmers.co.kr

문제

강철부대의 각 부대원이 여러 지역에 뿔뿔이 흩어져 특수 임무를 수행 중입니다. 지도에서 강철부대가 위치한 지역을 포함한 각 지역은 유일한 번호로 구분되며, 두 지역 간의 길을 통과하는 데 걸리는 시간은 모두 1로 동일합니다. 임무를 수행한 각 부대원은 지도 정보를 이용하여 최단시간에 부대로 복귀하고자 합니다. 다만 적군의 방해로 인해, 임무의 시작 때와 다르게 되돌아오는 경로가 없어져 복귀가 불가능한 부대원도 있을 수 있습니다.

강철부대가 위치한 지역을 포함한 총지역의 수 n, 두 지역을 왕복할 수 있는 길 정보를 담은 2차원 정수 배열 roads, 각 부대원이 위치한 서로 다른 지역들을 나타내는 정수 배열 sources, 강철부대의 지역 destination이 주어졌을 때, 주어진 sources의 원소 순서대로 강철부대로 복귀할 수 있는 최단시간을 담은 배열을 return하는 solution 함수를 완성해주세요. 복귀가 불가능한 경우 해당 부대원의 최단시간은 -1입니다.

풀이

#include <string>
#include <vector>
#include <queue>
#include <iostream>

using namespace std;
vector<vector<int>> v;
vector<int> dist;

vector<int> solution(int n, vector<vector<int>> roads, vector<int> sources, int destination) {
    v = vector<vector<int>>(n + 1, vector<int>());
    dist = vector<int>(n + 1, -1);
    
    for(vector<int> road : roads)
    {
        v[road[0]].push_back(road[1]);
        v[road[1]].push_back(road[0]);
    }
    
    queue<int> q;
    q.push(destination);
    dist[destination] = 0;
    
    while(!q.empty())
    {
        int here = q.front();
        q.pop();
        
        for(int i = 0; i < v[here].size(); ++i)
        {
            int to = v[here][i];
            if(dist[to] != -1)
                continue;
            
            q.push(to);
            dist[to] = dist[here] + 1;
        }
    }
    
    vector<int> answer;
    for(int n : sources)
        answer.push_back(dist[n]);
    
    return answer;
}

BFS를 이용하여 문제를 해결하였습니다.
dist를 -1로 모두 초기화합니다. 단 한번도 해당 노드를 방문하지 못하는경우, -1로 리턴할 수 있게 합니다.
시작점에서 가까운 노드들을 먼저 방문하고, 그 다음에는 그 노드들과 인접한 노드들을 방문하게 됩니다. 이런식으로 하나씩 계속해서 가까운 순서대로 이동하면, 최종적으로 목표 지점까지의 가장 짧은 경로를 찾을 수 있습니다.
while을 시작하기 전 push를 시작점인 destination을 삽입하여 모든 노드에 대하여 검색하도록 합니다.
q가 empty가 되어 while문을 빠져나온경우, sources를 순회하여 dist의 값을 answer에 차례대로 삽입합니다.

[티스토리] 업데이트된 Namecard 제거하기

bonnate — Sat, 25 Nov 2023 18:26:07 +0900

최근 티스토리에서 추가된 Namecard로 다크모드에서 색상이 올바르게 적용되지 않아 어색하게 보이는 문제점이 생겨 이를 제거하는 방법을 공유합니다.

위 이미지와 같이 다크모드에서 흰색 영역으로 매우 어색한것을 볼 수 있습니다.

div[data-tistory-react-app="Namecard"] 
{
  display: none
}

티스토리 스킨편집에서 CSS 영역에 위 코드를 추가합니다.

적용 후 새로고침하면 정상적으로 제거된것을 볼 수 있습니다.

[C++][프로그래머스] 등대

bonnate — Sat, 25 Nov 2023 18:08:44 +0900

프로그래머스

programmers.co.kr

문제

인천 앞바다에는 1부터 n까지 서로 다른 번호가 매겨진 등대 n개가 존재합니다. 등대와 등대 사이를 오가는 뱃길이 n-1개 존재하여, 어느 등대에서 출발해도 다른 모든 등대까지 이동할 수 있습니다. 등대 관리자 윤성이는 전력을 아끼기 위하여, 이 중 몇 개의 등대만 켜 두려고 합니다. 하지만 등대를 아무렇게나 꺼버리면, 뱃길을 오가는 배들이 위험할 수 있습니다. 한 뱃길의 양쪽 끝 등대 중 적어도 하나는 켜져 있도록 등대를 켜 두어야 합니다.

예를 들어, 아래 그림과 같이 등대 8개와 7개의 뱃길들이 있다고 합시다. 이 경우 1번 등대와 5번 등대 두 개만 켜 두어도 모든 뱃길은 양쪽 끝 등대 중 하나가 켜져 있으므로, 배들은 안전하게 운항할 수 있습니다.

등대의 개수 n과 각 뱃길이 연결된 등대의 번호를 담은 이차원 배열 lighthouse가 매개변수로 주어집니다. 윤성이가 켜 두어야 하는 등대 개수의 최솟값을 return 하도록 solution 함수를 작성해주세요.

풀이

#include <string>
#include <vector>

using namespace std;

vector<vector<int>> v;
bool light[100001] = {false, }; // 불이 켜진 등대인지 체크
int answer = 0;

// from: 어느 노드에서 왔는가?
// here: 현재 노드
void DFS(int from, int here) 
{
    // here(현재 위치)에서 갈 수 있는 모든 노드를 검사
    for (int i = 0; i < v[here].size(); i++) 
    {
        // 이전 노드(from)로 돌아가지 않아야 함
        // DFS를 통해 무방향 탐색을 할경우 1 -> 2 -> 3 -> 2처럼 v[here][i] == from이 되는 경우가 있음
        if (v[here][i] != from) 
        {
            // 현재 위치에서 v[here][i]로 이동
            DFS(here, v[here][i]);
            
            // 만약 현재 위치와, 다음 위치 모두 불이 꺼져있는경우, 불을 켜면서, ++answer
            if (!light[v[here][i]] && !light[here]) 
            {
                light[here] = true;
                ++answer;
            }
        }
    }
}

int solution(int n, vector<vector<int>> lighthouse) {
    v = vector<vector<int>>(n + 1, vector<int>());
    
    // 무방향 그래프로 양쪽으로 이동할 수 있게 삽입
    for(vector<int> path : lighthouse)
    {
        v[path[0]].push_back(path[1]);
        v[path[1]].push_back(path[0]);
    }
    
    // 가상위치(0)에서 1번 노드로 이동하는것으로 탐색 시작
    DFS(0, 1);
    
    return answer;
}

DFS를 이용하여 문제를 해결하였습니다.
무방향 그래프로, 왕복할 수 있도록 v에 1 -> 2, 2 -> 1에 대하여 경로를 삽입해줘야합니다.
1번 노드부터 시작하여 DFS를 시작합니다.
현재 노드(here)에서부터 갈 수 있는 모든 노드를 검사합니다. 이때, here과 이전 노드(from)이 같다면, 말단 노드에 들렀다가 돌아온 경우로, 더 이상 진행하지 않습니다.
- 이 상태에서는 불에 대한 검사를 수행하지 않습니다. 말단 노드에서 불이 켜질 수 없습니다.
깊이 탐색 중 현재 노드와, 다음 노드가 둘 다 불이 꺼져있다면, 해당 위치에 불을 켜고, ++answer을 수행합니다.

[C++][프로그래머스] 숫자 타자 대회

bonnate — Sat, 25 Nov 2023 15:05:47 +0900

프로그래머스

programmers.co.kr

문제

이동하지 않고 제자리에서 다시 누르는 것은 가중치가 1입니다.
상하좌우로 인접한 숫자로 이동하여 누르는 것은 가중치가 2입니다.
대각선으로 인접한 숫자로 이동하여 누르는 것은 가중치가 3입니다.
같지 않고 인접하지 않은 숫자를 누를 때는 위 규칙에 따라 가중치 합이 최소가 되는 경로를 따릅니다.

예를 들어 1 위에 있던 손가락을 0 으로 이동하여 누르는 것은 2 + 2 + 3 = 7 만큼의 가중치를 갖습니다.
단, 숫자 자판은 버튼의 크기가 작기 때문에 같은 숫자 버튼 위에 동시에 두 엄지 손가락을 올려놓을 수 없습니다. 즉, 어떤 숫자를 눌러야 할 차례에 그 숫자 위에 올려져 있는 손가락이 있다면 반드시 그 손가락으로 눌러야 합니다.

숫자로 이루어진 문자열 numbers가 주어졌을 때 최소한의 시간으로 타이핑을 하는 경우의 가중치 합을 return 하도록 solution 함수를 완성해주세요.

풀이

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

using namespace std;

unordered_map<char, pair<int, int>> m;
int dp[100001][10][10];

int getWeight(int from, char c) {
    // from을 기준으로 c에 해당하는 x, y의 길이를 가져오기
    int x = abs(m[c].first - m[from + '0'].first) ;
    int y = abs(m[c].second - m[from + '0'].second);
    
    int weight = -1;
    if(!x && !y) // 만약 x, y가 from과 같은 위치라면 1 리턴
        return 1;
    else if(!x || !y) // 만약 x나 y중 하나가 0이라면, 직선 거리만 사용하기에 큰 값 * 2 리턴
        return max(x, y) * 2;
    else // 대각선이 포함된경우 직선거리 * 2 + 대각선거리 * 3 리턴
    {
        int minValue = min(x, y);
        x -= minValue;
        y -= minValue;
        return minValue * 3 + max(x, y) * 2;
    }
}

int func(string& numbers, int left = 4, int right = 6, int idx = 0) {
    // 끝까지 검사하였다면 리턴
    if(idx == numbers.size())
        return 0;

    // 두 손가락의 위치가 같으면 안되기에 매우 큰 수를 리턴하여 사용할 수 없도록 함
    if(left == right)
        return 99999999;
    
    // 이미 해당 값이 있다면, 중복 연산을 피하기 위하여 즉시 리턴
    if(dp[idx][left][right])
        return dp[idx][left][right];
    
    // 현재 left와 right의 위치에서 numbers[idx]까지의 가중치를 구하기
    int leftW1 = getWeight(left, numbers[idx]);
    int rightW1 = getWeight(right, numbers[idx]);
    
    // left와 right를 이용한 가중치를 각각 구하기
    int leftW2 = leftW1 + func(numbers, numbers[idx] - '0', right, idx + 1);
    int rightW2 = rightW1 + func(numbers, left, numbers[idx] - '0', idx + 1);

    // 각 가중치에서 최소값을 선택
    return dp[idx][left][right] = min(leftW2, rightW2);
}

int solution(string numbers) {
    // 숫자 글자에 해당하는 위치를 map에 저장
    char c = '1';
    for(int i = 0; i < 3; ++i)
        for(int j = 0; j < 3; ++j)
            m[c++] = {i, j};
    m['0'] = {3, 1};
  
    // 정답 구하기
    return func(numbers);
}

numbers의 길이가 100,000이기때문에 n^2로 해결할 수 없는 문제입니다.
탐욕법 해결법으로, 두 손가락의 현재 위치에서 가중치가 낮은 손가락을 사용하였을때에도 뒤에있는 값들을 고려해야하기에 이 방법으로도 해결할 수 없습니다.
Top-Down 방식의 DP를 해결하여 문제를 해결할 수 있었습니다.
- 현재 상태에서 왼손, 오른손을 사용할 때의 모든 경우의 수를 고려해야합니다.
- 2 + 4 + 8 + 16 + 32.... 와 같이 계산을 해야 문제를 해결할 수 있지만, DP를 이용하여 중복된 계산을 회피할 수 있습니다.
왼손, 오른손을 모두 사용한다고 가정하였을 때, 누적된 가중치의 최소값을 찾아낼 수 있습니다.

[유니티] BoxColliders does not support negative scale or size. 해결 Tool

bonnate — Tue, 21 Nov 2023 12:55:52 +0900

"BoxColliders does not support negative scale or size." Warning은 오브젝트의 스케일과 반대 값인 Collider의 size가 Negative값으로 설정되어있으면 나타나는 경고입니다. 이것은 오브젝트를 좌우반전 등 특정 scale을 음수값으로 설정하였을 때, Collider의 size도 함께 음수로 설정하지 않아 발생합니다. 이것을 쉽게 해결하는 Tool을 제작하여 배포합니다.

서론

구현 내용

Tools에서 Window창을 열고 쉽게 Scene에 있는 문제가 발생할 수 있는 BoxCollider을 찾을 수 있습니다.
해당 오브젝트를 손쉽게 보고, 문제를 해결할 수 있습니다.

✅ 적용

· 스크립트 다운로드

NegativeBoxColliderModifier.cs

0.00MB

스크립트를 다운로드 받아 프로젝트에 포함시킵니다.
스크립트 파일의 위치는 어디든지 상관 없습니다.

· Window 열기

Tools/Bonnate/Negative Box Collider Modifier을 엽니다.

· 보기 및 수정

창이 열리면, 오브젝트 이름들과 View, Fix 버튼이 나타납니다.
View 버튼을 클릭하면, 해당 오브젝트를 Scene에서 바로 보고, 선택할 수 있습니다.
Fix 버튼을 클릭하면, 해당 오브젝트의 scale값에 대하여 자동으로 Collider의 size의 음수, 양수가 결정됩니다.

· 문제가 없는경우

문제되는 BoxCollider가 없는경우 아무것도 나오지 않습니다.

️ Unity Affiliate

Unity Affiliate Program 파트너로서 아래의 배너를 통해 접속하신 경우 수수료를 받을 수 있습니다.
아래 배너의 에셋들은 '실시간 무료 에셋 랭킹'을 나타냅니다.

[C++][프로그래머스] 단체사진 찍기

bonnate — Mon, 20 Nov 2023 19:13:29 +0900

프로그래머스

programmers.co.kr

문제

가을을 맞아 카카오프렌즈는 단체로 소풍을 떠났다. 즐거운 시간을 보내고 마지막에 단체사진을 찍기 위해 카메라 앞에 일렬로 나란히 섰다. 그런데 각자가 원하는 배치가 모두 달라 어떤 순서로 설지 정하는데 시간이 오래 걸렸다. 네오는 프로도와 나란히 서기를 원했고, 튜브가 뿜은 불을 맞은 적이 있던 라이언은 튜브에게서 적어도 세 칸 이상 떨어져서 서기를 원했다. 사진을 찍고 나서 돌아오는 길에, 무지는 모두가 원하는 조건을 만족하면서도 다르게 서는 방법이 있지 않았을까 생각해보게 되었다. 각 프렌즈가 원하는 조건을 입력으로 받았을 때 모든 조건을 만족할 수 있도록 서는 경우의 수를 계산하는 프로그램을 작성해보자.

풀이

#include <string>
#include <vector>
#include <map>
#include <iostream>

using namespace std;

vector<bool> ch; // DFS에서 해당 원소를 사용했는가
vector<int> sel; // n번째에서 몇번 값을 사용하는가
string characters; // 캐릭터 배열
int cnt; // 사용할 개수 (캐릭터는 8개)
int answer; // 정답 누적

bool checkValid(vector<string>& data, map<char, int>& m)
{
    for(string s : data)
    {
        // 두 캐릭터 사이의 간격
        int dist = abs(m[s[0]] - m[s[2]]) - 1;
        
        // 요구 숫자
        int num = s[4] - '0';
                
        // 요구 조건
        switch(s[3])
        {
            case '=': // 간격이 같은경우?
            {
                // 간격이 다르면 false
                if(dist != num)
                    return false;
                break;
            }
            case '<': // 간격이 미만?
            {
                // 간격이 이상이면 false
                if(dist >= num)
                    return false;
                break;
            }
            case '>': // 간격이 초과?
            {
                // 간격이 이하이면 false
                if(dist <= num)
                    return false;                
                break;
            }                
        }
    }
    
    return true;
}

void DFS(int n, vector<string>& data)
{
    // 모두 선택했다면?
    if(n == cnt)
    {
        // map에 해당 캐릭터의 위치를 저장
        map<char, int> m;
        for(int i = 0; i < cnt; ++i)
            m[characters[sel[i]]] = i;
        
        // 해당 캐릭터 조합이 data 조건을 모두 만족한다면, ++answer;
        if(checkValid(data, m))
            ++answer;
    }
    else
    {
        for(int i = 0; i < cnt; ++i)
        {
            if(!ch[i])
            {
                sel[n] = i;
                ch[i] = true;
                DFS(n + 1, data);
                ch[i] = false;
            }
        }
    }
}

// 전역 변수를 정의할 경우 함수 내에 초기화 코드를 꼭 작성해주세요.
int solution(int n, vector<string> data) {
    
    characters = {'A', 'C', 'F', 'J', 'M', 'N', 'R', 'T'};
    ch = vector<bool>(8, false);
    sel = vector<int>(8, -1);
    answer = 0;
    cnt = 8;
    DFS(0, data);
    
    return answer;
}

DFS와 map을 이용하여 문제를 해결하였습니다.
DFS를 이용하여 캐릭터 8개의 가능한 모든 배치 순열을 구합니다.
하나의 캐릭터 조합이 나왔다면, map에 해당 캐릭터 글자를 기반으로 위치를 저장합니다. 이 과정은 조건계산에서 위치값을 빠르게 찾기 위해 사용합니다.
checkValid 함수에서 data의 글자 규칙을 기반으로 필요한 요소들을 추출한 후 계산합니다.
m[char]의 값은 현재 해당 캐릭터의 위치로, dist를 구할 수 있습니다.
= < > 의 조건에 맞게 거짓이 되는 return false를 적은 후, 모든 조건을 통과하였다면 return true와 함께 answer을 1씩 올려줍니다.

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

using namespace std;

vector<bool> ch; // DFS에서 해당 원소를 사용했는가
vector<int> sel; // n번째에서 몇번 값을 사용하는가
string characters; // 캐릭터 배열
int cnt; // 사용할 개수 (캐릭터는 8개)
int answer; // 정답 누적

bool checkValid(vector<string>& data, map<char, int>& m)
{
    for(string s : data)
    {
        // 두 캐릭터 사이의 간격
        int dist = abs(m[s[0]] - m[s[2]]) - 1;
        
        // 요구 숫자
        int num = s[4] - '0';
                
        // 요구 조건
        switch(s[3])
        {
            case '=': // 간격이 같은경우?
            {
                // 간격이 다르면 false
                if(dist != num)
                    return false;
                break;
            }
            case '<': // 간격이 미만?
            {
                // 간격이 이상이면 false
                if(dist >= num)
                    return false;
                break;
            }
            case '>': // 간격이 초과?
            {
                // 간격이 이하이면 false
                if(dist <= num)
                    return false;                
                break;
            }                
        }
    }
    
    return true;
}

// 전역 변수를 정의할 경우 함수 내에 초기화 코드를 꼭 작성해주세요.
int solution(int n, vector<string> data) {
    
    characters = "ACFJMNRT";
    ch = vector<bool>(8, false);
    sel = vector<int>(8, -1);
    answer = 0;
    cnt = 8;
    
    do {
        map<char, int> m;
        for(int i = 0; i < cnt; ++i)
            m[characters[i]] = i;
        
        if(checkValid(data, m))
            ++answer;
        
    } while(next_permutation(characters.begin(), characters.end()));
    
    return answer;
}

DFS를 이용하여 직접 순열을 구하지 않고, 내장된 함수인 next_permutation 함수를 이용하여 더욱 간편하게 문제를 해결할 수 있습니다.
이 방법에서 do-while을 사용한 이유는, while문을 먼저 사용할경우, next_permutation을 먼저 호출하여 첫번째 순열부터 검사를 시작하기 때문입니다. 초기 값인 "ACFJMNRT"가 검사되지 않습니다.
DFS를 이용하여 직접 구현하는 방식보다 성능이 좋습니다. 위 DFS를 활용한 방식은 4500ms가 나온 반면, 함수를 통해 구현한 방식은 4000ms로 약 10%의 성능 개선이 있습니다.

[C++][프로그래머스] 게임 맵 최단거리

bonnate — Mon, 20 Nov 2023 18:06:56 +0900

문제

ROR 게임은 두 팀으로 나누어서 진행하며, 상대 팀 진영을 먼저 파괴하면 이기는 게임입니다. 따라서, 각 팀은 상대 팀 진영에 최대한 빨리 도착하는 것이 유리합니다.

지금부터 당신은 한 팀의 팀원이 되어 게임을 진행하려고 합니다. 다음은 5 x 5 크기의 맵에, 당신의 캐릭터가 (행: 1, 열: 1) 위치에 있고, 상대 팀 진영은 (행: 5, 열: 5) 위치에 있는 경우의 예시입니다.

위 그림에서 검은색 부분은 벽으로 막혀있어 갈 수 없는 길이며, 흰색 부분은 갈 수 있는 길입니다. 캐릭터가 움직일 때는 동, 서, 남, 북 방향으로 한 칸씩 이동하며, 게임 맵을 벗어난 길은 갈 수 없습니다.
아래 예시는 캐릭터가 상대 팀 진영으로 가는 두 가지 방법을 나타내고 있습니다.

첫 번째 방법은 11개의 칸을 지나서 상대 팀 진영에 도착했습니다.

두 번째 방법은 15개의 칸을 지나서 상대팀 진영에 도착했습니다.

위 예시에서는 첫 번째 방법보다 더 빠르게 상대팀 진영에 도착하는 방법은 없으므로, 이 방법이 상대 팀 진영으로 가는 가장 빠른 방법입니다.

만약, 상대 팀이 자신의 팀 진영 주위에 벽을 세워두었다면 상대 팀 진영에 도착하지 못할 수도 있습니다. 예를 들어, 다음과 같은 경우에 당신의 캐릭터는 상대 팀 진영에 도착할 수 없습니다.

게임 맵의 상태 maps가 매개변수로 주어질 때, 캐릭터가 상대 팀 진영에 도착하기 위해서 지나가야 하는 칸의 개수의 최솟값을 return 하도록 solution 함수를 완성해주세요. 단, 상대 팀 진영에 도착할 수 없을 때는 -1을 return 해주세요.

풀이

#include<vector>
#include<queue>
using namespace std;

int dx[4] { -1, 1, 0, 0};
int dy[4] { 0, 0, -1, 1};
 
int solution(vector<vector<int> > maps)
{
    int row = maps.size();
    int col = maps[0].size();
    
    vector<vector<int>> dist(row, vector<int>(col, -1));
    
    queue<pair<int, int>> q;
       
    q.push({0, 0});
    dist[0][0] = 1;
    
    while(!q.empty())
    {
        int y = q.front().first;
        int x = q.front().second;
        q.pop();
 
        for(int i = 0; i < 4; ++i)
        {
            int yy = y + dy[i];
            int xx = x + dx[i];
            
            if(xx == -1 || yy == -1 || xx == col || yy == row || maps[yy][xx] == 0 || dist[yy][xx] != -1)
                continue;
            
            q.push({yy, xx});
            dist[yy][xx] = dist[y][x] + 1;
        }
    }
    
    return dist[row - 1][col - 1];
}

BFS를 이용하여 문제를 해결할 수 있습니다.
2차원 벡터 dist를 이용하여 누적 거리를 검사합니다.
현재 위치 {y, x}에서 네 방향을 검사합니다.
만약 해당 위치가 map을 벗어나거나, 이미 다른 방법에 의해 도달한적이 있어 dist가 초기값인 -1이 아니라면 해당 경로로 검사하지 않습니다. 이 이유는 Queue의 특성으로, 이전에 이미 도달한 위치라면 이보다 최선의 값이 갱신될 수 없기 때문입니다.(선입선출)
목적지인 {row -1, col -1}위치의 dist를 리턴합니다.

[C++][프로그래머스] 가장 큰 정사각형 찾기

bonnate — Mon, 20 Nov 2023 17:43:49 +0900

프로그래머스

programmers.co.kr

문제

1와 0로 채워진 표(board)가 있습니다. 표 1칸은 1 x 1 의 정사각형으로 이루어져 있습니다. 표에서 1로 이루어진 가장 큰 정사각형을 찾아 넓이를 return 하는 solution 함수를 완성해 주세요. (단, 정사각형이란 축에 평행한 정사각형을 말합니다.)

풀이

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int solution(vector<vector<int>> board)
{
    int answer = 0;
    bool isZero = true;

    // 블록이 한줄만 되어있는경우?
    if(board.size() == 1 || board[0].size() == 1)
    {
        bool isEscape = true;
        
        for(int i = 0; i < board.size() && isEscape; ++i)
            for(int j = 0; j < board[0].size(); ++j)
                if(board[i][j] == 1)
                {
                    isEscape = false;
                    break;
                }
    
        // 0만 있는 경우 0을 리턴
        if(isEscape)
            return 0;
        // 1이 하나라도 있는경우, 1리턴
        else
            return 1;
    }
    
    // dp
    for(int i = 1; i < board.size(); ++i)
    {
        for(int j = 1; j < board[0].size(); ++j)
        {
            if(board[i][j])
            {
                board[i][j] = 1 + min({board[i-1][j-1],board[i-1][j],board[i][j-1]});
                answer = max(answer, board[i][j] * board[i][j]);
            }
        }
    }
    
    // [0][0], [1][0], [0][1]의 값도 함께 검사하여 리턴
    return max({answer, board[0][0], board[0][1], board[1][0]});
}

dp를 이용하여 문제를 해결합니다.
2x2 영역을 차례대로 모두 검사하여 누적된 길이를 저장합니다.
2x2의 영역에 대한 최소값 + 1을 저장합니다. 낮은 값이 있다면, 그 값을 기준으로 정사각형이 이루어지기 때문입니다.
board[i][j]가 1이 아니라면, 빈 공간이므로 계산하지 않습니다.

[C++][프로그래머스] 배달 ⭐️

bonnate — Sun, 19 Nov 2023 21:37:41 +0900

프로그래머스

programmers.co.kr

문제

N개의 마을로 이루어진 나라가 있습니다. 이 나라의 각 마을에는 1부터 N까지의 번호가 각각 하나씩 부여되어 있습니다. 각 마을은 양방향으로 통행할 수 있는 도로로 연결되어 있는데, 서로 다른 마을 간에 이동할 때는 이 도로를 지나야 합니다. 도로를 지날 때 걸리는 시간은 도로별로 다릅니다. 현재 1번 마을에 있는 음식점에서 각 마을로 음식 배달을 하려고 합니다. 각 마을로부터 음식 주문을 받으려고 하는데, N개의 마을 중에서 K 시간 이하로 배달이 가능한 마을에서만 주문을 받으려고 합니다. 다음은 N = 5, K = 3인 경우의 예시입니다.

위 그림에서 1번 마을에 있는 음식점은 [1, 2, 4, 5] 번 마을까지는 3 이하의 시간에 배달할 수 있습니다. 그러나 3번 마을까지는 3시간 이내로 배달할 수 있는 경로가 없으므로 3번 마을에서는 주문을 받지 않습니다. 따라서 1번 마을에 있는 음식점이 배달 주문을 받을 수 있는 마을은 4개가 됩니다.
마을의 개수 N, 각 마을을 연결하는 도로의 정보 road, 음식 배달이 가능한 시간 K가 매개변수로 주어질 때, 음식 주문을 받을 수 있는 마을의 개수를 return 하도록 solution 함수를 완성해주세요.

풀이

다익스트라 알고리즘

적용 시점: 음의 가중치를 갖지 않는 그래프에 적합합니다. 각 간선의 가중치는 양수여야 합니다.
동작 방식: 시작 노드로부터 다른 모든 노드까지의 최단 경로를 찾을 때 사용됩니다.
작동 방식: 각 노드마다 최단 거리를 저장하면서, 해당 노드와 연결된 간선을 탐색하며 최단 거리를 업데이트합니다. 이를 위해 우선순위 큐를 사용하여 현재까지의 최단 거리를 계산하여 처리합니다.
시간 복잡도: 힙(우선순위 큐)을 사용하므로 O((V + E)logV)의 시간 복잡도를 가집니다. (V: 노드 수, E: 간선 수)

벨만-포드 알고리즘

적용 시점: 음의 가중치를 포함하거나 음수 사이클이 있는 경우에 사용됩니다. 음수 사이클이 없는 경우에도 사용 가능하지만, 다익스트라보다 느린 성능을 보입니다.
동작 방식: 모든 간선을 순회하면서 최단 경로를 찾습니다. 각 노드를 반복해서 거치며 최단 거리를 업데이트합니다. 음수 사이클을 탐지할 수 있습니다.
작동 방식: 간선을 모든 노드 수 - 1만큼 반복하여 최단 거리를 찾습니다. 모든 노드 쌍에 대한 최단 거리를 확인하기 위해 사용될 수 있습니다.
시간 복잡도: O(VE)의 시간 복잡도를 가집니다. (V: 노드 수, E: 간선 수)

어느 시점에서 사용하는가?

다익스트라 알고리즘은 음의 가중치가 없는 그래프에서 최단 거리를 찾을 때 적합합니다.
벨만-포드 알고리즘은 음의 가중치가 있거나 음수 사이클을 탐지해야 할 때 사용됩니다. 또한, 모든 노드 쌍에 대한 최단 경로를 확인할 때에도 사용될 수 있습니다.
요약하자면, 음의 가중치가 없는 경우에는 다익스트라 알고리즘이 효율적입니다. 그러나 음수 가중치가 있거나 음수 사이클을 확인해야 하는 경우에는 벨만-포드 알고리즘이 더 적합합니다.

#include <iostream>
#include <vector>
#include <climits>
using namespace std;

// 간선 정보
struct Edge {
    int from, to, weight;
};

int solution(int N, vector<vector<int>> road, int K) {
    vector<Edge> edges;
    vector<int> dist(N + 1, INT_MAX);

    // 그래프 정보 초기화 (무방향 그래프로 양측 노드에 삽입)
    for (vector<int> r : road) {
        edges.push_back({ r[0], r[1], r[2] });
        edges.push_back({ r[1], r[0], r[2] });
    }

    // 시작 노드의 거리는 0
    dist[1] = 0; 

    // 벨만-포드 알고리즘
    // 모든 노드에 대한 가장 짧은 경로는 노드의 수보다 하나 작은 간선의 수(N-1)로 이루어지기에 N-1번 반복
    for (int i = 0; i < N - 1; ++i)
        for (Edge edge : edges) 
        {
            int from = edge.from;
            int to = edge.to;
            int weight = edge.weight;
    
            // 아직 다른 간선에 의해 비용이 계산되지 않은경우에는 무시
            if(dist[from] == INT_MAX)
                continue;
            
            // 현재 위치의 비용(dist[from]) + 다음 위치까지의 비용(weight)이 저장된 비용(dist[to])보다 작으면 갱신
            dist[to] = min(dist[to], dist[from] + weight);
        }
    
    // 정답 구하기
    int answer = 0;
    for(int i = 1; i <= N; ++i)
        if(dist[i] <= K)
            ++answer;

    return answer;
}

#include <iostream>
#include <vector>
#include <climits>
using namespace std;

struct Edge {
    int from, to, weight;
};

int solution(int N, vector<vector<int>> road, int K) {

    vector<Edge> graph;
    for(vector<int>& v : road)
    {
        graph.push_back({v[0], v[1], v[2]});
        graph.push_back({v[1], v[0], v[2]});
    }
        
    vector<int> dist(N + 1, INT_MAX);
    
    dist[1] = 0; // 시작 지점은 거리가 0으로 시작

    // N-1만큼 반복한 후, 음의 사이클을 검사하기위해 한번 더 검사(<=로 표현)
    for (int i = 0; i <= N - 1; ++i) {
        for (Edge& edge : graph) {
            int from = edge.from;
            int to = edge.to;
            int weight = edge.weight;
            
            if(dist[from] == INT_MAX)
                continue;
            
            // 음의 사이클을 검사
            // N-1번째에도 dist[from] + weight < dist[to]가 참이라면, 음의 사이클이 존재
            if(i == N - 1 && dist[from] + weight < dist[to])
                return -1;
            
            dist[to] = min(dist[to], dist[from] + weight);
        }
    }

    // 정답 구하기
    int answer = 0;
    for(int i = 1; i <= N; ++i)
        if(dist[i] <= K)
            ++answer;        

    return answer;
}

벨만 포드 알고리즘을 활용하여 문제를 해결하였습니다.

#include <iostream>
#include <vector>
#include <queue>
#include <climits>
using namespace std;

// 간선 정보
struct Edge {
    int to, weight;
};

int solution(int N, vector<vector<int>> road, int K) {
    vector<vector<Edge>> graph(N + 1);
    vector<int> dist(N + 1, INT_MAX);

    // 그래프 정보 초기화 (양방향)
    for (vector<int> r : road) {
        int from = r[0];
        int to = r[1];
        int weight = r[2];
        graph[from].push_back({to, weight});
        graph[to].push_back({from, weight});
    }

    // 우선순위 큐를 이용한 다익스트라 알고리즘
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

    dist[1] = 0; // 시작 노드의 거리는 0
    pq.push({0, 1}); // {거리, 노드} 쌍을 우선순위 큐에 삽입

    while (!pq.empty()) {
        int current_distance = pq.top().first;
        int current_node = pq.top().second;
        pq.pop();

        // 현재 노드에서 갈 수 있는 모든 노드들에 대해 최단 거리 갱신
        for (Edge& e : graph[current_node]) {
            int next_node = e.to;
            int weight = e.weight;

            if (dist[next_node] > current_distance + weight) {
                dist[next_node] = current_distance + weight;
                pq.push({dist[next_node], next_node});
            }
        }
    }

    // 정답 구하기
    int answer = 0;
    for (int i = 1; i <= N; ++i)
        if (dist[i] <= K)
            ++answer;

    return answer;
}

#include <iostream>
#include <vector>
#include <queue>
#include <climits>
using namespace std;

int solution(int N, vector<vector<int> > road, int K) {

    vector<vector<pair<int, int>>> graph(N + 1, vector<pair<int, int>>());
    for(vector<int>& v : road)
    {
        graph[v[0]].push_back({v[1], v[2]});
        graph[v[1]].push_back({v[0], v[2]});
    }
    
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
    vector<int> dist(N + 1, INT_MAX);
    
    pq.push({0, 1});
    dist[1] = 0;
    while(!pq.empty())
    {
        int currentDistance = pq.top().first; // 현재 노드까지의 누적 가중치
        int currentNode = pq.top().second; // 현재 노드 위치
        
        pq.pop();
        
        // 현재 노드를 기준으로 갈 수 있는 모든 경로를 반복
        for(pair<int, int>& p : graph[currentNode])
        {
            int nextNode = p.first; // 다음 노드의 번호
            int weight = p.second; // 다음 노드로 가기까지 가중치
        
            // 현재 노드까지의 가중치 + 다음 노드 가중치가 저장된 값보다 더 작다면?
            if(dist[nextNode] > currentDistance + weight)
            {
                dist[nextNode] = currentDistance + weight; // 값을 갱신
                pq.push({dist[nextNode], nextNode}); // 큐에 가중치와 다음노드 번호를 삽입
            }
        }
    }
    
    // 정답 구하기
    int answer = 0;
    for (int i = 1; i <= N; ++i)
        if (dist[i] <= K)
            ++answer;
    
    return answer;
}

다익스트라 알고리즘을 이용하여 문제를 해결하였습니다.

[C++][프로그래머스] [1차] 프렌즈4블록

bonnate — Sun, 19 Nov 2023 20:57:24 +0900

프로그래머스

programmers.co.kr

문제

블라인드 공채를 통과한 신입 사원 라이언은 신규 게임 개발 업무를 맡게 되었다. 이번에 출시할 게임 제목은 "프렌즈4블록".
같은 모양의 카카오프렌즈 블록이 2 ×2 형태로 4개가 붙어있을 경우 사라지면서 점수를 얻는 게임이다.

만약 판이 위와 같이 주어질 경우, 라이언이 2×2로 배치된 7개 블록과 콘이 2×2로 배치된 4개 블록이 지워진다. 같은 블록은 여러 2×2에 포함될 수 있으며, 지워지는 조건에 만족하는 2×2 모양이 여러 개 있다면 한꺼번에 지워진다.

블록이 지워진 후에 위에 있는 블록이 아래로 떨어져 빈 공간을 채우게 된다.

만약 빈 공간을 채운 후에 다시 2×2 형태로 같은 모양의 블록이 모이면 다시 지워지고 떨어지고를 반복하게 된다.

TTTANT
RRFACC
RRRFCC
TRRRAA
TTMMMF
TMMTTJ

각 문자는 라이언(R), 무지(M), 어피치(A), 프로도(F), 네오(N), 튜브(T), 제이지(J), 콘(C)을 의미한다

입력으로 블록의 첫 배치가 주어졌을 때, 지워지는 블록은 모두 몇 개인지 판단하는 프로그램을 제작하라.

풀이

#include <string>
#include <vector>
#include <iostream>
#include <set>

using namespace std;

set<pair<int, int>> s;

void removeRect(vector<string>& board, int row, int col)
{
    set<char> m;
    
    m.insert(board[row][col]);
    m.insert(board[row][col + 1]);
    m.insert(board[row + 1][col]);
    m.insert(board[row + 1][col + 1]);
    
    if(m.size() == 1)
    {
        if(m.find('-') != m.end())
            return;
        
        s.insert({row, col});
        s.insert({row, col + 1});
        s.insert({row + 1, col});
        s.insert({row + 1, col + 1});
    }
}

void print(vector<string>& board);

void clearRect(vector<string>& board)
{
    for(pair<int, int> p : s)
        board[p.first][p.second] = '-';
    
    s.clear();
    
    // print(board);
    
    for(int i = 0; i < board[i].size(); ++i)
    {
        for(int j = board.size() - 1; j >= 1; --j)
        {
            if(board[j][i] == '-')
            {
                for(int k = j - 1; k >= 0; --k)
                {
                    if(board[k][i] != '-')
                    {
                        board[j][i] = board[k][i];
                        board[k][i] = '-';
                        break;
                    }
                }
            }
        }
    }
}

void print(vector<string>& board)
{
    for(int i = 0 ; i < board.size(); ++i)
    {
        for(int j = 0; j < board[0].size(); ++j)
        {
            cout<<board[i][j];
        }
        
        cout<<endl;
    }
    
    cout<<endl;
}

int solution(int m, int n, vector<string> board) {
    int answer = 0;
    
    while(1)
    {
        for(int i = 0; i < m - 1; ++i)
            for(int j = 0; j < n - 1; ++j)
                removeRect(board, i, j);
        
        if(s.empty())
            break;
        
        answer += s.size();
        clearRect(board);
        // print(board);
    }
    
    return answer;
}

set을 활용하여 문제를 해결하였습니다.
매번 2x2 영역이 같은지 removeRect에서 검사합니다. 만약 네 블록이 모두 같은 글자로 되어있다면, set에 삽입합니다. set에 삽입할 때 중복값을 제거할 수 있습니다.
clearRect에서 글자를 제거한 후, 빈 공간을 위 블록으로 채웁니다.
위 과정을 반복하여 set이 비어있을 때(더 이상 2x2가 없음) 종료합니다.

[C++] 코딩테스트 유용한 함수 및 표현 정리

bonnate — Sun, 19 Nov 2023 00:58:19 +0900

C++을 이용하여 코딩테스트를 볼 때 유용한 STL 함수 및 표현을 정리합니다. 이 글은 지속적으로 업데이트되어 추가 될 예정입니다.

문자열을 대소문자로 변환

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
	string s = "AbCdEfGhI";

	transform(s.begin(), s.end(), s.begin(), [](char c)
		{
			return toupper(c);
		});

	cout << s << endl;
}

std::transform은 C++ STL(표준 템플릿 라이브러리)에서 제공되는 알고리즘 중 하나로, 순차 컨테이너의 요소를 변환하는 함수입니다. 주로 범위 기반 알고리즘 중 하나로 사용됩니다.
s.begin()과 s.end()는 문자열 s의 시작과 끝을 가리키는 반복자(iterator)입니다.
세 번째 인자인 s.begin()은 출력 대상 범위의 시작 지점을 나타냅니다. 여기서는 변환된 값이 다시 s에 저장되기 때문에 입력과 출력이 같은 범위입니다.
네 번째 인자는 변환을 수행하는 함수자(람다 함수)입니다. [](char c) { return toupper(c); }는 입력으로 받은 문자 c를 toupper 함수를 사용하여 대문자로 변환한 값을 반환합니다.

문자열에서 숫자만 추출

#include <iostream>
#include <string>

using namespace std;

int main() {
	string str = "abc123def456ghi";

	string numbers;

	// 문자열에서 숫자만 추출하여 numbers에 저장
	for (char c : str)
		if (isdigit(c))
			numbers += c;

	// 추출된 숫자 출력
	cout << "추출된 숫자: " << numbers << endl;

	// string을 int로 변환
	stoi(numbers);

	return 0;
}

주어진 문자열에서 숫자만 추출합니다.
isdigit라는 함수를 이용할 수 있습니다.

#include <iostream>
#include <string>

using namespace std;

int main() {
	string str = "abc123def456ghi";

	string numbers;

	// 문자열에서 숫자만 추출하여 numbers에 저장
	for (char c : str)
		if (c >= '0' && c <= '9')
			numbers += c;

	// 추출된 숫자 출력
	cout << "추출된 숫자: " << numbers << endl;

	// string을 int로 변환
	stoi(numbers);

	return 0;
}

c++ 버전으로 인해 함수를 사용할 수 없는경우, if (c >= '0' && c <= '9')를 이용하여 직접 구현할 수 있습니다.

vector에서 값을 찾아 제거

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;
int main() {
	vector<string> v = { "apple", "orange", "banana", "orange", "grape" };

	string _s = "orange";

	// 벡터에서 특정 값 찾기
	auto it = find(v.begin(), v.end(), _s);

	if (it != v.end()) {
		// 값을 찾았으면 제거
		v.erase(it);
	}

	// 제거 후 벡터 출력
	for (const auto& element : v) {
		cout << element << " ";
	}
	cout << endl;

	return 0;
}

std::find 함수를 사용하여 벡터 v에서 _s라는 값을 찾습니다.
만약 해당 값이 벡터 안에 존재하면, std::erase 함수를 사용하여 해당 값을 제거합니다.
std::vector<string>::iterator 타입을 직접 명시하지 않고 auto를 사용하면 더욱 편리하게 사용할 수 있습니다.

vector의 배열 회전

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;
int main() {
	vector<int> v{ 0, 1, 2, 3, 4, 5 };
	int depth = 1;

	for (int n : v)
		cout << n << " ";
	cout << endl;

	rotate(v.begin(), v.begin() + depth, v.end()); // 인덱스가 감소하는 방향으로 depth만큼 회전

	for (int n : v)
		cout << n << " ";
	cout << endl;

	rotate(v.rbegin(), v.rbegin() + depth, v.rend()); // 인덱스가 증가하는 방향으로 depth만큼 회전

	for (int n : v)
		cout << n << " ";
	cout << endl;

	return 0;
}

rotate 함수를 이용하여 배열을 회전시킬 수 있습니다.
v.begin()을 시작으로 사용하면, 인덱스가 감소하는 방향으로 회전시킬 수 있습니다.
- {0 1 2 3 4 5} -> {1 2 3 4 5 0}
v.rbegin()을 시작으로 사용하면, 인덱스가 증가하는 방향으로 회전시킬 수 있습니다.
- {1 2 3 4 5 0} -> {0 1 2 3 4 5}

이분탐색

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;
int main() {
	vector<int> v = { 1, 2, 3, 3, 3, 3, 5, 6, 7, 8, 9 };

	bool found = binary_search(v.begin(), v.end(), 3);

	cout << "기존 벡터 값: ";
	for (int n : v)
		cout << n << " ";
	cout << endl;

	if (found) {
		cout << "3이 존재함" << endl;
	}
	else {
		cout << "3이 존재하지 않음!" << endl;
	}

	auto it_lower = lower_bound(v.begin(), v.end(), 3);

	if (it_lower != v.end()) {
		printf("3 이상이 처음으로 나타나는 인덱스 위치: %d, 값: %d\n", distance(v.begin(), it_lower), *it_lower);
	}
	else {
		cout << "3 이상이 나타나는 위치를 찾지 못함!" << endl;
	}

	auto it_upper = upper_bound(v.begin(), v.end(), 3);

	if (it_upper != v.end()) {
		printf("3보다 큰 값이 처음으로 나타나는 인덱스 위치: %d, 값: %d\n", distance(v.begin(), it_upper), *it_upper);
	}
	else {
		cout << "3보다 큰 값이 나타나는 위치를 찾지 못함!" << endl;
	}

	return 0;
}

기존 벡터 값: 1 2 3 3 3 3 5 6 7 8 9
3이 존재함
3 이상이 처음으로 나타나는 인덱스 위치: 2, 값: 3
3보다 큰 값이 처음으로 나타나는 인덱스 위치: 6, 값: 5

std::binary_search 함수: 주어진 값이 정렬된 범위에 존재하는지 확인합니다.
std::lower_bound 함수: 주어진 값 이상이 처음으로 나타나는 위치를 찾습니다.
std::upper_bound 함수: 주어진 값보다 큰 값이 처음으로 나타나는 위치를 찾습니다.
이분 탐색을 위해서는 아래의 조건을 따라야 합니다.
- 정렬된 데이터: 이분 탐색은 정렬된 데이터에서 사용됩니다. 데이터가 정렬되어 있지 않으면 이분 탐색을 적용할 수 없습니다.
- 가능한한 중복되지 않는 키 값: 중복된 값이 많을수록 이분 탐색의 성능이 저하될 수 있습니다. 중복을 줄이는 것이 유리합니다.
- 인덱스 기반 접근이 가능한 데이터 구조: 이분 탐색은 인덱스 기반으로 작동합니다. 배열 또는 벡터와 같이 인덱스로 원소에 접근할 수 있는 데이터 구조에서 사용됩니다.
- 순차적인 데이터: 이분 탐색은 일반적으로 순차적인 데이터에서 사용됩니다. 이는 특정 요소를 찾는 것이지 임의의 요소를 검색하는 것이 아닙니다.
- 탐색 대상의 크기가 충분히 크거나 탐색 빈도가 높을 때 유용: 데이터 크기가 작거나 탐색 빈도가 낮은 경우에는 선형 탐색과 비교해 별다른 이점을 얻을 수 없습니다.

우선순위 큐 오름차순

우선순위 큐는 기본으로 생성하면 내림차순으로 되어있습니다. { 9, 8, 7 .... }

생성을 할 때, 추가 매개변수를 통해 오름차순으로 설정할 수 있습니다.

// pair<int, int>를 오름차순
priority_queue <pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pqASC;

// int를 오름차순
priority_queue <int, vector<int>, greater<int>> pqIntASC;

pair<int, int>
- 우선순위 큐에 저장될 요소의 형식을 지정합니다. 여기서는 int형 두 개가 묶인 쌍(pair)으로 이루어진 요소입니다. 첫 번째 int는 거리를, 두 번째 int는 노드 번호를 나타냅니다.
vector<pair<int, int>>
- priority_queue에서 내부적으로 사용되는 컨테이너 타입을 지정합니다. priority_queue는 내부적으로 이 컨테이너를 사용하여 요소를 저장합니다. 여기서는 pair<int, int>를 저장하는 vector가 사용됩니다.
greater<pair<int, int>>
- 비교 함수 객체를 지정하는 부분입니다. greater는 STL 라이브러리에 내장된 비교 함수 객체로, 두 요소를 비교할 때 첫 번째 요소가 두 번째 요소보다 작은지 여부를 확인하여 우선순위를 정합니다.
- 이 경우에는 내림차순으로 정렬하도록 합니다.
- greater의 반대는 less입니다. (오름차순)

#include <iostream>
#include <queue>
using namespace std;

int main()
{
	priority_queue <pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pqASC;
	for (int i = 0; i < 10; ++i)
	{
		pqASC.push({ rand() % 1000, rand() % 1000 });
	}

	for (int i = 0; i < 10; ++i)
	{
		pqASC.push({ 500, rand() % 1000 });
	}

	cout << "오름차순" << endl;
	while (!pqASC.empty())
	{
		printf("%d %d\n", pqASC.top().first, pqASC.top().second);
		pqASC.pop();
	}

	priority_queue <pair<int, int>> pqDESC;
	for (int i = 0; i < 10; ++i)
	{
		pqDESC.push({ rand() % 1000, rand() % 1000 });
	}

	for (int i = 0; i < 10; ++i)
	{
		pqDESC.push({ 500, rand() % 1000 });
	}

	cout << "내림차순" << endl;
	while (!pqDESC.empty())
	{
		printf("%d %d\n", pqDESC.top().first, pqDESC.top().second);
		pqDESC.pop();
	}

	priority_queue <int, vector<int>, greater<int>> pqIntASC;
	for (int i = 0; i < 10; ++i)
	{
		pqIntASC.push({ rand() % 1000 });
	}

	for (int i = 0; i < 10; ++i)
	{
		pqIntASC.push({ 500 });
	}

	cout << "내림차순" << endl;
	while (!pqIntASC.empty())
	{
		printf("%d\n", pqIntASC.top());
		pqIntASC.pop();
	}
}

#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
using namespace std;

int getNextPickaxe(vector<int>& picks)
{
    if(picks[0]-- > 0)
        return 0;
    if(picks[1]-- > 0)
        return 1;
    if(picks[2]-- > 0)
        return 2;

    return 3;
}

int solution(vector<int> picks, vector<string> minerals) {
    int answer = 0;
    priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>, greater<pair<int, pair<int, int>>>> pq;
    int pickaxeCount = picks[0] + picks[1] + picks[2];

    for(int i = 0; i < ceil(minerals.size() / 5.0f); ++i)
    {
        int arr[3] {0, 0, 0};
        for(int j = 0; j < 5 && i * 5 + j < minerals.size() && pickaxeCount - i; ++j)
        {
            switch(minerals[i * 5 + j][0])
            {
                case 'd':
                    ++arr[0];
                    break;
                case 'i':
                    ++arr[1];
                    break;
                case 's':
                    ++arr[2];
                    break;            
            }
        }

        pq.push({arr[0], {arr[1], arr[2]}});
    }

    while(!pq.empty())
    {
        int diamond = pq.top().first;
        int iron = pq.top().second.first;
        int stone = pq.top().second.second;
        pq.pop();
        
        printf("%d %d %d\n", diamond, iron, stone);

        switch(getNextPickaxe(picks))
        {
            case 0:
                answer += (diamond + iron + stone);
                break;
            case 1:
                answer += (diamond * 5 + iron + stone);
                break;
            case 2:
                answer += (diamond * 25 + iron * 5 + stone);
                break;
            default:
                return answer;
                break;
        }
    }

    return answer;
}

int main()
{
    solution({1, 3, 2}, {"diamond", "diamond", "diamond", "iron", "iron", "diamond", "iron", "stone"});
}

priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>, greater<pair<int, pair<int, int>>>> pq;와 같은 복잡한 형태의 우선순위 큐라 할지라도, 생성 규칙을 제대로 적용하면 내림차순의 우선순위 큐를 만들 수 있습니다.

2차원 벡터의 생성자

동적으로 크기를 할당할 때, 2차원 벡터를 사용할 수 있습니다.

vector<vector<int>> v = vector<vector<int>>(10, vector<int>(20, 30));

vector<vector<int>>: 2차원 벡터를 나타냅니다. 즉, 각 요소가 정수형 벡터인 벡터입니다.
v = vector<vector<int>>(10, vector<int>(20, 30)): 10개의 요소를 가진 벡터를 생성합니다.
각 요소는 20개의 정수로 이루어진 벡터이며, 모든 요소는 30으로 초기화됩니다.
이 코드는 10x20 크기의 2차원 벡터를 만들고, 모든 요소를 30으로 초기화하는 데 사용됩니다.
만약 예를 들어, v[0][0]을 조회하면 30이 반환됩니다.

또는, 아래와 같이 선언과 동시에 초기화 할 수 있습니다.

vector<vector<int>> v(10, vector<int>(20, 30));

순열

[C++][DFS] 수의 조합 ⭐

#include int sel; int used[10]; int ch[10]; char arr[10]{ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' }; /// /// 순서를 무시하고 가능한 모든 경우의 수를 조합 /// /// void DFS_ALL_Combinations(int s) { if (s == sel) { for (int i = 0;

bonnate.tistory.com

[C++][프로그래머스] 단체사진 찍기

프로그래머스 코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요. programmers.co.kr 문제

bonnate.tistory.com

주어진 문자열을 서로 다르게 나열하는 모든 경우의 수 순열을 DFS를 통해 직접 구현하지 않고, 알고리즘 함수를 이용하여 간편하게 사용할 수 있습니다.
next_permutation 함수를 사용합니다.

do {
    map<char, int> m;
    for(int i = 0; i < cnt; ++i)
        m[characters[i]] = i;

    if(checkValid(data, m))
        ++answer;

} while(next_permutation(characters.begin(), characters.end()));

next_permutaion(characters.begin(), characters.end())를 사용하면 characters의 요소 자체의 값이 변경됩니다. 이를 통해 가능한 모든 조합을 얻어낼 수 있습니다.
DFS를 이용하여 직접 구현하는 방식보다 성능이 좋습니다. DFS를 활용한 구현은 위 문제에서 4500ms가 나온 반면, 함수를 통해 구현한 방식은 4000ms로 약 10%의 성능 개선이 있습니다.

[C++][프로그래머스] [1차] 캐시

bonnate — Sun, 19 Nov 2023 00:13:55 +0900

프로그래머스

programmers.co.kr

문제

지도개발팀에서 근무하는 제이지는 지도에서 도시 이름을 검색하면 해당 도시와 관련된 맛집 게시물들을 데이터베이스에서 읽어 보여주는 서비스를 개발하고 있다.
이 프로그램의 테스팅 업무를 담당하고 있는 어피치는 서비스를 오픈하기 전 각 로직에 대한 성능 측정을 수행하였는데, 제이지가 작성한 부분 중 데이터베이스에서 게시물을 가져오는 부분의 실행시간이 너무 오래 걸린다는 것을 알게 되었다.
어피치는 제이지에게 해당 로직을 개선하라고 닦달하기 시작하였고, 제이지는 DB 캐시를 적용하여 성능 개선을 시도하고 있지만 캐시 크기를 얼마로 해야 효율적인지 몰라 난감한 상황이다.

어피치에게 시달리는 제이지를 도와, DB 캐시를 적용할 때 캐시 크기에 따른 실행시간 측정 프로그램을 작성하시오.

풀이

#include <string>
#include <vector>
#include <set>
#include <iostream>
#include <algorithm>

using namespace std;


int solution(int cacheSize, vector<string> cities) {
    int answer = 0;
    
    set<string> s;
    vector<string> v;
    
    for(string _s : cities)
    {
        transform(s.begin(), s.end(), s.begin(), [](char c) { return toupper(c); });
        v.push_back(_s);
        
        if(s.find(_s) != s.end()) // cache hit
        {
            ++answer;
            
            auto it = find(v.begin(), v.end(), _s);
            if(it != v.end())
                v.erase(it);
        }
        else // cache miss
        {
            answer += 5;
            
            if(s.size() >= cacheSize)
            {
                s.erase(*v.begin());    
                v.erase(v.begin());
            }
            
            if(cacheSize != 0)
                s.insert(_s);
        }
    }
    
    return answer;
}

map과 vector 배열을 활용해서 문제를 해결하였습니다.
map을 이용하여 현재 캐시에 값이 있는지 확인합니다.
s에는 가장 마지막에 사용한 값이 front에 이동하도록 합니다.

[C++][프로그래머스] 다리를 지나는 트럭 rotate(), q.back()

bonnate — Sat, 18 Nov 2023 23:02:16 +0900

프로그래머스

programmers.co.kr

문제

트럭 여러 대가 강을 가로지르는 일차선 다리를 정해진 순으로 건너려 합니다. 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 알아내야 합니다. 다리에는 트럭이 최대 bridge_length대 올라갈 수 있으며, 다리는 weight 이하까지의 무게를 견딜 수 있습니다. 단, 다리에 완전히 오르지 않은 트럭의 무게는 무시합니다.

예를 들어, 트럭 2대가 올라갈 수 있고 무게를 10kg까지 견디는 다리가 있습니다. 무게가 [7, 4, 5, 6]kg인 트럭이 순서대로 최단 시간 안에 다리를 건너려면 다음과 같이 건너야 합니다.

solution 함수의 매개변수로 다리에 올라갈 수 있는 트럭 수 bridge_length, 다리가 견딜 수 있는 무게 weight, 트럭 별 무게 truck_weights가 주어집니다. 이때 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 return 하도록 solution 함수를 완성하세요.

풀이

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

using namespace std;

int solution(int bridge_length, int weight, vector<int> truck_weights) {
    int answer = 0;
    int n = truck_weights.size();
    
    vector<int> v(bridge_length + 1, 0);
    int sum = 0;
    int idx = 0;
    
    while(idx < n)
    {
        // 왼쪽으로 한칸씩 이동
        rotate(v.rbegin(), v.rbegin() + 1, v.rend());
        
		// 마지막에 있는 트럭을 내보내기
		sum -= v[bridge_length]; // 마지막에 있는 트럭의 무게를 빼기
		v[bridge_length] = 0; // 해당 값은 0으로 설정        
        
		// 트랙 보내기 시도
		if (sum + truck_weights[idx] <= weight)
		{
			v[0] = truck_weights[idx++];
			sum += v[0];
		}

		++answer;
    }
    
    for(int i = 0; i < bridge_length; ++i)
        if(v[i])
        {
            answer += bridge_length - i;
            break;
        }
    
    return answer;
}

rotate 함수를 이용하여 문제를 해결하였습니다.
- (인덱스가 1에서 0로) 한칸씩 이동 rotate(v.begin(), v.begin() + 1, v.end());
- (인덱스가 0에서 1로) 한칸씩 이동 rotate(v.rbegin(), v.rbegin() + 1, v.rend());
트럭의 무게를 0부터 삽입하여 brigde_length까지 회전하여 더합니다.
v[brigde_length]에 값이 있다면, 트럭이 다리를 모두 지난것으로, sum에서 빼줍니다.
매 반복문마다 검사하여 트럭의 무게를 삽입하고, 종단에서 트럭을 빼줌으로써 문제를 해결하였습니다.

#include <string>
#include <vector>
#include <algorithm>
#include <queue>

using namespace std;

int solution(int bridge_length, int weight, vector<int> truck_weights) {
    queue<pair<int, int>> q;
    int sum = 0; // 현재 다리에 있는 트럭의 무게 합
    int idx = 0; // 삽입할 인덱스 번호
    int time = 0; // 경과된 시간
    int n = truck_weights.size(); // 트럭의 개수
    
    while(idx < n)
    {
        // q가 비어있지 않으면서, q의 front의 시간이 경과되었다면? (도착)
        if(!q.empty() && time >= q.front().second)
        {
            sum -= q.front().first; // 무게에서 빼기
            q.pop(); // 큐에서 제거
        }
        
        // idx번째의 트럭을 다리에 둘 수 있는가? (무게를 초과하지 않는가?)
        if(sum + truck_weights[idx] <= weight)
        {
            q.push({truck_weights[idx], time + bridge_length}); // 큐에 트럭의 무게와 도착 예정 시간 삽입
            sum += truck_weights[idx++]; // 무게 합
        }
        
        ++time; // 시간 경과
    }
    
    // 큐의 가장 마지막 원소의 시간 + 1을 리턴
    return q.back().second + 1;
}

큐를 이용하여 문제를 해결합니다.
큐에 차례대로 삽입을 시도합니다. 이때, 총 합의 무게가 weight를 넘어서는 안됩니다.
time을 지속적으로 증가하여 만약, 큐의 front의 second(도착 예정 시간)이 time 이상이라면, 도착을 한 경우로 sum에서 first(무게)를 제거하고, 큐에서 제거합니다.
모든 idx를 삽입하였다면, q.back().second + 1을 리턴합니다. 이 과정은 다리 위에서 가장 늦게 삽입된 트럭이 도착하는 시간을 더한 값입니다.

[C++][프로그래머스] 주식가격

bonnate — Fri, 17 Nov 2023 23:25:12 +0900

프로그래머스

programmers.co.kr

문제

초 단위로 기록된 주식가격이 담긴 배열 prices가 매개변수로 주어질 때, 가격이 떨어지지 않은 기간은 몇 초인지를 return 하도록 solution 함수를 완성하세요.

풀이

#include <string>
#include <vector>
#include <stack>

using namespace std;

vector<int> solution(vector<int> prices) {
    int n = prices.size();
    vector<int> answer(n, 0);
    stack<int> s;
    
    // 모든 값 검사
    for(int i = 0; i < n; ++i)
    {
        // s가 비어있지 않을때, 
        // top의 가격이 prices[i]보다 크다면 가격이 떨어지기 시작
        while(!s.empty() && prices[s.top()] > prices[i])
        {
            // answer[s.top()]에는 현재 위치(i) 에서 삽입한 위치(s.top)의 차이를 삽입
            answer[s.top()] = i - s.top();
            s.pop();
        }
        
        // 현재 위치 삽입
        s.push(i);
    }

    // 해당 위치의 가격은 마지막까지 한번도 떨어지지 않은 경우임
    // s가 빌때까지 모두 정답에 삽입
    while(!s.empty())
    {
        answer[s.top()] = n - s.top() - 1;
        s.pop();
    }
    
    return answer;
}

스택을 이용하여 문제를 해결하였습니다.
i를 지속적으로 push하면서 가격이 직전 가격보다 떨어지는지 검사합니다.
만약, 가격이 떨어진다면 가격이 떨어지지 않는 경우까지 계속 정답에 삽입한 후, s의 값을 pop 합니다.

[C++][프로그래머스] 기능 개발

bonnate — Fri, 17 Nov 2023 23:11:31 +0900

프로그래머스

programmers.co.kr

문제

프로그래머스 팀에서는 기능 개선 작업을 수행 중입니다. 각 기능은 진도가 100%일 때 서비스에 반영할 수 있습니다.

또, 각 기능의 개발속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 기능보다 먼저 개발될 수 있고, 이때 뒤에 있는 기능은 앞에 있는 기능이 배포될 때 함께 배포됩니다.

먼저 배포되어야 하는 순서대로 작업의 진도가 적힌 정수 배열 progresses와 각 작업의 개발 속도가 적힌 정수 배열 speeds가 주어질 때 각 배포마다 몇 개의 기능이 배포되는지를 return 하도록 solution 함수를 완성하세요.

풀이

#include <string>
#include <vector>

using namespace std;

vector<int> solution(vector<int> progresses, vector<int> speeds) {
    
    int size = progresses.size();
    vector<int> answer;
    
    int idx = 0;
    int days = 0;
    while(idx < size)
    {
        for(int i = idx; i < size; ++i)
            progresses[i] += speeds[i];

        int cnt = 0;
        for(int i = idx; i < size; ++i)
            if(progresses[i] >= 100)
                ++cnt, ++idx;
            else
                break;
                
        if(cnt)
            answer.push_back(cnt);
    }
    
    return answer;
}

while문에서 idx부터 끝까지 speeds[i]만큼을 더해줍니다.
progress[i]가 100 이상일경우, 완료된 작업입니다. 100 미만일때까지 개수를 샌 후 정답에 push합니다.

[C++][프로그래머스] 프로세스

bonnate — Fri, 17 Nov 2023 00:16:51 +0900

프로그래머스

programmers.co.kr

문제

운영체제의 역할 중 하나는 컴퓨터 시스템의 자원을 효율적으로 관리하는 것입니다. 이 문제에서는 운영체제가 다음 규칙에 따라 프로세스를 관리할 경우 특정 프로세스가 몇 번째로 실행되는지 알아내면 됩니다.

1. 실행 대기 큐(Queue)에서 대기중인 프로세스 하나를 꺼냅니다.
2. 큐에 대기중인 프로세스 중 우선순위가 더 높은 프로세스가 있다면 방금 꺼낸 프로세스를 다시 큐에 넣습니다.
3. 만약 그런 프로세스가 없다면 방금 꺼낸 프로세스를 실행합니다.
3.1 한 번 실행한 프로세스는 다시 큐에 넣지 않고 그대로 종료됩니다.
예를 들어 프로세스 4개 [A, B, C, D]가 순서대로 실행 대기 큐에 들어있고, 우선순위가 [2, 1, 3, 2]라면 [C, D, A, B] 순으로 실행하게 됩니다.

현재 실행 대기 큐(Queue)에 있는 프로세스의 중요도가 순서대로 담긴 배열 priorities와, 몇 번째로 실행되는지 알고싶은 프로세스의 위치를 알려주는 location이 매개변수로 주어질 때, 해당 프로세스가 몇 번째로 실행되는지 return 하도록 solution 함수를 작성해주세요.

풀이

#include <string>
#include <vector>
#include <iostream>

using namespace std;

int solution(vector<int> priorities, int location) {
    
    int answer = 0;
    int lastIdx = 0;
    for(int i = 9; i >= 0; --i)
    {
        int last = lastIdx;
        
        for(int j = 0; j < priorities.size(); ++j)
        {
            int idx = j + lastIdx;
            while(idx >= priorities.size())
                idx -= priorities.size();
            
            if(priorities[idx] == i)
            {
                ++answer;
                
                if(idx == location)
                    return answer;    
                
                last = idx;
            }
        }
        
        lastIdx = last;
    }
    
    return 0;
}

2중 for문을 이용하여 문제를 해결하였습니다.
i를 9부터 0까지 차례대로 검사하여 우선순위가 높은 순서대로 검사합니다.
i가 9일때, priorities.size()만큼 검사하여 모든 값을 검사하면, 다음 값인 i를 8부터 검사하되, lastIdx부터 시작하도록 합니다. 그렇게되면 가장 최근에 검사한 위치 이후부터 priorities.size()만큼 검사할 수 있습니다.

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

using namespace std;

int solution(vector<int> priorities, int location) {
    int answer = 0;
    
    // max_element를 사용하여 priorities 내에서 가장 큰 값을 가져오기
    int max = *max_element(priorities.begin(), priorities.end());
    
    while(true)
    {
        // priorities.size()까지 검색
        // max 값이 바뀌어도 i의 값은 1씩 증가하며 검색 (C, D, E, F, A, B 순서 가능)
        for(int i = 0; i < priorities.size(); ++i)
            if(priorities[i] == max) // 현재 위치(i)가 max값이라면?
            {
                ++answer; // 실행 순서 1 증가
                priorities[i] = -1; // 해당 위치는 사용 완료
                max = *max_element(priorities.begin(), priorities.end()); // 다음 max값 검색(같은 max일 수 있음)

                // i가 현재 위치라면 리턴
                if(i == location)    
                    return answer;
            }
    }
    
    return answer;
}

max_element를 이용하여 문제를 해결합니다. 반대로, min_element 함수도 있습니다.
현재 주어진 수에서 가장 큰 수를 구한 후, 해당 값을 찾아 검사합니다.
만약, 큰 수가 더 이상 없다면, 새로운 max를 구하여 해당 값을 또 검사합니다.
for문에서 i의 위치가 1씩 증가하기에 max를 구해도 i는 유지되어 이어서 검사할 수 있습니다.

[C++][프로그래머스] 소수 찾기

bonnate — Wed, 15 Nov 2023 23:21:44 +0900

프로그래머스

programmers.co.kr

문제

한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.

각 종이 조각에 적힌 숫자가 적힌 문자열 numbers가 주어졌을 때, 종이 조각으로 만들 수 있는 소수가 몇 개인지 return 하도록 solution 함수를 완성해주세요.

풀이

#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <set>

using namespace std;

int sel[7];
bool ch[7];
vector<bool> v;
set<string> duplicatedSet;
int answer = 0;

void DFS(string numbers, int select, int s)
{
    if(s == select)
    {
        string num;
        for(int i = 0; i < select; ++i)
            num.push_back(numbers[sel[i]]);
            
        while(num.size() > 0)
            if(num[0] == '0')
                num.erase(0, 1);
            else
                break;
        
        if(num.size() > 0 && duplicatedSet.find(num) == duplicatedSet.end())
        {
            duplicatedSet.insert(num);
            if(v[stoi(num)])
                ++answer;
        }
    }
    else
    {
        for(int i = 0; i < numbers.size(); ++i)
        {
            if(!ch[i])
            {
                ch[i] = true;
                sel[s] = i;
                DFS(numbers, select, s + 1);
                ch[i] = false;
            }
        }
    }
}

int solution(string numbers) {

    sort(numbers.begin(), numbers.end(), greater<int>());
    int num = stoi(numbers);

    v = vector<bool>(num, true);
    v[0] = v[1] = false;
    
    for(int i = 2; i <= sqrt(num); ++i)
        for(int j = i * 2; j <= num; j += i)
            v[j] = false;
    
    for(int i = 1; i <= numbers.size(); ++i)
        DFS(numbers, i, 0);
    
    return answer;
}

DFS를 이용하여 numbers를 뽑을 수 있는 모든 경우의 수를 뽑아서 찾습니다.
찾은 수열에서 앞자리 0을 제거한 후 중복되는지 확인하기위해 set을 이용합니다.
에라스토테네스의 체를 이용하여 numbers에서 가장 큰 값에 대한 모든 소수를 빠르게 찾은 후 v벡터에 저장합니다.
수열에서 v 벡터의 값을 비교하여 해당 값이 소수이면, answer의 값을 1씩 올려 정답을 리턴합니다.

[C++][프로그래머스] 큰 수 만들기

bonnate — Wed, 15 Nov 2023 00:13:30 +0900

문제

어떤 숫자에서 k개의 수를 제거했을 때 얻을 수 있는 가장 큰 숫자를 구하려 합니다.

예를 들어, 숫자 1924에서 수 두 개를 제거하면 [19, 12, 14, 92, 94, 24] 를 만들 수 있습니다. 이 중 가장 큰 숫자는 94 입니다.

문자열 형식으로 숫자 number와 제거할 수의 개수 k가 solution 함수의 매개변수로 주어집니다. number에서 k 개의 수를 제거했을 때 만들 수 있는 수 중 가장 큰 숫자를 문자열 형태로 return 하도록 solution 함수를 완성하세요.

풀이

number "12345", k 2일때

i 반복문은 0부터 2까지 반복합니다. (number.size() - 2)

i가 0일때에는 startIdx가 0이므로, j는 0부터 시작합니다. j는 2까지 반복할 수 있습니다.

그러면, {1, 2, 3}에서 가장 큰 값은 3이고, maxIdx는 2가 됩니다.

i가 1이 되면, startIdx는 3이 됩니다. j는 3부터 시작합니다. j는 3까지 반복할 수 있습니다. (j <= k + i)

이 상태에서는 최대값이 3이 됩니다. maxIdx는 3이 됩니다.

i가 2가 되면, startIdx는 4가 됩니다. j는 4부터 시작하며, 4까지 반복할 수 있습니다.

#include <string>
#include <vector>
 
using namespace std;
 
string solution(string number, int k) {
    string answer = "";
 
    int startIdx = 0;
    // number에서 k개를 뺀 것을 뽑기 위해 number.size() - k 만큼 반복
    for(int i = 0; i < number.size() - k; ++i)
    {
        char maxChar = number[startIdx];
        int maxIdx = startIdx;

        // 시작 위치로부터 k + 1번까지 반복 (뒤에서 뽑을 것을 보장하기 위해 반복을 제한)
        // 만약, 현재 뽑은 값이 마지막 인덱스가 가장 크다면, 다음에 뽑는 경우는 호출되지 않을 수 있음
        // 12345 중 k가 2인경우, {1, 2, [3]}, [4], [5] 가 뽑힘
        for(int j = startIdx; j <= k + i; ++j)
        {
            // 현재 선택에서 최상의 값을 구하기
            if(maxChar < number[j])
            {
                maxChar = number[j];
                maxIdx = j;
            }
        }
        
        // 정답에 추가하고, 다음 반복문은 maxIdx + 1번부터 뽑기 시작
        answer.push_back(maxChar);
        startIdx = maxIdx + 1;
    }
 
    return answer;
}

number에서 k개를 뺀 수를 구하는 문제이기에 number.size() - k 만큼 반복을 해 해당 반복문에서 수를 무조건 1개씩 뽑아 정답에 삽입하도록 합니다.
j가 startIdx로부터 k + 1까지만 뽑아야 합니다. 그 이유는, 다음 뽑기에서 영역에 제한을 두어 나중에 값을 무조건 뽑을 수 있도록 보장하기 위해서입니다.
이런 상태에서, startIdx부터 k + i까지 값 중 가장 큰 값을 뽑아 정답에 삽입합니다.