2019년 5월 14일. 과제에 시달리며 살던 저는 처음으로 코딩 공부를 하기위해 "Hello World" 를 외치며 백준으로 뛰어들었습니다.

 

단 몇개월만에 icpc 예선에서 학교 1등을 차지하여 본선에 진출하기도 했고, 그외 몇몇 알고리즘 대회에서 수상하기도 했습니다.

대회에서 수상을 하면서 알고리즘 푸는것을 점점 좋아하게 되었습니다.

 

중간에 solved.ac 티어가 생겼고, 확인해보니 이미 플래티넘이던 기억과, 이후 회사다니면서 다이아를 찍었던 기억이 남아있습니다.

무엇보다도 제 인생에서 처음으로 무언가를 내세울 수 있고, 자랑할 수 있는게 생겨서 좋았습니다.

 

사람들은 저를 보면서

알고리즘에 미친사람,

잠이 오면 알고리즘 푸는사람,

개발하다가 화나면 알고리즘 푸는사람,

이렇게 부르고는 했습니다.

특히 ssafy 교육시간에 막히는 부분이 있을때 저는 백준을 키고 문제를 풀었습니다. 마음이 편안해지는 순간이었습니다.

팀원들은 이해를 못하는 눈치였습니다. 진짜 재밌는데..

 

저는 현재 1725일째 1일 1알고리즘을 실천 중입니다.

ssafy 프로젝트를 하던 중 막히는 부분이 발생하여 백준으로 시선을 돌렸고, solved.ac에 깃허브처럼 잔디를 심는 기능이 추가된 것을 발견했습니다.

저는 이건 해야지 하며 그날부터 바로 시작했습니다.

이후 취준생일때도, 취업을 하고나서도, 잠시 다른일을 하며 보내는 지금까지도 백준만큼은 놓지않고 1일 1알고리즘을 실천하고 있습니다.

 

https://www.acmicpc.net/board/view/165799

그리고 오늘 오후, 백준님의 서비스 종료 공지가 포스팅되었습니다.

2026년 4월 28일을 끝으로 서비스가 종료된다고 합니다.

 

처음 이 글을 봤을때 처음 들었던 생각은 "나 오늘 아직 안풀었는데" 였습니다. 그냥 그렇다고요.

그냥 멍한 느낌이었습니다. 제 얼마 안되는 개발 인생을 함께 보낸 친구같은 존재였기 때문이죠.

그런 친구를 갑자기 놓게되는건 정말 쉽지 않을거라고 생각합니다.

당분간은 오늘 백준 풀었는지 한번 확인해보고 아 섭종했지 하고 다시 닫는 일이 생길 것 같네요.

 

저도 벌써 입문한지 7년이 다되어가네요. 20대 중반부터 지금까지도 함께 하고있는 백준을 저도 덮어둘 때가 온 것 같습니다.

지금 저는 2950문제를 푼 상태입니다. 서비스 종료까지 남은 시간은 2주. 2주 내에 3000문제를 채우는 것을 목표로 막판 스퍼트를 해볼 생각입니다. 깔끔하잖아요.

너무 갑작스러운 공지라 아직까지도 전혀 실감이 나지않고 글을 쓰는 지금까지도 무슨 생각이 드는지 잘 모르겠습니다.

그저 돌아오실 날을 기다리면서 살아가려고 합니다.

 

백준 덕분에 행복했습니다. 감사합니다.

https://www.acmicpc.net/problem/14848

 

요즘 빠져있는 포함 배제 원리 문제입니다.

 

문제에 나와있는 게임의 규칙은

1. 정수 N과 크기가 K인 배열 A를 정한다.

2. 1 ~ N의 정수를 모두 종이에 적는다.

3. 배열 A의 정수를 하나씩 골라서 제거하고, 그 수의 배수를 종이에서 지운다.

4. 배열 A의 정수가 모두 제거될 때까지 3을 반복한다.

 

위 내용을 정리하면

1 ~ N의 정수 중에 배열 A의 정수들의 배수가 아닌 수의 갯수를 구해라.

라는 문제가 됩니다.

 

그러면 처음 생각해볼 수 있는건 배열 A의 정수를 하나씩 빼서 N / A[i]를 구하면 그게 A[i]의 배수의 갯수라고 볼 수 있습니다.

즉 N = 15, A = {3, 5}이면

3의 배수는 15/3 =5개, 5의 배수는 15/5 = 3개 이렇게 쉽게 구할 수 있습니다.

하지만 여기서 문제는 3의 배수와 5의 배수 모두 15가 포함된다는 것입니다.

그래서 이런 중복되는 것들을 추가로 더해줘야하는 작업이 필요합니다.

 

위 벤 다이어그램을 참고했을 때 A가 3의 배수, B가 5의 배수, A ∩ B가 15의 배수에 해당됩니다.

A ∪ B = A + B - A ∩ B가 되고, 이걸 이용하여 포함 배제 원리 문제에 접근할 수 있습니다.

여기서 수식만 봐도 겹치는 부분이 1개 (홀수)인 부분은 덧셈, 2개 (짝수)인 부분은 뺄셈 연산을 한다는 것을 알 수 있습니다.

 

그러면 정수들을 적절하게 조합해서 나온 수들의 최소공배수가 교집합 부분이라는 것을 알 수 있고, 최소공배수로 구할 수 있습니다.

그냥 곱하면 안되는 이유로 4, 6을 들 수 있습니다.

4 * 6 = 24인데 12도 4의 배수와 6의 배수 둘다 포함됩니다.

 

배열의 갯수는 K <= 15 입니다.

따라서 비트마스킹 사용이 가능합니다.

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
#include <iostream>
#define MAX 15
using namespace std;
typedef long long ll;
 
ll list[MAX];
ll N;
int K;
 
ll gcd(ll x, ll y) {
    return y ? gcd(y, x % y) : x;
}
 
ll lcm(ll x, ll y) {
    return x * y / gcd(x, y);
}
 
void func() {
    ll ret = 0;
    for (int i = 1; i < (1 << K); i++) {
        int cnt = 0;
        ll tmp = 1LL;
        bool flag = false;
        for (int j = 0; j < K; j++) {
            if (!(i & (1 << j))) continue;
            cnt++;
            tmp = lcm(tmp, list[j]);
            if (tmp > N) {
                flag = true;
                break;
            }
        }
        if (flag) continue;
 
        if (cnt & 1) ret += (N / tmp);
        else ret -= (N / tmp);
    }
    cout << N - ret << '\n';
}
 
void input() {
    cin >> N >> K;
    for (int i = 0; i < K; i++) {
        cin >> list[i];
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    func();
 
    return 0;
}
 cs

'algorithm > Inclusion-Exclusion Principal' 카테고리의 다른 글

boj 7121 Pencil Factory  (0) 2025.04.12

https://www.acmicpc.net/problem/7121

 

K일간 작업하여 N + 1의 배수일에는 페인팅 작업을, M + 1의 배수일에는 바니싱 작업을 하지 않고 쉽니다.

 

1. 페인팅과 바니싱을 모두 완료한 날

2. 페인팅과 바니싱 둘다 쉰 날

3. 페인팅만 완료한 날

4. 바니싱만 완료한 날

위 값들을 순서대로 구하는 문제입니다.

 

우선 작업을 언제 쉬었는지에 대해서는 전체 일수에서 처음 쉬는날인 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
#include <iostream>
using namespace std;
typedef long long ll;
 
ll N, M, K;
 
ll gcd(ll x, ll y) {
    return y ? gcd(y, x % y) : x;
}
 
ll lcm(ll x, ll y) {
    return x * y / gcd(x, y);
}
 
void func() {
    ll x = K / (N + 1);
    ll y = K / (M + 1);
    ll z = K / lcm(N + 1, M + 1);
    cout << K - x - y + z << ' ' << z << ' ' << y - z << ' ' << x - z << '\n';
}
 
void input() {
    cin >> N >> M >> K;
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    func();
 
    return 0;
}
 cs

'algorithm > Inclusion-Exclusion Principal' 카테고리의 다른 글

boj 14848 정수 게임  (0) 2025.04.17

https://www.acmicpc.net/problem/29721

 

문제 난이도는 쉬운 편이지만 cpp의 unordered_set에 대해 새롭게 알게된 부분이 있어서 정리해봅니다.

 

문제는 체스판 위에 놓여져 있는 다바바를 이동시킬 수 있는 칸이 몇 개인지 세기만 하면 됩니다.

다바바는 상하좌우로 2칸만 이동할 수 있으며 나이트처럼 경로에 위치한 다른 기물을 뛰어 넘을 수 있습니다.

 

체스판의 크기가 10만이므로 배열로는 해결할 수 없습니다.

set과 unordered_set 둘다 사용이 가능했지만 정렬이 필요없기에 unordered_set을 사용했습니다.

 

문제 로직은 간단합니다.

다바바는 맵 밖이나 다른 다바바가 위치한 좌표에는 갈 수 없으니 최초 다바바의 위치는 set에 미리 넣어둡니다.

이후에 상하좌우로 2칸씩 이동시켜서 set에 insert하고, 그 횟수를 구하면 됩니다.

 

set
unordered_set

확실히 메모리와 시간이 줄어드는 것을 확인할 수 있습니다.

 

 

저는 처음에는 set을 활용하여 문제를 풀었고, 시간을 줄이기 위해 unordered_set으로 바꾸는 도중에 컴파일 에러가 떴는데

unordered_set은 key를 해시화해서 사용하는데 pair에 대한 기본 해시 함수가 없기 때문에 발생한 에러였고, 해시 함수를 직접 정의를 해야했습니다.

 

1
2
3
4
5
struct pair_hash {
    size_t operator()(const pii& p) const {
        return hash<int>()(p.first) ^ hash<int>()(p.second);
    }
};
 cs

이런식으로 해시 함수를 직접 정의할 수 있습니다.

 

다만 이렇게 둔다면 p.first와 p.second가 비슷한 값이면 해시 충돌이 많이 발생한다고 합니다.

특히 이 문제에서는 상하좌우로 2칸씩만 이동하기 때문에 치명적인 문제가 될 수 있겠다는 생각이 들었습니다.

역시나 TLE가 떴습니다.

 

p.first나 p.second 둘 중 하나에 소수를 곱해준다면 충돌 확률을 낮추는 효과를 가져올 수 있습니다.

다만 너무 큰 숫자를 곱하게 되면 곱셈 연산에 소요되는 시간이 더 많이 발생할 수 있으니 적당한 수를 곱하는게 좋아보입니다.

그리고 양쪽 모두 소수를 곱하는 방법도 있는데 충돌은 줄어들겠지만 그만큼 곱셈 연산이 더 늘어나서 시간이 더 소요될 수 있습니다.

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
#include <iostream>
#include <vector>
#include <unordered_set>
#define MAX 100001
using namespace std;
typedef pair<int, int> pii;
 
struct pair_hash {
    size_t operator()(const pii& p) const {
        return hash<int>()(p.first) ^ (hash<int>()(p.second) * 31);
    }
};
 
unordered_set<pii, pair_hash> s;
vector<pii> v;
int direct[4][2] = { {2,0},{0,2},{-2,0},{0,-2} };
int N, K;
 
void func() {
    int ret = 0;
    for (auto xy : v) {
        int x = xy.first;
        int y = xy.second;
        for (int d = 0; d < 4; d++) {
            int nx = x + direct[d][0];
            int ny = y + direct[d][1];
 
            if (nx <= 0 || ny <= 0 || nx > N || ny > N) continue;
            if (s.find({ nx,ny }) != s.end()) continue;
 
            ret++;
            s.insert({ nx,ny });
        }
    }
 
    cout << ret << '\n';
}
 
void input() {
    int x, y;
    cin >> N >> K;
    for (int i = 0; i < K; i++) {
        cin >> x >> y;
        v.push_back({ x,y });
        s.insert({ x,y });
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    func();
 
    return 0;
}
 cs

 

 

'algorithm > data-structure' 카테고리의 다른 글

boj 15926 현욱은 괄호왕이야!!  (1) 2023.07.24
boj 21939 문제 추천 시스템 Version 1  (0) 2022.02.11
boj 17299 오등큰수  (0) 2021.02.22
boj 9372 상근이의 여행  (0) 2021.02.09
boj 1158 요세푸스 문제  (0) 2021.02.09

https://www.acmicpc.net/problem/27966

 

N개의 정점으로 이루어진 트리에서 i < j인 정점들 사이 거리가 최소가 되도록 하려면 어떤 트리를 만들어야하는지 구하는 문제입니다.

 

트리를 직접 그려보면 Star Graph 형식이 최소가 된다는 것을 알 수 있습니다.

Star Graph는 하나의 정점에 다른 모든 정점이 연결된 형태입니다.

 

이렇게되면 1번 정점과 연결된 다른 정점은 거리가 각각 1입니다. (N - 1)

나머지 정점들끼리의 거리는 각각 2입니다.

나머지 N - 1개의 정점에서 2개를 고르는 경우의 수는 N-1C2이며, 두개 곱하면 (N - 2) * (N - 1)이 됩니다.

위에서 구한 두 수를 더하면 N - 1 + (N - 2) * (N - 1) 이라는 답을 구할 수 있습니다.

 

스페셜 저지 문제이기 때문에 기준이 되는 정점을 아무거나 고르시면 됩니다. 저는 1번 정점을 기준으로 정했습니다.

그리고 기준이 되는 정점과 i를 반복해서 출력해주시면 되겠습니다.

 

 

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 <iostream>
using namespace std;
typedef long long ll;
 
ll N;
 
void func() {
    cout << N - 1LL + (N - 2LL) * (N - 1LL) << '\n';
    for (int i = 2; i <= N; i++) {
        cout << "1 " << i << '\n';
    }
}
 
void input() {
    cin >> N;
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    func();
 
    return 0;
}
 cs

'algorithm > ad-hoc' 카테고리의 다른 글

boj 7982 순열 그래프의 연결성 판별  (0) 2024.08.16
boj 16161 가장 긴 증가하는 팰린드롬 부분수열  (0) 2024.08.15
boj 24553 팰린드롬 게임  (0) 2024.08.07
boj 14370 전화번호 수수께끼 (Large)  (0) 2024.08.06
boj 21316 스피카  (0) 2024.08.05

https://www.acmicpc.net/problem/7982

 

순열 그래프는 N개의 정점이 1 ~ N의 번호가 하나씩 구성되어 있습니다.

그리고 두 정점 쌍 i, j (1 ≤ i < j ≤ n) 는 ai > aj 일때 간선으로 연결되어 있습니다.

4
2 3 1 4

순열이 이렇게 주어졌을 때  2, 3 > 1이므로 (1, 2), (1, 3)이 각각 연결되어 있고

(1, 2, 3) (4) 로 집합을 나눌 수 있습니다.

 

여기서 알 수 있는건 i번째 까지 순회했을때 max가 i이면 해당 위치까지 하나의 집합으로 묶을 수 있습니다.

위의 예시로 보면

3번 인덱스까지의 max가 3이므로 1, 2, 3을 집합으로 묶을 수 있고, 4번 인덱스까지의 max가 4이므로 4를 집합으로 묶을 수 있습니다.

이전 집합의 max값을 유지해주면서 배열을 순회하면 정답을 구할 수 있습니다.

 

 

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
#include <iostream>
#include <vector>
#include <algorithm>
#define MAX 1000001
using namespace std;
 
vector<int> v;
int list[MAX];
int N;
 
void func() {
    int maxValue = 0;
    for (int i = 1; i <= N; i++) {
        maxValue = max(maxValue, list[i]);
        if (i == maxValue) v.push_back(i);
    }
 
    int pre = 0;
    cout << v.size() << '\n';
    for (auto x : v) {
        cout << x - pre << ' ';
        for (int i = pre + 1; i <= x; i++) cout << i << ' ';
        cout << '\n';
        pre = x;
    }
}
 
void input() {
    cin >> N;
    for (int i = 1; i <= N; i++) {
        cin >> list[i];
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    func();
 
    return 0;
}
 cs

'algorithm > ad-hoc' 카테고리의 다른 글

boj 27966 △  (0) 2024.08.22
boj 16161 가장 긴 증가하는 팰린드롬 부분수열  (0) 2024.08.15
boj 24553 팰린드롬 게임  (0) 2024.08.07
boj 14370 전화번호 수수께끼 (Large)  (0) 2024.08.06
boj 21316 스피카  (0) 2024.08.05

https://www.acmicpc.net/problem/16161

 

팰린드롬은 앞/뒤에서 읽었을 때 같은 수열입니다.

이 문제에서는 증가하는 팰린드롬을 구해야 합니다.

 

1, 2, 3, 4, 3, 2, 1
1, 3, 6, 7, 7, 6, 3, 1

이런것처럼 중앙으로 갈수록 값이 커지는 것이 증가하는 팰린드롬 수열입니다.

 

1, 2, 4, 3, 2, 1
4, 3, 2, 3, 4
1, 1, 1, 1

 

 

증가하는 팰린드롬이 아닌 경우는

1. 애초에 팰린드롬이 아닌 경우

2. 팰린드롬이지만 값이 증가하지 않는 경우 (값이 같아도 x)

이렇게 두가지가 되겠습니다.

 

저는 중앙을 먼저 정해놓고 한칸씩 이동하여 팰린드롬의 길이를 직접 구해봤습니다.

팰린드롬의 길이에 따라 중앙은 1개 or 2개가 될 수 있습니다.

따라서 l번째 수와 l + 1번째 수가 같으면 묶어서 중앙으로 두고 구할 수 있습니다.

이후에는 그냥 왼쪽, 오른쪽으로 한칸씩 이동하면서 증가하는 팰린드롬인지 확인해주시고, 최대 길이를 갱신해주시면 됩니다.

 

그리고 이 문제가 "증가하는 팰린드롬"이기 때문에 하나 더 생각할 수 있는건

s ~ e 범위의 팰린드롬을 찾았다고 했을 때, list[s], list[e]은 해당 팰린드롬에서 항상 가장 작은 수를 담당하고 있습니다.

그렇기 때문에 e번째 수에서 왼쪽으로 이동하더라도 큰 수가 있을 수밖에 없고, 더 큰 범위의 팰린드롬을 찾을 수 없습니다.

따라서 중앙값인 l, r을 +1씩 볼 필요 없이 s ~ e 범위의 다음 인덱스부터 다시 확인해주시면 불필요한 계산 없이 정답을 구할 수 있습니다.

 

 

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
#include <iostream>
#include <algorithm>
#define MAX 100001
using namespace std;
 
int list[MAX];
int N;
 
void func() {
    int l = 0;
    int ret = 1;
    while (l < N) {
        int r = l;
        if (r + 1 < N && list[l] == list[r + 1]) r++;
 
        int s = l - 1;
        int e = r + 1;
        while (s >= 0 && e < N) {
            if (list[s] != list[e] || list[s] >= list[s + 1]) break;
            e++;
            s--;
        }
 
        ret = max(ret, e - s - 1);
        l = e;
    }
    cout << ret << '\n';
}
 
void input() {
    cin >> N;
    for (int i = 0; i < N; i++) {
        cin >> list[i];
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    func();
 
    return 0;
}
 cs

'algorithm > ad-hoc' 카테고리의 다른 글

boj 27966 △  (0) 2024.08.22
boj 7982 순열 그래프의 연결성 판별  (0) 2024.08.16
boj 24553 팰린드롬 게임  (0) 2024.08.07
boj 14370 전화번호 수수께끼 (Large)  (0) 2024.08.06
boj 21316 스피카  (0) 2024.08.05

https://www.acmicpc.net/problem/1756

 

오븐의 깊이에 따라 피자가 들어갈 수 있는 크기가 다릅니다.

오븐에 피자를 위에서부터 차례대로 쌓는 방식인데 중간에 크기가 좁은 오븐을 만나면 더이상 내려갈 수 없습니다.

따라서 오븐의 크기를 먼저 조정해줄 수 있습니다.

 

5 6 4 3 6 2 3

오븐의 크기가 위에서부터 이렇게 주어진다면

위에서부터 최솟값을 갱신한다면

 

5 5 4 3 3 2 2

이렇게 바뀌게되고, 크기가 같거나 작아지는 수열이 됩니다.

그러면 위에서부터 크기가 맞는 높이를 계속 찾아줄 필요 없이 밑에서부터 맞는 크기를 찾아주면 됩니다.

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
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <iostream>
#include <algorithm>
#define MAX 300001
using namespace std;
 
int width[MAX];
int list[MAX];
int N, M;
 
void func() {
    int idx = N;
    for (int i = 0; i < M; i++) {
        bool flag = false;
        while (idx > 0) {
            if (width[idx] >= list[i]) {
                idx--;
                flag = true;
                break;
            }
            idx--;
        }
        if (!flag) {
            cout << "0\n";
            return;
        }
    }
    cout << idx + 1 << '\n';
}
 
void input() {
    cin >> N >> M;
    for (int i = 1; i <= N; i++) {
        cin >> width[i];
        if (i > 1) {
            width[i] = min(width[i], width[i - 1]);
        }
    }
 
    for (int i = 0; i < M; i++) {
        cin >> list[i];
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    func();
 
    return 0;
}
 cs

'algorithm > Implementation' 카테고리의 다른 글

boj 3758 KCPC  (0) 2024.06.09
boj 17143 낚시왕  (0) 2021.04.23
boj 20207 달력  (0) 2021.04.22
boj 17144 미세먼지 안녕!  (0) 2021.04.14
boj 2564 경비원  (0) 2021.04.13

https://www.acmicpc.net/problem/24553

 

N개의 돌 중에 팰린드롬 수만큼의 돌을 가져갈 수 있으며, 마지막에 모든 돌을 가져가는 사람이 이깁니다.

 

우선 1 ~ 9는 팰린드롬이므로 무조건 먼저하는 사람이 이깁니다.

N = 10이라면 1 ~ 9개를 가져가더라도 9 ~ 1개는 무조건 남기 때문에 먼저하는 사람이 집니다.

그리고 N = 11 ~ 19는 1 ~ 9를 적절하게 뺀다면 다음 사람에게 10을 넘겨줄 수 있으므로 무조건 이길 수 있습니다.

이런식으로 간다면 10의 배수가 아닐때는 무조건 선공이 이긴다는 것을 알 수 있습니다.

0으로 시작하는 수는 없으므로 10의 배수는 팰린드롬이 올 수 없으므로 다른건 고려하지 않아도 됩니다.

 

 

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
#include <iostream>
using namespace std;
typedef long long ll;
 
ll N;
 
void func() {
    if (N % 10) cout << "0\n";
    else cout << "1\n";
}
 
void input() {
    cin >> N;
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    int tc;
    cin >> tc;
    while (tc--) {
        input();
        func();
    }
 
    return 0;
}
 cs

'algorithm > ad-hoc' 카테고리의 다른 글

boj 7982 순열 그래프의 연결성 판별  (0) 2024.08.16
boj 16161 가장 긴 증가하는 팰린드롬 부분수열  (0) 2024.08.15
boj 14370 전화번호 수수께끼 (Large)  (0) 2024.08.06
boj 21316 스피카  (0) 2024.08.05
boj 10350 Banks  (0) 2024.07.31

https://www.acmicpc.net/problem/14370

 

안그래도 문자열에 약한데 애드혹까지 섞이니 뇌정지가 오는 문제였습니다.

우선 문자열이 섞여있는 채로 저장되어있고,  문자열이 어떤 수들로 구성되어 있는지 파악해야 합니다.

그러면 각 숫자들의 고유한 알파벳을 구해서 카운팅하는 방법을 떠올릴 수 있습니다.

 

0 2 4 6 8은 각각 고유한 알파벳이 있습니다.

0 - Z

2 - W

4 - U

6 - X

8 - G

 

그리고 이들을 제외한 숫자들 중 고유한 알파벳을 뽑으면

3 - H

5 - F

7 - S

9 - I

1 - 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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include <iostream>
#include <string>
#include <cstring>
#define MAX 10
using namespace std;
 
string str;
string alpha[MAX] = { "ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE" };
pair<int, char> ch[MAX] = { {0,'Z'}, {2,'W'}, {4, 'U'}, {6, 'X'}, {8, 'G'}, {3,'H'}, {5, 'F'}, {7, 'S'}, {9, 'I'}, {1,'O'} };
int alphaCnt[26];
int cnt[MAX];
int len;
 
void solve() {
    for (auto c : ch) {
        while (alphaCnt[c.second - 'A']) {
            cnt[c.first]++;
            for (auto a : alpha[c.first]) {
                alphaCnt[a - 'A']--;
            }
        }
    }
}
 
void func(int tc) {
    for (auto x : str) {
        alphaCnt[x - 'A']++;
    }
    solve();
 
    cout << "Case #" << tc << ": ";
    for (int i = 0; i < MAX; i++) {
        while (cnt[i]--) {
            cout << i;
        }
    }
    cout << '\n';
}
 
void input() {
    cin >> str;
    len = str.size();
}
 
void init() {
    memset(cnt, 0, sizeof(cnt));
    memset(alphaCnt, 0, sizeof(alphaCnt));
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    int tc;
    cin >> tc;
    for (int t = 1; t <= tc; t++) {
        input();
        func(t);
        init();
    }
 
    return 0;
}
 cs

'algorithm > ad-hoc' 카테고리의 다른 글

boj 16161 가장 긴 증가하는 팰린드롬 부분수열  (0) 2024.08.15
boj 24553 팰린드롬 게임  (0) 2024.08.07
boj 21316 스피카  (0) 2024.08.05
boj 10350 Banks  (0) 2024.07.31
boj 5527 전구 장식  (0) 2024.07.30

https://www.acmicpc.net/problem/21316

 

12개 간선이 입력으로 주어지고, 어떤 입력이든 이 모양으로 주어진다고 합니다.

여기서 Spica가 되는 정점의 조건은 주변 정점들과 간선들로 알아낼 수 있습니다.

 

저는 Spica에 인접한 정점들은 각각 1, 2, 3개의 간선이 있다는 것을 파악했고, 그대로 구현했습니다.

1, 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
#include <iostream>
#include <vector>
#define MAX 13
using namespace std;
 
vector<int> v[MAX];
 
void func() {
    for (int i = 1; i < MAX; i++) {
        int flag = 0;
        for (auto next : v[i]) {
            flag |= (1 << (v[next].size() - 1));
        }
 
        if (flag == 7) {
            cout << i << '\n';
            return;
        }
    }
}
 
void input() {
    int x, y;
    for (int i = 1; i < MAX; i++) {
        cin >> x >> y;
        v[x].push_back(y);
        v[y].push_back(x);
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    func();
 
    return 0;
}
 cs

'algorithm > ad-hoc' 카테고리의 다른 글

boj 24553 팰린드롬 게임  (0) 2024.08.07
boj 14370 전화번호 수수께끼 (Large)  (0) 2024.08.06
boj 10350 Banks  (0) 2024.07.31
boj 5527 전구 장식  (0) 2024.07.30
boj 14864 줄서기  (0) 2024.07.26

https://www.acmicpc.net/problem/4442

 

처음 주어지는 배열과 다르게 배치된 쌍의 갯수를 구하는 문제로 inversion counting 방식으로 접근할 수 있습니다.

inversion counting이란 순서가 바뀐 순서쌍을 구하는데 사용되는 기법입니다.

즉 자신보다 작지만 뒤에 몇 명이 서있는지 구한다거나 그런 문제들을 이 방식을 사용할 수 있습니다.

 

우선 입력이 문자열로 되어있으니 map을 활용하여 첫 번째 배열을 입력받는 순서대로 정수 인덱스로 변경해줍니다.

그 다음 두 번째 배열은 첫 번째 배열에서 구한 인덱스 번호로 변경합니다.

두 번째 입력에서 구한 정수 배열로 트리를 만들도록 합니다.

이 때 트리에 수를 넣어주면서 자신보다 크지만 먼저 들어온 수들의 갯수를 세어주면 됩니다.

배열이 2 3 1 순서대로 저장한다고 가정하면 1을 트리에 넣을때 이미 들어와있던 2, 3을 카운팅 해주는 것입니다.

 

일반적인 map을 사용한 코드의 채점현황입니다.

unordered_map으로 변경한 코드의 채점현황입니다.

이 문제처럼 순서가 중요하지 않고 조회가 많이 발생하는 경우 unordered_map을 사용하는게 더 효율적이라는 것을 알 수 있었습니다.

 

 

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
#include <iostream>
#include <unordered_map>
#include <string>
#include <cstring>
#define MAX 100001
using namespace std;
typedef long long ll;
 
unordered_map<string, int> m;
int idxList[MAX];
ll tree[MAX << 2];
int N;
 
void init() {
    m.clear();
    memset(tree, 0, sizeof(tree));
}
 
ll update(int node, int l, int r, int idx, int diff) {
    if (idx < l || r < idx) return tree[node];
    if (l == r) return ++tree[node];
 
    int m = (l + r) >> 1;
    return tree[node] = update(node << 1, l, m, idx, diff) + update((node << 1) + 1, m + 1, r, idx, diff);
}
 
ll query(int node, int l, int r, int s, int e) {
    if (l > e || r < s) return 0LL;
    if (s <= l && r <= e) return tree[node];
 
    int m = (l + r) >> 1;
    return query(node << 1, l, m, s, e) + query((node << 1) + 1, m + 1, r, s, e);
}
 
void func() {
    ll ret = 0LL;
    for (int i = 0; i < N; i++) {
        ret += query(1, 1, N, idxList[i] + 1, N);
        update(1, 1, N, idxList[i], 1);
    }
    cout << ret << '\n';
}
 
void input() {
    cin >> N;
    if (!N) exit(0);
    
    string str;
    int cnt = 0;
    for (int i = 0; i < N; i++) {
        cin >> str;
        m[str] = ++cnt;
    }
 
    for (int i = 0; i < N; i++) {
        cin >> str;
        idxList[i] = m[str];
    }
}
 
int main() {
    cin.tie(nullptr); cout.tie(nullptr);
    ios::sync_with_stdio(false);
 
    while (1) {
        input();
        func();
        init();
    }
 
    return 0;
}
 cs

'algorithm > SegmentTree' 카테고리의 다른 글

boj 8330 순열  (0) 2024.07.21
boj 1517 버블 소트  (0) 2024.06.16
boj 17131 여우가 정보섬에 올라온 이유  (3) 2024.04.25
boj 12895 화려한 마을  (0) 2022.09.07
boj 10167 금광  (0) 2022.09.02

+ Recent posts

티스토리툴바