펭로그

[C++] 백준 BOJ 1107 리모컨

노랑펭귄 — Sun, 19 May 2019 17:22:00 +0900

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#include <iostream>
 
using namespace std;
 
bool unabledNum[10];
 
// 사용 불가능한 숫자라면 -1을 반환
// 사용 가능할 경우 자릿수를 반환
int isUnableNum(int input){
    int curDigit;
    int numOfDigits = 0;
    do {
        curDigit = input % 10;
        if(unabledNum[curDigit])
            return -1;
        input /= 10;
        numOfDigits++;
    } while(input != 0);
    return numOfDigits;
}
 
 
int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    int targetNum;
    int unabledSize;
    int result = INT32_MAX;
 
    cin >> targetNum;
    cin >> unabledSize;
 
    int input;
    for(int i = 0; i < unabledSize; i++) {
        cin >> input;
        unabledNum[input] = true;
    }
 
    // 100부터 +/- 누르는 case
    result = min(result, abs(targetNum - 100));
 
    int curNum = -1;
    // 모든 숫자를 누를 수 없는 경우 스킵
    if(unabledSize == 10)
        goto SKIP;
    while(++curNum < 999999){
        int numOfDigits = isUnableNum(curNum);
        if(numOfDigits == -1)
            continue;
        result = min(result, numOfDigits + abs(targetNum - curNum));
    }
 
    SKIP:
    cout << result;
 
    return 0;
}
Colored by Color Scripter

cs

[C++] 백준 BOJ 1986 체스

노랑펭귄 — Wed, 20 Feb 2019 18:41:53 +0900

문제링크 : https://noj.am/1986

간단하면서도 지저분한 시뮬레이션 문제로 보인다.

최대한 깔끔하게 하기 위해서 define을 사용하여 직관성을 높였으며 queen과 knight의 이동시 조건을 고려하여 별도의 함수로 구성하였다.

문제를 풀이할 때 주의할 점은 Queen 말이 이동할 때 장애물에 가로막혀있으면 이동 못한다는 점이다.

풀이시에 안전하지 않는 영역은 'X'로 만들어 두었고 장애물 체크는 board[x][y] == 0 (빈공간) 상태일때만 체크했었는데 올바른 답이 나오지 않는 실수를 풀이 과정에서 겪었다.

5번째 줄에서 적어놓은 것처럼 Q, K, P가 아닐 경우라고 명시해주니 쉽게 풀 수 있었다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
// BOJ_1986 체스
#include <iostream>
 
#define CHK_RANGE (nx >= 1 && nx <= N && ny >= 1 && ny <= M)
#define CHK_BRR(X, Y) (board[X][Y] != 'Q' && board[X][Y] != 'K' && board[X][Y] != 'P')
using namespace std;
 
char board[1002][1002];
int N, M; // 보드 크기
 
inline void queen(int x, int y) {
    int dx[] = {0, 0, -1, 1, -1, -1, 1, 1};
    int dy[] = {-1, 1, 0, 0, -1, 1, -1, 1};
    for (int i = 0; i < 8; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];
        while (CHK_RANGE && CHK_BRR(nx, ny)) {
            board[nx][ny] = 'X';
            nx += dx[i];
            ny += dy[i];
        }
    }
}
 
void knight(int x, int y) {
    int dx[] = {-2, -2, 2, 2, -1, -1, 1, 1};
    int dy[] = {-1, 1, -1, 1, -2, 2, -2, 2};
    for (int i = 0; i < 8; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];
        if (CHK_RANGE && CHK_BRR(nx, ny))
            board[nx][ny] = 'X';
    }
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    // freopen("../input.txt", "r", stdin);
 
    cin >> N >> M;
 
    // Q, K, P 순서로 3회 반복 입력
    for (int i = 0; i < 3; i++) {
        int num;
        cin >> num;
        for (int ii = 0; ii < num; ii++) {
            int x, y;
            cin >> x >> y;
            if (i == 0)
                board[x][y] = 'Q';
            else if (i == 1)
                board[x][y] = 'K';
            else
                board[x][y] = 'P';
        }
    }
 
    // 완전탐색 시뮬
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= M; j++) {
            if (board[i][j] == 'Q')
                queen(i, j);
            else if (board[i][j] == 'K')
                knight(i, j);
        }
    }
 
    // 결과 카운팅
    int cnt = 0;
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= M; j++) {
            if (board[i][j] == 0)
                cnt++;
        }
    }
    cout << cnt;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 11047 동전 0

노랑펭귄 — Wed, 30 Jan 2019 16:48:06 +0900

문제링크 : https://noj.am/11047

최소의 동전 갯수로 주어진 금액을 때려맞추는 그리디한 문제이다.

주어진 동전도 이미 정렬되어있기 때문에 솔루션도 매우 간단하다.

큰 동전부터 차례대로 나누어서 값을 누적시키고 나머지 값들은 더 작은 단위의 동전으로 나눠서 또 누적시키면 쉽게 구할 수 있다.

혹시라도 중간에 모든 동전을 소진했을 경우 바로 탈출하기 위해 24번째 줄과 같이 total == 0일 경우 탈출하는 조건을 두었다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// BOJ_11047 동전 0
#include <iostream>
 
using namespace std;
 
int coins[11];
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    int N, total;
    cin >> N >> total;
 
    for(int i = 0; i < N; i++)
        cin >> coins[i];
 
    int result = 0;
 
    for(int i = 1; i <= N; i++){
        result += total / coins[N-i];
        total %= coins[N-i];
        if(total == 0)
            break;
    }
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 2217 로프

노랑펭귄 — Wed, 30 Jan 2019 16:33:41 +0900

문제링크 : https://noj.am/2217

각 로프에는 동일한 하중이 걸려야 한다는 점이 이 문제의 핵심이다.

이때, 각각의 로프에 걸리는 하중은 병렬로 연결되어 있는 어떤 로프의 최대 중량을 초과할 수는 없다.

그렇기 때문에 현재 병렬로 연결되어있는 로프 중에서 가장 적은 수치의 최대 중량이 각 로프들에 걸릴 수 있는 최대 하중이 되는 것이다.

따라서, 임의로 뽑은 로프들 중에서 가장 값이 작은 것을 뽑은 로프의 갯수 만큼 곱하면 답을 구할 수 있다.

각 로프의 최대 하중을 담은 배열을 내림차순으로 정렬하여 최대 하중 값이 큰 것부터 차례대로 계산을 해주고 그 중에서 최대치만을 답으로 출력하면 된다.

예를 들자면, [110, 70, 20, 5, 35, 40]의 배열이 있다면 이를 내림차순 정렬하여 [110, 70, 40, 35, 20, 5]로 바꾸어 준 후

110*1 / 70*2 / 40*3 / 35*4 / 20*5 / 5*6 이런 순서대로 계산을 해준 것들 중에서 가장 큰 값을 정답으로 출력한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// BOJ_2217 로프
#include <iostream>
#include <algorithm>
#include <numeric>
 
using namespace std;
 
int rope[100001];
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    int N;
    cin >> N;
    for (int i = 0; i < N; i++)
        cin >> rope[i];
    sort(rope, rope + N, greater<int>());
 
    long long result = 0;
    for (int i = 0; i < N; i++) {
        long long sum = rope[i] * (i + 1);
        if(sum > result)
            result = sum;
    }
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 프로그래머스 코딩테스트 연습 - 완주하지 못한 선수

노랑펭귄 — Tue, 29 Jan 2019 16:59:38 +0900

문제링크 : https://programmers.co.kr/learn/courses/30/lessons/42576

algorithm 헤더의 sort를 사용하면 쉽게 풀 수 있다.

정렬된 후 participant와 completion 배열을 비교하다가 서로 다른 부분을 발견하게 되면 완주하지 못한 선수가 빠진 것임을 알 수 있기 때문에 아래와 같이 간단한 코드를 작성할 수 있다.

예를 들어 아래와 같이 두 배열을 정렬했을때

["abc", "abcd", "bcde", "cvfw"] - participant

["abc", "abcd", "cvfw"] - completion

"bcde"가 빠져있어서 2번 인덱스의 값이 서로 불일치하는 순간을 확인할 수 있다. 이때의 participant의 인덱스 값을 출력하면 정답이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <string>
#include <vector>
#include <algorithm>
 
using namespace std;
 
string solution(vector<string> participant, vector<string> completion) {
    sort(participant.begin(), participant.end());
    sort(completion.begin(), completion.end());
    int idx = 0;
    for(;idx < completion.size() && participant[idx] == completion[idx]; idx++);
    return participant[idx];
}
Colored by Color Scripter
cs

[C++] 프로그래머스 코딩테스트 연습 - 전화번호 목록

노랑펭귄 — Tue, 29 Jan 2019 16:55:20 +0900

문제링크 : https://programmers.co.kr/learn/courses/30/lessons/42577

알고리즘 헤더에 있는 sort를 이용하여 쉽게 구현하였다.

먼저 sort를 하게되면 숫자 순서대로 정렬이 되고 문제에서 요구하는 접두어의 경우 반드시 인접한 위치에 정렬되게 된다.

예를 들어서 [12345, 332, 123]을 정렬하게 되면 [123, 12345, 332] 이런 식으로 정렬된다는 뜻이다.

그리고 여기서 한가지 알 수 있는 사실은 정렬된 이후 접두어에 해당하는 숫자는 무조건 앞에 나오게 된다.

따라서, 모든 배열의 원소를 완전탐색하여 현재의 위치와 현재의 위치 직전의 문자열을 서로 비교하여 string 클래스의 find() 함수를 사용하여 일치하는 문자열이 나오면 정답으로 출력하면 된다.

만약, find()로 일치하는 문자열이 나오지 않았을 경우 return 값으로 string::npos가 iterator로 반환된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <string>
#include <vector>
#include <algorithm>
 
using namespace std;
 
bool solution(vector<string> phone_book) {
    bool answer = true;
    sort(phone_book.begin(), phone_book.end());
    for(int i = 1; i < phone_book.size(); i++){
        if(phone_book[i].find(phone_book[i-1]) != string::npos){
            answer = false;
            break;
        }
    }
    return answer;
}
Colored by Color Scripter
cs

string 클래스의 find()를 사용하지 않고 문자 하나 하나를 일일이 비교하는 방법으로 아래와 같이 풀 수도 있다. 시간복잡도 면에서는 차이가 나지는 않을 것이다.

다만, 문자를 일일이 비교할 경우 반드시 [이전문자의 길이] <= 다음문자의 길이]가 성립할 수 있는 case만 정답의 조건이 되므로 if문으로 11번째 줄과 같이 처리해주었다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <string>
#include <vector>
#include <algorithm>
 
using namespace std;
 
bool solution(vector<string> phone_book) {
    bool answer = true;
    sort(phone_book.begin(), phone_book.end());
    for(int i = 1; i < phone_book.size(); i++){
        if(phone_book[i].size() < phone_book[i-1].size())
            continue;
        bool chk = false;
        for(int j = 0; j < phone_book[i-1].size(); j++){
            if(phone_book[i][j] != phone_book[i-1][j]){
                chk = true;
                break;
            }
        }
        if(!chk){
            answer = false;
            break;
        }
    }
    return answer;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 1475 방 번호

노랑펭귄 — Wed, 16 Jan 2019 17:34:23 +0900

문제링크 : https://noj.am/1475

문자열을 입력 받아서 갯수를 카운팅 하고 그 중에서 가장 많이 카운팅 된 숫자가 몇개인 지를 구하는 문제이다.

단, 문제의 조건에서 6과 9는 뒤집어서 사용할 수도 있다고 했기 때문에 0.5씩 카운팅하여 쉽게 해결하였다.

이러한 과정을 위해서 float형을 사용하였다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// BOJ_1475 방 번호
#include <iostream>
#include <string>
 
using namespace std;
 
int max(int a, int b){
    return a > b ? a : b;
}
 
int round(float input){
    float temp = (int)input;
    return input != temp ? input + 1 : input;
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    string room_number;
    cin >> room_number;
 
    // 0~8까지
    float cnt[9] = {0.0, };
    for(auto i : room_number){
        int num = i - '0';
        // 6이나 9일 경우는 0.5만 카운트
        if(num == 6 || num == 9){
            cnt[6] += 0.5;
            continue;
        }
        cnt[num]++;
    }
 
    int result = 0;
    for(auto i : cnt)
        result = max(result, round(i));
 
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 1018 체스판 다시 칠하기

노랑펭귄 — Wed, 16 Jan 2019 16:56:15 +0900

문제링크 : https://noj.am/1018

브루트포스 문제로 4중 for문이라는 더러운 코드로 문제를 풀게 되었다.....

체스판의 격자를 다음과 같은 2가지의 임의의 규칙을 정할 수 있다.

1-1. 홀수번째 줄의 홀수 칸이 'W'

1-2. 홀수번째 줄의 짝수 칸이 'B'

1-3. 짝수번째 줄의 짝수 칸이 'W'

1-4. 짝수번째 줄의 짝수 칸이 'B'

2-1. 홀수번째 줄의 홀수 칸이 'B'

2-2. 홀수번째 줄의 짝수 칸이 'W'

2-3. 짝수번째 줄의 짝수 칸이'B'

2-4. 짝수번째 줄의 짝수 칸이'W'

위와 같은 조건에 해당이 되지 않는 칸이라면 전부 카운트를 시켜서 값을 누적시키면 다시 칠해야하는 칸이 몇칸인지 구할 수 있다.

하지만 2가지의 case를 모두 비교할 필요 없이 1의 case를 골라서 반전을 시키면 2의 case가 된다.

따라서, 1에서의 cnt를 구해서 64-cnt를 하면 2의 case를 계산할 수 있다.

이러한 법칙에 따라서 문제를 아래와 같이 풀이하면 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
// BOJ_1018 체스판 다시 칠하기
#include <iostream>
 
using namespace std;
 
char board[52][52];
 
int min(int a, int b) {
    return a > b ? b : a;
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int N, M;
    cin >> N >> M;
 
    for (int i = 1; i <= N; i++)
        for (int j = 1; j <= M; j++)
            cin >> board[i][j];
 
    int result = INT32_MAX;
    // x, y 시작 좌표 설정
    for (int x = 1; x <= N - 7; x++) {
        for (int y = 1; y <= M - 7; y++) {
            // 8*8 칸 탐색 및 'B' 카운트
            int cnt = 0;
            for (int i = 0; i < 8; i++) {
                for (int j = 0; j < 8; j++) {
                    if (i % 2 == 1) { // i가 홀수일 때
                        // j가 홀수이면서 'B'일 때
                        if (j % 2 == 1 && board[x + i][y + j] == 'B')
                            cnt++;
                        // j가 짝수이면서 'W'일 때
                        else if (j % 2 == 0 && board[x + i][y + j] == 'W')
                            cnt++;
                    } else { // i가 짝수일 때
                        // j가 짝수이면서 'B'일 때
                        if (j % 2 == 0 && board[x + i][y + j] == 'B')
                            cnt++;
                        // j가 홀수이면서 'W'일 때
                        else if (j % 2 == 1 && board[x + i][y + j] == 'W')
                            cnt++;
                    }
                }
            }
            // 카운트 누적 값 계산
            cnt = min(cnt, 64 - cnt);
            // 최소값 저장
            result = min(cnt, result);
        }
    }
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 5566 주사위 게임

노랑펭귄 — Mon, 14 Jan 2019 17:35:59 +0900

문제링크 : https://noj.am/5566

주사위의 지시사항 대로 구현하면 쉽게 풀리는 단순 시뮬레이션 문제이다.

1. 현재 위치에서 주사위를 던져 해당 눈금만큼 진행한다.

2. 보드의 범위를 초과 했는지 체크한다.

3. 초과하지 않았으면 진행된 자리에 있는 지시사항을 수행한다.

4. 보드의 범위를 초과 했는지 체크한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// BOJ_5566 주사위 게임
#include <iostream>
 
using namespace std;
 
int direction[1001];
int dice[1001];
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int board_cnt;
    int dice_cnt;
    cin >> board_cnt >> dice_cnt;
 
    for(int i = 1; i <= board_cnt; i++)
        cin >> direction[i];
 
    for(int i = 1; i <= dice_cnt; i++)
        cin >> dice[i];
 
    int cnt = 0;
    int player_position = 1;
 
    while(true){
        // 현재위치에서 주사위 눈금만큼 진행
        player_position += dice[++cnt];
        if(player_position >= board_cnt)
            break;
        // 진행한 위치에 있는 지시사항 수행
        player_position += direction[player_position];
        if(player_position >= board_cnt)
            break;
    }
    cout << cnt;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 1120 문자열

노랑펭귄 — Mon, 14 Jan 2019 16:38:50 +0900

문제링크 : https://noj.am/1120

단순하게 두 문자열을 같은 길이 만큼만 비교하여 일치하지 않는 만큼의 문자가 몇개인지를 체크하여 최소값을 구하는 브루트포스 알고리즘적 방법으로 접근하였다.

1. A의 앞에 아무 알파벳이나 추가한다. 2. A의 뒤에 아무 알파벳이나 추가한다.

이 두 조건을 최소값이 나오게 하려면 추가할 아무 알파벳을 B와 같게 만들면 되기 때문에 신경 안써도 되는 조건이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// BOJ_1120 문자열
#include <iostream>
#include <string>
 
using namespace std;
 
int min(int a, int b) {
    return a > b ? b : a;
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    string A, B;
    cin >> A >> B;
 
    int result = INT32_MAX;
 
    for (int i = 0; i <= B.size() - A.size(); i++) {
        int cnt = 0;
        int idxB = i;
        for (int idxA = 0; idxA < A.size(); idxA++, idxB++) {
            if (A[idxA] == B[idxB])
                continue;
            cnt++;
        }
        result = min(cnt, result);
    }
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 1057 토너먼트

노랑펭귄 — Wed, 9 Jan 2019 17:48:33 +0900

문제링크 : https://noj.am/1057

문제의 조건에서 지민과 한수가 둘이 만나기 전까지는 무조건 이긴다고 하였다.

따라서 문제에서 나온 조건대로 하면 '만약 서로 대결하지 않을 때는 -1을 출력한다.'은 절대로 나올 수 없기 때문에 무시해도 된다.

두 사람이 만날 수 있는 조건은 A와 B가 각각 2n-1과 2n 이어야 하는 조건이다.

계산을 편하게 하기 위해서 그냥 A, B를 작은 순서대로 정렬하고 A가 홀수이고 A-B의 차가 1이면 정답으로 출력하도록 했다.

두 사람이 각 라운드에서 만나지 못한다면 div( ) 함수를 통하여 입력값을 절반으로 나누어주면서 정답을 찾아가면 된다.

절반씩 계속 나누기 때문에 최악의 경우에도 O(logN)의 시간복잡도를 보일 것이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// BOJ_1057 토너먼트
#include <iostream>
 
using namespace std;
 
// 입력 값을 절반으로 나누고
// 홀수면 +1을 더해준 값으로 반환
int div(int n) {
    return n % 2 ? n / 2 + 1 : n / 2;
}
 
// 작은 숫자가 a, 큰 숫자가 b가 되도록 정렬(스왑)
int sort(int &a, int &b) {
    if (a > b) {
        int temp = a;
        a = b;
        b = temp;
    }
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    int num;
    int person1, person2;
    cin >> num >> person1 >> person2;
 
    sort(person1, person2);
    int round = 0;
 
    while (true) {
        round++;
        // person1이 홀수이고 person2와의 차가 1이면
        if (person1 % 2 && person2 - person1 == 1)
            break;
 
        // 다음 라운드로 진출 시 숫자를 절반으로 나눔
        person1 = div(person1);
        person2 = div(person2);
    }
    cout << round;
 
    return 0;
}
Colored by Color Scripter
cs

더 쉬운 방법으로는 각 숫자를 1씩 빼줘서 1~N 범위의 숫자를 0~N 범위로 만든 다음에 2n과 2n+1일때의 case를 찾으면 더 간단하게 풀린다. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// BOJ_1057 토너먼트
#include <iostream>
 
using namespace std;
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    int num;
    int person1, person2;
    cin >> num >> person1 >> person2;
 
    // 1~N 범위를 0~N-1로 변환
    person1--;
    person2--;
 
    int round = 0;
    // 두 수가 각각 2n과 2n+1이면 정답
    // 이때, 2로 나눴을 때 두 수가 같아지므로 탈출 조건으로 설정
    while(person1 != person2){
        round++;
        person1 >>= 1;
        person2 >>= 1;
    }
    cout << round;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 14500 테트로미노

노랑펭귄 — Tue, 13 Nov 2018 20:26:01 +0900

문제링크 : https://noj.am/14500

1. 모든 경우의 수를 시뮬레이션하여 풀기

테트로미노가 나올 수 있는 모든 상황을 시뮬레이션해서 문제를 푸는 방법이다.

문제에서 조건을 살펴보면

N*M은 최대 500*500 = 250,000

테트로미노가 나올 수 있는 모양의 가지 수 = 19가지

250,000 * 19 = 4,750,000번 이므로 1억번을 초과하지 않는다.

무식하게 한 좌표를 기준으로 19번의 테트로미노의 상태 모두를 탐색하는 방법으로 푸는게 시간복잡도 면에서는 가장 효율적이다.

다만, 이 방법으로 풀 경우 모든 경우, 숫자를 한개라도 틀리게 적었을 경우 실수하기가 매우 쉽다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
// BOJ_14500 테트로미노
#include <iostream>
#include <vector>
 
using namespace std;
 
int dx[][4] = {{0, 0, 0, 0}, {0, 1, 2, 3}, {0, 0, 1, 1}, {0, 1, 2, 2},
               {1, 0, 0, 0}, {0, 0, 1, 2}, {1, 1, 1, 0}, {2, 2, 1, 0},
               {0, 0, 0, 1}, {2, 1, 0, 0}, {0, 1, 1, 1}, {0, 1, 1, 2},
               {1, 1, 0, 0}, {2, 1, 1, 0}, {0, 0, 1, 1}, {1, 1, 1, 0},
               {1, 0, 1, 2}, {0, 0, 0, 1}, {0, 1, 2, 1}};
 
int dy[][4] = {{0, 1, 2, 3}, {0, 0, 0, 0}, {0, 1, 0, 1}, {0, 0, 0, 1},
               {0, 0, 1, 2}, {0, 1, 1, 1}, {0, 1, 2, 2}, {0, 1, 1, 1},
               {0, 1, 2, 2}, {0, 0, 0, 1}, {0, 0, 1, 2}, {0, 0, 1, 1},
               {0, 1, 1, 2}, {0, 0, 1, 1}, {0, 1, 1, 2}, {0, 1, 2, 1},
               {0, 1, 1, 1}, {0, 1, 2, 1}, {0, 0, 0, 1}};
 
int N, M;
vector<vector<int> > arr;
 
int max(int a, int b) {
    return a > b ? a : b;
}
 
int search(int x, int y) {
    int maxNum = 0;
    for (int i = 0; i < 19; i++) {
        int sum = 0;
        for (int j = 0; j < 4; j++) {
            int nx = x + dx[i][j];
            int ny = y + dy[i][j];
            // 범위를 벗어날 경우
            if (nx < 1 || ny < 1 || nx > N || ny > M)
                break;
            sum += arr[nx][ny];
        }
        maxNum = max(maxNum, sum);
    }
    return maxNum;
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    cin >> N >> M;
    arr = vector<vector<int> >(N + 1, vector<int>(M + 1));
 
    for (int i = 1; i <= N; i++)
        for (int j = 1; j <= M; j++)
            cin >> arr[i][j];
 
    int result = 0;
    for (int i = 1; i <= N; i++)
        for (int j = 1; j <= M; j++)
            result = max(result, search(i, j));
 
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

2. 백트래킹으로 문제 풀기
한 좌표를 중심으로 상/하/좌/우로 가지치기를 연속 3번 하다보면 테트로미노가 나올 수 있는 경우라는 것을 알 수 있다.
이러한 단서를 바탕으로 백트래킹으로 문제를 풀이하면 된다.
250,000 * 4 * 3 * 3 = 9,000,000번 (2회째부터 3회씩인 이유는 전 단계의 지점이 방문체크가 되었기 때문에)

다만, ㅗ 모양의 경우는 백트래킹으로는 절대로 나올 수 없기 때문에 별도로 예외 케이스를 계산해서 처리해야 한다.
+ 형태를 구해서 상,하,좌,우로 한개씩만 빼줄 경우 ㅓ ㅜ ㅏ ㅗ의 형태가 나온다.
각 좌표마다 O(1) 만큼의 시간 복잡도가 추가되므로 9,250,000번 탐색하게 된다.

시간복잡도 면에선 방법1과 비교했을땐 비효율적이지만 실수할 경우는 절대 없을 것 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
// BOJ_14500 테트로미노
#include <iostream>
#include <vector>
 
using namespace std;
 
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
 
int N, M;
int result = 0;
vector<vector<int> > arr;
vector<vector<bool> > visited;
 
int max(int a, int b) {
    return a > b ? a : b;
}
 
// 백트래킹
void search(int x, int y, int cnt, int sum) {
    // 테트로미노를 4번 더했을 경우 return
    if(cnt >= 4) {
        result = max(result, sum);
        return;
    }
    for(int i = 0; i < 4; i++){
        int nx = x + dx[i];
        int ny = y + dy[i];
        if(nx < 1 || ny < 1 || nx > N || ny > M || visited[nx][ny])
            continue;
        visited[nx][ny] = true;
        search(nx, ny, cnt + 1, sum + arr[nx][ny]);
        visited[nx][ny] = false;
    }
}
 
// ㅗ 모양 탐색
void searchFxxk(int x, int y){
    int sum = arr[x][y];
    int cnt = 1;
    
    // + 모양 만들기
    for(int i = 0; i < 4; i++){
        int nx = x + dx[i];
        int ny = y + dy[i];
        if(nx < 1 || ny < 1 || nx > N || ny > M)
            continue;
        sum += arr[nx][ny];
        cnt++;
    }
    // cnt가 4이면 ㅓ ㅜ ㅏ ㅗ 중 하나임
    if(cnt == 4){
        result = max(result, sum);
        return;
    }
    // cnt가 4 이하면 제대로된 모양이 아님
    if(cnt < 4) return;
 
    // + 모양에서 상,하,좌,우 하나씩만 빼주면 ㅓ ㅜ ㅏ ㅗ가 나옴
    for(int i = 0; i < 4; i++){
        int nx = x + dx[i];
        int ny = y + dy[i];
        if(nx < 1 || ny < 1 || nx > N || ny > M)
            continue;
        result = max(result, sum - arr[nx][ny]);
    }
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    cin >> N >> M;
    arr = vector<vector<int> >(N + 1, vector<int>(M + 1));
    visited = vector<vector<bool> >(N + 1, vector<bool>(M + 1, false));
 
    for (int i = 1; i <= N; i++)
        for (int j = 1; j <= M; j++)
            cin >> arr[i][j];
 
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= M; j++) {
            // 백트래킹 탐색
            visited[i][j] = true;
            search(i, j, 1, arr[i][j]);
            visited[i][j] = false;
            // ㅗ모양 탐색
            searchFxxk(i, j);
        }
    }
 
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs


아래는 방법1, 위는 방법2로 풀었을 때, 걸린 시간이다. 약 2배 가량의 시간이 차이나는 것을 알 수 있다.

[C++] 백준 BOJ 16236 아기 상어

노랑펭귄 — Tue, 30 Oct 2018 21:01:34 +0900

문제링크 : https://noj.am/16236

BFS로 그냥 풀면 간단한 문제일 줄 알았는데 개인적으로는 약간 고민을 많이 했던 문제이다.

아기 상어가 물고기를 먹을 때 먹을 수 있는 물고기 중에서 가장 가까운 아무거나 먹는게 아니라 가장 위, 가장 왼쪽에 있는 것을 먹어야 한다는 까다로운 조건이 붙기 때문이다.

이를 해결하기 위하여 우선순위 큐 + BFS를 사용하여 해결하였다.

BFS를 위해 필요한 큐를 우선순위 큐로 사용하였고

큐에 담길 데이터는 연산자 오버로딩을 통하여 아래와 같이 min heap이 구성되는 방식이다.

① BFS 레벨이 작은 순서 (상어의 이동 거리)

② x의 좌표가 작은 순서

③ y의 좌표가 작은 순서

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
// BOJ_16236 아기 상어
#include <iostream>
#include <vector>
#include <queue>
 
using namespace std;
 
const int dx[] = {0, 0, -1, 1};
const int dy[] = {-1, 1, 0, 0};
 
struct pt {
    int x, y;
    int len; // 상어의 이동거리
 
    const bool operator<(const pt &p) const {
        // 1. len 비교
        if (len == p.len) {
            // 2. x 좌표 비교
            if (x == p.x)
                // 3. y 좌표 비교
                return y > p.y;
            return x > p.x;
        }
        return len > p.len;
    }
};
 
struct shark {
    int x, y;
    int cnt = 0;
    int size = 2;
 
    shark() {}
 
    shark(int x, int y) {
        this->x = x;
        this->y = y;
    }
 
    void sizeUp() {
        cnt = 0;
        size++;
    }
};
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int N;
    cin >> N;
 
    vector<vector<int> > arr(N + 2, vector<int>(N + 2, INT32_MAX));
    vector<vector<bool> > visited(N + 2, vector<bool>(N + 2, false));
 
    shark baby;
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            cin >> arr[i][j];
            if (arr[i][j] == 9) {
                baby = {i, j}; // 상어 좌표 저장
                arr[i][j] = 0;  // 해당 자리는 빈칸으로
            }
        }
    }
 
    int result = 0;
    priority_queue<pt> Q;
    Q.push({baby.x, baby.y, 0});
    visited[baby.x][baby.y] = true;
 
    while (!Q.empty()) {
        pt cur = Q.top();
        Q.pop();
        // 먹을 수 있는 물고기라면
        if (arr[cur.x][cur.y] != 0 && baby.size > arr[cur.x][cur.y]) {
            // 좌표 이동
            baby.x = cur.x;
            baby.y = cur.y;
            // 물고기 냠냠
            baby.cnt++;
            arr[cur.x][cur.y] = 0;
            // 물고기 먹은 갯수가 몸집에 도달시
            if (baby.cnt >= baby.size)
                baby.sizeUp();
            // 방문 초기화
            visited = vector<vector<bool> >(N + 2, vector<bool>(N + 2, false));
            // 큐 초기화
            while(!Q.empty()) Q.pop();
            // 정답 저장
            result = cur.len;
        }
        for (int i = 0; i < 4; i++) {
            // 다음 4방향 이동 좌표
            int nx = cur.x + dx[i];
            int ny = cur.y + dy[i];
            // 아기 상어의 사이즈보다 크거나 방문했으면
            if (arr[nx][ny] > baby.size || visited[nx][ny])
                continue;
            // 방문 체크
            visited[nx][ny] = true;
            Q.push({nx, ny, cur.len + 1});
        }
    }
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] SWEA 1949 등산로 조성

노랑펭귄 — Mon, 22 Oct 2018 12:18:27 +0900

문제링크 : https://www.swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV5PoOKKAPIDFAUq

가장 긴 등산로를 만드는 문제로 시작점은 가장 높은 봉우리에서 시작한다.

입력을 받을 때 가장 높은 숫자를 highest 변수에 저장하고

완전 탐색을 돌리는듯 하면서 값이 highest일 때만 dfs를 돌려서 탐색한다.

71
72
73
74
75
76
77
// 값 저장
for (int i = 1; i <= N; i++) {
    for (int j = 1; j <= N; j++) {
        cin >> arr[i][j];
        highest = max(highest, arr[i][j]);
    }
}
Colored by Color Scripter
cs

A->B 까지 가는 등산로는 A->C->D->B로 돌아서 가는 식의 등산로로 표현할 수도 있기 때문에

A->까지 최단 경로로 등산로가 완성되었다고 하더라도 다른 루트로 돌아서 가는 형태를 고려하는 백트래킹 방식의 탐색을 해야한다.

dfs를 돌리기 전에 방문 체크를 해주고 dfs가 끝난 시점에서 방문 해제를 해줘야 한다.

86
87
88
visited[i][j] = true;
dfs(cur);
visited[i][j] = false;
cs

문제에서 특이한 조건이 하나 있는데, [긴 등산로를 만들기 위해 딱 한 곳을 정해서 최대 K 깊이만큼 지형을 깎는 공사를 할 수 있다.]

이 조건에 따라서 등산로를 만들 수 없는 탐색 지역이 있으면 등산로 공사를 통해서 진행을 해주는 코드를 넣어야 한다.

현재 노드를 cur로 하고 다음 노드를 nxt라고 했을때,

(cur의 높이) <= (nxt의 높이) 인 경우

(cur의 높이) > (nxt의 높이) - (최대 공사 가능 깊이) 가 성립하는 경우에 탐색이 가능하다고 할 수 있다.

다만, 이 때 주의할 점은 최대한 길게 등산로를 만들어야 하기 때문에 (cur의 높이)에서 -1 만 해주도록 한다.

42
43
44
45
46
if (!cur.chk && cur.h > nxt.h - K) {
    nxt.chk = true; // 공사 체크
    nxt.h = cur.h - 1; // 1만큼만 빼기
    flag = true;
}
Colored by Color Scripter
cs

dfs 백트래킹을 돌릴 때 저장할 값들은 구조체에 좌표, 높이, 등산로길이, 공사여부를 담았다.

20
21
22
23
24
25
struct point {
    int x, y; // 좌표
    int h;    // 높이
    int len;  // 등산로 길이
    bool chk; // 공사여부
};
cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
// SWEA_1949 등산로 조성
#include <iostream>
#include <vector>
 
using namespace std;
 
const int dx[] = {0, 0, -1, 1};
const int dy[] = {-1, 1, 0, 0};
 
vector<vector<int> > arr;
vector<vector<bool> > visited;
int N, K; // 한변의 길이, 최대 공사 가능 깊이
int highest; // 가장 높은 등산로 높이
int result;
 
int max(int a, int b) {
    return a > b ? a : b;
}
 
struct point {
    int x, y; // 좌표
    int h;    // 높이
    int len;  // 등산로 길이
    bool chk; // 공사여부
};
 
void dfs(point cur) {
    for (int i = 0; i < 4; i++) {
        int nx = cur.x + dx[i];
        int ny = cur.y + dy[i];
        if(visited[nx][ny])
            continue;
        int nh = arr[nx][ny];
        int nlen = cur.len + 1;
        bool nchk = cur.chk;
        point nxt = {nx, ny, nh, nlen, nchk};
        bool flag = false; // dfs 실행할지 여부
        if (nxt.h < cur.h)
            flag = true;
        else {
            // 공사하지 않았고 공사 후 진행 가능한 경우
            if (!cur.chk && cur.h > nxt.h - K) {
                nxt.chk = true; // 공사 체크
                nxt.h = cur.h - 1; // 1만큼만 빼기
                flag = true;
            }
        }
        if (flag) {
            result = max(result, nxt.len);
            visited[nxt.x][nxt.y] = true;
            dfs(nxt);
            visited[nxt.x][nxt.y] = false;
        }
    }
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
//    freopen("../input.txt", "r", stdin);
 
    int tc;
    cin >> tc;
    for (int T = 1; T <= tc; T++) {
        highest = 0, result = 0;
        cin >> N >> K;
        arr = vector<vector<int> >(N + 2, vector<int>(N + 2, INT32_MAX));
        visited = vector<vector<bool> >(N + 2, vector<bool>(N + 2, false));
 
        // 값 저장
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= N; j++) {
                cin >> arr[i][j];
                highest = max(highest, arr[i][j]);
            }
        }
 
        // 탐색 시작
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= N; j++) {
                if (arr[i][j] < highest)
                    continue;
                point cur = {i, j, arr[i][j], 1, false};
                result = max(result, 1);
                visited[i][j] = true;
                dfs(cur);
                visited[i][j] = false;
            }
        }
        cout << "#" << T << " " << result << "\n";
    }
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 16234 인구 이동

노랑펭귄 — Sun, 21 Oct 2018 22:09:20 +0900

문제링크 : https://noj.am/16234

완탐 + DFS/BFS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

// BOJ 16234 인구 이동
#include <iostream>
#include <vector>
 
using namespace std;
 
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
 
struct node {
    int x, y;
};
 
 
int N;  // 크기
int L, R; // 최저, 최대
int sum; // 세포들의 합
int cnt; // 세포 갯수
 
vector<vector<int> > arr; // 세포 배열
vector<vector<bool> > visited; // 방문 체크
vector<node> change; // 바꿀 세포 리스트
 
int abs(int a) {
    return a >= 0 ? a : -a;
}
 
void dfs(node cur) {
    for (int i = 0; i < 4; i++) {
        int nx = cur.x + dx[i];
        int ny = cur.y + dy[i];
 
        if(visited[nx][ny])
            continue;
 
        int diff = abs(arr[cur.x][cur.y] - arr[nx][ny]);
        if(diff >= L && diff <= R){
            visited[nx][ny] = true; // 방문 체크
            change.push_back({nx, ny}); // 변경할 인덱스 추가
            sum += arr[nx][ny]; // 값 누적
            cnt++;  // 세포 카운팅
            dfs({nx, ny});
        }
    }
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    cin >> N >> L >> R;
 
    arr = vector<vector<int> >(N + 2, vector<int>(N + 2));
    visited = vector<vector<bool> >(N + 2, vector<bool>(N + 2, true));
 
    for(int i = 1; i <= N; i++)
        for(int j = 1; j <= N; j++)
            cin >> arr[i][j];
 
    int result = 0;
    while (true) {
        // visited 초기화
        for (int i = 1; i <= N; i++)
            for (int j = 1; j <= N; j++)
                visited[i][j] = false;
 
        bool flag = false; // 세포가 변경 되었는지 체크
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= N; j++) {
                if (visited[i][j])
                    continue;
                visited[i][j] = true; // 방문 체크
                sum = arr[i][j]; // 값 초기화
                cnt = 1; // 세포 갯수 카운팅
                change.clear();
                change = vector<node>();
                change.push_back({i, j}); // 바꿀 목록에 추가
                dfs({i, j});
 
                // cnt가 1이라는 것은 탐색 못했다는 뜻
                if (cnt == 1)
                    continue;
 
                flag = true;
                int avg = sum / cnt;
                for (auto &c:change)
                    arr[c.x][c.y] = avg;
            }
        }
        // 완탐 돌리는 동안 세포가 변경 안되었으면 탈출
        if (!flag)
            break;
        result++;
    }
 
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 14888 연산자 끼워넣기 (SWEA 4008 숫자 만들기)

노랑펭귄 — Sat, 20 Oct 2018 12:03:55 +0900

문제링크 : https://noj.am/14888

문제링크 : https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWIeRZV6kBUDFAVH

<아래 풀이는 백준 14888 문제 기준>

DFS를 이용하여 완전탐색을 시행한 브루트포스 문제이다.

각 시행 마다 + - * / 연산 모두를 다음 탐색에서 시행한다.

구조를 간단하게 하기 위하여 구조체 안에 생성자를 통해서 다음 노드의 구조체를 만들어준다.

이 때, 입력받은 연산이 무엇인지를 확인하여 + - * / 의 연산을 구분해서 데이터를 새로 만들어준다.

재귀 호출 시마다 4번의 추가 호출이 있기 때문에 시간 복잡도는 O(4^N)이다.

문제에서 N은 11까지라는 조건이 있으므로 4^11 = 4,194,304 이다.

최대 1억번이 넘질 않으므로 문제가 없는 알고리즘이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
// BOJ_14888 연산자 끼워넣기
#include <iostream>
#include <vector>
 
using namespace std;
 
int N; // 숫자 갯수
vector<int> arr; // 숫자 배열
int oper[4]; // + - * / 연산자 갯수
 
int maxNum = INT32_MIN;
int minNum = INT32_MAX;
 
int min(int a, int b) {
    return a > b ? b : a;
}
 
int max(int a, int b) {
    return a > b ? a : b;
}
 
struct info {
    int idx; // 현재 탐색중인 인덱스
    int pl; // 덧셈 연산자 갯수
    int mi; // 뺄셈 연산자 갯수
    int mul;// 곱셈 연산자 갯수
    int div;// 나눗셈 연산자 갯수
    int result; // 현재 누적 연산자 갯수
 
    // 초기화를 위한 생성자
    info(int a, int b, int c, int d, int e, int f)
            : idx(a), pl(b), mi(c), mul(d), div(e), result(f) {};
 
    // 다음 노드의 연산 결과를 만들어주는 생성자
    info(info &node, string a) {
        // node로 부터 받은 값 저장
        idx = node.idx;
        pl = node.pl;
        mi = node.mi;
        mul = node.mul;
        div = node.div;
        result = node.result;
        // 연산 결과를 저장함과 동시에 idx 증가
        if (a == "pl") {
            result += arr[++idx];
            pl--;
        }
        else if (a == "mi") {
            result -= arr[++idx];
            mi--;
        }
        else if (a == "mul") {
            result *= arr[++idx];
            mul--;
        }
        else if (a == "div") {
            result /= arr[++idx];
            div--;
        }
    }
};
 
void dfs(info node) {
    // 각 연산 수행
    if (node.pl > 0)
        dfs({node, "pl"});
    if (node.mi > 0)
        dfs({node, "mi"});
    if (node.mul > 0)
        dfs({node, "mul"});
    if (node.div > 0)
        dfs({node, "div"});
    // 최대값, 최소값 저장
    if (node.idx >= N - 1) {
        maxNum = max(maxNum, node.result);
        minNum = min(minNum, node.result);
    }
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    cin >> N;
    arr = vector<int>(N);
    for (int i = 0; i < N; i++)
        cin >> arr[i];
    for (int i = 0; i < 4; i++)
        cin >> oper[i];
 
    info init = {0, oper[0], oper[1], oper[2], oper[3], arr[0]};
    dfs(init);
 
    cout << maxNum << "\n" << minNum;
 
    return 0;
}
Colored by Color Scripter
cs

<SWEA 4008 소스코드>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
// SWEA_4008 숫자 만들기
#include <iostream>
#include <vector>
 
using namespace std;
 
int N; // 숫자 갯수
vector<int> arr; // 숫자 배열
int oper[4]; // + - * / 연산자 갯수
 
int maxNum;
int minNum;
 
int min(int a, int b) {
    return a > b ? b : a;
}
 
int max(int a, int b) {
    return a > b ? a : b;
}
 
struct info {
    int idx; // 현재 탐색중인 인덱스
    int pl; // 덧셈 연산자 갯수
    int mi; // 뺄셈 연산자 갯수
    int mul;// 곱셈 연산자 갯수
    int div;// 나눗셈 연산자 갯수
    int result; // 현재 누적 연산자 갯수
 
    // 초기화를 위한 생성자
    info(int a, int b, int c, int d, int e, int f)
            : idx(a), pl(b), mi(c), mul(d), div(e), result(f) {};
 
    // 다음 노드의 연산 결과를 만들어주는 생성자
    info(info &node, string a) {
        // node로 부터 받은 값 저장
        idx = node.idx;
        pl = node.pl;
        mi = node.mi;
        mul = node.mul;
        div = node.div;
        result = node.result;
        // 연산 결과를 저장함과 동시에 idx 증가
        if (a == "pl") {
            result += arr[++idx];
            pl--;
        }
        else if (a == "mi") {
            result -= arr[++idx];
            mi--;
        }
        else if (a == "mul") {
            result *= arr[++idx];
            mul--;
        }
        else if (a == "div") {
            result /= arr[++idx];
            div--;
        }
    }
};
 
void dfs(info node) {
    // 각 연산 수행
    if (node.pl > 0)
        dfs({node, "pl"});
    if (node.mi > 0)
        dfs({node, "mi"});
    if (node.mul > 0)
        dfs({node, "mul"});
    if (node.div > 0)
        dfs({node, "div"});
    // 최대값, 최소값 저장
    if (node.idx >= N - 1) {
        maxNum = max(maxNum, node.result);
        minNum = min(minNum, node.result);
    }
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    int tc;
    cin >> tc;
    for(int T = 1; T <= tc; T++) {
        cin >> N;
        arr = vector<int>(N);
        maxNum = INT32_MIN;
        minNum = INT32_MAX;
 
        for (int i = 0; i < 4; i++)
            cin >> oper[i];
        for (int i = 0; i < N; i++)
            cin >> arr[i];
 
        info init = {0, oper[0], oper[1], oper[2], oper[3], arr[0]};
        dfs(init);
 
        cout << "#" << T << " " << maxNum - minNum << "\n";
    }
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 14891 톱니바퀴 (SWEA 4013 특이한 자석)

노랑펭귄 — Fri, 19 Oct 2018 14:46:57 +0900

문제링크 : https://noj.am/14891

문제링크 : https://www.swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWIeV9sKkcoDFAVH

<백준 14891 기준 문제 풀이>

톱니바퀴가 회전하게 되면 각각의 인덱스 위치가 변동된다.

어떤 톱니바퀴의 인덱스가 다음과 같다면

0 1 2 3 4 5 6 7

시계방향으로 회전시

7 1 2 3 4 5 6

반시계방향으로 회전시

1 2 3 4 5 6 0

이렇게 순서가 바뀌므로 rot[] 에 회전이 얼마나 되었는지를 저장해준다.

8바퀴를 회전하게 되면 제자리가 되므로 8로 나눈 값을 저장해주면 된다.

10
11
12
13
// 톱니바퀴 회전
void rotat(int idx, int dir) {
    rot[idx] = (rot[idx] - dir) % 8;
}
Colored by Color Scripter
cs

회전시 바뀐 좌표를 가져오는 경우는 다음과 같이 구성했다.

15
16
1-
18
19
20
// 왼쪽(9시 방향 톱니) 좌표
int left(int idx) {
    int left = (6 + rot[idx]) % 8;
    if (left < 0) left += 8;
    return left;
}
Colored by Color Scripter
cs

문제에서 톱니바퀴가 회전을 하게 되었을 경우

[좌측 톱니바퀴의 3시 방향] 과 [현재 톱니바퀴의 9시 방향]이 서로 다를 경우 좌측 톱니바퀴가 회전을 하게 되고

[현재 톱니바퀴의 3시 방향] 과 [우측 톱니바퀴의 9시 방향]이 서로 다른 경우 우측 톱니바퀴가 회전을 하게 된다.

따라서, 다음과 같이 재귀적으로 좌/우측 탐색을 시행해주면 된다.

40
41
42
43
44
45
46
if (chkL && prev >= 1) {
    int l = gear[prev][right(prev)]; // 좌측 톱니의 3시
    int r = gear[cur][left(cur)]; // 현재 톱니의 9시
    // 좌측 톱니와 서로 극이 다르면 좌측 탐색
    if (l != r)
        find(prev, -dir, 1, 0);
}
Colored by Color Scripter
cs

맨 처음 톱니바퀴 회전시 - 좌측과 우측의 톱니바퀴가 회전을 하는지 체크를 해야하기 때문에

find( ) 함수를 다음과 같이 구성했다.

chkL과 chkR을 통하여 좌/우측 톱니바퀴를 체크하며

36
void find(int cur, int dir, bool chkL, bool chkR)
cs

첫 시행에서는 chkL = 1, chkR = 1로 좌/우측을 모두 탐색하며

77
find(sel, dir, 1, 1);
cs

좌측 톱니바퀴를 재귀적으로 탐색할 때는 chkL = 1, chkR = 0으로 재귀적으로 탐색하고

우측 톱니바퀴를 재귀적으로 탐색할 때는 chkL = 0, chkR = 1으로 재귀적으로 탐색한다.

45

53
find(prev, -dir, 1, 0);
 
find(next, -dir, 0, 1);
cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
// BOJ_14891 톱니바퀴
#include <iostream>
#include <cmath>
 
using namespace std;
 
char gear[5][8]; // 톱니바퀴
int rot[5]; // 회전수
 
// 톱니바퀴 회전
void rotat(int idx, int dir) {
    rot[idx] = (rot[idx] - dir) % 8;
}
 
// 왼쪽(9시 방향 톱니) 좌표
int left(int idx) {
    int left = (6 + rot[idx]) % 8;
    if (left < 0) left += 8;
    return left;
}
 
// 오른쪽(3시 방향 톱니) 좌표
int right(int idx) {
    int right = (2 + rot[idx]) % 8;
    if (right < 0) right += 8;
    return right;
}
 
// 맨위(12시 방향 톱니) 좌표
int top(int idx) {
    int top = 0 + rot[idx];
    if (top < 0) top += 8;
    return top;
}
 
void find(int cur, int dir, bool chkL, bool chkR) {
    int prev = cur - 1; // 좌측 톱니 인덱스
    int next = cur + 1; // 우측 톱니 인덱스
    // 좌측 톱니 찾기
    if (chkL && prev >= 1) {
        int l = gear[prev][right(prev)]; // 좌측 톱니의 3시
        int r = gear[cur][left(cur)]; // 현재 톱니의 9시
        // 좌측 톱니와 서로 극이 다르면 좌측 탐색
        if (l != r)
            find(prev, -dir, 1, 0);
    }
    // 우측 톱니 찾기
    if (chkR && next <= 4) {
        int l = gear[cur][right(cur)]; // 현재 톱니의 3시
        int r = gear[next][left(next)]; // 우측 톱니의 9시
        // 우측 톱니와 서로 극이 다르면
        if (l != r)
            find(next, -dir, 0, 1);
    }
 
    rotat(cur, dir); // 회전 ㄱㄱ
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
    // N극 0 / S극 1
    // 오른쪽 [2] 왼쪽 [6]
 
    for (int i = 1; i <= 4; i++)
        cin >> gear[i];
 
    int N;
    cin >> N;
    while (N--) {
        int sel; // 몇번째 톱니?
        int dir; // 시계 1 / 반시계 -1
        cin >> sel >> dir;
 
        find(sel, dir, 1, 1);
    }
 
    int result = 0;
    for (int i = 1; i <= 4; i++)
        if (gear[i][top(i)] == '1')
            result += pow(2, i - 1);
 
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

<SWEA 4013 소스코드>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
// SWEA_4013 특이한 자석
#include <iostream>
#include <cmath>
 
using namespace std;
 
char gear[5][8]; // 톱니바퀴
int rot[5]; // 회전수
 
// 톱니바퀴 회전
void rotat(int idx, int dir) {
    rot[idx] = (rot[idx] - dir) % 8;
}
 
// 왼쪽(9시 방향 톱니) 좌표
int left(int idx) {
    int left = (6 + rot[idx]) % 8;
    if (left < 0) left += 8;
    return left;
}
 
// 오른쪽(3시 방향 톱니) 좌표
int right(int idx) {
    int right = (2 + rot[idx]) % 8;
    if (right < 0) right += 8;
    return right;
}
 
// 맨위(12시 방향 톱니) 좌표
int top(int idx) {
    int top = 0 + rot[idx];
    if (top < 0) top += 8;
    return top;
}
 
void find(int cur, int dir, bool chkL, bool chkR) {
    int prev = cur - 1; // 좌측 톱니 인덱스
    int next = cur + 1; // 우측 톱니 인덱스
    // 좌측 톱니 찾기
    if (chkL && prev >= 1) {
        int l = gear[prev][right(prev)]; // 좌측 톱니의 3시
        int r = gear[cur][left(cur)]; // 현재 톱니의 9시
        // 좌측 톱니와 서로 극이 다르면 좌측 탐색
        if (l != r)
            find(prev, -dir, 1, 0);
    }
    // 우측 톱니 찾기
    if (chkR && next <= 4) {
        int l = gear[cur][right(cur)]; // 현재 톱니의 3시
        int r = gear[next][left(next)]; // 우측 톱니의 9시
        // 우측 톱니와 서로 극이 다르면
        if (l != r)
            find(next, -dir, 0, 1);
    }
 
    rotat(cur, dir); // 회전 ㄱㄱ
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    int tc;
    cin >> tc;
    for (int T = 1; T <= tc; T++) {
        int N;
        cin >> N;
        
        for (int i = 1; i <= 4; i++)
            for (int j = 0; j < 8; j++)
                cin >> gear[i][j];
        for (int i = 1; i <= 4; i++)
            rot[i] = 0;
 
        while (N--) {
            int sel; // 몇번째 톱니?
            int dir; // 시계 1 / 반시계 -1
            cin >> sel >> dir;
 
            find(sel, dir, 1, 1);
        }
 
        int result = 0;
        for (int i = 1; i <= 4; i++)
            if (gear[i][top(i)] == '1')
                result += pow(2, i - 1);
 
        cout << "#" << T << " " << result << "\n";
    }
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 문자열 계산기

노랑펭귄 — Thu, 18 Oct 2018 08:03:53 +0900

참고자료 : https://www.swexpertacademy.com/main/learn/course/subjectDetail.do?subjectId=AV184uV6I70CFAZN

어느 회사 오프라인 코딩 테스트 문제로 문자열 계산기가 나왔었다.

중위표기를 후위표기법로 바꿔서 풀면 풀린다는 개념은 알고 있었지만 당시엔 제대로 생각이 안나서 시간만 허비했었다....

시험은 이미 끝났지만 그래도 다시 한번 풀어보기로 했다.

사칙연산을 할 때 연산 우선 순위는 다음과 같다.

1. 괄호를 먼저 계산하라.

2. 곱셈 또는 나눗셈

3. 덧셈 또는 뺄셈

하지만, 이는 사람이 쉽게 이해할 수 있는 형태의 논리이며 컴퓨터가 이해할 수 있는 논리로 바꾸면 다음과 같다.

- Step1. 중위 표기법 수식을 후위 표기법 수식으로 변환하기 -

1. 입력 값이 피연산자이면 출력

2. 입력 값이 연산자일 경우

- 스택에 있는 top 값보다 연산자 우선순위가 높으면 push

- 스택에 있는 top 값보다 연산자 우선순위가 높지 않으면 우선순위가 높아질 때까지 pop하여 출력 후 자기 자신을 push

3. 입력 값이 괄호일 경우

- ( 의 경우는 stack에 push 하고 연산자 우선 순위를 최하위로 둠 (괄호 위에 연산자가 쌓일 수 있게 하기 위해)

- ) 의 경우 stack에서 ( 를 만날 때까지 pop 하여 출력

4. 후위표기 형태로 변환 완료

5. stack을 pop 하면서 연산

- Step2. 후위 표기법 수식을 스택으로 계산하기 -

1. 숫자를 만났을 경우 숫자 스택에 push

2. 연산자를 만났을 경우 스택에서 숫자를 2개 pop 하여 연산하고 다시 숫자 스택에 push

3. 모든 연산이 끝나면 남은 스택의 원소는 하나가 되며 그게 정답이 된다.

이러한 원리에 따라 구현하면 문자열 계산기를 풀이할 수 있다.

다만, Step1과 Step2를 굳이 따로 나눠서 할 필요 없이 숫자 스택, 연산자 스택을 각각 별도로 만들어서 풀이를 해도 된다.

괄호를 기준으로 연산자의 우선 순위가 정해지기 때문에 ( 를 만난 이후 )를 만났을 때 바로바로 연산을 해도 된다.

어짜피 이 방법이나 저 방법이나 똑같이 후위순회 계산 방식이므로 큰 차이는 없다.

이 경우는 아래와 같은 방법으로 연산할 수 있다.

- 숫자와 연산자를 따로 구분하여 계산하기 -

1. 숫자를 만났을 경우 숫자 스택에 push

2. 연산자를 만났을 경우

- 연산자 스택에 있는 top 값보다 우선순위가 높으면 push

- 연산자 스택에 있는 top 값보다 우선순위가 높지 않으면 우선 순위가 높아질 때까지 pop 하면서 계산

- 계산을 할 때는 숫자 스택에서 2개의 원소를 pop 하여 계산한 후 그 결과를 다시 숫자 스택에 push

3. 괄호를 만났을 경우

- ( 의 경우는 stack에 push 하고 연산자 우선 순위를 최하위로 둠 (괄호 위에 연산자가 쌓일 수 있게 하기 위해)

- ) 의 경우 stack에서 ( 를 만날 때까지 pop 하면서 계산

4. 입력이 다 끝났을 경우 스택에 남아있는 모든 연산자를 pop 하면서 계산

"15 + 32 * ( 1 - 8 ) / 2" 의 계산 결과는 다음과 같다.

모든 과정을 자세히 보려면 클릭

↓↓↓

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
// String Calculator
#include <iostream>
#include <string>
#include <stack>
#include <sstream>
 
using namespace std;
 
struct oper{
    int p; // 연산자 우선순위
    string o; // 연산자
};
 
stack<int> num; // 숫자 스택
stack<oper> op; // 연산자 스택
 
void calc() {
    int a, b, result;
    b = num.top();
    num.pop();
    a = num.top();
    num.pop();
    string oper = op.top().o;
    op.pop();
 
    if (oper == "*")
        result =  a * b;
    else if (oper == "/")
        result = a / b;
    else if (oper == "+")
        result = a + b;
    else if (oper == "-")
        result = a - b;
    // 결과 값 스택에 다시 저장
    num.push(result);
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    string input = "15 + 32 * ( 1 - 8 ) / 2"; // -97
    stringstream ss(input);
 
    // 연산자 우선순위에 따라 스택에 push
    // 0 : ( )
    // 1 : + -
    // 2 : * /
    string tok;
    while (ss >> tok) {
        // ( 는 무조건 연산자 스택에 push
        if (tok == "(") {
            op.push({0, tok});
        } // ) 가 나오면 ( 가 나올 때 까지 계산
        else if (tok == ")") {
            while (op.top().o != "(")
                calc();
            op.pop();
        }
        else if (tok == "*" || tok == "/" || tok == "+" || tok == "-") {
            int prior; // 연산자 우선순위
            if(tok == "*")
                prior = 2;
            else if(tok == "/")
                prior = 2;
            else if(tok == "+")
                prior = 1;
            else if(tok == "-")
                prior = 1;
 
            // 연산자 우선 순위 낮은게 top으로 올 때까지 계산
            while (!op.empty() && prior <= op.top().p)
                calc();
            // 스택에 연산자 push
            op.push({prior, tok});
        }
        else // 숫자일 경우 숫자 스택에 push
            num.push(stoi(tok));
    }
    // 남은 연산자 계산
    while (!op.empty())
        calc();
 
    cout << num.top();
 
    return 0;
}
Colored by Color Scripter
cs

[IDE] 윈도우에서 CLion 한글 깨짐 현상 해결하기

노랑펭귄 — Wed, 17 Oct 2018 08:41:36 +0900

윈도우에서 MinGW를 이용하여 gcc 컴파일러를 이용할 때 한글을 출력하게 되면 깨지는 현상이 발생한다.

이는 MinGW + gcc 로 설치된 기본 환경에서 한글 캐릭터셋을 지원하지 않기 때문이다.

CLion을 윈도우에서 사용하면 위 그림과 같이 한글이 깨져서 출력되는 것을 알 수 있다.

이를 해결하려면 캐릭터 셋을 euc-kr 또는 CP949와 같은 형태로 바꿔줘야 한다.

1
set(CMAKE_CXX_FLAGS "-fexec-charset=CP949")
cs

한글 문자로 인코딩 방법을 바꾸기 위해 CMakeLists.txt 파일에 위와 같이 CP949 캐릭터 셋을 출력하기 위한 문구를 입력하고 Reload changes 버튼을 누르면 간단하게 한글 깨짐 현상을 해결할 수 있다.

캐릭터 셋을 euc-kr로 설정하게 될 경우 일반적인 문자는 출력이 가능하지만 위와 같이 외계어(?) 문자는 출력할 수 없다.

CP949로 설정을 바꿀 경우 외계어도 정상적으로 출력 가능하다.

euc-kr은 완성형이고 CP949는 통합완성형이기 때문이란다.

자세한 내용은 https://goo.gl/S6dXwD를 참고하면 알 수 있다.

[C++] 백준 BOJ 14890 경사로 (SWEA 4014 활주로 건설)

노랑펭귄 — Sat, 13 Oct 2018 01:17:25 +0900

문제링크 : https://noj.am/14890

문제링크 : https://www.swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWIeW7FakkUDFAVH

<아래 풀이는 백준 14890 기준>

(이전 노드 - 현재 노드)의 높이 차이가 +1일 경우 : 내리막

(이전 노드 - 현재 노드)의 높이 차이가 -1일 경우 : 오르막

내리막 경사로가 건설되려면 앞으로 len 만큼의 길이가 확보되어야 하고

오르막 경사로가 건설되려면 이전에 이미 len 만큼의 길이가 확보되었어야 한다.

내리막 + 오르막 경사로가 건설되어야 할 경우에도 그 사이 길이가 len 만큼 확보되어야 한다.

공간의 확보를 위해선 높이의 차이가 같은 구간이 몇개인지 카운트를 해가면서 계산하면 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
// BOJ 14890 경사로
#include <iostream>
#include <vector>
 
using namespace std;
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int n, len;
    cin >> n >> len;
    vector<vector<int> > arr(n, vector<int>(n));
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            cin >> arr[i][j];
 
    int result = 0;
    for (int i = 0; i < n; i++) {
        // 가로행
        int cnt = 1; // 높이가 같은 타일 수
        for (int j = 1; j < n; j++) {
            int prev = arr[i][j - 1];
            int cur = arr[i][j];
            // 높이가 같으면
            if (prev == cur)
                cnt++;
            // 내리막이면
            else if (prev - cur == 1 && cnt >= 0)
                cnt = -len + 1;
            // 오르막이면
            else if (prev - cur == -1 && cnt >= len)
                cnt = 1;
            else {
                cnt = -1;
                break;
            }
        }
        if (cnt >= 0)
            result++;
 
        // 세로행
        cnt = 1;
        for (int j = 1; j < n; j++) {
            int prev = arr[j - 1][i];
            int cur = arr[j][i];
            if (prev == cur)
                cnt++;
            else if (prev - cur == 1 && cnt >= 0)
                cnt = -len + 1;
            else if (prev - cur == -1 && cnt >= len)
                cnt = 1;
            else {
                cnt = -1;
                break;
            }
        }
        if (cnt >= 0)
            result++;
    }
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#include <iostream>
#include <vector>
 
using namespace std;
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    int tc;
    cin >> tc;
    for(int T = 1; T <= tc; T++) {
        int n, len;
        cin >> n >> len;
        vector<vector<int> > arr(n, vector<int>(n));
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                cin >> arr[i][j];
 
        int result = 0;
        for (int i = 0; i < n; i++) {
            // 가로행
            int cnt = 1; // 높이가 같은 타일 수
            for (int j = 1; j < n; j++) {
                int prev = arr[i][j - 1];
                int cur = arr[i][j];
                // 높이가 같으면
                if (prev == cur)
                    cnt++;
                    // 내리막이면
                else if (prev - cur == 1 && cnt >= 0)
                    cnt = -len + 1;
                    // 오르막이면
                else if (prev - cur == -1 && cnt >= len)
                    cnt = 1;
                else {
                    cnt = -1;
                    break;
                }
            }
            if (cnt >= 0)
                result++;
 
            // 세로행
            cnt = 1;
            for (int j = 1; j < n; j++) {
                int prev = arr[j - 1][i];
                int cur = arr[j][i];
                if (prev == cur)
                    cnt++;
                else if (prev - cur == 1 && cnt >= 0)
                    cnt = -len + 1;
                else if (prev - cur == -1 && cnt >= len)
                    cnt = 1;
                else {
                    cnt = -1;
                    break;
                }
            }
            if (cnt >= 0)
                result++;
        }
        cout << "#" << T << " " << result << "\n";
    }
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 5639 이진 검색 트리

노랑펭귄 — Fri, 12 Oct 2018 00:40:12 +0900

문제링크 : https://noj.am/5639

이진 트리를 구성하고 있는 각 노드는 다음과 같이 표현한다.

V - 부모 노드

L - 왼쪽 자식 노드

R - 오른쪽 자식 노드

이진 트리의 순회 방식은 다음과 같다.

전위 순회 : V-L-R

중위 순회 : L-V-R

후위 순회 : L-R-V

문제에서 주어진 다음 조건을 보면 힌트를 유추할 수 있다.

이진 검색 트리는 다음과 같은 세 가지 조건을 만족하는 이진 트리이다.

노드의 왼쪽 서브트리에 있는 모든 노드의 키는 노드의 키보다 작다.
노드의 오른쪽 서브트리에 있는 모든 노드의 키는 노드의 키보다 크다.
왼쪽, 오른쪽 서브트리도 이진 검색 트리이다.

입력으로 전위순회를 시행했을 때의 결과가 주어진다고 했기 때문에 위의 원리를 그대로 적용해보면 각 노드별 서브트리를 구할 수 있다.

50 30 24 5 28 45 98 52 60

V-L-R의 순서로 순회할 때 가장 먼저 방문하는 노드(빨간색)는 루트 노드(V)이고,

조건1에 따라 50보다 작은 모든 노드(파란색)는 왼쪽 서브트리이고,

조건2에 따라 50보다 큰 모든 노드(초록색)는 오른쪽 서브트리이다.

우리는 이 V-L-R의 순서를 L-R-V로 바꿔야한다.

따라서, L sub와 R sub를 재귀적인 방법으로 다시 탐색하고 모든 탐색이 끝난 후 V를 출력해주면 될 것이다.

재귀적인 방법을 쭉 나열해보면 아래와 같이 시행된다.

* 각 시행마다 진하게 표시된 글자는 다음 시행에서 실행될 프로시저를 의미

* 컬러로 표시된 글자는 이전 시행에서의 결과를 의미

위 이미지가 너무 빠르다면 클릭

↓↓↓

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// BOJ 5639 이진 검색 트리
#include <iostream>
#include <vector>
 
using namespace std;
 
vector<int> arr;
 
void preToPost(int l, int r) {
    int ans = l; // 현재 노드(부모노드)
    int sub = l++; // 좌,우 서브트리를 나누는 인덱스
    while (arr[++sub] < arr[ans]); // 인덱스 계산
    // 좌측 서브트리
    if (l <= sub - 1)
        preToPost(l, sub - 1);
    // 우측 서브트리
    if (sub <= r)
        preToPost(sub, r);
    cout << arr[ans] << '\n';
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
    int input;
    while (cin >> input) arr.push_back(input);
    arr.push_back(INT32_MAX); // segment fault 방지
    preToPost(0, arr.size() - 2);
 
    return 0;
}
Colored by Color Scripter
cs

참고로 다음 코드는
29
arr.push_back(INT32_MAX); // segment fault 방지
cs

이 부분에서 arr.size()를 초과하는 범위를 탐색했을 경우 컴파일 에러가 나기 때문에 아무 의미 없는 int의 MAX 값을 넣은 것이다.
12
while (arr[++sub] < arr[ans]); // 인덱스 계산
cs

아니면 다음과 같이 표현해도 된다.

12
while (++sub < arr.size() && arr[sub] < arr[ans]); // 인덱스 계산
cs

[C++] 백준 BOJ 6603 로또

노랑펭귄 — Mon, 8 Oct 2018 05:30:08 +0900

문제링크 : https://noj.am/6603

N개의 원소를 가지는 집합에서 K개를 고르는 조합(Combination) 문제로 STL의 permutation을 사용하면 쉽게 풀 수 있다.

algorithm 헤더에 있는 next_permutation()과 prev_permutation()으로 순열을 구할 수 있다.

[1, 2, 3, 4]를 next_permutation()을 사용하면

[1, 2, 4, 3] [1, 3, 2, 4] [1, 3, 4, 2] [1, 4, 2, 3] ..... 이런 식으로 사전 순서대로 순열이 적용된다.

prev_permutation()은 그 반대라고 볼 수 있다.

그렇다면 조합을 사용하려면 어떻게 해야할까?

[1, 1, 0, 0]을 prev_permutation()으로 돌려보면 아래와 같은 값을 얻을 수 있다.

[1, 0, 1, 0] [1, 0, 0, 1] [0, 1, 1, 0] [0, 1, 0, 1] [0, 0, 1, 1]

중복된 원소들은 제외하고 순열을 만들어 주는 것을 확인할 수 이다.

위의 순서를 잘 살펴보면 N개의 집합에서 K개를 고르는 조합의 순서와 동일하다는 사실을 알 수 있다!

따라서, 4개의 원소를 가지는 집합에서 2개를 고르는 방법은 아래와 같이 표현 가능하다.

[1, 1, 0, 0] [1, 0, 1, 0] [1, 0, 0, 1] [0, 1, 1, 0] [0, 1, 0, 1] [0, 0, 1, 1] - A

[1, 2, 3, 4] [1, 2, 3, 4] [1, 2, 3, 4] [1, 2, 3, 4] [1, 2, 3, 4] [1, 2, 3, 4] - B

A 배열에서 1의 값을 가지는 인덱스를 B에서 출력해주면 된다.

이를 표현하면 if( A[idx] == 1 ) cout << B[idx]; 가 되겠다.

자료형을 bool 타입으로 사용한다면 조금이나마 메모리 공간을 줄일 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// BOJ 6603 로또
#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int n = 1234;
    while (cin >> n && n != 0) {
        vector<int> num(n);
        for (int i = 0; i < n; i++)
            cin >> num[i];
        // nCr을 위한 배열
        vector<bool> comb(n, false);
        for (int i = 0; i < 6; i++)
            comb[i] = true;
        do {
            for (int i = 0; i < n; i++)
                if (comb[i])
                    cout << num[i] << ' ';
            cout << '\n';
        } while (prev_permutation(comb.begin(), comb.end()));
        cout << '\n';
    }
    return 0;
}
 
Colored by Color Scripter
cs

다른 풀이법으로는 DFS를 이용한 백트래킹 방법이 있다.

DFS처럼 탐색하되 사이즈가 '6'이 되면 탐색을 중단하고 스택에 쌓여있는 다음 dfs로 넘어가는 방법이다.

이 방법으로 완전탐색을 시행하면 된다. 그리고, 남은 노드의 갯수가 6 이하면 탐색을 할 필요가 전혀 없으므로 해당 조건을 추가해주었다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// BOJ 6603 로또
#include <iostream>
#include <vector>
 
using namespace std;
 
int n = 1234;
vector<int> num;
vector<int> result;
 
void dfs(int idx) {
    // 6개를 채우면 출력하고 dfs 탐색 중단
    if (result.size() == 6) {
        for (int r : result)
            cout << r << ' ';
        cout << '\n';
        return;
    }
    for (int i = idx; i < n; i++) {
        // 남은 노드 수가 6 이하면 탐색할 필요 없음
        if(n - i + result.size() < 6) return;
        result.push_back(num[i]);
        dfs(i + 1);
        result.pop_back();
    }
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    while (cin >> n && n != 0) {
        num = vector<int>(n);
        for (int i = 0; i < n; i++)
            cin >> num[i];
 
        dfs(0);
 
        cout << '\n';
    }
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 9935 문자열 폭발

노랑펭귄 — Mon, 8 Oct 2018 02:27:19 +0900

문제링크 : https://noj.am/9935

요즘 알고리즘 테스트 문제들이 파싱 문제들이 하도 많이 나와서 연습해볼겸 별 의미는 없지만 string stream을 사용하여 풀어보았다.

string stream을 통하여 입력된 문자열이 폭발 문자열의 '마지막 문자'에 해당할 경우 이전에 입력되었던 문자열이 폭발 문자열과 일치하는지 체크하는 방법으로 풀이했다. 본 풀이법은 스택을 사용한 풀이법이라 할 수 있다.

예제에서는 "C4"가 폭발 문자열이다.

아래의 조건에서 '4'를 찾았다면 문자열 탐색이 실행된다.

1
if (s == bomb.back())
cs

먼저 idx 변수를 폭발 문자열 크기만큼 뺀 인덱스로 초기화 시켜준다.
폭발 문자열의 맨 앞인 'C'에 해당하는 값이다.

1
2
3
int idx = result.size() - bomb.size();
// 인덱스가 0보다 작을 수 없음
if (idx < 0) continue;
cs

idx를 하나씩 늘려가면서 폭발 문자열 탐색을 수행해준다.

1
2
3
4
5
6
7
8
9
10
11
// 변수 설정
bool del = true;
int size = bomb.size();
// 폭발 문자열 탐색
for(int i = 0; i < size; i++) {
    // 하나라도 다른 문자 나오면 탈출
    if (result[idx++] != bomb[i]) {
        del = false;
        break;
    }
}
Colored by Color Scripter
cs

C++의 string 클래스는 컨테이너 형태이기 때문에 push_back() 함수로 글자 제거가 가능하다.

1
2
// 문자열 제거
if(del) while(size--) result.pop_back();
cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
// BOJ 9935 문자열 폭발
#include <iostream>
#include <string>
#include <sstream>
 
using namespace std;
 
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    string input; // 입력 문자열
    string bomb;  // 폭발 문자열
    string result;
    cin >> input >> bomb;
    stringstream ss(input);
 
    char s; // 문자열 탐색을 위한 변수
    while (ss >> s) {
        result.push_back(s);
        // 입력 문자가 bomb의 끝 문자랑 같으면 실행
        if (s == bomb.back()) {
            int idx = result.size() - bomb.size();
            // 인덱스가 0보다 작을 수 없음
            if (idx < 0) continue;
            // 변수 설정
            bool del = true;
            int size = bomb.size();
            // 폭발 문자열 탐색
            for(int i = 0; i < size; i++) {
                // 하나라도 다른 문자 나오면 탈출
                if (result[idx++] != bomb[i]) {
                    del = false;
                    break;
                }
            }
            // 문자열 제거
            if(del) while(size--) result.pop_back();
        }
    }
    if(result.size() == 0)
        cout << "FRULA";
    else
        cout << result;
 
    return 0;
}
 
Colored by Color Scripter
cs

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

노랑펭귄 — Sat, 6 Oct 2018 04:13:48 +0900

문제링크 : https://noj.am/9095

어떤 숫자 N을 1, 2, 3 더하기로 나타내는 방법은 다음과 같다.

[1] - 1개

[2] - 2개

1+1 → [1]+1

[3] - 4개

1+2 → [1]+2

1+1+1, 2+1 → [2]+1

[4] - 7개 (1+2+4)

1+3 : [1]+3 → [1] + 3

1+1+2, 2+2 → [2] + 2

1+2+1, 1+1+1+1, 2+1+1, 3+1 → [3] + 1

[5] - 13개 (2+4+7)

1+1+3, 2+3 → [2] + 3

1+2+2, 1+1+1+2, 2+1, 3+2 → [3] + 2

1+3+1, 1+1+2+1, 2+2+1, 1+2+1+1, 1+1+1+1+1, 2+1+1+1, 3+1+1 → [4] + 1

위와 같이 시뮬레이션을 해보면 DP[N] = DP[N-3] + DP[N-2] + DP[N-1]의 점화식을 구할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// BOJ 9095 1, 2, 3 더하기
#include <iostream>
 
using namespace std;
 
int dp[12];
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    dp[1] = 1;
    dp[2] = 2;
    dp[3] = 4;
    for (int i = 4; i <= 11; i++)
            dp[i] = dp[i-3] + dp[i-2] + dp[i-1];
    int tc;
    cin >> tc;
    while (tc--) {
        int input;
        cin >> input;
        cout << dp[input] << '\n';
    }
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 2583 영역 구하기

노랑펭귄 — Sat, 6 Oct 2018 03:29:33 +0900

문제링크 : https://noj.am/2583

단순 DFS/BFS 문제이다.

계산하기 편하게 (1,1)~(N,M)의 영역을 사용한다.

초기에 테두리를 방문한 것으로 체크하고 내부를 미방문한 상태로 초기화 시키면 ▣ <- 이런 형태로 만들어진다.

입력된 사각형은 (x1+1, y2+1)~(x2, y2)의 영역으로 방문 체크를 해주는 것으로 구현하였다.

dfs를 실행할 때마다 cnt 변수를 통해 칸을 체크해준다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
// BOJ 2583 영역 구하기
#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
int cnt = 0;
const int dx[] = {0, 0, -1, 1};
const int dy[] = {-1, 1, 0, 0};
vector<vector<bool> > arr;
 
void dfs(int x, int y) {
    for (int i = 0; i < 4; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];
        if (!arr[nx][ny]) {
            cnt++;
            arr[nx][ny] = true;
            dfs(nx, ny);
        }
    }
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int X, Y, K;
    cin >> Y >> X >> K;
    // true : 방문, false : 미방문
    // 테두리를 방문한 것으로 만들고 내부는 미방문 상태로 초기화
    arr = vector<vector<bool> >(X + 2, vector<bool>(Y + 2, true));
    for (int i = 1; i <= X; i++)
        for (int j = 1; j <= Y; j++)
            arr[i][j] = false;
 
    // 사각형 영역을 방문한 것으로 입력
    for (int i = 1; i <= K; i++) {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        for (int x = x1 + 1; x <= x2; x++)
            for (int y = y1 + 1; y <= y2; y++)
                arr[x][y] = true;
    }
 
    // 결과 카운팅
    vector<int> result;
    for (int x = 1; x <= X; x++) {
        for (int y = 1; y <= Y; y++) {
            if (!arr[x][y]) {
                cnt = 1;
                arr[x][y] = true;
                dfs(x, y);
                result.push_back(cnt);
            }
        }
    }
    sort(result.begin(), result.end());
    cout << result.size() << '\n';
    for (int i : result)
        cout << i << ' ';
 
    return 0;
}
Colored by Color Scripter
cs

[C++] Codeforces Round #514 (Div. 2) - C. Sequence Transformation

노랑펭귄 — Sat, 6 Oct 2018 02:18:21 +0900

문제링크 : http://codeforces.com/contest/1059

C. Sequence Transformation

각 숫자들을 인수분해 하면 소수들의 곱으로 이루어진다.
입력 사이즈가 100만이기 때문에 100만의 제곱근 만큼인 1000까지의 소수를 구하고 그 소수들 중에서 가장 많은 배수들을 가지고 있는 소수를 추려내고 나머지 모든 수를 1로 출력, 그 소수의 제곱수가 아닌 숫자를 그 소수로 출력, 소수의 제곱수를 출력 하는 식으로 문제를 접근했는데.. 답은 맞게 나오겠지만 메모리 공간이 분명 초과되는듯 하다.

기존엔 문제를 이렇게 풀었으나 출력해서 규칙을 보니.. 2의 배수만 신경쓰면 되는 것을 발견했다.
3을 제외하고 전부 2로 출력되었으니 말이다..

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
// Codeforces Round #514 (Div. 2)
// C. Sequence Transformation
#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cmath>
 
using namespace std;
 
struct node {
    int pnum;
    vector<int> factors;
 
    node(int num) : pnum(num) {}
 
    bool operator<(const node &a) const {
        // 사이즈가 같으면 큰 숫자 우선
        if (factors.size() == a.factors.size())
            return pnum < a.pnum;
        else
            return factors.size() < a.factors.size();
    }
};
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    int input;
    cin >> input;
    if (input == 1) {
        cout << 1;
        return 0;
    }
 
    // 소수 리스트
    bool isPrime[101];
    memset(isPrime, true, sizeof(isPrime));
    vector<node> prime;
    // 입력 최대 값이 1,000,000이므로 최대 제곱근(100)까지만 소수 구함
    for (int i = 2; i <= 1000 && i <= input; i++) {
        if (isPrime[i]) {
            prime.push_back({i}); // 소수 저장
            for (int j = i; j <= input; j += i) {
                isPrime[j] = false;
                prime.back().factors.push_back(j); // 소수의 배수 저장
            }
        }
    }
    sort(prime.begin(), prime.end());
    // 가장 많은 factor를 가지고 있는 소수를 제외한 나머지는 1을 출력
    int size = prime.back().factors.size();
    int print1 = input - size;
    for (int i = 0; i < print1; i++)
        cout << 1 << ' ';
 
    // 소수 factor들의 마지막 숫자의 제곱수만 취함
    int result = prime.back().pnum;
    int cnt = 0;
    int root = prime.back().factors.back();
    while (root /= 2)
        cnt++;
    // 제곱수를 제외한 나머지
    int print2 = size - cnt;
 
    for (int i = 0; i < print2; i++)
        cout << result << ' ';
 
    // 소수의 제곱 순서대로 출력
    for (int i = 1; i <= cnt; i++)
        cout << pow(result, i) << ' ';
 
    return 0;
}
Colored by Color Scripter
cs


그래서 2의 배수를 이용한 방법으로 아래와 같이 수정하면 된다.
처음부터 시뮬레이션으로 접근했으면 쉽게 풀 수 있었던 문제였다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// Codeforces Round #514 (Div. 2)
// C. Sequence Transformation
#include <iostream>
#include <cmath>
 
using namespace std;
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    int input;
    cin >> input;
    switch (input) {
        case 1:
            cout << "1";
            return 0;
        case 2:
            cout << "1 2";
            return 0;
        case 3:
            cout << "1 1 3";
            return 0;
    }
    int tmp = input;
    int cnt = 0;
    while (tmp /= 2)
        cnt++;
 
    int result = input;
    if(result % 2)
        result++;
    result /= 2;
    for (int i = 1; i <= result; i++)
        cout << "1 ";
    for(int i = 1; i <= input - result - cnt; i++)
        cout << "2 ";
    for (int i = 1; i <= cnt; i++)
        cout << pow(2, i) << " ";
 
    return 0;
}
Colored by Color Scripter
cs

[C++] Codeforces Round #514 (Div. 2) - A. Cashier

노랑펭귄 — Sat, 6 Oct 2018 02:16:20 +0900

문제링크 : http://codeforces.com/contest/1059

A. Cashier

단순 구현문제로 중간에 비는 시간에 담배탐을 할 수 있는 시간이 있는지 체크하여 누적하고 업무가 끝나고 남은 시간도 담배탐을 할 수 있는 만큼 더해준다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// Codeforces Round #514 (Div. 2)
// A. Cahier
#include <iostream>
#include <vector>
 
using namespace std;
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int num; // 고객수
    int time; // 일하는 시간
    int smoke; // 담배탐 시간
    cin >> num >> time >> smoke;
 
    int result = 0;
    int prev = 0; // 이전 고객 시간
    int come = 0; // 고객이 오는 시간
    int service = 0; // 상담 시간
    for (int i = 0; i < num; i++) {
        cin >> come >> service;
        int brktime = come - prev;
        if (brktime >= smoke) {
            result += brktime / smoke;
        }
        prev = come + service;
    }
    int remain = time - prev;
    if(remain >= smoke)
        result += remain / smoke;
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 13458 시험 감독

노랑펭귄 — Fri, 5 Oct 2018 22:34:03 +0900

문제링크 : https://noj.am/13458

단순 구현 문제인데 정답률이 25%대로 낮은 문제이다.

그 이유는 출력 자료형을 다들 고려하지 않아서 그런 것 같다.

최대로 나올 수 있는 값이 1,000,000 * 1,000,000이기 때문에 long long 타입을 사용해야한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// BOJ 13458 시험 감독
#include <iostream>
#include <vector>
 
using namespace std;
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
//    freopen("../input.txt", "r", stdin);
 
    int num, main, sub;
    cin >> num;
    vector<int> person(num);
    for (auto &i : person)
        cin >> i;
    cin >> main >> sub;
 
    long long result = 0;
    for (int idx = 0; idx < num; idx++) {
        person[idx] -= main;
        result++;
        if (person[idx] <= 0)
            continue;
        if (person[idx] % sub > 0)
            result++;
        result += person[idx] / sub;
    }
    cout << result;
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 1991 트리 순회

노랑펭귄 — Wed, 3 Oct 2018 20:59:06 +0900

문제링크 : https://boj.am/1991

문제에서 입력은 A~Z로만 한정되어 있다. 이러한 특성 덕분에 간단한 형태로 트리를 구현할 수 있다.

char 형태의 A(65) ~ Z(90)에서 A(65)씩 빼주면 A(0) ~ Z(25)로 표현할 수 있기 때문이다.

따라서, 인덱스 번호 자체가 노드에 들어있는 문자를 의미하는 것이기 때문에 2개의 배열 만으로도 트리의 구현이 가능하다.

현재 노드를 V, 좌측 자식 노드를 L, 우측 자식노드를 R이라고 한다면

전위순회는 V-L-R 순서로

중위순회는 L-V-R 순서로

후위순회는 L-R-V 순서로 순회하게 된다.

스택을 이용하여 구현을 하려고 시도해봤으나 너무 복잡하여 재귀로 구현했다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
// BOJ 1991 트리 순회
#include <iostream>
 
using namespace std;
 
char lNode[26]; // 좌측 자식 노드
char rNode[26]; // 우측 자식 노드
 
void pre(int idx) {
    // 현재 노드 출력
    cout << char(idx + 'A');
    // 자식 노드가 비어있지 않으면
    if (lNode[idx] != '.')
        pre(lNode[idx] - 'A');
    if (rNode[idx] != '.')
        pre(rNode[idx] - 'A');
}
 
void mid(int idx) {
    if (lNode[idx] != '.')
        mid(lNode[idx] - 'A');
    cout << char(idx + 'A');
    if (rNode[idx] != '.')
        mid(rNode[idx] - 'A');
}
 
void post(int idx) {
    if (lNode[idx] != '.')
        post(lNode[idx] - 'A');
    if (rNode[idx] != '.')
        post(rNode[idx] - 'A');
    cout << char(idx + 'A');
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int num;
    cin >> num;
    char v, l, r;
    for (int i = 0; i < num; i++) {
        cin >> v >> l >> r;
        // idx: 0~25 -> idx+A: A~Z
        int idx = v - 'A';
        lNode[idx] = l;
        rNode[idx] = r;
    }
    pre(0);
    cout << '\n';
    mid(0);
    cout << '\n';
    post(0);
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 8916 이진 검색 트리

노랑펭귄 — Wed, 3 Oct 2018 02:36:02 +0900

문제링크 : https://noj.am/8916

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
// BOJ 8916 이진 검색 트리
#include <bits/stdc++.h>
 
using namespace std;
 
long long comb(int n, int r) { // nCr
    r = n - r > r ? r : n - r;
    long long result = 1;
    for (int i = 0; i < r; i++)
        result *= n - i;
    for (int i = 2; i <= r; i++)
        result /= i;
    return result;
}
 
struct node {
    int value = -1;
    int lcnt = 0; // 좌측 자식 수
    int rcnt = 0; // 우측 자식 수
    int left = -1;// 좌측 자식 인덱스
    int right = -1;// 우측 자식 인덱스
};
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int tc;
    cin >> tc;
    while (tc--) {
        int num, input;
        vector<node> tree(1);
        cin >> num;
        while(num--) {
            int idx = 0; // 루트노드 인덱스
            cin >> input;
            while (true) {
                // 빈노드이면 값 추가
                if (tree[idx].value == -1) {
                    tree[idx].value = input;
                    break;
                    // 입력 값이 부모노드보다 작을 경우
                } else if (input < tree[idx].value) {
                    // 자식노드 카운팅
                    tree[idx].lcnt++;
                    // 좌측 자식이 존재하지 않을 경우
                    if (tree[idx].left == -1) {
                        // 자식 추가
                        tree.push_back({});
                        tree[idx].left = tree.size() - 1;
                    }
                    idx = tree[idx].left; // 인덱스 저장
                } else {
                    tree[idx].rcnt++;
                    if (tree[idx].right == -1) {
                        tree.push_back({});
                        tree[idx].right = tree.size() - 1;
                    }
                    idx = tree[idx].right;
                }
            }
        }
        long long result = 1;
        for (node i : tree)
            result = (result * comb(i.lcnt + i.rcnt, i.lcnt)) % 9999991;
        cout << result << '\n';
    }
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 11403 경로 찾기

노랑펭귄 — Tue, 2 Oct 2018 17:37:34 +0900

문제링크 : https://noj.am/11403

전형적인 BFS / DFS 문제

그냥 풀면 된다.

자기 자신노드로 돌아오는 경우가 있기 때문에 맨 처음은 방문체크를 하지 않았다.

인접리스트는 graph[0] = {1, 3, 5, 6, 7} 이런 형태로 저장된다. 현재 노드에서 해당 노드로 갈 수 있으면 저장된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// BOJ 11403 경로 찾기
#include <iostream>
#include <vector>
#include <queue>
 
using namespace std;
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int num;
    cin >> num;
    vector<vector<int> > graph(num); // 인접리스트
 
    int input;
    for (int i = 0; i < num; i++) {
        for (int j = 0; j < num; j++) {
            cin >> input;
            if (input)
                graph[i].push_back(j);
        }
    }
 
    for (int i = 0; i < num; i++) {
        for (int j = 0; j < num; j++) {
            vector<bool> visited(num, false);
            queue<int> Q;
            bool flag = false;
            for(int g : graph[i])
                Q.push(g);
            while(!Q.empty()){
                int cur = Q.front();
                Q.pop();
                visited[cur] = true;
                if(cur == j){
                    flag = true;
                    cout << 1 << " ";
                    break;
                }
                for(int g : graph[cur])
                    if(!visited[g])
                        Q.push(g);
            }
            if(!flag)
                cout << 0 << " ";
        }
        cout << "\n";
    }
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 1759 암호 만들기

노랑펭귄 — Mon, 1 Oct 2018 16:00:52 +0900

문제링크 : https://noj.am/1759

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
// BOJ 1759 암호 만들기
#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
vector<char> arr; // 전체 문자
vector<char> mo;  // 모음
vector<char> answer; // 정답 문자
vector<char> expt;  // 검색 제외
vector<vector<char> > result; // 출력
int size, inp; // 문자열 길이, 입력 크기
 
// 모음인지?
bool isMo(char input){
    return (input == 'a' || input == 'e' || input == 'i'
            || input == 'o' || input == 'u');
}
// 검색할 문자가 제외 문자인지?
bool except(char input){
    for(char e : expt)
        if(input == e)
            return true;
    return false;
}
 
// 문자열 선택
void pick(){
    // 정답 출력
    if(answer.size() >= size){
        vector<char> output = answer;
        sort(output.begin(), output.end());
        int numOfJa = 0; // 자음 갯수
        for(char c : output){
            if(!isMo(c))
                numOfJa++;
        }
        // 자음 2개 이상
        if(numOfJa >= 2)
            result.push_back(output);
        answer.pop_back();
        return;
    }
    char s = answer.back();
    for(char i : arr){
        if((answer.size() == 1 || i > s) && !except(i)){
            answer.push_back(i);
            pick();
        }
    }
    answer.pop_back();
    return;
}
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    // freopen("../input.txt", "r", stdin);
 
    cin >> size >> inp;
 
    char tmp;
    for (int i = 0; i < inp; i++) {
        cin >> tmp;
        if (isMo(tmp))
            mo.push_back(tmp);
        arr.push_back(tmp);
    }
 
    sort(arr.begin(), arr.end());
    sort(mo.begin(), mo.end());
 
    for(char m : mo){
        // 모음을 벡터에 push
        answer.push_back(m);
        // 검색시 스킵을 위해
        expt.push_back(m);
        pick();
    }
 
    sort(result.begin(), result.end());
 
    for(auto r : result){
        for(char o : r)
            cout << o;
        cout << '\n';
    }
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 11726 2xn 타일링 / 11727 2xn 타일링 2

노랑펭귄 — Thu, 27 Sep 2018 17:16:24 +0900

문제링크 : https://boj.kr/11726

시뮬레이션을 해보면 아래 그림과 같이 규칙을 찾을 수 있다.

하나의 타일을 1*2로 고정 시키면 N-1의 모든 케이스를 적용할 수 있고

두개의 타일을 2*1 두개로 고정 시키면 N-2의 모든 케이스를 적용할 수 있다.

하지만, 여기서 신기한 점은 1, 2, 3, 5.... 피노나치 수열과 동일한 문제임을 알 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// BOJ 11726 2xn 타일링
#include <iostream>
 
using namespace std;
 
int dp[1001];
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    // freopen("../input.txt", "r", stdin);
    int num;
    cin >> num;
    dp[1] = 1;
    dp[2] = 2;
    for (int i = 3; i <= num; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
        if (dp[i] >= 10007)
            dp[i] %= 10007;
    }
    cout << dp[num];
 
    return 0;
}
Colored by Color Scripter
cs

문제링크 : https://boj.kr/11727

11726 문제의 접근 방법과 동일하지만 조건이 1가지 추가되었다.

2*1을 2개 쌓은 것과 2*2 블럭 1개의 경우를 동일하게 생각하여 조건을 2배 해주면 너무 쉽게 풀린다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// BOJ 11726 2xn 타일링 2
#include <iostream>
 
using namespace std;
 
int dp[1001];
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    // freopen("../input.txt", "r", stdin);
    int num;
    cin >> num;
    dp[1] = 1;
    dp[2] = 2;
    for (int i = 3; i <= num; i++) {
        dp[i] = dp[i - 1] + dp[i - 2] * 2;
        if (dp[i] >= 10007)
            dp[i] %= 10007;
    }
    cout << dp[num];
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 3048 개미

노랑펭귄 — Fri, 21 Sep 2018 11:24:17 +0900

문제링크 : https://boj.kr/3048

개미 그룹이 서로 -> <- 방향으로 맞닥뜨렸을 때 스왑이 일어나는 것을 구현하면 된다.

구조체를 만들어서 별도의 디렉션을 저장해주어도 되지만 귀찮아서 대문자 / 소문자로 개미 그룹을 구분했다.

1
2
3
4
5
6
7
// 방향 구분을 위해 ->는 소문자 <- 는 대문자로 입력
for (int i = 1; i <= n1; i++) {
    cin >> str[n1 - i];
    str[n1 - i] = str[n1 - i] - 'A' + 'a';
}
for (int i = n1; i < size; i++)
    cin >> str[i];
cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// BOJ 3048 개미
#include <iostream>
#include <vector>
 
using namespace std;
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int n1, n2, cnt;
    cin >> n1 >> n2;
    int size = n1 + n2;
    vector<char> str(size);
    // 방향 구분을 위해 ->는 소문자 <- 는 대문자로 입력
    for (int i = 1; i <= n1; i++) {
        cin >> str[n1 - i];
        str[n1 - i] = str[n1 - i] - 'A' + 'a';
    }
    for (int i = n1; i < size; i++)
        cin >> str[i];
    cin >> cnt;
 
    while (cnt--) {
        for(int i = 1; i < size; i++){
            // -> <- 일 경우 스왑
            if(str[i-1] >= 'a' && str[i-1] <= 'z'
                && str[i] >= 'A' && str[i] <= 'Z'){
                char tmp = str[i-1];
                str[i-1] = str[i];
                str[i] = tmp;
                i++; // 탐색을 했으므로 스킵
            }
        }
    }
    for (auto i : str) {
        if (i >= 'a' && i <= 'z')
            cout << char(i + 'A' - 'a');
        else
            cout << i;
    }
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 11559 Puyo Puyo

노랑펭귄 — Thu, 20 Sep 2018 19:04:15 +0900

문제링크 : https://boj.kr/11559

1. 블럭은 4개 이상 모였을 때 터짐

2. 동시에 터지는 것은 하나의 연쇄 단계임

3. 한 연쇄 단계에 블럭이 터진 이후 중력에 의해 블럭이 아래로 내려감

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
// BOJ 11559 Puyo Puyo
#include <iostream>
#include <queue>
#include <cstring>
 
using namespace std;
 
char arr[14][8];
bool visited[14][8];
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, -1, 1};
 
struct pt {
    int x, y;
};
int p = 0; // 현재 탐색 위치
 
bool puyo(pt input) {
    int ix = input.x;
    int iy = input.y;
    char ans = arr[ix][iy]; // 탐색할 문자
    if(ans == '.')
        return false;
    queue<pt> Q; // BFS를 위한 큐
    queue<pt> memory; // 탐색한 노드 저장
    Q.push(input);
    memory.push(input);
    visited[ix][iy] = true;
    int cnt = 0;
    while (!Q.empty()) {
        pt cur = Q.front();
        Q.pop();
        int x = cur.x;
        int y = cur.y;
        memory.push({x, y});
        cnt++;
        for (int i = 0; i < 4; i++) {
            int a = x + dx[i];
            int b = y + dy[i];
            if (arr[a][b] == ans && !visited[a][b]) {
                visited[a][b] = true;
                memory.push({a, b});
                Q.push({a, b});
            }
        }
    }
 
    // 4개 이상 같은 색 발견시 뿌요 가능
    if (cnt >= 4) {
        while (!memory.empty()) {
            pt del = memory.front();
            memory.pop();
            arr[del.x][del.y] = '.';
        }
        return true;
    } else
        return false;
}
 
// 중력에 의해 블럭 아래로
void bDown() {
    int M = 0; // 열 좌표
    while (++M <= 6) {
        if(arr[12][M] == 'X')
            continue;
        int N = 12; // 행 좌표
        bool flag = false;
        for (int i = 12; i >= 1; i--) {
            // 빈 공간이 아니라면
            if (arr[i][M] != '.') {
                flag = true;
                // 블럭 아래로 내림
                char tmp = arr[i][M];
                arr[i][M] = '.';
                arr[N--][M] = tmp;
            }
        }
        // 블럭을 찾지 못하였다면 X로 표시하여
        // 다음 탐색때부턴 스킵
        if (!flag)
            arr[12][M] = 'X';
    }
}
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    memset(arr, 'X', sizeof(arr));
 
    for (int i = 1; i <= 12; i++)
        cin >> arr[i] + 1;
 
    int result = 0;
    bool isPuyo = false;
    while (true) {
        if(++p > 6 && isPuyo){
            result++;
            // 다음 뿌요를 위하여 visited 초기화
            memset(visited, false, sizeof(visited));
            // 블럭 아래로 떨어뜨리고
            // 다시 처음부터 진행
            bDown();
            isPuyo = false;
            p = 0;
            continue;
        }
        else if(p > 6 && !isPuyo)
            break;
        // 현재 열에 블럭이 없다면 continue
        if (arr[12][p] == 'X' || arr[12][p] == '.')
            continue;
        for(int i = 12; i >= 1; i--) {
            if (puyo({i, p})) {
                isPuyo = true;
            }
        }
    }
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 6359 만취한 상범

노랑펭귄 — Thu, 20 Sep 2018 16:08:53 +0900

문제링크 : https://boj.kr/6359

DP 문제라고 한다.

왜 DP 문제인지는 잘 모르겠지만 DP로 풀지 않으면 정말 쉽게 풀린다.

N이 5라고 가정하고 시뮬레이션을 해보자.

0은 문이 닫힌 상태를 1은 문이 열린 상태를 의미한다.

맨 처음

0 0 0 0 0

1라운드

1 1 1 1 1

2라운드

1 0 1 0 1

3라운드

1 0 0 0 1

4라운드

1 0 0 1 1

5라운드

1 0 0 1 0

이쯤 하면 규칙을 찾을 수 있다.

각 라운드에 해당하는 숫자만큼의 배수를 찾아서 1 → 0 / 0 → 1 으로 바꿔주면 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// BOJ 6359 만취한 상범
#include <iostream>
#include <vector>
 
using namespace std;
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    int tc, num;
    cin >> tc;
    while (tc--) {
        cin >> num;
        vector<bool> prison(num + 1, false);
        for(int i = 1; i <= num; i++)
            for(int j = i; j <= num; j += i)
                prison[j] = !prison[j];
 
        int result = 0;
        for(int i = 1; i <= num; i++)
            result += prison[i];
        cout << result << '\n';
    }
 
    return 0;
}
Colored by Color Scripter
cs

N = 100 까지를 미리 구하면 DP? 라고 할 수도 있겠다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// BOJ 6359 만취한 상범
#include <iostream>
 
using namespace std;
 
bool prison[101];
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int tc, num;
    cin >> tc;
    
    for(int i = 1; i <= 100; i++)
        for(int j = i; j <= 100; j += i)
            prison[j] = !prison[j];
    
    while (tc--) {
        cin >> num;
        int result = 0;
        for(int i = 1; i <= num; i++)
            result += prison[i];
        cout << result << '\n';
    }
    return 0;
}
Colored by Color Scripter
cs

하지만, 뭔가 아쉽다. N을 10으로 해서 다른 단순한 규칙이 없나 찾아보자.

0 - 0 0 0 0 0 0 0 0 0 0

1 - 1 1 1 1 1 1 1 1 1 1

2 - 1 0 1 0 1 0 1 0 1 0

3 - 1 0 0 0 1 1 1 0 0 0

4 - 1 0 0 1 1 1 1 1 0 0

5 - 1 0 0 1 0 1 1 1 0 1

6 - 1 0 0 1 0 0 1 1 0 1

7 - 1 0 0 1 0 0 0 1 0 1

8 - 1 0 0 1 0 0 0 0 0 1

9 - 1 0 0 1 0 0 0 0 1 1

10- 1 0 0 1 0 0 0 0 1 0

만취한 상범이의 미친 짓을 수행할 때 마다 문이 열리고 닫히는 것은 계속 수행하다보면

전 라운드의 값을 메모이제이션 할 수 있는 것을 알 수 있다.

이를 토대로 DP로 풀면 된다.

하지만, 또 다른 규칙을 발견할 수 있는데..

N라운드 시행 이후 문이 열려있는 감옥은 우연히도 제곱수인 것을 확인할 수 있다...!

0 - 1 2 3 4 5 6 7 8 9 10

0 - 0 0 0 0 0 0 0 0 0 0

1 - 1 1 1 1 1 1 1 1 1 1

2 - 1 0 1 0 1 0 1 0 1 0

3 - 1 0 0 0 1 1 1 0 0 0

4 - 1 0 0 1 1 1 1 1 0 0

5 - 1 0 0 1 0 1 1 1 0 1

6 - 1 0 0 1 0 0 1 1 0 1

7 - 1 0 0 1 0 0 0 1 0 1

8 - 1 0 0 1 0 0 0 0 0 1

9 - 1 0 0 1 0 0 0 0 1 1

10- 1 0 0 1 0 0 0 0 1 0

결론은.. N보다 작은 제곱수가 몇개인지만 구하면 된다.

N을 루트 씌우고 소수점을 떼면... 답이 나온다.

DP로 풀어도 되지만 DP로 푸는 것보다 훨씬 간단하다.

// BOJ 6359 만취한 상범
#include <iostream>
#include <cmath>
using namespace std;
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    int tc, num;
    cin >> tc;
    while (tc--) {
        cin >> num;
        cout << int(sqrt(num)) << '\n';
    }
 
    return 0;
}

Colored by Color Scripter

카카오프렌즈 라이언 에어팟 케이스 후기

노랑펭귄 — Thu, 20 Sep 2018 15:35:16 +0900

카카오프렌즈 라이언 에어팟 케이스!!!

에어팟 순정 케이스는 너무 치실통처럼 보인다.

~~치실통의~~ 새 옷을 입혀주기 위해서 구매했다! 그것도 라이언으로!

제품 패키징 후면

포장은 이렇게 되어있다.

빈틈 없이 아주 잘 맞음

하단 부분에 잘 보면 라이트닝 단자 보호 캡이 존재한다.

약간의 생활 방수를 기대해볼 수 있겠다.

보호캡이 없는 엘라고 제품과의 비교

카카오프렌즈 에어팟 케이스는 타사 케이스처럼 키링 옵션이 없는게 아쉬운 점

때가 잘 안타는 검은색으로 구매했는데 먼지가 묻으면 다른 색상에 비해 잘보인다.

다만, 맨들맨들한 재질의 케이스라서 생각보다 먼지가 잘 털어지는 것은 장점!

하늘색 후드라이언을 살걸 그랬나 생각이 들기도 하지만 검은색 라이언도 예쁘다!!!

[C++] 백준 BOJ 1010 다리 놓기

노랑펭귄 — Wed, 19 Sep 2018 22:04:21 +0900

문제링크 : https://boj.kr/1010

이 문제는 M개의 사이트에 N개의 다리를 놓는 가지수를 구하면 되는 문제로 조합을 이용하여 풀었다.

MCN = M! / ((M-N)! * N!) 을 구현하면 된다.

6C4를 구하는 경우 (6*5*4*3*2*1) / ( (2*1) * (4*3*2*1) ) 인데 (4*3*2*1)에 해당하는 N!이 약분되어 (6*5) / (2*1)인 것을 중학교때 많이 배웠을 것이다. (M-N)!과 N! 중에서 더 많은 숫자를 제거할 수 있는 값을 고르면 되고 이를 그대로 식으로 표현하면 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// BOJ 1010 다리 놓기
#include <bits/stdc++.h>
 
using namespace std;
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int tc;
    cin >> tc;
    while (tc--) {
        int n, m;
        long long result = 1;
        cin >> n >> m;
 
        // nCr을 위해 n-r과 r 중에 작은 값 선택
        n = n > m - n ? m - n : n;
        // nCr
        for (int i = 0; i < n; i++)
            result *= m - i; // n! / (n-r)! 또는 r!
        for (int i = 2; i <= n; i++)
            result /= i; // r! 또는 (n-r)!
        cout << result << '\n';
    }
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 1929 소수 구하기

노랑펭귄 — Wed, 19 Sep 2018 00:38:52 +0900

문제링크 : https://boj.kr/1929

BOJ 2581 소수 문제랑 완전 동일한 문제라고 할 수 있다.

소수는 어떤 수 N의 약수가 1과 자기 자신만 가지는 숫자를 의미한다.

소수를 구하는 것은 정말 어렵지만 '판별'은 가능하다.

자기 자신보다 작은 정수 중에서 약수가 존재하는지를 2~N까지 반복하면 된다.

하지만, 약수는 N의 제곱근 보다 큰 숫자는 절대로 나올 수 없다. N의 제곱근 보다 큰 정수에 어떤 정수를 곱하면 이미 N보다 커지기 때문이다. 따라서 N의 제곱근 범위까지만 구하면 된다.

하지만 이 방법은 소수를 판별하는 방법이지 소수를 구하는 방법이 아니다.

어떤 범위의 숫자가 주어졌을때 소수인지 아닌지를 판별하려면 1~N의 제곱근 까지 계산해야 하는데 이 것을 주어진 범위만큼 반복해야 하기 때문에 소수 리스트를 미리 구해놓고 구하는 편이 빠른 연산 방법이다.

소수 리스트를 구하는 방법은 에라토스테네스의 체를 이용하여 구하였다.

미리 구해둔 소수 리스트를 통해서 소수인지 아닌지를 판별하면 더 빨리 구할 수 있다.

또다른 방법으로는 N의 제곱근까지만 소수 리스트를 구해서 그 소수 리스트들에 있는 숫자로 자기 자신이 나누어 떨어질 수 있는가만 구해도 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// BOJ 1929 소수 구하기
#include <bits/stdc++.h>
 
using namespace std;
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    int M, N;
    cin >> M >> N;
    vector<bool> isPrime(N + 1, true); // 소수 리스트
    bool chk = false;
 
    // 에라토스테네스의 체 이용하여 N까지의 소수 구하기
    isPrime[0] = false;
    isPrime[1] = false;
    for (int i = 2; i <= N; i++) {
        if (isPrime[i]) {
            // 소수의 N배수들은 모두 소수가 아님
            for (int j = 2 * i; j <= N; j += i)
                isPrime[j] = false;
        }
    }
 
    for(int i = M; i <= N; i++)
        if(isPrime[i])
            cout << i << '\n';
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 3055 탈출

노랑펭귄 — Tue, 18 Sep 2018 22:57:04 +0900

문제링크 : https://boj.kr/3055

BFS를 이용하여 풀이한 시뮬레이션 문제이다.

다른 사람들 이야기를 들어보면 굳이 BFS를 이용하고 풀지 않아도 되는 것 같다.

(물이 차오르는 시간들을 저장한 배열을 따로 만들면 되는듯 하다.)

아무튼 이 풀이는 BFS!!

BFS로 풀이를 고려한다면

1. 고슴도치가 비버굴을 찾기 위한 BFS

2. 물이 차오르는 BFS

동시에 2개의 BFS를 돌려야 한다.

하지만, 문제의 조건에서 '고슴도치는 물이 찰 예정인 칸으로 이동할 수 없다.'라고 하였기 때문에

물이 차오르는 BFS를 먼저 선행하고 고슴도치의 BFS를 후행하는 식으로 돌리면 된다.

그렇게 하기 위해선 같은 큐 안에 '물'을 먼저 넣어서 돌리고 '고슴도치'를 뒤이어서 넣으면 된다.

입력시 물일 경우 큐에 넣고 고슴도치는 따로 저장해둔다.

'물' BFS가 먼저 선행되어야하기 때문이다.

1
2
3
4
5
6
7
8
9
10
11
for (int i = 1; i <= N; i++) {
    for (int j = 1; j <= M; j++) {
        cin >> arr[i][j];
        if (arr[i][j] == 'S') {
            go = {'S', i, j, 0}; // 고슴도치
            visited[i][j] = true;
            arr[i][j] = '.'; // 고슴도치 자리를 빈공간으로
        } else if (arr[i][j] == '*')
            Q.push({'*', i, j, 0}); // 물을 큐에 넣음
    }
}
Colored by Color Scripter
cs

현재의 노드가 '물'이고 인접 노드가 '빈공간'일 경우 물이 차오를 수 있는 조건이 성립한다.

1
2
3
4
if (cur.type == '*' && arr[nx][ny] == '.') {
    arr[nx][ny] = '*';
    Q.push({'*', nx, ny, cur.t + 1});
}
Colored by Color Scripter
cs

현재의 노드가 '고슴도치'이고 인접 노드가 '빈공간'이면서 방문하지 않았을 경우 고슴도치의 이동이 가능하다.

1
2
3
4
5
else if (cur.type == 'S' && arr[nx][ny] == '.'
         && !visited[nx][ny]) {
    visited[nx][ny] = true;
    Q.push({'S', nx, ny, cur.t + 1});
}
Colored by Color Scripter
cs

현재의 노드가 '고슴도치'이고 인접 노드에 '비버굴'이 있다면 결과를 출력한다.
1
2
3
4
5
// 고슴도치면서 비버굴
else if (cur.type == 'S' && arr[nx][ny] == 'D') {
    cout << cur.t + 1;
    exit(0);
}
Colored by Color Scripter
cs

고슴도치가 이동할 수 없는 위치일 경우를 나타낸 조건문이다.

사실 이 문장은 제외하여도 결과를 도출하는 데에는 전혀 상관 없다.

다만, 고슴도치가 더 이상 이동하지 못하는 시점에 바로 탈출하기 때문에 시간을 먼지만큼 줄일 수 있다.

1
2
3
4
5
6
7
8
9
// 현재 큐가 물인데 다음 큐가 고슴도치가 아니면서
// 시간대는 다음 단계라면
// == 고슴도치가 큐에서 아예 사라졌을 때
// == 더 이상 고슴도치가 이동할 곳이 없을 때
if (cur.type == '*' && Q.front().type != 'S'
    && (cur.t < Q.front().t)) {
    cout << "KAKTUS";
    exit(0);
}
Colored by Color Scripter
cs

큐에서 출력이 안되었을지도 모르므로 return 전에 "KAKTUS" 출력 구문을 넣어줬다.

1
2
3
4
    cout << "KAKTUS";
 
    return 0;
}
cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
// BOJ 3055 탈출
#include <iostream>
#include <vector>
#include <queue>
 
using namespace std;
 
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
 
struct pt {
    char type; // S = 고슴도치 * = 물
    int x, y, t;
};
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    // . 비어있는곳
    // * 물차있는곳
    // X 돌
    // D 비버굴 (목적지)
    // S 고슴도치
 
    int N, M;
    cin >> N >> M;
    vector<vector<char> > arr(N + 2, vector<char>(M + 2, 'X'));
    vector<vector<bool> > visited(N + 2, vector<bool>(M + 2, false));
 
    pt go; // 고슴도치
    queue<pt> Q;
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= M; j++) {
            cin >> arr[i][j];
            if (arr[i][j] == 'S') {
                go = {'S', i, j, 0}; // 고슴도치
                visited[i][j] = true;
                arr[i][j] = '.'; // 고슴도치 자리를 빈공간으로
            } else if (arr[i][j] == '*')
                Q.push({'*', i, j, 0}); // 물을 큐에 넣음
        }
    }
    // 고슴도치 큐에 넣음
    Q.push(go);
 
    while (!Q.empty()) {
        pt cur = Q.front();
        Q.pop();
        int x = cur.x;
        int y = cur.y;
 
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            // 물일 경우
            if (cur.type == '*' && arr[nx][ny] == '.') {
                arr[nx][ny] = '*';
                Q.push({'*', nx, ny, cur.t + 1});
            }
            // 고슴도치일 경우
            else if (cur.type == 'S' && arr[nx][ny] == '.'
                     && !visited[nx][ny]) {
                visited[nx][ny] = true;
                Q.push({'S', nx, ny, cur.t + 1});
            }
            // 고슴도치면서 비버굴
            else if (cur.type == 'S' && arr[nx][ny] == 'D') {
                cout << cur.t + 1;
                exit(0);
            }
        }
 
        // 현재 큐가 물인데 다음 큐가 고슴도치가 아니면서
        // 시간대는 다음 단계라면
        // == 고슴도치가 큐에서 아예 사라졌을 때
        // == 더 이상 고슴도치가 이동할 곳이 없을 때
        if (cur.type == '*' && Q.front().type != 'S'
            && (cur.t < Q.front().t)) {
            cout << "KAKTUS";
            exit(0);
        }
    }
    cout << "KAKTUS";
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 1547 공

노랑펭귄 — Tue, 18 Sep 2018 18:58:17 +0900

https://boj.kr/1547

간단한 시뮬레이션 문제로 배열의 value를 swap을 해주기만 하면 끝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// BOJ 1547 공
#include <iostream>
 
using namespace std;
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
    int cup[] = {0, 1, 0, 0};
    int cnt;
    cin >> cnt;
    while(cnt--){
        int a, b, tmp;
        cin >> a >> b;
        tmp = cup[a];
        cup[a] = cup[b];
        cup[b] = tmp;
    }
    int result = 0;
    while(!cup[++result]);
    cout << result;
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 3190 뱀

노랑펭귄 — Tue, 18 Sep 2018 16:42:26 +0900

문제링크 : https://boj.kr/3190

N*N의 정사각 보드에 빈칸은 0, 사과는 1, 뱀은 2로 표시해주었다.

뱀이 이동할 때 꼬리부터 없어진다는 규칙 때문에 뱀의 몸통은 큐(Queue)를 이용하여 저장하면 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
// BOJ 3190 뱀
#include <iostream>
#include <vector>
#include <queue>
 
using namespace std;
 
// 방향변화
const int dx[] = {0,1,0,-1};
const int dy[] = {1,0,-1,0};
 
struct pt{
    int x, y;
};
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int size, apple;
    cin >> size >> apple;
    vector<vector<int> > arr(size + 1, vector<int>(size + 1, 0));
 
    int a, b;
    while(apple--){
        cin >> a >> b;
        arr[a][b] = 1; // 사과
    }
 
    int x = 1, y = 1;
    arr[x][y] = 2; // 뱀
    int dir = 0; // 머리 방향
    queue<pt> snake; // 뱀 몸통
    snake.push({x,y});
 
    int cnt, time;
    char cmd;
    int result = 0;
    cin >> cnt >> time;
    while(true) {
        result++;
        x += dx[dir], y += dy[dir]; // 좌표 증감
        // 벽, 뱀 몸통일 경우 출력 후 exit
        if (x < 1 || y < 1 || x > size || y > size
            || arr[x][y] == 2) {
            cout << result;
            break;
        }
            // 빈칸일 경우 꼬리 제거
        else if (arr[x][y] == 0) {
            pt t = snake.front();
            snake.pop();
            arr[t.x][t.y] = 0; // pop 좌표 값을 빈칸으로
        }
        // 머리 추가
        arr[x][y] = 2;
        snake.push({x, y});
 
        if (result == time) {
            cin >> cmd;
            if(--cnt) // 다음 시간
                cin >> time;
            // 방향 전환
            if (cmd == 'L')
                dir = --dir < 0 ? 3 : dir;
            else
                dir = ++dir > 3 ? 0 : dir;
        }
    }
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 14499 주사위 굴리기

노랑펭귄 — Tue, 18 Sep 2018 01:27:44 +0900

문제링크 : https://boj.kr/14499

이 문제는 약간의 노가다 문제라고 할 수 있겠다.

주사위를 굴릴 때마다 주사위에 써진 숫자의 순서가 뒤바뀌기 때문이다.

방향이 전환 되었을 때마다 어떻게 바뀌는지 전개도를 직접 바꿔보면 아래와 같이 표현 가능하다.

이러한 전개도를 기반으로 다음과 같이 배열을 만들어주고

1
2
3
4
5
6
7
const int s[5][6] = {
    {1, 2, 3, 4, 5, 6}, // 0 기본
    {4, 2, 1, 6, 5, 3}, // 1 동쪽
    {3, 2, 6, 1, 5, 4}, // 2 서쪽
    {5, 1, 3, 4, 6, 2}, // 3 북쪽
    {2, 6, 3, 4, 1, 5}  // 4 남쪽
};
cs

주사위가 재배치 되었을때 재배치 작업을 거쳐주면 된다.

1
2
3
4
5
6
7
void update(int dir) {
    int tmp[6];
    for (int i = 0; i < 6; i++)
        tmp[i] = dice[i];
    for (int i = 0; i < 6; i++)
        dice[s[dir][i] - 1] = tmp[i];
}
Colored by Color Scripter
cs

이 작업이 생각보다 머리아프고 숫자 실수하게 되면 정말 골치아프게 되버리니 신중하게 작성해야 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
// BOJ 14499 주사위 굴리기
#include <iostream>
#include <vector>
 
using namespace std;
 
int x, y; // 좌표
int dice[6]; // 주사위
vector<vector<int> > arr; // 지도
 
// 전개도
const int s[5][6] = {
        {1, 2, 3, 4, 5, 6}, // 0 기본
        {4, 2, 1, 6, 5, 3}, // 1 동쪽
        {3, 2, 6, 1, 5, 4}, // 2 서쪽
        {5, 1, 3, 4, 6, 2}, // 3 북쪽
        {2, 6, 3, 4, 1, 5}  // 4 남쪽
};
 
const int dx[5] = {0, 0, 0, -1, 1};
const int dy[5] = {0, 1, -1, 0, 0};
 
// 명령 후 주사위 재배치
void update(int dir) {
    int tmp[6];
    for (int i = 0; i < 6; i++)
        tmp[i] = dice[i];
    for (int i = 0; i < 6; i++)
        dice[s[dir][i] - 1] = tmp[i];
}
 
// 복사
void copy() {
    if (arr[x][y] == 0)
        arr[x][y] = dice[5];
    else {
        dice[5] = arr[x][y];
        arr[x][y] = 0;
    }
}
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int N, M, num;
    cin >> N >> M >> x >> y >> num;
 
    arr.assign(N + 2, vector<int>(M + 2, -1));
 
    for (int i = 1; i <= N; i++)
        for (int j = 1; j <= M; j++)
            cin >> arr[i][j];
 
    x++, y++; // 계산 편의상 1씩 추가
 
    copy(); // 맨 처음 위치 복사
    int cmd, xx, yy;
    while (num--) {
        cin >> cmd;
        xx = x + dx[cmd];
        yy = y + dy[cmd];
        // 맵 범위 체크
        if (arr[xx][yy] == -1)
            continue;
        else
            x = xx, y = yy; // 좌표 업데이트
        update(cmd); // 주사위 업데이트
        copy(); // 복사
        cout << dice[0] << '\n'; // 맨 위에 있는 값 출력
    }
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 11048 이동하기

노랑펭귄 — Mon, 17 Sep 2018 23:47:32 +0900

문제링크 : https://boj.kr/11048

위 그림과 같이 3방향으로 이동하면서 경로 상의 최대 값을 찾는 문제이다.

단계를 계속 진행해서 마지막까지 가게 되면 계산이 가능한 방향은 위 그림처럼 된다.

DP 식으로 표현해보면 다음과 같이 표현 가능하다.

DP[N][M] = MAX (DP[N-1][M], DP[N][M-1], DP[N-1][M-1]) + 자기자신값

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// BOJ 11048 이동하기
#include <iostream>
#include <vector>
 
using namespace std;
 
int max(int a, int b) {
    return a > b ? a : b;
}
 
int max(int a, int b, int c) {
    return max(max(a, b), c);
}
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int N, M, input;
    cin >> N >> M;
    vector<vector<int> > dp(N + 1, vector<int>(M + 1, 0));
 
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= M; j++) {
            cin >> input;
            dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + input;
        }
    }
    cout << dp[N][M];
 
    return 0;
}
Colored by Color Scripter
cs

Codeforces Round #509 (Div. 2) 후기

노랑펭귄 — Sun, 16 Sep 2018 21:41:33 +0900

처음으로 코드포스의 시스템을 경험해보았다.

일단 해커랭크처럼 영어로 되어 있기 때문에 해석하는 데에 약간의 시간이 걸리는 것은 어쩔 수 없는 모양.. ㅠㅠ

첫 도전의 결과는 너무 참담했다.. 겨우 2문제

B번 문제도 50분만에 겨우 풀었는데 예외 조건을 제대로 생각하지 못해서 시간을 너무 많이 썼다.

예외 찾는데만 문제 풀이 시간만큼을 더 써버렸으니..

A. Heist

사실 너무 쉬운 문제인데 문제 이해 + 해석 덕분에 약간 시간을 잡아 먹은듯 하다.

주어진 숫자를 오름차순으로 정렬한 다음 중간 중간 비어있는 숫자 간격이 몇인지 누적해서 체크하면 쉽게 구할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Codeforces Round #509 (Div. 2)
// A. Heist
#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int num, result = 0;
    cin >> num;
    vector<int> arr(num);
    for (int i = 0; i < num; i++)
        cin >> arr[i];
    sort(arr.begin(), arr.end());
    for (int i = 1; i < num; i++)
        result += arr[i] - arr[i - 1] - 1;
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

B. Buying a TV set

주어진 TV ratio를 일단 기약분수 꼴로 만드는 것이 핵심이다.

그리고 그 기약분수 형태가 주어진 범위 안에 속하는 모든 ratio를 구하면 풀 수 있다.

1
2
3
4
5
6
7
8
9
ul gcd(ul a, ul b) {
    ul c;
    while (b != 0) {
        c = a % b;
        a = b;
        b = c;
    }
    return a;
}
cs

여기서 한가지 팁은 그 gcd로 나눈 몫을 그대로 활용하는 것이다.

1
2
3
ul num = gcd(x, y);
ul a = x / num, b = y / num;
ul result = num;
cs

만약 이 숫자를 사용하지 않고 오로지 gcd의 배수 만으로 값을 구하려 한다면 시간초과가 난다.

1
2
3
4
5
while(x > w || y > h){
    result--;
    x -= a;
    y -= b;
}
cs

그리고 x와 y가 입력 범위의 숫자보다 작거나 같은 조건을 만족해야 하기 때문에 gcd 만큼 빼주면서 범위를 한정시켜야한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// Codeforces Round #509 (Div. 2)
// B. Buying a TV set
#include <iostream>
 
using namespace std;
typedef unsigned long long ul;
 
ul gcd(ul a, ul b) {
    ul c;
    while (b != 0) {
        c = a % b;
        a = b;
        b = c;
    }
    return a;
}
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
    ul w, h, x, y;
    cin >> w >> h >> x >> y;
    ul num = gcd(x, y);
    ul a = x / num, b = y / num;
    ul result = num;
    while(x > w || y > h){
        result--;
        x -= a;
        y -= b;
    }
    while (true) {
        x += a;
        y += b;
        if(x <= w && y <= h)
            result++;
        else
            break;
    }
    cout << result;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 14503 로봇 청소기

노랑펭귄 — Fri, 14 Sep 2018 20:21:45 +0900

문제링크 : https://boj.kr

시뮬레이션 문제로 주어진 조건에 맞게 그대로 풀어내려가면 되는 문제이다.

문제 접근 방법은 DFS 방식이랑 크게 차이 없지만 DFS로 풀면 스택이 계속 쌓이기 때문에 이렇게 푸는 편이 더 좋지 않을까 생각한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// BOJ 14503 로봇 청소기
#include <iostream>
#include <vector>
 
using namespace std;
 
struct pt{
    int x, y, d;
};
 
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
 
void turn(int& dir){
    dir = --dir < 0 ? 3 : dir; // 왼쪽 회전
}
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    // freopen("../input.txt", "r", stdin);
 
    int N, M;
    int x, y;
    int nx, ny;
    int dir; // 0-북 1-동 2-남 3-서
    int ans = 0;
    cin >> N >> M >> x >> y >> dir;
    x++, y++; // 계산 편의상 1씩 더함
    vector<vector<int> > map(N + 2, vector<int>(M + 2, 1));
    for(int i = 1; i <= N; i++)
        for (int j = 1; j <= M; j++)
            cin >> map[i][j];
 
    while(true){
        // 현재 위치를 청소한다.
        if(map[x][y] == 0){
            map[x][y] = 2;
            ans++;
        }
        bool chk = false;
        // 현재 위치에서 현재 방향을 기준으로
        // 왼쪽방향부터 차례대로 탐색을 진행한다.
        for(int i = 0; i < 4; i++) {
            turn(dir);
            nx = x + dx[dir];
            ny = y + dy[dir];
            // 왼쪽 방향에 아직 청소하지 않은 공간이 존재한다면,
            if (map[nx][ny] == 0) {
                // 그 방향으로 회전한 다음 한 칸을 전진하고 1번부터 진행한다.
                chk = true; // 1번으로 가기 위한 플래그 변수
                x = nx;
                y = ny;
                break;
            }
        }
        if(chk) // 1번 ㄱㄱ
            continue;
        // 반대방향
        nx = x - dx[dir];
        ny = y - dy[dir];
        // 네 방향 모두 청소가 이미 되어있거나 벽인 경우에는,
        // 바라보는 방향을 유지한 채로 한 칸 후진을 하고 2번으로 돌아간다.
        if(map[nx][ny] != 1){
            x = nx;
            y = ny;
            continue;
        }
        // 네 방향 모두 청소가 이미 되어있거나 벽이면서,
        // 뒤쪽 방향이 벽이라 후진도 할 수 없는 경우에는 작동을 멈춘다.
        else
            break;
    }
    cout << ans;
 
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 7562 나이트의 이동

노랑펭귄 — Fri, 14 Sep 2018 18:56:27 +0900

문제링크 : https://boj.kr/7562

(시작점) -> (끝점)까지 나이트가 갈 수 있는 경로의 최단거리를 구하는 문제로 이동 가능한 8방향으로 BFS를 돌리면 풀 수 있다.

장애물 없이 오로지 도달만 하면 되기 때문에 방문 체크를 위한 배열 visited만 선언해주었다.

방문 조건은 (0,0) ~ (len-1, len-1)의 범위로만 한정하였다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
// BOJ 7562 나이트의 이동
#include <iostream>
#include <queue>
#include <vector>
 
using namespace std;
 
const int dx[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const int dy[] = {-1, 1, -2, 2, -2, 2, -1, 1};
 
struct pt {
    int x, y, cnt;
 
    pt() {
        cnt = 0;
    }
 
    pt(int a, int b, int c) {
        x = a, y = b, cnt = c;
    }
};
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
    int tc;
    cin >> tc;
    while (tc--) {
        int len, ans;
        cin >> len;
        vector<vector<int> > visited(len, vector<int>(len, false));
        pt S, E;
        cin >> S.x >> S.y;
        cin >> E.x >> E.y;
        visited[S.x][S.y] = true;
        queue<pt> Q;
        Q.push(S);
        while (!Q.empty()) {
            pt cur = Q.front();
            Q.pop();
            if (cur.x == E.x && cur.y == E.y) {
                ans = cur.cnt;
                break;
            }
            for (int i = 0; i < 8; i++) {
                int x = cur.x + dx[i];
                int y = cur.y + dy[i];
                if ((x >= 0 && x < len && y >= 0 && y < len)
                    && !visited[x][y]) {
                    visited[x][y] = true;
                    Q.push({x, y, cur.cnt + 1});
                }
            }
        }
        cout << ans << '\n';
    }
    return 0;
}
Colored by Color Scripter
cs

[C++] 백준 BOJ 9465 스티커

노랑펭귄 — Thu, 13 Sep 2018 12:08:36 +0900

문제링크 : https://boj.kr/9465

DP 문제로 아래의 3가지 케이스로 계산할 수 있다.

case 1.

o x

x o

case 2.

o x x

x x o

case 3.

x x o x

o x x o

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// BOJ 9465 스티커
#include <iostream>
#include <vector>
 
int max(int a, int b) {
    return a > b ? a : b;
}
int max(int a, int b, int c){
    return max(max(a, b), c);
}
 
using namespace std;
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("../input.txt", "r", stdin);
 
    int tc;
    cin >> tc;
    while (tc--) {
        int num;
        cin >> num;
 
        vector<vector<int> > arr(3, vector<int>(num + 1, 0));
        vector<vector<int> > dp(3, vector<int>(num + 1, 0));
 
        for(int n = 1; n <= 2; n++)
            for (int i = 1; i <= num; i++)
                cin >> arr[n][i];
 
        dp[1][1] = arr[1][1];
        dp[2][1] = arr[2][1];
 
        for(int i = 3; i <= num; i++){
            dp[1][i] = max(dp[2][i-2], dp[1][i-2] + arr[2][i-1],
                dp[1][i-3] + arr[2][i-1]) + arr[1][i];
            dp[2][i] = max(dp[1][i-2], dp[2][i-2] + arr[1][i-1],
                dp[2][i-3] + arr[1][i-1]) + arr[2][i];
        }
 
        cout << max(dp[1][num], dp[2][num]) << '\n';
    }
 
    return 0;
}
Colored by Color Scripter
cs

[여의도 맛집] 새싹 왕돌판구이 - 고기만 시키면 다 주는 혜자 고기집!!

노랑펭귄 — Wed, 12 Sep 2018 19:15:06 +0900

오늘 소개할 곳은 비빔밥 전문점 '새싹'이다.

하지만 난 여기서 비빔밥을 먹지 않았다.

점심에 가면 비빔밥을 판매하고 저녁에 가면 고기를!! 판다.

국회의사당 근처에 어떤 건물 상가 2층에 위치한 곳으로 생각보다 찾기가 어려운 곳이다.

하지만 숨어있는 만큼 정말 맛집이라고 추천할 수 있는 곳!!!!!

오늘 주문할 메뉴는 바로 이 왕돌판구이!!!!!

가격대는 아주 양호한 편에 속한다.

하지만, 삼겹살 1인분에 15,000원??

비싸다고 생각이 들 수 있지만 막상 시켜보면 전혀 아니다!!

이게 바로 그 왕돌판구이다.

막상 차림상을 보면 이것저것 꽤나 고기 말고도 부수적인 반찬들이 상당히 많아보인다.

지글지글

고기가 거의 다 익을 때 쯤 김치찌개와 계란찜을 서비스로 준다.

그리고 된장국 밑에 막창과 껍데기를!!!! 서비스로 깔아준다.

너무 맛있게 먹어서 막창이랑 껍데기는 찍지 못했다 ㅠ.ㅠ

치즈 계란후라이도 서비스!!!!!

무엇보다 좋은건 여기는 처음부터 끝까지 사장님이 다 구워준다!

냉면? 한 젓가락도 주고

다 먹을때 쯤 되면 후식으로 과일도 이렇게 준다.

여의도에 위치한 대부분의 식당들의 가격대가 상당히 높은 편이지만 이 집은 1인분에 15,000원이면서

삼겹살에 껍데기, 막창, 계란찜, 치즈 계란후라이 등등.. 푸짐하게 메뉴가 나오기 때문에 1인분만 시켜놓고 정말 배불리 먹을 수 있었던 것 같다. (원래 고기집가면 항상 1.5인분~2인분만 주문하는데도 불구하고 정말 배불리 먹었다.)

물가 높은 여의도 임에도 추천하고 싶은 맛집!! 인정

국회의사당 근처에 위치하고 있으며 아래 지도 위치에 있는 건물 2층에 있다.

[C++] 백준 BOJ 2805 나무 자르기

노랑펭귄 — Tue, 11 Sep 2018 12:30:05 +0900

문제링크 : https://boj.kr/2805

1. 동적계획법(DP)을 이용한 풀이법 : 시간복잡도 O(N)

나무의 길이가 제일 큰 것부터 시작하여 한단계씩 내려오면서 누적 합이 입력에서 주어진 값보다 클 때까지 구하는 방법으로 풀었다.

입력 받은 값들을 내림차순으로 정렬하고 맨 첫번째 인덱스에 해당하는 값부터 시작하여 1씩 높이를 빼가면서 계산했다.

나무의 높이(arr[N])가 기준 높이(result)보다 높은 부분 까지만 인덱스를 탐색하고 기준 높이 이하(arr[N] - result)가 0 이하인 값들)가 나오면 현재 누적 잘린 나무들의 합이 정답보다 작다면 계속 루프를 진행한다.

이때, 높이를 1씩 빼게되면 현재까지 진행해왔던 나무들의 높이가 각각 1씩 추가되기 때문에 sum += ptr 구문을 넣어 더해줬다.

그림으로 설명하자면 아래와 같이 설명할 수 있다.

회색은 이전 루프에서 누적된 값 (sum)

노란색은 현재 루프에서 누적된 값 (sum += arr[ptr++] - result)

초록색은 다음 루프로 넘어갈 때 추가되는 값 (sum += ptr)

여기서 노란색 ptr은 루프 끝나는 부분의 인덱스이며

초록색 ptr은 루프 시작 부분의 인덱스를 의미한다.

++이 후위연산(postfix)이기 때문에 현재 루프를 탈출하기 전에는 노란색 인덱스, 다음 루프때 ++이 되어 초록색 인덱스가 된다.

(답이 나올 때까지 반복)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// BOJ 2805 나무 자르기
#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>
using namespace std;
 
int main() {
    // freopen("input.txt", "r", stdin);
    ios_base::sync_with_stdio(false);
    int num, legnth;
    cin >> num >> legnth;
    vector<int> arr(num);
    for (int i = 0; i < num; i++)
        cin >> arr[i];
    sort(arr.begin(), arr.end(), greater<int>());
    int sum = 0;
    int result = arr.front() - 1;
    int ptr = 0;
    while (true) {
        while (arr[ptr] - result > 0)
            sum += arr[ptr++] - result;
        if (sum < legnth) {
            result--;
            sum += ptr;
        }
        else {
            break;
        }
    }
    cout << result;
 
    return 0;
}        
Colored by Color Scripter
cs

2. 이진탐색(Binary Search)를 추가로 적용한 풀이법 : 시간복잡도 O(logN)

위에서 정답을 찾기 위해서 맨 큰 숫자부터 시작하여 1씩 줄여가면서 찾았기 때문에 최악의 경우는 N번을 모두 실행해야 하기 때문에 O(N)임을 알 수 있다.

하지만, 이진탐색 기법을 추가로 적용한다면 정답의 가능성이 있는 부분만 취하고 나머지 절반은 버리는 식으로 계속 탐색을 하기 때문에 탐색 횟수를 훨씬 줄일 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// BOJ 2805 나무 자르기
#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>
 
using namespace std;
 
int main() {
    // freopen("input.txt", "r", stdin);
    ios_base::sync_with_stdio(false);
    int num, length;
    cin >> num >> length;
    vector<int> arr(num);
    for (int i = 0; i < num; i++)
        cin >> arr[i];
    sort(arr.begin(), arr.end(), greater<int>());
 
    int top = arr.front();
    int mid = 0;
    int btm = 0;
    int result = 0;
 
    while (btm < top) {
        long long sum = 0;
        mid = (top + btm) / 2;
        for (int i = 0; i < num && arr[i] - mid > 0; i++)
            sum += arr[i] - mid;
        if (sum < length) {
            top = mid;
        } else {
            result = mid;
            btm = mid + 1;
        }
    }
    cout << result;
 
    return 0;
}        
Colored by Color Scripter
cs

DP를 적용하지 않고 풀어도 수행시간은 의미있는 수치만큼의 차이는 없다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// BOJ 2805 나무 자르기
#include <iostream>
#include <vector>
 
using namespace std;
 
int main() {
    // freopen("input.txt", "r", stdin);
    ios_base::sync_with_stdio(false);
    int num, length;
    cin >> num >> length;
    vector<int> arr(num);
 
    int top = 0;
    int mid = 0;
    int btm = 0;
    int result = 0;
    
    for (int i = 0; i < num; i++) {
        cin >> arr[i];
        top = max(top, arr[i]);
    }
    
    while (btm < top) {
        long long sum = 0;
        mid = (top + btm) / 2;
        for (int i = 0; i < num; i++)
            if(arr[i] - mid > 0)
                sum += arr[i] - mid;
        if (sum < length) {
            top = mid;
        } else {
            result = mid;
            btm = mid + 1;
        }
    }
    cout << result;
 
    return 0;
}        
 
Colored by Color Scripter
cs

수행시간 비교

1. DP

2. 이진탐색