Problem Solving on Jiho Kim

BOJ 24535 둘레길

Thu, 09 Apr 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/24535

🧐 관찰 및 접근
#

점이 500개가 주어진다.
적당한 사각형 하나를 잡아서, 사각형 위에 점이 최대로 올라가게 하자.
흠, 일단 좌표압축하면 x, y좌표 각각 500개로 줄일 수 있겠다.
나이브하게 돌리면? 대충 $O(N^4)$가 되는거같은데…
- 2초에 $N = 500$이니까, 세제곱까지만 줄여도 어떻게 될거같긴 하다.
변 하나를 결정하는 경우의수가 $O(N^3)$개 인거같고, 그때 나머지 변 세개 최댓값을 잘 하면 되는데..
- 이것도 아래서부터 잘 긁으면서 올라오면 될거같은데?
- 아니 50퍼에서 틀린다고?? 머지
  - 아하 세로 한줄로 오는거 약간 걱정했었는데 역시 오류가 있었다. 이것만 고치면 되네
  - 가로는 잘 처리 되더라

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<pii> points(N);
 vector<int> xs, ys;
 rep(i, 0, N){
 int x, y; cin >> x >> y;
 points[i] = {x, y};
 xs.push_back(x);
 ys.push_back(y);
 }
 sort(all(xs)); xs.erase(unique(all(xs)), xs.end());
 sort(all(ys)); ys.erase(unique(all(ys)), ys.end());

 rep(i, 0, N){
 points[i].first = lower_bound(all(xs), points[i].first) - xs.begin();
 points[i].second = lower_bound(all(ys), points[i].second) - ys.begin();
 }

 vector<vector<bool>> isPoint(xs.size(), vector<bool>(ys.size()));
 for(auto [x, y] : points) isPoint[x][y] = true;

 int ans = 0;
 vector<vector<int>> DP(ys.size(), vector<int>(ys.size()));
 rrep(i, 0, xs.size()){
 vector<vector<int>> cur_cnt(ys.size(), vector<int>(ys.size())); // cur_cnt[j][k] = j, k 사이에 있는 점의 개수
 rep(j, 0, ys.size()){
 if(isPoint[i][j]) cur_cnt[j][j]++;
 rep(k, j+1, ys.size()) cur_cnt[j][k] = cur_cnt[j][k-1] + isPoint[i][k];
 }

 rep(j, 0, ys.size()) rep(k, j+1, ys.size()){
 ans = max(ans, cur_cnt[j][k] + DP[j][k]);
 DP[j][k] = max(DP[j][k] + isPoint[i][j] + isPoint[i][k], cur_cnt[j][k]);
 }
 }

 // 세로 한줄 처리
 rep(i, 0, ys.size()){
 int cnt = 0;
 rep(j, 0, xs.size()) if(isPoint[j][i]) cnt++;
 ans = max(ans, cnt);
 }
 cout << ans;
}

🔒

구현 코드 잠금

BOJ 32527 Insane Drift

Thu, 09 Apr 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/32527

🧐 관찰 및 접근
#

$(0, 0) \rightarrow (X, Y)$ 로 이동해야한다.
과정을 최소화할 필요는 없는데, 4000번 안쪽으로 가야한다.
일단 음.. 다음과 같은 연산들을 추가로 정의할 수 있겠다.
- $a$개의 $R$을 사용해서 $x$ 좌표를 $2^a - 1$ 만큼 증가시킨다.
- $b$개의 $U$을 사용해서 $y$ 좌표를 $2^b - 1$ 만큼 증가시킨다.
- 한 연산을 반복해서 사용할 수는 없다.
- 위 연산을 아래에서는 각각 $A, B$ 연산이라고 하겠다.
예제 1번인 $(8, 3)$은 $(7+1, 3)$로 변환하면 된다는걸 알 수 있다.
관찰을 조금 더 해야할 것 같다.
- $A, B$ 연산의 횟수는 최대 1회 차이날 수 있다.
  - 번갈아가며 사용해야하므로
- $A ,B$ 연산의 결과는 언제나 홀수이다.
- 연산은 $a, b = 1$이 아닌 이상 3개로 쪼갤 수 있다.
  - 연산에 2개를 더하는건 쉽게 할 수 있다는 뜻
- 이건 직관인데, 그리디하게 가장 큰 연산을 가져가는게 될 수도 있지 않을까 싶다.
  - 21 = 15 + 3 + 3 = 7 + 7 + 7
  - 43 = 31 + 7 + 3 + 1 + 1 = 15 + 15 + 7 + 3 + 3
  - 음.. 되는거같은데 흠 이걸 어떻게 증명할 수 있지?
  - 뭔가 위에서 3개로 쪼개진다고 했듯이 31 = 15 + 15 + 1인데, 31을 안쓰면 15를 두번쓰는건 사실상 확정이고, 이때 뒤에있는 1을 훔쳐와서 두개를 줄이고 / 뒤에 1을 훔쳐오게되면서 2개가 늘어나면 또이또이고, 만약에 뒤에 1이 남아있었다면 하나 줄고 같은 느낌으로 그리디가 증명 될 것 같다.
믿고 짜볼까? 귀찮으니 PQ로 관리하자.
ㅋㅋㅋㅋ X, Y에 대해 같은 로직인데 함수화하기 귀찮아서 그대로 박았더니 코드가 더럽다…

💻 풀이
#

코드 (C++):

void solve(){
 vector<ll> int_to_op;
 int_to_op.push_back(0);
 while(int_to_op.back() < 1e18) int_to_op.push_back(int_to_op.back()*2 + 1);
 map<ll, int> op_to_int;
 rep(i, 0, int_to_op.size()) op_to_int[int_to_op[i]] = i;
 
 ll X, Y; cin >> X >> Y;
 priority_queue<ll> Xpq, Ypq;
 while(X){
 int ok = 0, ng = int_to_op.size();
 while(ng - ok > 1){
 int mid = (ok + ng) >> 1;
 if(int_to_op[mid] <= X) ok = mid;
 else ng = mid;
 }
 Xpq.push(ok);
 X -= int_to_op[ok];
 }
 while(Y){
 int ok = 0, ng = int_to_op.size();
 while(ng - ok > 1){
 int mid = (ok + ng) >> 1;
 if(int_to_op[mid] <= Y) ok = mid;
 else ng = mid;
 }
 Ypq.push(ok);
 Y -= int_to_op[ok];
 }
 while(abs((int)Xpq.size() - (int)Ypq.size()) > 1){
 if(Xpq.size() < Ypq.size()){
 if(Xpq.size() == 0 || Xpq.top() == 1){
 cout << "impossible";
 return;
 }
 ll top = Xpq.top(); Xpq.pop();
 Xpq.push(top-1);
 Xpq.push(top-1);
 Xpq.push(1);
 }
 else{
 if(Ypq.size() == 0 || Ypq.top() == 1){
 cout << "impossible";
 return;
 }
 ll top = Ypq.top(); Ypq.pop();
 Ypq.push(top-1);
 Ypq.push(top-1);
 Ypq.push(1);
 }
 }

 string ans = "";
 if(Xpq.size() >= Ypq.size()){
 while(!Xpq.empty() || !Ypq.empty()){
 rep(i, 0, Xpq.top()) ans += 'R';
 Xpq.pop();
 if(Ypq.empty()) break;
 rep(i, 0, Ypq.top()) ans += 'U';
 Ypq.pop();
 }
 }
 else{
 while(!Xpq.empty() || !Ypq.empty()){
 rep(i, 0, Ypq.top()) ans += 'U';
 Ypq.pop();
 if(Xpq.empty()) break;
 rep(i, 0, Xpq.top()) ans += 'R';
 Xpq.pop();
 }
 }
 if(ans.size() <= 4000) cout << ans;
 else cout << "impossible";
}

🔒

구현 코드 잠금

BOJ 11385 씽크스몰

Mon, 06 Apr 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/11385

🧐 관찰 및 접근
#

그냥 FFT의 정의대로, 두 다항식의 곱을 해서 계수들을 구해야한다.
그런데 값이… 너무 많이 커질 수 있다.
$N, M = 1000000$, 모든 $a, b = 1000000$이라면… $f(x) \times g(x)$의 $1000000$차항의 계수는 $10^{18}$이 되는 것 같다.
- 이건 FFT로 하면 실수오차가 너무 심할 것 같은데…
이럴때, NTT를 여러 소수 $p_1, p_2, \cdots$에 대해서 구해두고, 중국인의 나머지 정리를 이용해 원래 계수를 복원하는 방법을 생각할 수 있겠다.
- CRT를 사용하면, $\text{LCM}(m_1, m_2)$ 에 대한 모듈러 값을 얻을 수 있다.
- $p_1 = 998244353, p_2 = 1004535809$을 사용하면 $p_1p_2 > 10^{18}$이므로, 두개면 되겠다.

💻 풀이
#

코드 (C++):

void solve(){
 int N, M; cin >> N >> M; N++; M++;
 vector<int> f(N), g(M);
 rep(i, 0, N) cin >> f[i];
 rep(i, 0, M) cin >> g[i];

 int sz = 1;
 while(sz < N+M) sz <<= 1;

 vector<mint> A1(sz), A2(sz);
 rep(i, 0, N) A1[i] = f[i];
 rep(i, 0, M) A2[i] = g[i];
 FFT::ntt(A1);
 FFT::ntt(A2);
 rep(i, 0, sz) A1[i] *= A2[i];
 FFT::ntt(A1, true);

 vector<mint2> B1(sz), B2(sz);
 rep(i, 0, N) B1[i] = f[i];
 rep(i, 0, M) B2[i] = g[i];
 FFT::ntt(B1);
 FFT::ntt(B2);
 rep(i, 0, sz) B1[i] *= B2[i];
 FFT::ntt(B1, true);

 ll ans = 0;
 rep(i, 0, N+M-1){
 ll r1 = A1[i].val, r2 = B1[i].val;
 auto [x, m] = EGCD::CRT(MOD, r1, MOD2, r2);
 ans ^= x;
 }
 cout << ans;
}

🔒

구현 코드 잠금

BOJ 14958 Rock Paper Scissors

Sun, 05 Apr 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/14958

번역
#

문제
#

가위바위보(RPS) 기계가 있으며, 이 기계는 가위, 바위, 보 중 하나를 무작위로 생성한다. 당신도 비슷한 소형 가위바위보 기계를 가지고 있다. 게임 전에, RPS 기계는 길이 $n$의 가위바위보 선택 목록을 생성하고, 당신의 기계도 길이 $m$의 선택 목록을 생성한다. 즉, RPS 기계의 전체 선택 목록과 당신의 기계의 선택 목록을 모두 알고 있다. 물론, 각 기계의 선택은 세 가지 옵션(가위, 바위, 보) 중 하나이다.

BOJ 20176 Needle

Sat, 04 Apr 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/20176

번역
#

문제
#

“바늘"은 북쪽 왕국에 사는 전설적인 암살자이다. 알다시피, 바늘은 매우 가늘고 길다. 무엇보다, 치명적으로 날카롭다. 북쪽 왕국의 왕은 바늘이 수없이 찔러 자신을 죽일지도 모른다는 생각에 사로잡혀 있다. 왕은 바늘을 체포하라는 긴급 명령을 내렸다. 그리하여 바늘은 남쪽 왕국으로 탈출하기로 결심했다.

BOJ 25456 궁금한 시프트

Thu, 02 Apr 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/25456

🧐 관찰 및 접근
#

0과 1로 이루어진 두 문자열 $S, T$가 주어진다.
두 문자열에 시프트 연산이 가능하다고 할때, 합성곱의 최댓값을 구하자.
합성곱이므로 FFT를 의심해볼 수 있겠다.
0과 1로 이루어진 문자열을 다항식으로 해석하면 된다.
곱 결과가 같은 차수에 올 수 있도록 한 다항식의 계수들을 뒤집고, 시프트 연산을 위해 둘중 한 배열을 두배로 늘려서 계산하자.

💻 풀이
#

코드 (C++):

void solve(){
 string S, T;
 cin >> S >> T;
 int N = S.size();
 int sz = 1;
 while(sz < 3*N) sz <<= 1;
 vector<cd> A(sz), B(sz);
 rep(i, 0, N) if(S[i] == '1') A[i] = 1;
 rep(i, 0, N) if(S[i] == '1') A[i+N] = 1;
 rep(i, 0, N) if(T[i] == '1') B[N-1-i] = 1;
 FFT::fft(A);
 FFT::fft(B);
 rep(i, 0, sz) A[i] *= B[i];
 FFT::fft(A, true);
 int ans = 0;
 rep(i, N-1, 2*N-1) ans = max(ans, (int)round(A[i].real()));
 // rep(i, 0, 3*N) cout << i << ' ' << A[i] << '\n';
 cout << ans << '\n';
}

🔒

구현 코드 잠금

BOJ 32453 Efficient Slabstones Rearrangement

Sun, 22 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/32453

문제
#

Barbara는 정원을 가지고 있다. 정원은 길고 좁으며, 일렬로 배치된 $m$개의 동일한 크기의 구역으로 나뉘어 있다. 그녀의 친구 Babara는 생일 선물로 $n$개의 디딤돌을 주었다. Barbara는 이 디딤돌들을 정원에 배치하여 매일 디딤돌을 밟으며 즐길 수 있게 했다. $i$번째 디딤돌은 정원의 $l_i$번째부터 $r_i$번째 구역을 완전히 차지한다. 디딤돌들은 서로 겹치지 않으며, 어떤 두 디딤돌 사이에도 최소 $d$개의 빈 구역이 있다.

BOJ 5638 수문

Tue, 17 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/5638

🧐 관찰 및 접근
#

댐에 수문이 있고, 유량과 피해비용이 있는 것 같다.
피해비용은 여는 시간에 비례하지 않는 것 같다.
그러면 각 수문에 대해, 유량에 시간을 곱해서 각 수문이 버릴 수 있는 물의 양을 구할 수 있고, 그에 따른 가격이 나온다.
- 이건 그리디하게는 조금 곤란하고, 배낭 문제로 되나? 했는데, $V$가 너무 크다!
그런데 수문의 개수가 $n \leq 20$으로 유의미하게 작다. 각 테스트케이스에 대해 모든 수문을 열어보는 경우의 수를 수행할 수 있을 것 같다.
- 시간복잡도 $O(2^n \cdot nm)$ 정도에 동작할 것 같다.

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<pll> door(N);
 rep(i, 0, N) cin >> door[i].first >> door[i].second;
 int Q; cin >> Q;
 rep(q, 1, Q+1){
 ll V, T; cin >> V >> T;
 ll ans = 1e18;
 rep(bit, 0, 1<<N){
 ll wat = 0, cost = 0;
 rep(i, 0, N) if(bit & (1<<i)) wat += door[i].first*T, cost += door[i].second;
 if(wat >= V) ans = min(ans, cost);
 }
 cout << "Case " << q << ": ";
 if(ans == 1e18) cout << "IMPOSSIBLE\n";
 else cout << ans << '\n';
 }
}

🔒

구현 코드 잠금

BOJ 1739 도로 정비하기

Tue, 10 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/1739

🧐 관찰 및 접근
#

$(1, 1) \rightarrow (6, 6)$으로 가기 위해선 어때야 하지?
- $r_1, c_6$이 오른쪽 / 아래이거나, $c_1, r_6$이 아래 / 오른쪽이거나..
- 오른쪽 / 아래를 참, 왼쪽/위를 거짓이라고 생각하면,
- $(r_1 \land c_6) \lor (r_6 \land c_1)$ 같은 느낌인가?
- 이걸 어떻게 잘 하면 2-sat으로 바꿀 수 있을것같은데..
- $r6$이 아니라면, $r1, c6$이 참이어야하고, 이런 느낌으로 되는것같다.
- $(\neg r_6 \rightarrow r_1) \land (\neg r_6 \rightarrow c_6)$
  - 이런걸 4개에 대해서 하면 될거같은데?
$(r_1, c_1) \rightarrow (r_2, c_2)$ 라고 해보자.
- 일단 $r_1 < r_2, c_1 < c_2$라고 하자.
  - $(\neg r_1 \rightarrow r_2) \land (\neg r_1 \rightarrow c_1)$
  - $(\neg c_2 \rightarrow r_2) \land (\neg c_2 \rightarrow c_1)$
  - $(\neg r_2 \rightarrow r_1) \land (\neg r_2 \rightarrow c_2)$
  - $(\neg c_1 \rightarrow r_1) \land (\neg c_1 \rightarrow c_2)$
  - 이렇게 할 수 있을 것 같다.
- 그러면 $r_1 > r_2, c_1 > c_2$라면?
  - 똑같이 $r_1, c_2$의 경로를 이용하거나, $r_2, c_1$의 경로를 이용해야하는건 같다.
  - 그런데 왼쪽이라서 참이어야 하는게 아니라 목적지가 거짓이어야 한다.
  - $(\neg r_1 \land \neg c_2) \lor (\neg r_2 \land \neg c_1)$ 처럼 되어야할 것 같다.
  - 아하, 대소관계가 바뀌면 이게 낫으로 바뀐다. 이걸 이용해서 더 쉽게 구현이 될라나?
구현 실수하지 않게 조심하자.

💻 풀이
#

코드 (C++):

void solve(){
 int N, M, K; cin >> N >> M >> K;
 DirectedGraph tsat((N+M)*2);
 rep(i, 0, K){
 int r1, c1, r2, c2;
 cin >> r1 >> c1 >> r2 >> c2;
 r1--; c1--; r2--; c2--;
 r1 *= 2; r2 *= 2;
 c1 = (c1 + N) * 2;
 c2 = (c2 + N) * 2;

 if(r1 == r2 && c1 == c2) continue;
 if(r1 == r2){
 if(c1 < c2) tsat.add_edge(r1^1, r1);
 else tsat.add_edge(r1, r1^1);
 continue;
 }
 if(c1 == c2){
 if(r1 < r2) tsat.add_edge(c1^1, c1);
 else tsat.add_edge(c1, c1^1);
 continue;
 }

 if(c1 > c2) r1^=1, r2^=1;
 if(r1 > r2) c1^=1, c2^=1;

 tsat.add_edge(c1^1, r1);
 tsat.add_edge(c1^1, c2);
 tsat.add_edge(r2^1, r1);
 tsat.add_edge(r2^1, c2);
 tsat.add_edge(r1^1, r2);
 tsat.add_edge(r1^1, c1);
 tsat.add_edge(c2^1, r2);
 tsat.add_edge(c2^1, c1);
 }
 cout << (tsat.is2SAT() ? "Yes\n" : "No\n");
}

🔒

구현 코드 잠금

BOJ 11111 두부장수 장홍준 2

Sun, 08 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/11111

🧐 관찰 및 접근
#

대충봐도 격자그래프에서 MCMF같은데..
- 덜끊어도 되니까 MaxFlow가 아닌가?
- 아하 뒤집으면 된다
아하, Flow 자체도 다 보내기 전이 최적일수도 있는것만 잊지 말자

💻 풀이
#

코드 (C++):

void solve(){
 int N, M; cin >> N >> M;

 vector<vector<int>> costs = {
 {10, 8, 7, 5, 1},
 {8, 6, 4, 3, 1},
 {7, 4, 3, 2, 1},
 {5, 3, 2, 2, 1},
 {1, 1, 1, 1, 0}
 };

 vector<vector<int>> board(N, vector<int>(M));
 map<char, int> mp;
 mp['A'] = 0; mp['B'] = 1; mp['C'] = 2; mp['D'] = 3; mp['F'] = 4;
 rep(i, 0, N){
 string S; cin >> S;
 rep(j, 0, M) board[i][j] = mp[S[j]];
 }

 MinCostMaxFlow MCMF(N*M+2);
 MCMF.setST(N*M, N*M+1);
 vector<int> dx = {-1, 1, 0, 0}, dy = {0, 0, -1, 1};
 rep(i, 0, N) rep(j, 0, M){
 if((i+j)%2){
 MCMF.add(i*M+j, N*M+1, 1, 0);
 continue;
 }

 MCMF.add(N*M, i*M+j, 1, 0);
 rep(d, 0, 4){
 int nx = i + dx[d], ny = j + dy[d];
 if(nx < 0 || nx >= N || ny < 0 || ny >= M) continue;
 MCMF.add(i*M + j, nx*M + ny, 1, -costs[board[i][j]][board[nx][ny]]);
 }
 }
 cout << max(0LL, -MCMF.match());
}

🔒

구현 코드 잠금

BOJ 14587 도미노 (Large)

Sun, 08 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/14587

🧐 관찰 및 접근
#

전처리를 적당히 할 수 있을까?
- 이분탐색을 좀 하면서 밀면서 하면, 특정 도미노를 한쪽으로 밀었을때 어디까지 넘어가는지 할 수 있나?
- 아, min/max 세그먼트 트리로 되는거같다
마지막은 그리디가 아니라 DP로 해야한다!
아니근데 X가 정렬되어 주어지지 않는다;;;;; 그래도 구현이 막 어렵지 않은듯

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<ll> X(N), H(N);
 
 vector<pll> dominos(N);
 rep(i, 0, N) cin >> dominos[i].first >> dominos[i].second;
 sort(all(dominos));
 rep(i, 0, N){
 X[i] = dominos[i].first;
 H[i] = dominos[i].second;
 }

 SegmentTreeMinMax ST_min(N), ST_max(N);
 
 // calc leftmost
 ST_min.set(0, 0);
 rep(i, 1, N){
 ll val = X[i] - H[i];
 auto idx = lower_bound(all(X), val) - X.begin();
 auto Q = ST_min.query(idx, i-1);
 ST_min.set(i, min((ll)i, ST_min.query(idx, i-1).first));
 }
 
 // calc rightmost
 ST_max.set(N-1, N-1);
 rrep(i, 0, N-1){
 ll val = X[i] + H[i];
 auto idx = upper_bound(all(X), val) - X.begin() - 1;
 auto Q = ST_min.query(i+1, idx);
 ST_max.set(i, max((ll)i, ST_max.query(i+1, idx).second));
 }

 vector<int> DP(N, 1e9);
 DP[0] = 1;
 DP[ST_max.get_val(0)] = 1;
 rep(i, 1, N){
 int lft = ST_min.get_val(i)-1;
 if(lft < 0) DP[i] = 1;
 else DP[i] = min(DP[i], DP[lft] + 1);

 int rht = ST_max.get_val(i);
 DP[rht] = min(DP[rht], DP[i-1] + 1);
 }
 cout << DP[N-1];
}

🔒

구현 코드 잠금

BOJ 30478 Candy Rush

Sun, 08 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/30478

문제
#

러시아워입니다! 오늘 퇴근 후, 쇼핑몰이 닫기 전에 가족 모두에게 줄 사탕을 사야 합니다.

가족들은 독점성과 균일성을 매우 중요하게 여기기 때문에, 당신은 그들을 감동시키기 위한 계획을 세웠습니다. 각 가족 구성원에게 주는 사탕은 모두 단일 브랜드여야 하며, 동일한 브랜드의 사탕을 다른 가족 구성원이 받아서는 안 됩니다. 또한, 누군가를 더 사랑한다는 사실을 들키고 싶지 않기 때문에 모든 가족 구성원이 같은 수의 사탕을 받아야 합니다.

BOJ 30880 쿼리는 락이 아니다

Sun, 08 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/30880

🧐 관찰 및 접근
#

누가봐도 세그먼트트리 세팅인것같다. 금광같은거죠
노드 정의를 어떻게 하면 좋을까?
- 부분열이니까, R / O / C / K 개수는 당연히 있어야하고..
- ROCK 개수는 ROCK개수 + 왼쪽 R + 오른쪽 OCK, RO + CK, ROC + K,,
- 아하, R / RO / ROC / ROCK / O / OC / OCK / C / CK / K 다 세면 되나?
아 그런데, ROCK의 개수를 세는게 아니라 ROCK로 끝나는 문자열의 개수를 세야한다는건, 길이도 어떻게 잘 곱해야되는것같은데
- $XRRX$ 와 $XOCK$ 를 합친다고 생각해보자.
- 답은 $XRROCK, XROCK, XROCK, RROCK, ROCK, ROCK$로 6개인것 같다.
- 뒤에 $OCK$근처에서는 별 감흥이 없는 것 같고, 앞에있는 $R$들에 대해서만 상관이 있는 것 같다. 그 위치들에 대해, $2 + 4$ 해서 6이 나온 것 같다.
- 노드 안에서 $R$에 대해, $R$의 개수가 아니라 $R$로 끝나는 부분 문자열의 개수를 저장하는게 좋겠다.
- R, RO, ROC, ROCK에 대해서 그렇게 해주면 충분하다!

💻 풀이
#

코드 (C++):

struct Node{
 mint R = 0, RO = 0, ROC = 0, ROCK = 0, O = 0, OC = 0, OCK = 0, C = 0, CK = 0, K = 0;
 mint len = 0;
 mint ans = 0;
 Node(){};
 Node(char c){
 if(c == 'R') R += 1;
 if(c == 'O') O += 1;
 if(c == 'C') C += 1;
 if(c == 'K') K += 1;
 len = 1;
 };
};

Node pull(Node a, Node b){
	Node ret;
	ret.R = a.R + mint(2).pow(a.len.val)*b.R;
	ret.O = a.O + b.O;
	ret.C = a.C + b.C;
	ret.K = a.K + b.K;
	ret.RO = a.RO + mint(2).pow(a.len.val)*b.RO + a.R*b.O;
	ret.OC = a.OC + b.OC + a.O*b.C;
	ret.CK = a.CK + b.CK + a.C*b.K;
	ret.ROC = a.ROC + mint(2).pow(a.len.val)*b.ROC + a.RO*b.C + a.R*b.OC;
	ret.OCK = a.OCK + b.OCK + a.OC*b.K + a.O*b.CK;
	ret.ROCK = a.ROCK + mint(2).pow(a.len.val)*b.ROCK + a.ROC*b.K + a.RO*b.CK + a.R*b.OCK;
	ret.len = a.len + b.len;
	return ret;
}

void solve(){
 int N; cin >> N;
 string S; cin >> S;
 vector<Node> v(N);
 rep(i, 0, N) v[i] = Node(S[i]);
 SegmentTreeNode ST(N, v);

 int Q; cin >> Q;
 while(Q--){
 int op; cin >> op;
 if(op == 1){
 int idx; cin >> idx;
 char c; cin >> c;
 ST.set(idx-1, Node(c));
 }
 else{
 int l, r; cin >> l >> r;
 l--; r--;
 cout << ST.query(l, r).ROCK << '\n';
 }
 }
}

🔒

구현 코드 잠금

BOJ 11493 동전 교환

Sat, 07 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/11493

🧐 관찰 및 접근
#

동전들을 swap해서 잘 옮겨서 맞춰야한다..
- 일단 색을 모두 신경쓰긴 싫으니까, 1의 위치를 맞춘다고만 생각하자.
뭔가 이분그래프적으로 생각할 수 있지 않을까?
이게 움직이는것만 신경쓰면 플로이드워셜 + 이분그래프 매칭 최소비용…으로 하면 되는거같은데?
- 근데 swap이다보니 이렇게 맘대로 하는것보다 효율적인 방법이 무시될 것 같다.
일단 이분그래프로 생각을 좀 해보긴 하자. 그림을 그려보자.
- 그림 1의 예시이다. 어우 난잡해 ㅋㅋ
- 뭔가 증가경로 맛처럼 할 수 있는거같기는 한데..
- ….가 아니라 그냥 이상태로 최소비용 최대유량 아닌가? 끝이네?
이분그래프로 분할할 필요도 없이, 그냥 유량으로 달리면 된다.

💻 풀이
#

코드 (C++):

void solve(){
 int N, M; cin >> N >> M;
 MinCostMaxFlow MCMF(N+2);
 MCMF.setST(0, N+1);
 rep(i, 0, M){
 int u, v; cin >> u >> v;
 MCMF.add(u, v, 1e9, 1);
 MCMF.add(v, u, 1e9, 1);
 }
 rep(i, 1, N+1){
 int x; cin >> x;
 if(x == 1) MCMF.add(0, i, 1, 0);
 }
 rep(i, 1, N+1){
 int x; cin >> x;
 if(x == 1) MCMF.add(i, N+1, 1, 0);
 }
 cout << MCMF.match() << '\n';
}

🔒

구현 코드 잠금

BOJ 35108 게국지

Sat, 07 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/35108

🧐 관찰 및 접근
#

$N$이 2500이니까 뭔가 제곱로그?까진 돌지 않을까 싶다.
음, 어떻게 잡으면 좋을지 모르겠지만, 저 주어진 게국지 그래프에서 안쪽의 네모중 왼쪽 위부터 반시계방향으로 $1, 2, 3, 4$ 라고 하면, $2, 4$번 정점을 기준으로 카운팅하고싶게 생기긴 했다.
일단 예제 그래프를 그려보자.
- 여기서 저 게국지모양을 찾아야 하는데… $1, 2, 3, 4$를 기7준으로 하면 $1, 2, 4$에 $5, 7, 6$을 붙이거나, $6, 7, 5$를 연결하는 두가지가 있겠다.
어.. 정점을 기준으로 세려고 하니 좀 까다로운거 같기도..? 그러면 간선을 기준으로..?
- 그러면 아무래도 양쪽에 날개가 붙어있는 간선으로 생각하자.
- 크아아아악 이래도 안되는데
일단 두 간선을 골라서 사이클을 고정시키는건 맞는거같다.
- 잉 이러면 걍 포함배제로 되는거 아닌가?
  - 그러면 두 정점에 중복되는 정점, 세 정점에 중복되는 정점 뭐 그런게 필요한거같은데…
    - 비트셋으로 하면 될라나? $O(M^2N/64)$ 정도인거같은데;; 일단 짜보자
좀 빡빡하다. 전처리를 잘 하면 시간 내로 들어간다. Clang이 훨 빠르네. 왜지?

💻 풀이
#

코드 (C++):

void solve(){
 int N, M; cin >> N >> M;
 vector<pii> edges;
 vector<bitset<2500>> con(N);
 rep(i, 0, M){
 int u, v; cin >> u >> v;
 u--; v--;
 edges.push_back({u, v});
 con[u][v] = 1;
 con[v][u] = 1;
 }

 vector<ll> cnt1(N);
 rep(i, 0, N) cnt1[i] = con[i].count();

 vector<vector<bitset<2500>>> con2(N, vector<bitset<2500>>(N));
 rep(i, 0, N) rep(j, i+1, N) con2[i][j] = con2[j][i] = con[i]&con[j];
 vector<vector<ll>> cnt2(N, vector<ll>(N));
 rep(i, 0, N) rep(j, i+1, N) cnt2[i][j] = cnt2[j][i] = con2[i][j].count();
 

 auto calc = [&](int v1, int v2, int v3, int v4) -> ll {
 auto &b1 = con[v1], &b2 = con[v2], &b3 = con[v3];

 ll n1 = cnt1[v1] - (con[v1][v2] + con[v1][v3] + con[v1][v4]);
 ll n2 = cnt1[v2] - (con[v2][v1] + con[v2][v3] + con[v2][v4]);
 ll n3 = cnt1[v3] - (con[v3][v1] + con[v3][v2] + con[v3][v4]);

 ll n12 = cnt2[v1][v2] - (con2[v1][v2][v3] + con2[v1][v2][v4]);
 ll n23 = cnt2[v2][v3] - (con2[v2][v3][v1] + con2[v2][v3][v4]);
 ll n31 = cnt2[v3][v1] - (con2[v3][v1][v2] + con2[v3][v1][v4]);

 bitset<2500> b123 = b1&b2&b3;
 ll n123 = b123.count() - b123[v4];

 return n1*n2*n3 - (n12*n3 + n23*n1 + n31*n2) + 2*n123;
 };

 ll ans = 0;
 rep(i, 0, M) rep(j, i+1, M){
 auto [a, b] = edges[i];
 auto [c, d] = edges[j];
 if(a == c || a == d || b == c || b == d) continue;
 if((!con[a][c] || !con[b][d]) && (!con[a][d] || !con[b][c])) continue;

 ll ret = 0;
 ret += calc(a, b, c, d);
 ret += calc(b, c, d, a);
 ret += calc(c, d, a, b);
 ret += calc(d, a, b, c);

 if(con[a][c] && con[b][d]) ans += ret;
 if(con[a][d] && con[b][c]) ans += ret;
 }
 cout << ans/2;
}

🔒

구현 코드 잠금

BOJ 15309 스킬 트리

Fri, 06 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/15309

🧐 관찰 및 접근
#

이진트리..는 아니고 삼각형이구나. 걍 좀 펴서 생각하면, 이항계수처럼 생각하면 되는 것 같다.
$i$번째 줄은 $(Ax + B)^i$ 의 계수처럼 생각하면 되는듯?
- 아 근데 그 뭐냐 겹치게 하면 안되는구나
특정 삼각형은 그 초항만 생각하면 되는것같으니까, $m$개의 행을 포함하는 정삼각형을 어떻게 계산할지 생각해보자.
- 대충 로그정도에 계산하면 되는데.. 일단 초항이 1일때 식은 뭐랑 같지?
- $1 + (A+B) + (A^2 + AB + B^2) + \cdots$
- 같은 느낌인건데… 어차피 행 자체에는 누적합 맛으로 할 수 있겠네.
  - 어라? 이건 그냥 윗 행에다가 $A$를 곱하고, $B^N$만 더하면 될거같은딩. 대충 해버리죠?
  - 아니 잠깐만!!!!!!!!! $m$이 $10^{18}$이다!! 비상!!!!!!!!!
    - 로그가 붙을만한곳은 분할정복 거듭제곱같은거밖에 없는데…
- 아 잠깐만. 이거 그냥 그 유명한 고딩때 그 공식처럼 $(A-B)$곱하면 정리되는 꼴 아닌가?
- 그러면 $(A-B) + (A^2 - B^2) + (A^3 - B^3) + \cdots$
  - 이건 $(A + A^2 + \cdots + A^m) - (B + B^2 + \cdots + B^m)$이자나!
  - $\frac{A^{m+1} - 1}{A-1} - \frac{B^{m+1} - 1}{B-1}$ 로 계산할 수 있을 것 같고, 이걸 $A-B$로 나눠서 끝내자.
아!! $A = B$인 경우를 조심해야할 것 같고, $A = 1$이나 $B = 1$인경우도 조심해야할 것 같다.
- $A = B$라면? $1 + 2A + 3A^2 + \cdots + mA^{m-1}$ 를 구해야하는데,
  - 저 합을 $S$라고 하자. 그러면 $AS - S = 1 + A + A^2 + \cdots + A^m$ 니까, $A = 1$인 경우 말고는 이걸 구해서 $A-1$로 나누면 될 것 같은데?
케이스 처리를 조심하자.

💻 풀이
#

코드 (C++):

void solve(){
 mint A, B; cin >> A >> B;

 int Q; cin >> Q;
 while(Q--){
 ll x, y, m; cin >> x >> y >> m;
 x--; y--;
 mint cho = 1;
 cho *= A.pow(x-y);
 cho *= B.pow(y);
 
 mint trig = 0;

 if(A == B){
 if(A == 1) trig = mint(m)*(m+1)/2;
 else trig = (A.pow(m+1) - 1) / (A - 1).pow(2);
 }
 else{
 if(A == 1) trig += m;
 else trig += (A.pow(m+1) - 1) / (A - 1) - 1;
 if(B == 1) trig -= m;
 else trig -= (B.pow(m+1) - 1) / (B - 1) - 1;
 trig /= (A-B);
 }

 cout << cho * trig << '\n';
 }
}

🔒

구현 코드 잠금

BOJ 23887 프린트 전달

Fri, 06 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/23887

🧐 관찰 및 접근
#

설명을 대충 읽는데, BFS맛이 난다
허걱, 최대 학생이 25000명이라 나이브하게는 조금 곤란하긴 하다
근데 뭔가 트리처럼 해석할 수도 있을 것 같은데? MST인가?
- 아 근데 좀 유향 그래프? 맛인데… 위상정렬이네 이거
- 엥? 근데 이게 $2$번 학생이 $5, 6$번한테 받을 수 있다고해서 무조건 $5$번한테만 받는건 아니네?
- 그러면 다시 트리맛으로?
그러면 뭔가 트리의 지름을 최소화하는 느낌으로 가야하는 것 같은데…
- 그래프에서 가장 먼 두 점을 어떻게 구할 수 있을까?
- ???????? 아니 문제에서 $S$가 주어지는거였네
- 그러면 그냥 BFS를 돌리자
구현이 상당히 재밌다!

💻 풀이
#

코드 (C++):

void solve(){
 int N, M, K; cin >> N >> M >> K;
 vector<vector<int>> board(N, vector<int>(M, 0));
 vector<pii> students(K+1);
 vector<bool> visited(K+1);
 rep(i, 1, K+1){
 int x, y; cin >> x >> y;
 x--; y--;
 students[i] = {x, y};
 board[x][y] = i;
 }
 int S; cin >> S;
 set<int> Q;
 Q.insert(S);
 visited[S] = true;

 vector<vector<int>> links(K+1);

 vector<int> dx = {-1, -1, -1, 0, 0, 1, 1, 1};
 vector<int> dy = {-1, 0, 1, -1, 1, -1, 0, 1};
 while(!Q.empty()){
 set<int> nQ;
 for(auto cur: Q){
 auto [cx, cy] = students[cur];
 rep(d, 0, 8){
 int nx = cx + dx[d];
 int ny = cy + dy[d];
 if(nx < 0 || nx >= N || ny < 0 || ny >= M) continue;
 if(board[nx][ny] == 0) continue;
 int nxt = board[nx][ny];
 if(visited[nxt]) continue;

 visited[nxt] = true;
 links[cur].push_back(nxt);
 nQ.insert(nxt);
 }
 }
 swap(Q, nQ);
 }
 rep(i, 1, K+1) if(!visited[i]){
 cout << -1;
 return;
 }

 vector<int> sz(K+1);
 function<void(int)> dfs = [&](int cur){
 sz[cur] = 1;
 for(auto nxt: links[cur]){
 dfs(nxt);
 sz[cur] += sz[nxt];
 }
 };
 dfs(S);
 rep(i, 1, K+1) cout << sz[i] << ' ';
}

🔒

구현 코드 잠금

BOJ 34609 Secret Lilies and Roses

Thu, 05 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/34609
번역

문제
#

$1$번부터 $n$번까지 번호가 매겨진 $n$송이의 꽃이 왼쪽에서 오른쪽으로 일렬로 놓여 있다. 각 꽃은 백합(lily) 또는 장미(rose) 중 하나이다. $0$ 이상 $n$ 이하의 정수 $j$에 대해, $l_j$를 왼쪽 $j$개의 꽃 중 백합의 수, $r_j$를 오른쪽 $n - j$개의 꽃 중 장미의 수라 하자.

BOJ 1006 습격자 초라기

Wed, 04 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/1006

🧐 관찰 및 접근
#

유명한 통곡의 벽 문제 초라기
문제가 $2 \times N$의 원형이라 조금 곤란하다.
쉬운 경우부터 생각하자.
$1 \times N$의 선형이라면, 계단 수처럼 DP로 풀 수 있을 것 같다.
$2 \times N$의 선형이라도 DP로 가능한 것 같다.
- 두칸 전에서 오는 것에 대해 가로두개 / 위에 가로와 아래 따로 / 아래 가로와 위에 따로
- 한칸 전에서 오는 것에 대해 세로 / 위아래 따로
- 이 5가지 경우에서 가능한 것 같다!
그런데 원형이라 조금 곤란한데..
- 뭔가 케이스를 나눌 수 있을 것 같긴 하다.
- 선형으로 생각했을때 맨 왼쪽에 대해, 그게 반대쪽과 이어진경우 / 안이어진경우.
  - 위아래니까 각각 두가지, 총 4가지 경우의수를 따지면 될듯?
  - 근데 이걸 어떻게 깔끔하게 코딩하지? 큰일났다.
- 둘다 반대쪽과 이어진 경우는 문제를 한칸 밀어서 풀기만 하면 되는 것 같은데, 한쪽만 밀린 경우가 까다롭다.
그런데 사실 모든 칸이 지그재그로 연결된 경우 빼고는 언젠가는 선형으로 풀어도 되는 타이밍이 있는 것 같다!
- 위에서 말한 타이밍은 예제에서는 $1-2, 10-11, 3-4, \cdots$로 연결된 느낌과 같다.
- 시간복잡도가 $O(NW)$이 되긴 하는데, 돌만하지 않을까? 저 지그재그만 예외처리를 해버리자.
- ㄲㅂ 시간초과네. 테케가 여러개라 그런 것 같다.
  - 엥? 이거 그냥 길이를 $2N$으로 늘려서 하면 되지 않을까?
  - …인줄알았는데 전이식 자체부터 두개 전에서 땡겨오다보니 차분트릭이 안먹히는것 같다.
  - 전이식 자체에서도 여러칸 단위로 지그재그로 오면 할 수 있는게 없다..
DP에서, 상태공간을 조금 더 정의해보자. $\text{DP}[i][j]$라고 하면, i번째칸까지 봤을때 위아래 찬게 j상황이라고 생각해보자. $j = 0, 1, 2, 3$에서 위아래 모두 빔, 위 참, 아래 참, 위아래 모두 참과 같은 느낌이다. 이렇게해서 전이식을 잘 세우면 저 예외상황들을 처리하기 용이할 것 같다.
- 3번은 0번과 같으니 없애고, 나머지 3개로 정말 잘 처리해보자…

💻 풀이
#

코드 (C++):

void solve(){
 ll N, W; cin >> N >> W;
 vector<array<ll, 2>> v(N);
 rep(i, 0, N) cin >> v[i][0];
 rep(i, 0, N) cin >> v[i][1];

 auto calc = [&](bool con1, bool con2) {
 vector<array<ll, 3>> DP(N+1); // 0: 둘다끝, 1: 위가 튀어나감, 2: 아래가 튀어나감
 rep(i, 0, N+1) rep(j, 0, 3) DP[i][j] = 1e18;
 DP[0][0] = 0;
 if(con1) DP[0][1] = 0;
 if(con2) DP[0][2] = 0;
 if(con1 && con2) DP[1][0] = 0;

 rep(i, 1, N+1){
 DP[i][0] = min(DP[i][0], DP[i-1][0] + (v[i-1][0] + v[i-1][1] <= W ? 1 : 2));
 DP[i][0] = min(DP[i][0], DP[i-1][1] + 1);
 DP[i][0] = min(DP[i][0], DP[i-1][2] + 1);
 if(i-2 >= 0 && v[i-2][0]+v[i-1][0] <= W && v[i-2][1]+v[i-1][1] <= W){
 DP[i][0] = min(DP[i][0], DP[i-2][0] + 2);
 }

 DP[i][1] = min(DP[i][1], DP[i][0] + 1);
 if((i == N && con1) || (i < N && v[i-1][0] + v[i][0] <= W)){
 DP[i][1] = min(DP[i][1], DP[i-1][0] + 2);
 DP[i][1] = min(DP[i][1], DP[i-1][2] + 1);
 }

 DP[i][2] = min(DP[i][2], DP[i][0] + 1);
 if((i == N && con2) || (i < N && v[i-1][1] + v[i][1] <= W)){
 DP[i][2] = min(DP[i][2], DP[i-1][0] + 2);
 DP[i][2] = min(DP[i][2], DP[i-1][1] + 1);
 }
 }

 if(!con1 && !con2) return DP[N][0];
 if(con1 && !con2) return DP[N-1][2] + 1;
 if(!con1 && con2) return DP[N-1][1] + 1;
 if(con1 && con2) return DP[N-1][0] + 2;
 };

 auto origin = v;
 ll ans = 2*N;
 rep(con1, 0, 2) rep(con2, 0, 2){
 if(con1 && v[0][0] + v[N-1][0] > W) continue;
 if(con2 && v[0][1] + v[N-1][1] > W) continue;
 ans = min(ans, calc(con1, con2));
 }
 cout << ans << '\n';
}

🔒

구현 코드 잠금

BOJ 28359 수열의 가치

Wed, 04 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/28359

🧐 관찰 및 접근
#

일단 모두 $P$에 몰아넣거나, $Q$에 몰아넣거나는 가능하니 일단 기본적으로 모든 원소의 합정도는 여유롭게 가능하다.
그런데, 모든 수가 같다고 생각해보자. 그러면 모든 수는 $P$와 $Q$에 동시에 속하는데…
- 동시에 속할 수 있는 수를 어떻게 제어할 수 있지?
동시에 속한 수가 서로 다른 여러개의 수일 수는 없다.
- 어떤 수와 그 개수를 곱한 값이 최대인 수를 골라서, 맨 뒤로 보내자.

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 map<int, int> mp;
 int ans = 0;
 rep(i, 0, N){
 int x; cin >> x;
 mp[x]++;
 ans += x;
 }
 int mxIdx = -1, mxVal = -1;
 for(auto [k, v]: mp){
 if(k*v > mxVal){
 mxVal = k*v;
 mxIdx = k;
 }
 }
 ans += mxVal;
 vector<int> v1, v2;
 for(auto [k, v]: mp){
 if(k < mxIdx) rep(i, 0, v) v1.push_back(k);
 else if(k > mxIdx) rep(i, 0, v) v2.push_back(k);
 }
 rrep(i, 0, v2.size()) v1.push_back(v2[i]);
 rep(i, 0, mp[mxIdx]) v1.push_back(mxIdx);
 cout << ans << '\n';
 for(auto x: v1) cout << x << ' ';
}

🔒

구현 코드 잠금

BOJ 5916 농장 관리

Tue, 03 Mar 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/5916

🧐 관찰 및 접근
#

트리가 주어진다.
- 두 정점 사이 경로에 1을 더한다.
- 두 정점 사이 경로의 가중치의 합을 계산한다.
나이브하게는 $O(QN)$이겠지만, HLD와 Lazy 세그먼트 트리를 이용해서 $O(Qlog^2N)$정도에 계산할 수 있을 것 같다.

💻 풀이
#

코드 (C++):

void solve(){
 int N, M; cin >> N >> M;
 Tree tree(N);
 rep(i, 0, N-1){
 int u, v; cin >> u >> v;
 tree.add_edge(u, v);
 }
 tree.build();

 LazySegmentTree seg(N+1);
 while(M--){
 char op; cin >> op;
 int u, v; cin >> u >> v;
 if(op == 'P'){
 vector<pii> segs = tree.hld_path(u, v, false, false);
 for(auto [L, R]: segs) seg.update(L, R, 1);
 }
 else{
 ll ans = 0;
 vector<pii> segs = tree.hld_path(u, v, false, false);
 for(auto [L, R]: segs) ans += seg.query(L, R);
 cout << ans << '\n';
 }
 }
}

🔒

구현 코드 잠금

BOJ 16940 BFS 스페셜 저지

Thu, 26 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/16940

🧐 관찰 및 접근
#

풀이1
- 문제 그대로 큐에 넣으면서 시뮬레이션해볼 수 있겠다.
- 같은 레벨 안에서 원하는대로 선택할 수 있으니, 다음으로 들려야하는걸 셋으로 잘 관리하면서 해보자.
풀이2
- 현재 내가 있는 노드, 그리고 다음 노드를 큐에 넣을 수 있는지를 체크하는 노드 두가지로 문제를 시뮬레이션하자.
- cidx에서 nidx로 갈 수 있으면 nidx++를 하고, 없을때 cidx를 ++하자.
- nidx가 N에 닿지 못했다면 불가능한 것이다.
  - 이 풀이는 트리가 아닌 그래프에서만 가능하다!

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<vector<int>> links(N+1);
 rep(i, 0, N-1){
 int u, v; cin >> u >> v;
 links[u].push_back(v);
 links[v].push_back(u);
 }
 vector<int> order(N);
 bitset<100001> visited;
 rep(i, 0, N) cin >> order[i];
 queue<set<int>> v;
 v.push({1});
 visited[1] = true;
 int idx = 0;
 while(idx < N){
 set<int> nset;
 while(!v.empty() && v.front().empty()) v.pop();
 if(v.empty()){
 cout << 0;
 return;
 }
 if(v.front().count(order[idx]) == 0){
 cout << 0;
 return;
 }
 int cur = order[idx];
 v.front().erase(cur);
 for(int nxt: links[cur]){
 if(visited[nxt]) continue;
 visited[nxt] = true;
 nset.insert(nxt);
 }
 v.push(nset);
 idx++;
 }
 cout << 1;
}

🔒

구현 코드 잠금

BOJ 16964 DFS 스페셜 저지

Thu, 26 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/16964

🧐 관찰 및 접근
#

dfs를 돌리듯이 지금까지 걸어온 과정들을 기록하면서 다음 노드를 갈 수 있었는가?를 체크하자.

💻 풀이
#

코드 (C++):

import sys
input = sys.stdin.readline

N = int(input())
links = [set() for _ in range(N + 1)]

for _ in range(N-1):
 a, b = map(int, input().split())
 links[a].add(b)
 links[b].add(a)

lst = list(map(int, input().split()))

if lst[0] != 1:
 print(0)
 exit()

nidx = 1
stk = [1]

while nidx < N:
 if not stk:
 print(0)
 exit()
 cur = stk[-1]
 if lst[nidx] in links[cur]:
 stk.append(lst[nidx])
 nidx += 1
 else:
 stk.pop()
print(1)

🔒

구현 코드 잠금

BOJ 35288 Designant.

Wed, 25 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/35288

🧐 관찰 및 접근
#

문제를 정리하면 다음과 같다.
- 트리가 주어진다.
- 간선을 $K$개 지워서 포레스트로 만든다.
- 포레스트를 잘 합쳐서 트리의 지름이 최소가 되도록 하자.
포레스트를 잘 합치는 문제는 빌라봉으로 유명하다.
- 이 문제에 따르면, 세개 이상의 트리를 합칠 때, 가장 긴 트리의 지름 세개를 $a \geq b \geq c$ 라고 하면
- 그 결과는 $\max(a, \lceil\frac{a}{2}\rceil + \lceil\frac{b}{2}\rceil + 1, \lceil\frac{b}{2}\rceil + \lceil\frac{c}{2}\rceil + 2)$
- 결과는 위와 같고, 이는 새로 만든 간선을 $0, 1, 2$개 이용하는 경로중 가장 긴것과 같다.
  - 그리디하게 가장 긴 지름의 중심에 다른 중심들을 이은 모양에서 나온 결과이다.
그렇다면 트리를 빠르게 쪼개서 지름만 빠르게 계산할 수 있으면 되는 것 같다.
- 이걸 어떻게 할 수 있을까?
예제 1번의 트리를 ETT를 하면서 그려보자.
- 그리고 세번째 쿼리를 생각해보자.
  - $(1, 2), (3, 6), (4, 5, 7)$으로 나뉘어야 하는디…
  - ETT로 생각하면, $(1, 2, (5, (3, 6), 4, 7))$ 같은 느낌으로 그룹지어지는건가?
  - 잘 처리된 부분들은 상관 없는데, $(5, 4, 7)$같은데서 지름을 어떻게 구하면 좋을지 감이 안온다.
  - 일단 저걸 $(5), (4,7)$ 두 덩어리를 합치는 연산으로 보자. 오일러 투어 테크닉을 적용하면 연속 구간에 속하는 노드들의 지름은 세그먼트 트리로 구할 수 있다고 한다.
    - 이걸 어떻게 하는거지?
  - 트리 두개의 지름의 양끝 점을 각각 $(a, b), (c, d)$ 라고 할때
  - 두 트리를 합친곳에서의 지름은 $(a, b), (a, c), (a, d), (b, c), (b, d), (c, d)$중에서 존재한다.
  - 이를 pull연산으로 잘 정의해보자.
구현이 상당히 어렵다..

💻 풀이
#

코드 (C++):

void solve(){
 int N, Q; cin >> N >> Q;
 vector<vector<int>> links(N+1);
 vector<pii> edges;
 rep(i, 0, N-1){
 int u, v; cin >> u >> v;
 links[u].push_back(v);
 links[v].push_back(u);
 edges.push_back({u, v});
 }

 auto [ETT_in, ETT_out] = ETT(N, links);
 vector<int> ETT_inv(N+1);
 rep(i, 1, N+1) ETT_inv[ETT_in[i]] = i;

 LCA_Tree = new Tree_LCA(N+1, links);
 vector<Node> nodes(N+1);
 rep(i, 1, N+1) nodes[i] = Node(ETT_inv[i], ETT_inv[i], 0);
 SegmentTreeNode seg(N+1, nodes);

 vector<int> edge_to_subtree(N-1);
 rep(i, 0, N-1){
 auto [u, v] = edges[i];
 if(LCA_Tree->depth[u] < LCA_Tree->depth[v]) swap(u, v);
 edge_to_subtree[i] = u;
 }

 while(Q--){
 int K; cin >> K;
 vector<int> cuts(K);
 rep(i, 0, K) cin >> cuts[i];
 vector<Node> Query_nodes;
 vector<pair<int, bool>> events; // {ETT_idx, is_end}
 for(auto c: cuts){
 int u = edge_to_subtree[c-1];
 events.push_back({ETT_in[u], false});
 events.push_back({ETT_out[u], true});
 }
 sort(all(events));
 int cur = 1;
 stack<Node> stk;
 stk.push(Node());
 for(auto [idx, is_end]: events){
 if(is_end){
 Node& top = stk.top();
 top = seg.pull(top, seg.query(cur, idx));
 cur = idx+1;
 Query_nodes.push_back(top);
 stk.pop();
 }
 else{
 Node& top = stk.top();
 top = seg.pull(top, seg.query(cur, idx-1));
 cur = idx;
 stk.push(Node());
 }
 }
 Node& top = stk.top();
 top = seg.pull(top, seg.query(cur, N));
 Query_nodes.push_back(top);
 sort(all(Query_nodes), [](Node a, Node b){
 return a.dist > b.dist;
 });
 int ans = 0;
 if(Query_nodes.size() > 0) ans = Query_nodes[0].dist;
 if(Query_nodes.size() > 1) ans = max(ans, (Query_nodes[0].dist+1)/2 + (Query_nodes[1].dist+1)/2 + 1);
 if(Query_nodes.size() > 2) ans = max(ans, (Query_nodes[1].dist+1)/2 + (Query_nodes[2].dist+1)/2 + 2);
 cout << ans << "\n";
 }
}

🔒

구현 코드 잠금

BOJ 17364 대회

Sun, 22 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/17364

🧐 관찰 및 접근
#

어… 문제가 상당히 곤란해보인다. ㅋㅋㅋㅋ 첫번째 예제부터 친절해서 망정이지, 저런거 없었으면 당연히 1357번 1등한테 먹이고 3 출력했을 것 같다.
$K = 1$일때부터 풀어보자.
- 이때는 자명하게도 회의실 배정 문제와 같다.
- 끝나는 시간을 기준으로 정렬하고, 그리디하게 가져가자.
$K = 2$라면?
- 형섭이는 1등이 먹고 남은 대회들에 대해서, 결국 위의 그리디한 방법으로 가져갈 것이다.
- 이 때, 1등이 1, 3, 5, 7번 대회를 가져가서 남은 대회가 $(2, 3), (4, 5), (6, 7)$ 이라면 3개를 먹는 것이고,
- 1, 4, 7번째 대회를 가져가서 남은 대회가 $(2, 3), (3, 4), (5, 6), (6, 7)$ 이라면 2개밖에 못먹는 것이다.
- 이걸 DP같은걸로 어떻게 잘 가져가면 좋을것같은데..
엥? 근데 이거 약간 그리디하게 되지 않을까?
형섭씨도 그리디하게 먹으려고 하니, 형섭씨의 그리디를 의도적으로 방해하자.
- 제일처음에 시간은 $T = 0$일때, 형섭씨는 첫번째 대회 $(1, 2)$를 출전하려고 한다.
  - 바아로 1등 출동
- 힝잉잉거리면서 두번째 대회 $(2, 3)$을 출전하려고 한다.
  - 이걸 막을수는 없다. 그런데 이걸 나가고 나면 $(3, 4)$ 까지는 못나가시니 절대 안막아버리기
- 그다음에 $(4, 5)$ 대회를 나가시려고하면, 이때 첫번째 대회 나가신분은 퇴근 후 집에서 요양중이시다. 바로 저기 보내버리자.
- 다시 형섭씨는 힝잉잉거리면서.. 어쩌구
- 우선순위 큐로 관리하면서 그리디하게 진행할 수 있을 것 같다!!!!!!!
- ㅠ.ㅠ 바로 틀렸다. 이것만으로는 상대방이 너무 많은 대회를 나갈 수 있는 것 처럼 된다.
  - 아하, $(3, 5), (4, 5), (2, 7)$이 있다고 해보자. 단순하게 끝나는 시간만 관리해서는, 5일에 나와서 퇴근 후 저 $(2, 7)$ 대회에 나갈 수 있는것처럼 내가 해버렸다. 이러면 안되지
- 음.. 어차피 세개 다 무조건 못먹는건 맞는데. 그리디라고 생각하면.. 쓸 수 있는 놈중 가장 마지막에 끝나는 놈을 쓰는게 유효한가? 다음 $(s, e)$에서 어차피 $e$는 꽤 크고, $s$가 빠른 놈이 들어오는게 문제인 것 같은데, 그러면 자유로운 친구가 더 오래 쉬도록 해야하는거 같다 .그러면 맞는거같다!! 셋같은걸로 지점을 잘 찾아보자.

💻 풀이
#

코드 (C++):

void solve(){
 int N, K; cin >> N >> K;
 vector<pii> contests(N);
 rep(i, 0, N) cin >> contests[i].first >> contests[i].second;
 sort(all(contests), [](const pii &a, const pii &b){
 if(a.second == b.second) return a.first < b.first;
 return a.second < b.second;
 });
 int ans = 0;
 int T = 0;
 multiset<int> st;
 rep(i, 0, K-1) st.insert(0);
 for(auto &[a, b]: contests){
 if(a <= T) continue;
 auto it = st.lower_bound(a);
 if(it == st.begin()){
 ans++;
 T = b;
 continue;
 }
 it--;
 st.erase(it);
 st.insert(b);
 }
 cout << ans;
}

🔒

구현 코드 잠금

BOJ 2803 내가 어렸을 때 가지고 놀던 장난감

Sun, 22 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/2803

🧐 관찰 및 접근
#

비트마스킹적으로 접근해보면, 여러 장난감 상자들의 or 연산결과가 $1111111..$이 되도록 하는 조합의 개수를 찾으면 되는 것 같다.
$N$에 대해 생각하긴 까다로우므로, $M \leq 20$인 것을 이용해서 $M$에 대한 비트마스킹된 상자의 수로 생각해보자.
이후 과정을 포함배제로 진행하면 $O(2^N \times 2^N)$이겠지만, 우리는 SOS DP를 이용해서 $O(N2^N)$ 에 계산할 수 있음을 알 수 있다.
그런데 그냥 기본적인 SOS DP랑은 세팅이 조금 다른가? 고민해보자.
- 기본적인 SOS DP는 해당 비트마스크의 부분집합의 원소 개수의 합이다.
- 이번에 구해야하는건 해당 비트마스크를 만들어줄 수 있는 조합의 개수인데..
- 결국 어떤 상자 $110011$을 골랐다고 생각해보자.
  - 그러면, $??11??$ 인걸 모두 고르면 된다.
  - 이걸 부분집합으로 세긴 힘들지만, 뒤집어서 생각한다면 $??00??$을 찾는 것이고, 이건 $110011$의 부분집합의 개수와 같은 것 같다!
  - 자기 자신을 세지 않도록 조심하자.
- 그런데 저 방법으로 세면, 두개의 or연산밖에 고려하지 못한다… 3개 이상인걸 고려하려면 DP 설계를 조금 더 잘해야 할 것 같다.
  - 아하, 원래게 $??11??$인 개수를 안다면, 여기에서 한개 이상만 고르면 된다. 그 개수를 $\text{cnt}$라고 하면, $2^{\text{cnt}} - 1$이 성립하는거 같기도?
  - 근데 다시 생각해보니, 뭐랄까 원래가 $??10??$$ 인거랑 $??01??$$ 인거랑이 합쳐져서 되는것들을 못세는거..같기도?
  - 연산해서 $11$을 만들기 위해선, $(11 + 10 + 01 + 00)^2$ 같은 느낌으로 생각해보자.
  - 저 연산 결과는
  - $$ 11^2 + 10^2 + 01^2 + 00^2 + \\ 2(11\cdot10 + 11\cdot01 + 11\cdot00 + 10\cdot01 + 10\cdot00 + 01\cdot00) $$
  - 이고, 잘 고민해보니 $11$의 부분집합의 제곱 - $11, 01$의 부분집합의 제곱 - $00$의 부분집합의 제곱을 하면 깔끔하게 $11^2 + 2(11\times10 + 11\times01 + 11\times00 + 10\times01)$이 된다.
아니 잠깐만, 저 느낌을 그대로 가져가면 그냥 부분집합의 합으로 SOS DP를 한다음에 포함배제를 때려버리면 어떻게든 된다. 연산결과가 $11...11$인놈들 - $(01...11), (10..111)...$ + $...$ 이렇게 하면 되는구나!

💻 풀이
#

코드 (C++):

void solve(){
 int N, M; cin >> N >> M;
 vector<int> A(N);
 rep(i, 0, N){
 int K; cin >> K;
 int ret = 0;
 rep(j, 0, K){
 int x; cin >> x;
 ret |= (1 << (x-1));
 }
 A[i] = ret;
 }
 vector<int> SOS(1 << M, 0);
 for(auto x: A) SOS[x] += 1;
 rep(i, 0, M) rep(mask, 0, 1<<M) if(mask & (1 << i)) SOS[mask] += SOS[mask^(1<<i)];
 mint ans = 0;
 rep(mask, 0, 1<<M){
 int cnt = 0;
 rep(i, 0, M) if((mask & (1 << i)) == 0) cnt++;
 if(cnt & 1) ans -= (mint(2).pow(SOS[mask]));
 else ans += (mint(2).pow(SOS[mask]));
 }
 cout << ans << "\n";
}

🔒

구현 코드 잠금

BOJ 10868 최솟값

Sat, 21 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/10868

🧐 관찰 및 접근
#

구간 최솟값을 $M$번 구하는 문제이다.
구간합은 누적합 배열을 이용해서 $O(1)$에 구할 수 있다.
- 하지만 구간 최솟값은 역원과 역연산이 없기에, 누적 최솟값 배열을 이용하기 곤란하다.
세그먼트 트리를 이용해서 구간 $O(logN)$개의 구간만을 관리하는 방법으로 풀 수 있겠다.
하지만, 업데이트가 없는 경우 희소 배열을 이용해서 $O(1)$에 구할 수 있음이 알려져있다.

💻 풀이
#

코드 (C++):

struct RMQ{ // Range Minimum Query
 int N, H;
 vector<vector<int>> table;

 RMQ(int N, vector<int> &arr): N(N){
 H = 1;
 while((1 << H) <= N) H++;
 table.assign(N, vector<int>(H));

 rep(i, 0, N) table[i][0] = arr[i];
 rep(j, 1, H) rep(i, 0, N){
 int right = i + (1 << (j-1));
 if(right < N) table[i][j] = min(table[i][j-1], table[right][j-1]);
 else table[i][j] = table[i][j-1];
 }
 }

 int query(int l, int r){ // [L, R]
 r++;
 int k = 31 - __builtin_clz(r-l);
 return min(table[l][k], table[r-(1 << k)][k]);
 }
};

void solve(){
 int N, M;
 N = getu<6, int>();
 M = getu<6, int>();
 vector<int> A(N);
 rep(i, 0, N) A[i] = getu<10, int>();
 RMQ rmq(N, A);
 while(M--){
 int l, r; l = getu<6, int>(); r = getu<6, int>();
 putu<10, int>(rmq.query(l-1, r-1));
 }
}

🔒

구현 코드 잠금

BOJ 13537 수열과 쿼리 1

Sat, 21 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/13537

🧐 관찰 및 접근
#

부분수열에서 물어보는 쿼리가 있으니, 세그먼트 트리가 먼저 생각이 난다.
- 그런데 쿼리가 좀 까다롭다.
이럴때, $N, M$모두 10만이므로 제곱근 분할법을 한번 생각해보자.
수가 $C$개 들어있는 버킷을 $B$개 만든다면 $(C = N/B$), 버킷 내의 수들을 정렬하는데 $O(B \times C\log{C})$, 버킷들에 대해 답을 구하는데에 $O(B \times \log{C})$
따라서 이들을 최소화하기 위해서는 적당히 $\sqrt{N}$보다 약간 크게 잡으면 될 것 같다.

💻 풀이
#

코드 (C++):

const int sq = 700;
struct sqrtDecomposition{
 int N;
 vector<int> A;
 vector<vector<int>> bucket;

 sqrtDecomposition(int N, vector<int> &A): N(N), A(A){
 bucket.resize((N-1)/sq+1);
 rep(i, 0, N) bucket[i/sq].push_back(A[i]);
 for(int i = 0; i < (int)bucket.size(); i++) sort(all(bucket[i]));
 };

 int query(int L, int R, int val){
 int ret = 0;
 for(int i = L; i <= R;){
 if(i%sq == 0 && i+sq-1 <= R){
 ret += bucket[i/sq].end() - upper_bound(all(bucket[i/sq]), val);
 i += sq;
 }
 else{
 ret += A[i] > val;
 i++;
 }
 }
 return ret;
 }
};

void solve(){
 int N; cin >> N;
 vector<int> A(N);
 rep(i, 0, N) cin >> A[i];
 sqrtDecomposition sd(N, A);
 int Q; cin >> Q;
 while(Q--){
 int i, j, k; cin >> i >> j >> k;
 cout << sd.query(i-1, j-1, k) << "\n";
 }
}

🔒

구현 코드 잠금

BOJ 14504 수열과 쿼리 18

Sat, 21 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/14504

🧐 관찰 및 접근
#

수열과 쿼리 1과 비슷한데, 업데이트 쿼리가 추가되었다.
- 같은 방법으로 풀되, 배열 정렬 말고 multiset으로 관리하면 되지 않을까?
- 헉, multiset에서 거리를 계산할때 쓰는 distance함수가 $O(N)$이라고 한다!!
- 어차피 버킷의 크기가 작으니, 나이브하게 정렬해버려도 문제가 없겠다.

💻 풀이
#

코드 (C++):

const int sq = 700;
struct sqrtDecomposition{
 int N;
 vector<int> A;
 vector<vector<int>> bucket;

 sqrtDecomposition(int N, vector<int> &A): N(N), A(A){
 bucket.resize((N-1)/sq+1);
 rep(i, 0, N) bucket[i/sq].push_back(A[i]);
 for(int i = 0; i < (int)bucket.size(); i++) sort(all(bucket[i]));
 };

 void update(int i, int val){
 int b = i/sq;
 auto it = lower_bound(all(bucket[b]), A[i]);
 *it = val;
 A[i] = val;
 sort(all(bucket[b]));
 }

 int query(int L, int R, int val){
 int ret = 0;
 for(int i = L; i <= R;){
 if(i%sq == 0 && i+sq-1 <= R){
 ret += bucket[i/sq].end() - upper_bound(all(bucket[i/sq]), val);
 i += sq;
 }
 else{
 ret += A[i] > val;
 i++;
 }
 }
 return ret;
 }
};

void solve(){
 int N; cin >> N;
 vector<int> A(N);
 rep(i, 0, N) cin >> A[i];
 sqrtDecomposition sd(N, A);
 int Q; cin >> Q;
 while(Q--){
 int op; cin >> op;
 if(op == 1){
 int i, j, k; cin >> i >> j >> k;
 cout << sd.query(i-1, j-1, k) << "\n";
 }
 else{
 int i, k; cin >> i >> k;
 sd.update(i-1, k);
 }
 }
}

🔒

구현 코드 잠금

BOJ 2042 구간 합 구하기

Sat, 21 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/2042

🧐 관찰 및 접근
#

자명한 세그먼트 트리 연습 문제이다.
기본적으로 업데이트가 없이 구간의 합을 구해야 한다면, 이는 누적합으로 빠르게 해결할 수 있다.
- 이때 합을 구하는 쿼리는 $O(1)$, 업데이트는 $O(N)$이다.
업데이트를 빠르게 하기 위해선, 합을 나이브하게 구하는 방법이 있겠다.
- 이때 합을 구하는 쿼리는 $O(N)$, 업데이트는 $O(1)$이다.
버킷을 잘 나누어서, 두 방법의 이득만을 취하면 제곱근 분할법을 이용해서 $O(Q\sqrt{N})$까지 줄일 수 있고, 해당 문제에서는 $N \leq 10^6$이므로 약 2천만정도에 바운드된다.
지금과 같이 두 노드를 합치는 것이 직관적이고 용이할 경우에는 세그먼트 트리를 쓸 수 있으며, 두 노드를 이용해 역원과 역연산을 정의할 수 있는 경우 펜윅트리도 이용할 수 있다.

💻 풀이
#

코드 (C++):

void solve(){
 ll N, M, K; cin >> N >> M >> K;
 SegmentTreeSum ST(N);
 rep(i, 0, N){
 ll x; cin >> x;
 ST.set(i, x);
 }
 ST.build();

 rep(i, 0, M+K){
 ll a, b, c; cin >> a >> b >> c;
 if(a == 1) ST.update(b-1, c - ST.query(b-1, b-1));
 else cout << ST.query(b-1, c-1) << "\n";
 }
}

🔒

구현 코드 잠금

BOJ 25563 AND, OR, XOR

Sat, 21 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/25563

🧐 관찰 및 접근
#

일단 세개를 따로 구하면 되는 것 같다.
XOR이 제일 쉬워보인다.
- XOR은 역연산이 존재하므로, $A_i \oplus A_j = K$를 만족하는 $A_j$는 $A_i \oplus K$로 구할 수 있다.
- $A_i \leq 1\,000\,000$이므로 그냥 구하면 될듯. 양쪽에서 구했으니 2로 나누는것만 조심하면 되겠다.
- $K = 0$일때를 주의하자.
AND를 다음으로 봐보자.
- $A_i, A_j$ 모두 $K$와 and연산한 결과는 $K$여야 한다.
- 그리고 $A_i - K, A_j - K$는 and 연산한 결과가 $0$이어야 한다.
  - 숫자 $N$개에서 두 수의 and 결과가 $0$인 조합 개수를 빠르게 구할수가 있나?
  - 이 같은 아이디어로 OR도 해결할 수 있는 것 같으니, 이걸 고민해보자.
- 약간 포함배제같은맛으로 될라나?
  - 일단 쉽게 $A_i$에서 $k$번째 비트 하나가 켜져있다고 해보자.
    - 그러면 나머지들에서 $k$번째 비트가 꺼져있기만 하면 된다.
    - 이건 뭐 $k$번째 비트가 켜져있는 / 꺼져있는 집합으로 하면 될틴데,…
  - $A_i$에서 $k_1, k_2$번째 비트 두개가 켜져있다고 해보자.
    - 이번에는 나머지들에서 $k_1, k_2$ 번째 비트 모두가 꺼져있어야 한다.
    - 그거 개수는 $k_1$이 켜진거 + $k_2$가 켜진거 - $k_1, k_2$가 켜진것으로 구할 수 있고, 이거까진 또 쉽게 되는거같기도? 왜냐면 둘다 켜진건 처음에 보고있으니까.
  - $A_i$에서 $k_1, k_2, k_3$ 세개가..
    - 나머지들에서 세개가 다 꺼져있어야..
    - 근데 이건 각자 더하고 둘둘 빼고 세개 더하고.. 는 까다롭네. 앞에서 하면서 저장해왔으면 되는거같긴 한데..
  - 그런데, 이렇게 하다보면 결국 비트가 20개정도니까… 어? 되는거같기도 한데?
- 어떻게 풀 수 있나 고민해봤는데, 결국 각 비트 자체 대해서 저장한다음에, 다른 배열에서 이를 이용해서 만들어보자.
  - $\text{cntExact}$를 해당 비트가 그대로 켜져있는것 (그 숫자 자체)
  - $\text{cntOr}$을 켜져있는 비트중 하나라도 켜져있는것이라고 생각하면, 이걸 앞에서 얻은것들로 계산할 수 있을 것 같다.
  - 이를 SOS DP로 알려져있다.
- 두 수의 and 결과가 0인 것의 개수는, $A_i$를 정했다면 ${A_i}$ 를 뒤집은 비트에서 부분집합의 합과 같다.
OR은 어떻게 풀릴까?
- $A_i, A_j$ 모두 $K$랑 or 연산한 결과가 $K$여야 한다.
- 예를들어 목표가 $1101$이고, $A_i$가 $1000$이라면 $A_j$는 $?101$이어야 한다. $A_i$에서 꺼진 비트는 모두 켜져있어야 한다.
- 부분집합의 합을 구할때, $A$를 뒤집어서 저장하는 것으로 가능할 것 같다. $?$ 인 부분들에 대해 부분집합의 합을 계산하면 된다.

💻 풀이
#

코드 (C++):

void solve(){
 int N, K; cin >> N >> K;
 vector<int> A(N);
 rep(i, 0, N) cin >> A[i];

 int all1 = (1 << 20) - 1;

 // count and
 {
 ll ans = 0;
 vector<int> cnt(1<<20, 0), SOS(1<<20, 0);
 rep(i, 0, N) if((A[i] & K) == K){
 cnt[A[i] - K]++;
 SOS[A[i] - K]++;
 }
 rep(i, 0, 20) rep(mask, 0, 1<<20) if(mask & (1<<i)) SOS[mask] += SOS[mask^(1<<i)];
 rep(i, 0, N) if((A[i] & K) == K){
 int mask = all1 - (A[i] - K);
 ans += SOS[mask];
 }
 ans -= cnt[0];
 cout << ans/2 << ' ';
 }

 // count or
 {
 ll ans = 0;
 vector<int> cnt(1<<20, 0), SOS(1<<20, 0);
 rep(i, 0, N) if((A[i] | K) == K){
 cnt[A[i]]++;
 SOS[K - A[i]]++;
 }
 rep(i, 0, 20) rep(mask, 0, 1<<20) if(mask & (1<<i)) SOS[mask] += SOS[mask^(1<<i)];
 rep(i, 0, N) if((A[i] | K) == K){
 ans += SOS[A[i]];
 }
 ans -= cnt[K];
 cout << ans/2 << ' ';
 }

 // count xor
 {
 ll ans = 0;
 vector<int> cnt(1<<20, 0);
 rep(i, 0, N) cnt[A[i]]++;
 rep(i, 0, N) ans += cnt[A[i] ^ K];
 if(K == 0) ans -= N;
 cout << ans/2;
 }
}

🔒

구현 코드 잠금

BOJ 34088 It's a Mod, Mod, Mod, Mod World 2

Sat, 21 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/34088

🧐 관찰 및 접근
#

$K$로 나눈 나머지가 같다 = 고른 부분집합의 원소들의 차이가 모두 $K$의 배수이다.
그러면? 분위기상 소수만? 신경써도 되는거같다.
- 근데 숫자들의 차이가 $10^9$까지인데… 그러면 너무 많은데 흠
근데 일단 직관적으로, $K = 2$일때 비둘기집의 원리에 의해 답은 ${N/2}$ 이상이긴 하다.
- 그리고 직관적으로, 웬만한 경우에 $K$가 작을때 답이 있을 것 같다.
- $K$가 클때를 억지로 만들 수 있나? $K > 1000$ 쯤듸는 어떤 소수라고 하면, 억지로 만들 수 있는 것 같긴 하다.
- 그런데, 이때 $K$가 $N/2$개 이상의 부분집합에 대해 나머지가 같아야하므로, 다르게 말하면 어떤 두 수를 뽑앗을때 50% 이상의 확률로 $K$는 해당 수의 약수이다.
- 랜덤으로 풀 수 있지 않을까?

💻 풀이
#

코드 (C++):

void solve(){
 auto start = chrono::high_resolution_clock::now();

 bitset<32000> isPrime;
 isPrime.set();
 isPrime[0] = isPrime[1] = 0;
 rep(i, 2, 32000) if(isPrime[i]){
 for(ll j = (ll)i*i; j < 32000; j += i) isPrime[j] = 0;
 }
 vector<int> primes;
 rep(i, 2, 32000) if(isPrime[i]) primes.push_back(i);


 int N; cin >> N;
 vector<ll> A(N);
 rep(i, 0, N) cin >> A[i];

 int ans = (N+1)/2;
 while(1){
 auto end = chrono::high_resolution_clock::now();
 auto duration = chrono::duration_cast<chrono::milliseconds>(end - start);
 if(duration.count() > 900) break;
 int a = rand() % N, b = rand() % N;
 int diff = abs(A[a] - A[b]);
 vector<int> divs;
 for(int p: primes){
 if(p*p > diff) break;
 if(diff % p == 0){
 divs.push_back(p);
 while(diff % p == 0) diff /= p;
 }
 }
 if(diff > 1) divs.push_back(diff);
 for(int d: divs){
 map<int, int> mp;
 for(auto x: A) mp[x%d]++;
 for(auto [_, c]: mp) ans = max(ans, c);
 }
 }
 cout << ans;
}

🔒

구현 코드 잠금

BOJ 9345 디지털 비디오 디스크(DVDs)

Sat, 21 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/9345

🧐 관찰 및 접근
#

수열에서의 swap연산이 주어지고, 수열의 $L, R$ 범위가 주어졌을 때 해당 범위에 $L \leq x \leq R$의 모든 수가 있는지 묻는 문제이다.
합같은것으로는 저걸 구분할 수가 없다. $(3, 4)$나 $(2, 5)$나 같으니까.
아하, DVD들끼리 겹치지 않으므로 구간 최소/최댓값을 이용하면 되겠다.

💻 풀이
#

코드 (C++):

void solve(){
 int N, K; cin >> N >> K;
 vector<pii> a(N);
 rep(i, 0, N) a[i] = {i, i};
 SegmentTree ST(N, a);
 while(K--){
 int op, a, b; cin >> op >> a >> b;
 if(op == 0){
 int aval = ST.query(a, a).first;
 int bval = ST.query(b, b).first;
 ST.set(a, bval);
 ST.set(b, aval);
 }
 else{
 pii res = ST.query(a, b);
 if(res.first == a && res.second == b) cout << "YES\n";
 else cout << "NO\n";
 }
 }
}

🔒

구현 코드 잠금

BOJ 15896 &+ +&

Fri, 20 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/15896

🧐 관찰 및 접근
#

bitwise and들의 합과, 합들의 bitwise and 값을 구해야한다.
일단 앞에껏부터 해보자. $N$은 100만??이다. 개크네
모든 $(A_i \& B_j)$의 합을 1999로 나눈 나머지
- 나이브하게 제곱은 될 리가 없다.
- bitwise and의 특성을 생각해보자. $A_i$에서도, $B_j$에서도 켜져있어야 한다.
- 각 비트에 대해서 생각하면, $A$에서 해당 비트가 켜진 개수 * $B$에서 해당 비트가 켜진 개수와 같이 구할 수 있을 것 같다.
- 전처리에 $O(N\times29)$, 계산하는데에 $O(29)$가 걸릴 것 같다.
모든 $(A_i + B_j)$의 bitwise and 연산 값
- 자 이제 이게 문젠거같은데… 합이 이슈다. 받아올림이 있다보니 조금 신경쓰인다.
- 다시한번 bitwise and의 특성을 생각해보자. 모두 켜져있어야 한다는건, 모든 순서쌍 $(i, j)$에 대해 $A_i + B_j = C_k$라고 할때, 어떤 $C_k$의 비트가 꺼져있으면, 정답에서 해당 비트는 꺼진다.
- 일단 첫번째 비트에 대해서는 쉽게 구할 수 있는 것 같다. 더했을때 모두 $1$이 남기 위해선 $1 + 0, 0 + 1$ 두가지만 가능하기에, 개수가 $(N, 0), (0, N)$이 아니라면 비트가 꺼질 수밖에 없다.
- 하지만 해당 윗 비트부터는 받아올림이 생긴다… $11_2 + 01_2 = 100_2$ 와 같이 $(1, 0)$이었음에도 비트가 꺼질 수 있다. 혹은 $11_2 + 11_2 = 110_2$와 같이 $(1, 1)$이었으메도 비트가 켜질 수 있다.
- 하 이게 무슨 의미지? 예를들어 $4$의자리 비트가 켜져있나? 라는 질문은 $8$로 나눈 나머지들의 합에 대해, 나머지가 모두 $4$ 이상인가? 하는 질문과 같긴 하다. $0$~~$3$, $8$~~$11$은 안된다는거지. 그 사이에 값이 있는지 없는지를 체크할 수가 있나?
  - 일반화시키면, $2^k$의 비트가 켜져있는건 $\mod 2^{k+1}$ 에 대해 나눈 애들의 합에 대해 $0 \leq s < 2^k$ 또는 $2^{k+1} \leq s < 2^{k+1} + 2^k$ 인게 있으면 안된다.
- 이걸 각 비트에 대해 한다고 하면 그래도 정렬해서 이분탐색으로 구할 순 있을거같긴 한데…… $N$ 제한이 100만이라 $O(29 \times N\log{N})$을 하면 죽여버리겠다는 말과 같은 것 같다.
- 어? 근데 내가 필요한건, 비트단위로 하나씩 확장해나가면서 정렬하는거다. 이게 바로 Radix Sort 아닌가?
- 게다가 배열 두개로 쪼개져있을때, 다른 배열에서 하나하나 합이 저 안에 들어있는지 확인하는건 그리디하게 0/1로 쪼개진 두 배열의 맨앞/맨뒤를 보는것만으로 해결할 수 있는 것 같다. 덱을 이용해서 관리해보자.

💻 풀이
#

코드 (C++):

void solve(){
 ll N; cin >> N;
 vector<ll> A(N), B(N);
 rep(i, 0, N) cin >> A[i];
 rep(i, 0, N) cin >> B[i];

 vector<ll> bitCountA(30), bitCountB(30);
 rep(i, 0, N) rep(j, 0, 30){
 if((A[i] >> j) & 1) bitCountA[j]++;
 if((B[i] >> j) & 1) bitCountB[j]++;
 }

 ll ans1 = 0;
 rep(i, 0, 30){
 ans1 += (1LL << i) % 1999 * (bitCountA[i] * bitCountB[i]) % 1999;
 ans1 %= 1999;
 }
 cout << ans1 << " ";

 ll ans2 = 0;
 vector<ll> dq[2], ndq[2];
 dq[0].reserve(N);
 dq[1].reserve(N);
 ndq[0].reserve(N);
 ndq[1].reserve(N);
 rep(i, 0, N) dq[0].push_back(A[i]);
 rep(bit, 0, 30){
 ndq[0].clear();
 ndq[1].clear();
 for(ll x: dq[0]) (x >> bit) & 1 ? ndq[1].push_back(x) : ndq[0].push_back(x);
 for(ll x: dq[1]) (x >> bit) & 1 ? ndq[1].push_back(x) : ndq[0].push_back(x);
 swap(dq[0], ndq[0]);
 swap(dq[1], ndq[1]);

 vector<ll> cand;
 if(!dq[0].empty()){
 cand.push_back(dq[0].front());
 cand.push_back(dq[0].back());
 }
 if(!dq[1].empty()){
 cand.push_back(dq[1].front());
 cand.push_back(dq[1].back());
 }

 bool flag = true;
 for(auto x: B) for(auto c: cand) if((((x+c) >> bit) & 1) == 0){
 flag = false;
 break;
 }
 if(flag) ans2 += (1LL << bit);
 }
 cout << ans2 << "\n";
}

🔒

구현 코드 잠금

BOJ 25229 GCD Harmony

Fri, 20 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/25229
번역

번역
#

문제
#

방향이 없는 간선으로 이루어진 트리가 있으며, 각 노드는 정수 값을 가지고 있습니다. 인접한 두 노드의 값의 최대공약수(GCD)가 $1$보다 엄밀히 클 때, 이 두 노드를 **GCD-조화롭다(GCD-harmonic)**고 합니다.

BOJ 30449 Reafy 수열

Thu, 19 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/30449

🧐 관찰 및 접근
#

$R(n)$의 길이는 몇일까?
- $R(1) = 2$이고, $R(k) = R(k-1) + k$와 서로소인 자연수의 개수 인 것 같다.
  - 오일러 피함수의 부분합 개수랑 같다.
  - 암튼 나이브하게 돌려보니, 7600459개가 나온다. 이걸 0.5초안에 이걸 정렬하고 찾을?수?있을까? ㅋㅋ
- 수열이 좌우로 대칭인걸 고려하면 380만개정도만 정렬해도 될거같긴 한데… 그래도 빡세보인다. 0.5초라서
흠.. 답에 대한 이분탐색이 될까? 사실 깔끔하게 이분탐색 하기 위해선, 정수조건으로 바꾸려면 1~5000의 LCM을 구해야 한다.. 진짜 개에바
$10^{-4}$에 대한 정밀도까지만 하면 되지 않을까? 해봤자 가장 작은 수는 $\frac{1}{5000}$이니까… 라기엔 두 분수의 차는 결국 더 빡세지네. 해봤자 $\frac{1}{5000*4999}$인거같긴 한데…
아니 잠깐만, 생각해보니까 1~5000에 대해서 따로 정렬하면 시간복잡도가 꽤나 줄어드는것같다. 이렇게 해서 답에 대한 이분탐색을 해볼까..?
다 실패하고, nth_element와 short와 pragma Ofast와 Clang까지 섞은 최적화로 풀엇다… 하 이게 뭐하는 문제냐 ㄱ-
헉, 앞에 최대공약수를 구하는 부분을 반복문으로 전처리하면 훨씬 빠르게 돈다. 거기가 병목이었다니

💻 풀이
#

코드 (C++):

void solve(){
 int N, K; cin >> N >> K;
 vector<pair<short,short>> v;
 v.reserve(N * N / 2);
 v.push_back({0, 1});
 v.push_back({1, 1});
 rep(i, 1, N+1) rep(j, i+1, N+1){
 if(__gcd(i, j) != 1) continue;
 v.push_back({(short)i, (short)j});
 }
 int sz = (int)v.size();
 if(K*2 > sz){
 K = sz - K + 1;
 nth_element(v.begin(), v.begin() + K - 1, v.end(), [](auto& a, auto& b){
 return a.first * b.second > a.second * b.first;
 });
 } else {
 nth_element(v.begin(), v.begin() + K - 1, v.end(), [](auto& a, auto& b){
 return a.first * b.second < a.second * b.first;
 });
 }
 cout << v[K-1].first << " " << v[K-1].second << '\n';
}

🔒

구현 코드 잠금

BOJ 32528 월간 훈수회

Thu, 19 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/32528

🧐 관찰 및 접근
#

오늘도 찾아온 게임이론 문제이다.
주어진 그래프는 함수형 그래프이다.
- 함수형 그래프는 사이클 하나와, 해당 사이클로 들어가는 간선들의 모양을 가진다.
- 정점은 $N$개, 간선은 $N$개이다.
일단 선공 $A$가 $B$의 앞 칸을 끊어버렸다고 가정하자. 함수형 그래프이므로 앞 칸은 언제나 존재한다.
- 후공 $B$는 자신의 이웃한 정점으로 이동할 수가 없다. 따라서, 어떤 정점 하나를 삭제하는 수밖에 없다.
  - 선공 $A$의 턴의 경우의 수를 줄이기 위해, 해당 정점도 $A$의 앞 칸이었다고 가정하자.
  - 그렇다면 현재 남은 정점은 $N-2$개이므로, $N$이 짝수일때는 후공이, 홀수일때는 선공이 이기게 된다.
    - 그렇다면 $N$이 짝수일때는 선공이 $B$의 앞칸을 끊는것이 손해인가?
      - 시작 위치에서 $B$가 $A$의 앞에 있었다고 생각해보자. 그렇다면 $A$는 두번째 자신의 턴에서 $B$의 위치로 이동할 수 있고, 이후 삭제할 수 있는 정점의 개수는 $N-1$개, 턴은 $B$의 턴이다. 따라서 이때는 선공이 승리한다.
- 따라서, $N$이 홀수이거나, $N$이 짝수이면서 $B$가 $A$의 앞 칸이라면 선공이 무조건 승리할 수 있다.
$N$이 짝수고 $B$가 $A$의 앞칸이 아니라면 라면 선공이 어떻게 하면 좋을까? 상대한테 턴을 넘기는 편이 유리할 것 같다. 그러면 $A$가 한칸 앞으로 간다고 해보자.
- 이때 $B$는 또한 $A$를 억제하기 위해 위와 같은 행동을 할 수 있고, 이때 $N$은 짝수로 고정되어있으므로 $A$가 $B$의 앞칸이라면 후공이 무조건 승리할 수 있고, 그렇지 않다면 $B$도 한칸 앞으로 갈 것이다.
  - 이는 사이클 안에 갇힐때까지 반복된다!
풀이를 요약해보자.
- 둘이 같은 칸에 있을때는, 그때부터 N-1개 정점 지우기 게임이 된다.
  - $N$이 홀수일때는 나중에 행동하는 쪽이, 짝수일때는 먼저 행동하는 쪽이 이기게 된다.
- 상대의 앞 칸을 지울 수 있고, $N$이 홀수라면 바로 들어가서 삭제를 거는게 이득이다.
- 아니라면 이동을 할텐데, 그 이동을 한 결과 상대의 승리조건을 만족시켜버린다면 그냥 아무 정점이나 지워버려서 그런 상황이 오지 못하게 만들자.

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 int A, B; cin >> A >> B;
 vector<int> nxt(N+1);
 rep(i, 1, N+1) cin >> nxt[i];

 set<tuple<int, int, bool>> st;
 st.insert({A, B, true});
 bool Aturn = true;
 while(true){
 // cout << A << ' ' << B << ' ' << Aturn << '\n';
 if(A == B){
 if(N%2) cout << (Aturn ? "second" : "first");
 else cout << (Aturn ? "first" : "second");
 return;
 }
 if(Aturn && (nxt[B] != A && N%2)){
 cout << "first";
 return;
 }
 if(!Aturn && (nxt[A] != B && N%2)){
 cout << "second";
 return;
 }

 if(Aturn && nxt[nxt[A]] != B && N%2) N--;
 else if(!Aturn && nxt[nxt[B]] != A && N%2) N--;
 else if(Aturn) A = nxt[A];
 else B = nxt[B];
 Aturn = !Aturn;
 
 if(st.count({A, B, Aturn})){
 cout << "draw";
 return;
 }
 st.insert({A, B, Aturn});
 }
}

🔒

구현 코드 잠금

BOJ 17435 합성함수와 쿼리

Wed, 18 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/17435

🧐 관찰 및 접근
#

함수 $f$가 주어질 때, 최대 $500\,000$번 합성한 값을 구해야 한다.
- 나이브하게 계산하면 $O(QN)$으로 시간초과다.
- 전체를 전처리해두기엔, 공간복잡도가 $O(mN)$으로 너무 커진다.
- 따라서 적당히 전처리를 해두자.
  - 이는 LCA에서 했던것과 같이, 희소 배열로 가능할 것 같다.
  - 각 정의역에 대해 $1$번, $2$번, $4$번, $\cdots 2^k$번 합성한 결과를 저장해서 쿼리를 처리하자.

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<vector<int>> f(20, vector<int>(N+1));
 rep(i, 1, N+1) cin >> f[0][i];
 rep(k, 1, 20) rep(i, 1, N+1) f[k][i] = f[k-1][f[k-1][i]];
 int Q; cin >> Q;
 while(Q--){
 int n, x; cin >> n >> x;
 rep(k, 0, 20) if(n & (1 << k)) x = f[k][x];
 cout << x << "\n";
 }
}

🔒

구현 코드 잠금

BOJ 4817 괄호

Wed, 18 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/4817

🧐 관찰 및 접근
#

최대한 괄호를 제거해야 한다.
- 괄호 안에 덧셈이 없다면, 해당 괄호는 제거해도 된다.
- 어떨 때 괄호를 살려야 하는가?
  - $((x+y)z)$와 같이, 어떤 괄호로 이루어진 덧셈이 포함된 식과 어떤 식이 곱해지는 경우 남겨야 한다.
  - 라곤 했지만… 구현이 만만치 않다.
이를 위해 추상 구문 트리 라는것을 보통 사용한다고 한다.
- 노드단위로 연산을 나타내자.
- 이때 파싱 과정에서, 연산 우선순위가 낮은걸 먼저 해야한다. (상위 노드가 먼저 계산되므로)
  - 따라서 덧셈 -> 곱셈 -> 괄호의 순서로 진행하자.
쉽지 않은데.. 이런 생각보다 파서를 만드는 과정이 재밌다.
- 전산언어학 문제를 좀더 풀어보도록 하자.

💻 풀이
#

코드 (C++):

struct Node{
 char type;
 char var;
 Node *left, *right;

 Node(char c){ // var
 type = 'v';
 var = c;
 left = right = nullptr;
 }

 Node(char op, Node *l, Node *r){ // op
 type = 'o';
 var = op;
 left = l;
 right = r;
 }
};

struct AST{
 Node *root;

 AST(Node *r) : root(r) {}

 string emit(Node *n, char parOp){
 if(n->type == 'v') return string(1, n->var);
 if(n->var == '+'){
 string L = emit(n->left, '+');
 string R = emit(n->right, '+');
 if(parOp == '*') return "(" + L + "+" + R + ")";
 return L + "+" + R;
 }

 return emit(n->left, '*') + emit(n->right, '*');
 }

 string toString(){
 return emit(root, 0);
 }
};

struct Parser{
 const string &S;
 int pos;

 Parser(const string &s): S(s), pos(0){}

 Node *parseVal(){
 if(S[pos] == '('){
 pos++;
 Node *node = parsePlus();
 pos++;
 return node;
 }
 return new Node(S[pos++]);
 }

 Node *parseMul(){
 Node *node = parseVal();
 while(pos < (int)S.size() && (islower(S[pos]) || S[pos] == '(')){
 Node *right = parseVal();
 node = new Node('*', node, right);
 }
 return node;
 }

 Node *parsePlus(){
 Node *node = parseMul();
 while(pos < (int)S.size() && S[pos] == '+'){
 pos++;
 Node *right = parseMul();
 node = new Node('+', node, right);
 }
 return node;
 }

 AST parse(){
 return AST(parsePlus());
 }
};

void solve(){
 string S;
 while(cin >> S){
 Parser parser(S);
 AST ast = parser.parse();
 cout << ast.toString() << "\n";
 }
}

🔒

구현 코드 잠금

BOJ 1504 특정한 최단 경로

Tue, 17 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/1504

🧐 관찰 및 접근
#

$a$에서 $b$까지 가되, $v_1, v_2$를 무조건 지니야 한다.
- 이는 $a \rightarrow v_1 \rightarrow v_2 \rightarrow b$ 혹은 $a \rightarrow v_2 \rightarrow v_1 \rightarrow b$ 두가지중 하나이지 않을까?
  - 각 움직임에 대해 나이브하게 다익스트라를 수행해도 6번밖에 안되므로, 그냥 돌리자.
경로가 없을 수 있음에 유의하자.

💻 풀이
#

코드 (C++):

int N, E;
vector<pii> links[810];

int get_dist(int s, int e){
 vector<int> dist(N+1, 1e9);
 priority_queue<pii, vector<pii>, greater<pii>> pq;
 dist[s] = 0;
 pq.push({0, s});
 while(!pq.empty()){
 auto [d, u] = pq.top(); pq.pop();
 if(dist[u] < d) continue;
 if(u == e) return d;
 for(auto [v, w]: links[u]){
 if(dist[v] > d+w){
 dist[v] = d+w;
 pq.push({dist[v], v});
 }
 }
 }
 return 1e8;
}

void solve(){
 cin >> N >> E;
 rep(i, 0, E){
 int u, v, w; cin >> u >> v >> w;
 links[u].push_back({v, w});
 links[v].push_back({u, w});
 }
 int v1, v2; cin >> v1 >> v2;
 int ans = min(get_dist(1, v1) + get_dist(v1, v2) + get_dist(v2, N), get_dist(1, v2) + get_dist(v2, v1) + get_dist(v1, N));
 if(ans >= 1e8) cout << -1;
 else cout << ans;
}

🔒

구현 코드 잠금

BOJ 1865 웜홀

Tue, 17 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/1865

🧐 관찰 및 접근
#

무향인 도로와 유향인 웜홀이 있고, 음수 사이클이 있는지를 체크하는 문제이다.
- $N \leq 500$으로 크지 않으므로, 플로이드 워셜도 충분히 돈다.
  - 이건 $O(N^3)$
- 하지만 벨만포드로 $O(VE)$로 더 빠르게도 풀 수 있다.
- 벨만포드가 된다는건 SPFA로도 더 빠르게 풀 수 있다!
다 해본 결과, 플로이드워셜이 496ms, 벨만포드가 24ms, SPFA가 12ms가 나왔다.

💻 풀이
#

코드 (C++):

void solve(){
 int N, M, W; cin >> N >> M >> W;
 vector<vector<ll>> cost(N, vector<ll>(N, 1e15));
 rep(i, 0, N) cost[i][i] = 0;
 rep(i, 0, M){
 ll u, v, w; cin >> u >> v >> w;
 u--; v--;
 cost[u][v] = min(cost[u][v], w);
 cost[v][u] = min(cost[v][u], w);
 }
 rep(i, 0, W){
 ll u, v, w; cin >> u >> v >> w;
 u--; v--;
 cost[u][v] = min(cost[u][v], -w);
 }
 rep(k, 0, N) rep(i, 0, N) rep(j, 0, N) cost[i][j] = min(cost[i][j], cost[i][k] + cost[k][j]);
 rep(i, 0, N) if(cost[i][i] < 0){
 cout << "YES\n";
 return;
 }
 cout << "NO\n";
}

🔒

구현 코드 잠금

BOJ 21940 가운데에서 만나기

Tue, 17 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/21940

🧐 관찰 및 접근
#

일단 가중치가 있는 방향 그래프인데..
어떤 도시 $X$에 대해 준형이와 친구들이 살고있는 모든 도시에 대해 왕복 시간을 구할 수 있을까?
- $N$이 충분히 작으므로, 플로이드 워셜을 사용해서 모든 도시간의 이동시간을 구할 수 있겠다.
- 이후에는 모든 도시 $X$에 대해 $K$번의 계산으로 왕복시간들의 최댓값을 구할 수 있다.
시간복잡도 $O(N^3 + NK)$로 풀릴 것 같다!

💻 풀이
#

코드 (C++):

void solve(){
 cin >> N >> M;

 rep(i, 0, N) rep(j, 0, N) cost[i][j] = 1e15;
 rep(i, 0, N) cost[i][i] = 0;
 rep(i, 0, M){
 int u, v, w; cin >> u >> v >> w;
 u--; v--;
 cost[u][v] = w;
 }
 rep(k, 0, N) rep(i, 0, N) rep(j, 0, N) cost[i][j] = min(cost[i][j], cost[i][k] + cost[k][j]);

 cin >> K;
 vector<int> v(K), ans;
 rep(i, 0, K) cin >> v[i];

 ll mn = 1e15;
 rep(X, 0, N){
 ll tmp = 0;
 for(auto c: v) tmp = max(tmp, cost[X][c-1] + cost[c-1][X]);
 if(tmp < mn){
 mn = tmp;
 ans.clear();
 }
 if(tmp == mn) ans.push_back(X+1);
 }
 for(auto c: ans) cout << c << ' ';
}

🔒

구현 코드 잠금

BOJ 23807 두 단계 최단 경로 3

Tue, 17 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/23807

🧐 관찰 및 접근
#

무향그래프고, 정해진 정점중 세개 이상의 정점을 지나야 한다..
이걸 경로로 나타내면 $X \rightarrow P_i \rightarrow P_j \rightarrow P_k \rightarrow Z$이 될 것이다.
이때, $X$에서 시작한 경로와 $Z$에서 시작한 최단 경로는 다익스트라로 쉽게 계산할 수 있다.
이제 가운데 $P_j$에서 시작한 최단 경로를 구해서, 각 $P_i, P_k$에 대해 구하면 되겠다.
$O(V+E)$의 다익스트라를 $P \leq 100$번 돌려야 한다. 조금 무거운 4천만정도일거같은데, 6초제한이니 잘 돌것같다.

💻 풀이
#

코드 (C++):

void solve(){
 ll N, M; cin >> N >> M;
 vector<vector<pll>> links(N+1);
 rep(i, 0, M){
 ll u, v, w; cin >> u >> v >> w;
 links[u].push_back({v, w});
 links[v].push_back({u, w});
 }
 int X, Z; cin >> X >> Z;

 vector<ll> dist_fromX(N+1, 1e18), dist_fromZ(N+1, 1e18);
 auto dijkstra = [&](ll start, vector<ll> &dist){
 priority_queue<pll, vector<pll>, greater<pll>> pq;
 dist[start] = 0;
 pq.push({0, start});
 while(!pq.empty()){
 auto [cd, cur] = pq.top(); pq.pop();
 if(cd > dist[cur]) continue;
 for(auto [nxt, w] : links[cur]){
 ll nd = cd + w;
 if(nd < dist[nxt]){
 dist[nxt] = nd;
 pq.push({nd, nxt});
 }
 }
 }
 };
 dijkstra(X, dist_fromX);
 dijkstra(Z, dist_fromZ);

 int P; cin >> P;
 vector<int> cand(P);
 rep(i, 0, P) cin >> cand[i];

 ll ans = 1e18;
 for(int c2: cand){
 vector<ll> dist_fromC(N+1, 1e18);
 dijkstra(c2, dist_fromC);
 for(int c1: cand) for(int c3: cand){
 if(c1 == c2 || c2 == c3 || c1 == c3) continue;
 ans = min(ans, dist_fromX[c1] + dist_fromC[c1] + dist_fromC[c3] + dist_fromZ[c3]);
 }
 }
 if(ans >= 1e18) ans = -1;
 cout << ans;
}

🔒

구현 코드 잠금

BOJ 32655 출구가 바뀌는 미궁

Tue, 17 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/32655

🧐 관찰 및 접근
#

시작 정점에서 각 출구로 갈 수 있는 최단 경로를 구한 후, 열리는 타이밍에 맞춰 나갈 수 있는 최소 시간을 구하자.
$KX$초 단위로 출구가 도는게 로테이션 돌고, 이분탐색으로 그 타이밍을 찾은 후 그 블럭에서 나갈 수 있는지, 그 다음블럭에서 나갈 수 있는지 체크하면 될 것 같다.

💻 풀이
#

코드 (C++):

void solve(){
 ll N, M, K; cin >> N >> M >> K;
 vector<vector<pll>> links(N+1);
 rep(i, 0, M){
 ll u, v, w; cin >> u >> v >> w;
 links[u].push_back({v, w});
 links[v].push_back({u, w});
 }
 vector<ll> dist(N+1, LLONG_MAX);
 priority_queue<pll, vector<pll>, greater<pll>> pq;
 dist[1] = 0;
 pq.push({0, 1});
 while(!pq.empty()){
 auto [cd, cur] = pq.top(); pq.pop();
 if(dist[cur] < cd) continue;
 for(auto [nxt, w]: links[cur]){
 ll nd = cd + w;
 if(nd < dist[nxt]){
 dist[nxt] = nd;
 pq.push({nd, nxt});
 }
 }
 }

🔒

구현 코드 잠금

BOJ 33527 신촌 길찾기 서비스

Tue, 17 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/33527

🧐 관찰 및 접근
#

뭔가 전반적으로 세팅이 BOJ 5214 환승이 생각나는 것 같기도?
- 나이브하게 돈다면, 각 노선에 있을 수 있는 최대 정류장 수가 10만개니까, 이걸 다 돌기 시작하면 상당히 막막해진다.
그림을 그려서 어떤 상황인지 더 잘 판단해보자.
- - 일단 예제 1번은 이런데, 흠. 확실히 정류장보단 노선 단위로 어떻게 잘 보고싶긴 하다.
노선은 총 $5 \times X = 500$개이다.
- 이때, 노선의 환승 각 정류장 $N$개마다 $\binom{5}{2}$ 개이므로 최대 $100\,000 \times = 1\,000\,000$개인 것 같다. 중복도 제거할수도 있고.
- 아? 이게 노선이 충분히 적으니, 플로이드 워셜이 가능해보인다.
쿼리는 정점에 대해 들어오니, $U_i, V_i$가 각각 5개 노선에 속하는 경우 25가지에 대해 노선으로 계산하면 될 것 같다.

💻 풀이
#

코드 (C++):

void solve(){
 int N, X; cin >> N >> X;
 vector<array<int, 5>> bus(N);
 rep(i, 0, N) rep(j, 0, 5) cin >> bus[i][j];

 auto toIdx = [&](pii p){ 
 return p.first*X + (p.second - 1);
 };

 vector<vector<int>> dist(5*X, vector<int>(5*X, 1e9));
 rep(i, 0, 5*X) dist[i][i] = 0;
 rep(i, 0, N) rep(j, 0, 5) rep(k, j+1, 5){
 int u = toIdx({j, bus[i][j]}), v = toIdx({k, bus[i][k]});
 dist[u][v] = dist[v][u] = 1;
 }
 rep(k, 0, 5*X) rep(i, 0, 5*X) rep(j, 0, 5*X) dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);

 int Q; cin >> Q;
 while(Q--){
 int u, v; cin >> u >> v;
 int ans = 1e9;
 rep(i, 0, 5) rep(j, 0, 5){
 int idx_u = toIdx({i, bus[u-1][i]}), idx_v = toIdx({j, bus[v-1][j]});
 ans = min(ans, dist[idx_u][idx_v]);
 }
 cout << (ans == 1e9 ? -1 : ans+1) << "\n";
 }
}

🔒

구현 코드 잠금

BOJ 5925 Cow Beauty Pageant

Tue, 17 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/5925

🧐 관찰 및 접근
#

X로 그려지는 영역이 3개가 있고, 최소한의 비용으로 이들을 연결해야한다.
- 멀티 소스 BFS와 같은 맛으로 가능할 것 같다. 3개니까 전수조사 해도 되겠지.
아, 근데 좀 사고인 경우가 있구나.

.....
..X..
.X.X.
.....

위와 같은 경우에, 하나만으로도 칠할 수 있는 것 같다.
- 위와 같은 경우에, 세 그룹이 한 정점에서 무조건 모이게 된다.
- 따라서 빈 정점을 잡고, 거기서 세 그룹까지의 최단경로를 이용하자.

💻 풀이
#

코드 (C++):

void solve(){
 int N, M; cin >> N >> M;
 vector<string> S(N);
 rep(i, 0, N) cin >> S[i];

 vector<vector<int>> board(N, vector<int>(M));
 int color = 0;
 rep(i, 0, N) rep(j, 0, M) {
 if(S[i][j] == 'X' && board[i][j] == 0){
 queue<pii> Q;
 Q.push({i, j});
 board[i][j] = ++color;
 while(!Q.empty()){
 auto [cx, cy] = Q.front(); Q.pop();
 rep(d, 0, 4){
 int nx = cx + dx[d];
 int ny = cy + dy[d];
 if(nx < 0 || nx >= N || ny < 0 || ny >= M) continue;
 if(S[nx][ny] == 'X' && board[nx][ny] == 0){
 board[nx][ny] = color;
 Q.push({nx, ny});
 }
 }
 }
 }
 }

 vector<ll> dists;
 auto getDist = [&](int c1, int c2) -> ll {
 vector<vector<int>> dist(N, vector<int>(M, -1));
 queue<pii> Q;
 rep(i, 0, N) rep(j, 0, M){
 if(board[i][j] == c1){
 dist[i][j] = 0;
 Q.push({i, j});
 }
 }
 while(!Q.empty()){
 auto [cx, cy] = Q.front(); Q.pop();
 rep(d, 0, 4){
 int nx = cx + dx[d];
 int ny = cy + dy[d];
 if(nx < 0 || nx >= N || ny < 0 || ny >= M) continue;
 if(board[nx][ny] == c2){
 return dist[cx][cy];
 }
 if(board[nx][ny] == 0 && dist[nx][ny] == -1){
 dist[nx][ny] = dist[cx][cy] + 1;
 Q.push({nx, ny});
 }
 }
 }
 return (ll)1e18;
 };

 rep(i, 1, 4) rep(j, i+1, 4) dists.push_back(getDist(i, j));
 sort(all(dists));

 ll ans = dists[0] + dists[1];

 auto getDist2 = [&](int cx, int cy, int c) -> ll {
 vector<vector<int>> dist(N, vector<int>(M, -1));
 queue<pii> Q;
 dist[cx][cy] = 0;
 Q.push({cx, cy});
 while(!Q.empty()){
 auto [x, y] = Q.front(); Q.pop();
 rep(d, 0, 4){
 int nx = x + dx[d];
 int ny = y + dy[d];
 if(nx < 0 || nx >= N || ny < 0 || ny >= M) continue;
 if(board[nx][ny] == c){
 return dist[x][y];
 }
 if(board[nx][ny] == 0 && dist[nx][ny] == -1){
 dist[nx][ny] = dist[x][y] + 1;
 Q.push({nx, ny});
 }
 }
 }
 return (ll)1e18;
 };
 rep(i, 0, N) rep(j, 0, M) if(board[i][j] == 0){
 ans = min(ans, getDist2(i, j, 1) + getDist2(i, j, 2) + getDist2(i, j, 3) + 1);
 }

 cout << ans << "\n";
}

🔒

구현 코드 잠금

BOJ 7562 나이트의 이동

Tue, 17 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/7562

🧐 관찰 및 접근
#

가중치가 없으니, 간단한 BFS로 풀릴 것 같다. 시간복잡도는 $O(V + E) \approx O(N^2)$이다.

💻 풀이
#

코드 (C++):

void solve(){
 int dx[8] = {-2, -2, -1, -1, 1, 1, 2, 2};
 int dy[8] = {-1, 1, -2, 2, -2, 2, -1, 1};

 int N; cin >> N;
 vector<vector<int>> board(N, vector<int>(N, -1));
 int sx, sy, ex, ey; cin >> sx >> sy >> ex >> ey;
 queue<pii> q;
 q.push({sx, sy});
 board[sx][sy] = 0;
 while(!q.empty()){
 auto [cx, cy] = q.front(); q.pop();
 if(cx == ex && cy == ey){
 cout << board[cx][cy] << "\n";
 return;
 }
 rep(d, 0, 8){
 int nx = cx + dx[d];
 int ny = cy + dy[d];
 if(nx < 0 || nx >= N || ny < 0 || ny >= N) continue;
 if(board[nx][ny] == -1){
 board[nx][ny] = board[cx][cy] + 1;
 q.push({nx, ny});
 }
 }
 }

🔒

구현 코드 잠금

BOJ 24945 Copy ans Paste 3

Mon, 16 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/24945

🧐 관찰 및 접근
#

서브태스크가 상당히 많고, 문제가 쉽지 않아보인다. 차근차근 해보자.
$N = 3$
- 브루트포스에 가깝게 풀 수 있을 것 같다.
- 문자는 어차피 최대 3개 존재하므로, 3개에 대해 $X$가 가질 수 있는 경우의 수 $3^3$가지, $Y$가 가질 수 있는 경우 $3^3$가지를 전이하면서 다익스트라로 풀 수 있을 것 같다.
  - ㅇㅋ 된당
$S_i = a$
- 모든 문자가 a라면?
- $X$에 들어있는 문자 개수, $Y$에 들어있는 문자 개수 두가지를 이용해서 $N^2$ 정점 다익스트라가 가능해보인다.
$N \leq 30$
- 이제부터 진짜로 어떻게풀어야하는지 고민해봐야할 것 같은데…
  - 일단 복사할 문자 $Y$는 $X$의 substr이어야할 것이다.
    - 그럼 $Y$가 될 수 있는 경우의수는 $O(N^2)$이고
  - $X$를 만들때든, $Y$를 만들기위해 빌드업하고 있을때든 결국 $X$도 $X$의 substr로 존재해야한다.
    - 이것도 경우의수가 $O(N^2)$ 인 것 같다.
  - $Y$를 붙일 수 있는지 검사하는? 그런것들이 전처리를 안하면 $O(N)$쯤 되어보이니, 아마 종합해서 $O(N^5)$정도로 풀 수 있지 않나?
  - 근데 DP 전이식이 헷갈린다. 이게 상호 참조가 없나? 비용들이 달라서 다익으로 해야될 것 같은데.
- $\text{DP}[x][y]$: 현재 $X$에 $x$, $Y$에 $y$가 들어있다고 하자.
  - $A$ 연산을 거치면 $x$에 한개가 붙고, $y$는 그대로다.
  - $B$ 연산을 거치면 $x$가 빈 문자열이 되고, $y$는 $x$의 값으로 갱신된다.
  - $C$연산을 거치면 $x = x + y$가 되고, $y$는 그대로다.
  - 아하, 생각보다 $y$가 갱신될일이 없다. 그리고 $y$가 갱신된다면 $x$가 빈 문자열이 된 상태에서 시작한다!
- 복사하고 붙여넣는 과정을 그냥 해버렸다고 생각하는게 더 쉬울 것 같다.
  - $\text{DP}[i][j]$ : $S_i$~$S_j$까지 만드는 최소비용이라고 하자.
    - 이건 $\text{DP}[i][j-1]$ 후 $A$연산을 하거나
    - 어떤 $i \leq i', j' \leq j$가 있어서 그친구를 복사한 후 붙여넣기를 여러번 하거나.
      - 이건 그리디하게 되는듯? 한번 짜보자.
    - 오!!! 이걸로 대충 $30^5$정도는 성공했다!
$N \leq 200$
- 이제 $O(N^4)$는 16억이니 빡세고, $O(N^3\log{N})$쯤 까지는 줄여야하는데…
  - 섭태 5는 세제곱, 섭태 6은 제곱로그겠다.
- 음, 위에서 했던 관찰대로 $Y$에 복사해서 넣으면 $X$는 초기화돼서 시작하므로, DP를 $B$연산으로 $Y$에 복사한거까지 했을 때를 기준으로 하자.
- 젤 중요한거는 저 그리디하게 비교하면서 뒤로 슝슝슝 가는 파트인 것 같다.

💻 풀이
#

코드 (C++):

void solve(){
 cin >> N >> S >> A >> B >> C;

 if(N >= mxN) {
 cout << -1 << "\n";
 return;
 }

 rep(i, 0, N+1) rep(j, 0, N+1) DP[i][j] = LLONG_MAX;
 rep(i, 0, N+1) rep(j, i+1, N+1) DP[i][j] = A * (j-i) + B;

 const mint base = 131;
 const mint2 base2 = 137;
 vector<mint> hsh(N+1), pw(N+1);
 vector<mint2> hsh2(N+1), pw2(N+1);
 hsh[0] = 0; pw[0] = 1;
 hsh2[0] = 0; pw2[0] = 1;
 rep(i, 0, N){
 hsh[i+1] = hsh[i] * base + S[i];
 pw[i+1] = pw[i] * base;

 hsh2[i+1] = hsh2[i] * base2 + S[i];
 pw2[i+1] = pw2[i] * base2;
 }
 auto getHash = [&](int l, int r) -> pair<ll, ll>{
 ll ret1 = (hsh[r] - hsh[l] * pw[r-l]).get();
 ll ret2 = (hsh2[r] - hsh2[l] * pw2[r-l]).get();
 return {ret1, ret2};
 };

 ll ans = N*A;

 rep(L, 1, N+1){
 // A 연산 앞뒤에 붙여서 전이할 때
 if(L >= 2) rep(s, 0, N){
 if(s+L > N) break;
 int e = s+L;
 DP[s][e] = min(DP[s][e], DP[s+1][e]+A);
 DP[s][e] = min(DP[s][e], DP[s][e-1]+A);
 }

 // 해당 문자열을 복사하는 최소 비용
 map<pair<ll,ll>, vector<int>> mp;
 rep(s, 0, N){
 if(s+L > N) break;
 int e = s+L;
 mp[getHash(s, e)].push_back(s);
 }

 
 // 복사 연산으로 전이
 for(auto& [_, v]: mp){
 int sz = v.size();
 ll mn = 1e18;
 for(auto s: v) mn = min(mn, DP[s][s+L]);
 
 // 다음에 갈 수 있는 위치
 vector<int> nxt(sz, sz);
 for(int i = 0, j = 0; i < sz; i++){
 while(j < sz && v[j] < v[i]+L) j++;
 nxt[i] = j;
 }

 rep(i, 0, sz){
 int s_pos = v[i];
 int cidx = i;
 int cnt = 0;
 while(cidx < sz){
 cnt++;
 int e_pos = v[cidx]+L;
 if(e_pos > N) break;
 DP[s_pos][e_pos] = min(DP[s_pos][e_pos], mn + (C * cnt) + ((e_pos - s_pos) - (L * cnt)) * A + B);
 cidx = nxt[cidx];
 }
 }
 }
 }
 ans = min(ans, DP[0][N] - B);
 cout << ans << "\n";
}

🔒

구현 코드 잠금

BOJ 10044 小籠包 (Xiao Long Bao)

Fri, 13 Feb 2026 00:00:00 +0000

w## 📝 문제 정보

링크: https://www.acmicpc.net/problem/10044
번역

문제
#

JOI 군은 점심으로 중화요리집에서 샤오롱바오를 먹기로 했다. 샤오롱바오는 속재료와 뜨거운 국물을 밀가루 피로 싼 요리로, 먹을 때 국물이 주위로 튀는 것으로 알려져 있다.

JOI 군이 주문한 샤오롱바오 세트는 속재료나 국물이 다른 N개의 샤오롱바오로 이루어져 있다. N개의 샤오롱바오는 등간격으로 일렬로 놓여 있으며, 순서대로 1부터 N까지 번호가 매겨져 있다. i번째 샤오롱바오와 j번째 샤오롱바오 사이의 거리는 절댓값 |i - j|이다.

BOJ 27844 Fertilizing Pastures

Fri, 13 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/27844
번역

문제 번역
#

$N$개의 목초지가 있고 ($2 \le N \le 2\cdot 10^5$), $N-1$개의 도로로 연결되어 트리를 형성합니다. 모든 도로를 건너는 데 1초가 걸립니다. 각 목초지는 처음에 풀이 0개이고, $i$번째 목초지의 풀은 초당 $a_i$ ($1\le a_i\le 10^8$) 단위의 속도로 자랍니다. Farmer John은 처음에 목초지 1에 있으며, 모든 목초지의 풀에 비료를 주기 위해 돌아다녀야 합니다. 그가 $x$ 단위의 풀이 있는 목초지를 방문하면, $x$만큼의 비료가 필요합니다. 목초지는 처음 방문할 때만 비료를 주면 되고, 비료를 주는 데는 시간이 걸리지 않습니다.

BOJ 10108 Lazy Fox

Thu, 12 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/10108
번역

문제
#

당신은 간식을 좋아하는 애완용 여우를 키우고 있습니다. 서로 다른 위치(데카르트 평면 위의 점으로 표현됨)에 N명의 이웃이 있으며, 각 이웃은 당신의 애완 여우에게 간식을 나눠줍니다. 각 이웃은 무제한으로 간식을 줄 수 있습니다. 원점(여우가 시작하는 위치)은 이 N개의 위치 중 하나가 아닙니다.

BOJ 12008 262144

Thu, 12 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/12008

🧐 관찰 및 접근
#

흠, 결국 마지막에 사용한 모든 숫자들은 하나의 범위로 나타날 것 같다.
- 범위를 쪼개는 맛의 DP를 할 수 있나?
  - $\text{DP}[i][j]$: $i$~$j$까지의 숫자를 모두 사용해서 만들어진 수 라고 하면 $O(N^2)$의 시간이 걸린다…
이런 느낌으로 $\log$로 바운드 시킬 수 있q을까?
- $(1, 1, 1, 2)$ 에서 1들을 2로 묶을 수 있는 경우를 각 인덱스에 대해서 표시
- $(2, 1, 2), (1, 2, 2)$ 등으로 나타내져을때, 2들을 4로 묶을 수 있는 경우에 대해 표시..
- 그러니까, $(1, 1, 1, 2)$는 2로 묶었을때 다음 인덱스는 $(1, 2, -1, 3)$ 처럼 (0-based)
- 그러면 뒤로 계속 폴짝폴짝 뛰어다니면서 계산하면, 만들 수 있는 최대값인 58에 대해 $O(N)$번 하면 될거같기도..?

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<int> A(N);
 rep(i, 0, N) cin >> A[i];
 vector<vector<int>> v(60, vector<int>(N+1, -1));
 rep(i, 0, N) v[A[i]][i] = i;

 int ans = 0;
 rep(b, 0, 60){
 rep(i, 0, N) if(v[b][i] != -1 && v[b][v[b][i]+1] != -1) v[b+1][i] = v[b][v[b][i]+1];
 rep(i, 0, N) if(v[b][i] != -1) ans = max(ans, b);
 }
 cout << ans;
}

🔒

구현 코드 잠금

BOJ 17227 그래서 팩 주냐?

Thu, 12 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/17227

🧐 관찰 및 접근
#

생각하기 쉽게, $N$번 주제인 “그팩주” 근처에서 생각해보자.
- 어떤 정점에서, 다음 정점 중 $N$번 정점이 있다면 준표는 화제를 그 정점으로 보내면 안된다.
- 만영이의 차례에서 만영이는 다음 간선중 최대한 기댓값이 높은 정점으로 가려고 한다.
  - 그것들을 하나하나 반려해가는 맛인데..
DP식을 이런식으로 세울 수 있을까?
- $\text{DP}[i][a]$ : $i$번 정점에서 $a$번사람의 턴일때 기댓값
  - $\text{DP}[i][jun] = \min\limits_{nxt: links[i]}(\text{DP}[nxt][man])$
  - $\text{DP}[i][man] = \min\limits_{nxt: links[i]}(\text{DP}[nxt][jun] + cnt)$
    - 예를들어 만영이가 고르 수 있는 다음 정점이 $N, i, j, k$라고 하고, 기댓값은 각각 $1e9, 10, 10, 9$라고 하자.
    - $N$은 고르면 안되므로, 무조건 반려한다. 그러면 만영이는 10을 고르고, 이때 기댓값은 11이다.
    - 마지막 9를 고르기 위해 3번 반려해버리면 오히려 기댓값이 12이므로, 그러면 안된다! 따라서 내림차순으로 정렬한뒤 인덱스를 더해서 정리해보자.
- 예제 3번의 그림

💻 풀이
#

코드 (C++):

int calc(int cur, int turn){
 if(DP[cur][turn] != -1) return DP[cur][turn];
 int &ret = DP[cur][turn];
 ret = 1e9;
 if(turn == 0){ // 준표의 턴
 for(auto nxt: links[cur]) ret = min(ret, calc(nxt, 1));
 return ret;
 }
 else{ // 만영이의 턴
 vector<int> v;
 for(auto nxt: links[cur]) v.push_back(calc(nxt, 0));
 sort(all(v), greater<int>());
 rep(i, 0, v.size()) ret = min(ret, v[i] + i);
 return ret;
 }
}

void solve(){
 cin >> N >> E;
 rep(i, 0, E){
 int u, v; cin >> u >> v;
 links[u].push_back(v);
 inDeg[v]++;
 }
 rep(i, 0, N+1) DP[i][0] = DP[i][1] = -1;
 DP[N][0] = 1e9;
 DP[N][1] = 0;
 int ans = 1e9;
 rep(i, 1, N+1) if(inDeg[i] == 0) ans = min(ans, calc(i, 1));
 if(ans == 1e9) cout << -1 << '\n';
 else cout << ans << '\n';
}

🔒

구현 코드 잠금

BOJ 17790 Inquiry II

Thu, 12 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/17790
번역

문제
#

무방향 단순 그래프 G = (V, E)에 대해, V’ ⊆ V인 부분집합 V’를 독립 집합(independent set)이라고 부르는 것은 V’의 어떤 두 원소도 간선으로 연결되어 있지 않을 때입니다. G의 독립 집합을 최대 독립 집합(maximum independent set)이라고 부르는 것은 G에 그보다 엄격하게 더 많은 정점을 가진 독립 집합이 없을 때입니다. 특정한 종류의 연결된 그래프 G가 주어졌을 때, G의 최대 독립 집합의 크기를 구하세요.

BOJ 19545 소가 길을 건너간 이유 2020

Thu, 12 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/19545

🧐 관찰 및 접근
#

위쪽동네 소가 $N$마리, 아래쪽 소가 $1$마리라고 해보자.
- 그러면 연결 방법은 유일하다. 아래 헛간에 모든 위쪽 헛간을 연결해야한다.
아래쪽 소가 $2$마리라고 해보자.
- 위쪽 동네의 소를 $U_1, U_2, \cdots, U_k$를 헛간 $D_1$에, $U_{k+1}, \cdots U_N$을 $D_2$에 연결해야 한다.
따라서, 다음과 같은 식을 생각해보자.
- $\text{DP}[i][j]$: 위쪽 동네 소를 $i$마리, 아래쪽 동네 소를 $j$마리를 딱 매칭시켯을때 최솟값
- $\text{DP}[i][j] = min_{k < j}(DP[k][j-1] + \text{Cost}[k+1][i][j])$
  - 위와 같은 느낌의 식이 성립할 것 같은데, Cost를 구하는것도, DP식을 구하는것도 쉽지 않아보인다.
  - 하 이 식이 뭔가 위 / 아래쪽에 대해 대칭인게 의미심장한데…
아 스읍 이게 까다롭네.. 생각해보면, 어떤 간선을 연결했을때, 왼쪽/오른쪽에 남는 개수를 곱한만큼 에 그 경로의 길이를 곱한게 전체에 더해지는데 흠
- 아니근데 약간 그리디하게 안되나? 위랑 아래랑 같은 좌표인게 있으면 이게 무조건 잇는게 이득이 아니라고? 왜지? 경로가 길어질수가 있나?
그림을 열심히 그리다보니, 결국 간선은 두가지로 나뉜다.
- Type 1: 반대쪽 정점에 간선이 3개 이상 있고 그 중간에 있어서 해당 간선의 거리에 $N+M-1$이 곱해진다.
- Type 2: 반대쪽 정점의 가장자리 간선이라서, 해당 간선이 $i - j$를 잇는다면 $(i+j-1)(N+M-(i+j-1))$이 곱해진다.
- 그러면 각 $\text{DP}[i][j]$에 대해 마지막 친구에 대해 위에 몇개, 아래 몇개 들어있는지를 관리할 수 있지 않을까? 0개일 수는 없고, 1개면 Type1이 되고, 2개 이상이면 원래 간선을 Type2로 처리하고 Type 1을 붙이는 꼴로 될거같은딩

💻 풀이
#

코드 (C++):

ll type1(int i, int j){
 return dist(i, j) * (N + M - 1);
}

ll type2(int i, int j){
 return dist(i, j) * (i + j + 1) * (N + M - i - j - 1);
}

void solve(){
 cin >> N >> M >> L;
 rep(i, 0, N) cin >> U[i];
 rep(i, 0, M) cin >> D[i];
 rep(i, 0, N) rep(j, 0, M) rep(k, 0, 2) rep(l, 0, 2) DP[i][j][k][l] = 1e18;
 DP[0][0][0][0] = type2(0, 0);
 rep(i, 0, N) rep(j, 0, M) rep(k, 0, 2) rep(l, 0, 2){
 // 아래 헛간에 새로운 위 헛간 붙이기
 ll &cur = DP[i][j][k][l];
 if(i+1 < N){
 ll &ret = DP[i+1][j][0][1];
 if(l == 0) ret = min(ret, cur + type2(i+1, j));
 else ret = min(ret, cur - type2(i, j) + type1(i, j) + type2(i+1, j));
 }
 // 위 헛간에 새로운 아래 헛간 붙이기
 if(j+1 < M){
 ll &ret = DP[i][j+1][1][0];
 if(k == 0) ret = min(ret, cur + type2(i, j+1));
 else ret = min(ret, cur - type2(i, j) + type1(i, j) + type2(i, j+1));
 }
 }

 ll ans = 1e18;
 rep(k, 0, 2) rep(l, 0, 2) ans = min(ans, DP[N-1][M-1][k][l]);
 cout << ans << '\n';
}

🔒

구현 코드 잠금

BOJ 22348 헬기 착륙장

Thu, 12 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/22348

🧐 관찰 및 접근
#

안에서부터 각 동심원에 대해 다음과 같은 DP식을 생각해보자.
- $\text{DP}[i][j]$: $i$번째 동심원까지 그렸을 때 $j$통의 빨강 페인트를 쓰는 경우의 수
  - 그러면 파란 페인트는 $\sum\limits_{k = 1}^i k - j$ 통 필요하다.
    - 이게 $b$이하면 여유롭게 된다!
- 시간복잡도는.. $a+b \leq 100000$이므로 500번 안쪽으로 끝날거고, 그에 맞춰 나이브하게 구하면 업데이트에 5만번, 합을 구하는데 5만번이니… 500 * 50000 = 25'000'000번?
  - 근데 테케가 10000개라는 이슈가 있다… 이걸 더 줄여야만 해
아하, 다시 보니까 DP식은 안바뀐다.
- 그러면 그냥 $500 * 50000$ 테이블을 만들어놓고, 누적합을 이용해서 한번에 구하자.

💻 풀이
#

코드 (C++):

void solve(){
 vector<vector<mint>> DP(501, vector<mint>(50001, 0)), pfSum(501, vector<mint>(50002, 0));
 DP[0][0] = 1;
 rep(i, 1, 501) rep(j, 0, 50001) DP[i][j] = DP[i-1][j] + (j >= i ? DP[i-1][j-i] : 0);
 rep(i, 0, 501) rep(j, 0, 50001) pfSum[i][j+1] = pfSum[i][j] + DP[i][j];

 int tc; cin >> tc;
 while(tc--){
 ll a, b; cin >> a >> b;
 ll sum = 0;
 mint ans = 0;
 rep(i, 1, 501){
 sum += i;
 if(sum > a + b) break;
 ans += pfSum[i][min(a, sum) + 1] - pfSum[i][max(0LL, sum - b)];
 }
 cout << ans << '\n';
 }
}

🔒

구현 코드 잠금

BOJ 28693 재우의 카드깡

Thu, 12 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/28693

🧐 관찰 및 접근
#

문제 상황을 잘 생각해보자.
- $N$종류의 카드 $2N$개가 있다고 하자.
- 처음에 고른 두 카드가 같은 쌍이라면, $N-1$ 종류의 카드 $2(N-1)$개가 있는 문제로 바꿀 수 있다.
  - 이 확률은 $\frac{1}{2N-1}$이다.
- 처음에 고른 두 카드가 다른 쌍이라면, 2번의 기회를 더 써서 (총 3번의 기회로) $N-2$종류의 카드 $2(N-2)$개가 있는 문제로 바꿀 수 있다.
  - 이 확률은 $\frac{2N-2}{2N-1}$이다.
  - …인줄 알았는데 아니다! 생각해보니 $N \geq 3$일때 두개를 깐다고 해서 나머지의 위치를 모른다..
그렇다면 DP식을 새롭게 세워보자.
- $DP[N][K]$ : $N$ 쌍의 안깐 카드, $K$종의 위치를 아는 카드가 있을 때의 기댓값
  - 언제나 안깐 카드를 먼저 까는게 최적인데,
  - 그렇다면 $\frac{K}{2N+K}$의 확률로 이미 위치를 아는 카드를 발견하거나
  - $\frac{2N}{2N+K}$의 확률로 안깐카드를 발견하는데,
    - 이때 $\frac{1}{2N+K-1}$의 확률로 한방에 맞추거나
    - $\frac{K}{2N+K-1}$의 확률로 원래 알던 쌍이 나와서, 다음 턴에 그걸 맞추거나
    - $\frac{2N-2}{2N+K-1}$의 확률로 새로운 쌍이 나와서 $K$가 2 늘어나거나
  - 와 같은 식으로 정리된다.

💻 풀이
#

코드 (C++):

mint calc(int N, int K){ // $DP[N][K]$ : $N$ 쌍의 안깐 카드, $K$종의 위치를 아는 카드가 있을 때의 기댓값
 if(N < 0 || K < 0) return 0;
 if(N == 0) return mint(K);
 if(visited[N][K]) return DP[N][K];
 visited[N][K] = true;
 mint res = 0;

 // 위치를 아는 카드를 뽑는 경우
 res += (mint(K) / mint(2*N+K)) * (calc(N, K-1) + 1);

 // 위치를 모르는 카드를 뽑는 경우
 // 두번째 카드가 첫번째 뽑은 카드와 맞는 경우
 res += (mint(2*N) / mint(2*N+K)) * (mint(1) / mint(2*N+K-1)) * (calc(N-1, K) + 1);
 // 두번째 카드가 이미 위치를 아는 카드와 맞는 경우
 res += (mint(2*N) / mint(2*N+K)) * (mint(K) / mint(2*N+K-1)) * (calc(N-1, K) + 2);
 // 두번째 카드가 아예 새로운 카드일 경우
 res += (mint(2*N) / mint(2*N+K)) * (mint(2*N-2) / mint(2*N+K-1)) * (calc(N-2, K+2) + 1);

 return DP[N][K] = res;
}

void solve(){
 int N; cin >> N;
 cout << calc(N, 0);
}

🔒

구현 코드 잠금

BOJ 11000 강의실 배정

Wed, 11 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/11000

🧐 관찰 및 접근
#

각 강의를 선분이라고 생각하면, 선분이 가장 많이 겹쳐진 타이밍이 가장 많은 강의실을 필요로 하는 타이밍일 것이다.
스위핑을 사용해서 이를 계산하자.

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<pair<int, bool>> events; // {time, isStart}
 rep(i, 0, N){
 events.push_back({s, true});
 events.push_back({e, false});
 }
 sort(all(events));
 int ans = 0, cnt = 0;
 for(auto [time, isStart]: events){
 if(isStart) cnt++;
 else cnt--;
 ans = max(ans, cnt);
 }
 cout << ans;
}

🔒

구현 코드 잠금

BOJ 11066 파일 합치기

Wed, 11 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/11066

🧐 관찰 및 접근
#

파일 $C_i, C_{i+1}, \cdots, C_{j}$를 합치고 싶다고 하자.
- 이때, 해당 값은 $\text{DP}[i][j] = min_{i \leq k < j}(\text{DP}[i][k] + \text{DP}[k+1][j])$이 성립한다.
- 이는 $O(N^3)$이므로 충분히 돈다.
이런 문제는 top-down 재귀 DP로 구현하면 조금 더 편하게 짤 수 있다.
- TMI) 크누스 최적화를 이용해 더 빠르게도 풀 수 있다!

💻 풀이
#

코드 (C++):

ll calc(int L, int R){
 if(L == R) return 0;
 ll &ret = DP[L][R];
 if(ret != -1) return ret;
 ret = LLONG_MAX;
 rep(k, L, R) ret = min(ret, calc(L, k) + calc(k+1, R) + (pfsum[R] - pfsum[L-1]));
 return ret;
}

void solve(){
 cin >> N;
 rep(i, 1, N+1) cin >> C[i];
 rep(i, 1, N+1) pfsum[i] = pfsum[i-1] + C[i];
 rep(i, 1, N+1) rep(j, 1, N+1) DP[i][j] = -1;
 cout << calc(1, N) << '\n';
}

🔒

구현 코드 잠금

BOJ 1149 RGB거리

Wed, 11 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/1149

🧐 관찰 및 접근
#

현재 집 $i$번의 색을 선택하기 위해 알아야 하는 정보는 $i-1$번째 집의 색이다.
따라서 $\text{DP}[i][j]$를 $i$번째 칠했을 때, 집의 색이 $j$인 경우 (빨, 초, 파)로 정의하면 점화식은 다음과 같다.
- $\text{DP}[i][j] = min_{c \neq j}{\text{DP}[i-1][c] +\text{cost}[i][j]}$

💻 풀이
#

코드 (C++):

void solve(){
 cin >> N;
 rep(i, 0, N) rep(j, 0, 3) cin >> cost[i][j];
 rep(i, 1, N+1) rep(j, 0, 3) DP[i][j] = 1e18;
 rep(i, 0, N) rep(cur, 0, 3) rep(nxt, 0, 3) if(cur != nxt) DP[i+1][nxt] = min(DP[i+1][nxt], DP[i][cur] + cost[i][nxt]);
 cout << min({DP[N][0], DP[N][1], DP[N][2]});
}

🔒

구현 코드 잠금

BOJ 14464 소가 길을 건너간 이유 4

Wed, 11 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/14464

🧐 관찰 및 접근
#

소에 대해서는 끝나는 시간이 가장 빠른 소를, 닭에 대해서는 가장 $T$가 빨리 오는 닭을 쓰는 그리디가 성립한다.
이를 구현하는 방법은 여러가지가 있겠지만, 여기서는 multiset과 이분탐색을 이용하겠다.

💻 풀이
#

코드 (C++):

void solve(){
 int C, N; cin >> C >> N;
 multiset<int> chicken;
 rep(i, 0, C){
 int x; cin >> x;
 chicken.insert(x);
 }
 vector<pii> cow(N);
 rep(i, 0, N) cin >> cow[i].first >> cow[i].second;
 sort(all(cow), [](pii a, pii b){
 return a.second < b.second;
 });

 int ans = 0;
 for(auto [s, e]: cow){
 auto it = chicken.lower_bound(s);
 if(it != chicken.end() && *it <= e){
 ans++;
 chicken.erase(it);
 }
 }
 cout << ans << '\n';
}

🔒

구현 코드 잠금

BOJ 14939 불 끄기

Wed, 11 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/14939

🧐 관찰 및 접근
#

맨 윗줄을 어찌저찌 일처리를 끝냈다고 가정하자.
두번째 줄부터, 그 윗줄의 남은 전구를 끄는 방법은 해당 칸 아래의 스위치를 컨트롤 하는 방법이 유일하다.
이를 사용하면 맨 윗줄을 처리할 수 있는 방법 $= 2^{10} = 1024$가지에 대해 해볼 수 있고, 시뮬레이션은 $100 \times 100 = 10000$번으로 충분히 시간 내로 들어온다.
맨 아랫줄에 켜진 전구가 남아있으면 안됨에 유의한다.

💻 풀이
#

코드 (C++):

void solve(){
 vector<string> board(10);
 rep(i, 0, 10) cin >> board[i];

 int answer = 1e9;
 rep(bit, 0, 1<<10){
 vector<string> cboard = board;
 int cnt = 0;
 auto press = [&](int r, int c){
 cnt++;
 cboard[r][c] = (cboard[r][c] == 'O' ? 'X' : 'O');
 if(r > 0) cboard[r-1][c] = (cboard[r-1][c] == 'O' ? 'X' : 'O');
 if(r < 9) cboard[r+1][c] = (cboard[r+1][c] == 'O' ? 'X' : 'O');
 if(c > 0) cboard[r][c-1] = (cboard[r][c-1] == 'O' ? 'X' : 'O');
 if(c < 9) cboard[r][c+1] = (cboard[r][c+1] == 'O' ? 'X' : 'O');
 };
 rep(c, 0, 10) if(bit & (1 << c)) press(0, c);
 rep(r, 1, 10) rep(c, 0, 10) if(cboard[r-1][c] == 'O') press(r, c);
 bool ok = true;
 rep(c, 0, 10) if(cboard[9][c] == 'O') ok = false;
 if(ok) answer = min(answer, cnt);
 }
 if(answer == 1e9) cout << -1 << '\n';
 else cout << answer << '\n';
}

🔒

구현 코드 잠금

BOJ 2138 전구와 스위치

Wed, 11 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/2138

🧐 관찰 및 접근
#

첫번째 / 마지막 전구를 제외하고는, 그리디하게 끄는 규칙이 가능하다.
첫번째 전구를 건드린 경우 / 안건드린 경우 두가지에 대해, 그리디하게 끄고 전체를 끌 수 있는지 확인하자.

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 string S, T; cin >> S >> T;
 string ret = "";
 rep(i, 0, N) ret += (S[i] == T[i] ? "0" : "1");

 int ans = 1e9;

 // don't flip first
 string tmp = ret;
 int cnt = 0;
 rep(i, 1, N){
 if(tmp[i-1] == '1'){
 cnt++;
 tmp[i-1] = (tmp[i-1] == '1' ? '0' : '1');
 tmp[i] = (tmp[i] == '1' ? '0' : '1');
 if(i+1 < N) tmp[i+1] = (tmp[i+1] == '1' ? '0' : '1');
 }
 }
 if(tmp[N-1] == '0') ans = min(ans, cnt);

 // flip first
 tmp = ret;
 cnt = 1;
 tmp[0] = (tmp[0] == '1' ? '0' : '1');
 tmp[1] = (tmp[1] == '1' ? '0' : '1');
 rep(i, 1, N){
 if(tmp[i-1] == '1'){
 cnt++;
 tmp[i-1] = (tmp[i-1] == '1' ? '0' : '1');
 tmp[i] = (tmp[i] == '1' ? '0' : '1');
 if(i+1 < N) tmp[i+1] = (tmp[i+1] == '1' ? '0' : '1');
 }
 }
 if(tmp[N-1] == '0') ans = min(ans, cnt);

 if(ans == 1e9) ans = -1;
 cout << ans << "\n";
}

🔒

구현 코드 잠금

BOJ 2437 저울

Wed, 11 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/2437

🧐 관찰 및 접근
#

$1, 2, 4, 8, 16, \cdots$의 추로 모든 양의 정수를 측정할 수 있음이 자명하다.
이 이유를 살펴보면, $X$라는 무게의 추가 있을때, $X-1$까지의 모든 정수를 표현할 수 없다면 표현할 수 있는 최대치 + 1이 답이 된다.
추를 작은것부터 정렬해서, 빠지는 수 없이 무슨 양의 정수까지 최대한 잴 수 있는지 확인하자.

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<ll> v(N);
 rep(i, 0, N) cin >> v[i];
 sort(all(v));
 ll sum = 0;
 rep(i, 0, N){
 if(v[i] > sum + 1){
 cout << sum + 1 << "\n";
 return;
 }
 sum += v[i];
 }
 cout << sum + 1 << "\n";
}

🔒

구현 코드 잠금

BOJ 31740 Split the SSHS 3

Wed, 11 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/31740

🧐 관찰 및 접근
#

문제에서 주어진 그래프는 트리로 보인다.
- 트리에서는 모든 간선이 단절선이므로 하나만 잘라도 두 컴포넌트로 나뉘는것이 자명하다.
- 간선을 하나 자르고 나면 서브트리 하나와 나머지 부분으로 나뉜다.
  - 서브트리의 가중치는 트리DP를 활용해 미리 계산해둘 수 있고, 나머지 부분은 전체 가중치 합에서 해당 서브트리의 가중치 합만큼을 빼면 된다.
  - $O(N)$에 계산 가능해보인다.

💻 풀이
#

코드 (C++):

int dfs(int c, int p){
 par[c] = p;
 DP[c] = W[c];
 for(auto nxt : links[c]){
 if(nxt == p) continue;
 DP[c] += dfs(nxt, c);
 }
 return DP[c];
}

void solve(){
 cin >> N;
 rep(i, 0, N-1){
 int u, v; cin >> u >> v;
 links[u].push_back(v);
 links[v].push_back(u);
 }
 rep(i, 1, N+1) cin >> W[i];

 int SUM = dfs(1, -1);
 int ans = 2e9;
 pii ans2 = {-1, -1};
 rep(i, 2, N+1) if(ans > abs(DP[i] - (SUM - DP[i]))){
 ans = abs(DP[i] - (SUM - DP[i]));
 ans2 = {i, par[i]};
 }
 cout << ans << '\n';
 cout << ans2.first << ' ' << ans2.second << '\n';
}

🔒

구현 코드 잠금

BOJ 1300 K번째 수

Tue, 10 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/1300

🧐 관찰 및 접근
#

나이브하게 계산한다면, 정수가 $10^{10}$개 있으니 아무것도 안된다. 심지어 저장도 불가능하다.
어떤 수 $X$가 주어질 때, $X$보다 작거나 같은 수가 몇개인지는 $O(N)$에 셀 수 있다.
그리고 $X$보다 작거나 같은 수가 $K$개 이상인 수중 가장 작은 $X$가 정답이다.
따라서 파라메트릭 서치를 이용해 $O(N\log{10^9})$정도에 계산하자.

💻 풀이
#

코드 (python):

N = int(input())
K = int(input())

def count(X): # 배열에서 X 이하 수의 개수
 result = 0
 for i in range(1, N+1):
 result += min(N, X // i)
 return result

ok = N*N
ng = 0 # 답의 범위는 [1, N*N]이므로

while ok - ng > 1:
 mid = (ok + ng) // 2
 if count(mid) >= K:
 ok = mid
 else:
 ng = mid
 
print(ok)

🔒

구현 코드 잠금

BOJ 18214 Reordering the Documents

Tue, 10 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/18214
번역

문제 번역
#

Susan은 식탁 정리는 잘하지만, 사무실 책상 정리는 잘 못합니다.

Susan은 방금 일련의 문서들에 대한 서류 작업을 마쳤고, 문서들은 여전히 책상에 쌓여 있습니다. 문서들은 일련번호가 있으며, 상사가 가져왔을 때는 순서대로 쌓여 있었습니다. 그러나 지금은 순서가 완벽하지 않은데, Susan이 너무 게을러서 더미에서 빠져나온 문서들을 제자리에 다시 넣지 않았기 때문입니다. 작업이 끝났다는 소식을 듣고, 상사는 그녀에게 보내고 있는 문서 상자에 문서들을 즉시 반납하기를 원합니다. 물론 문서들은 일련번호 순서대로 상자에 보관되어야 합니다.

BOJ 20929 중간

Tue, 10 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/20929

🧐 관찰 및 접근
#

문제의 제한인 $2^{19}$와 횟수를 볼때, 이분 탐색을 장려하고 있는 것 같다.
다음과 같은 상황을 생각해보자.
- - 길이 8의 배열 2개에서 다음과 같이 $N/2$번째 수인 4번째 수를 비교했을 때, 위와 같이 작은 배열의 아래 절반과 큰 배열의 윗쪽 절반은 고려할 필요가 없어진다.
- - 위와 마찬가지로, 위에서 작은 배열 쪽 4개를 제외하고 보면 $N$이 절반으로 줄어든 상황에서 같은 방식으로 반복할 수 있음을 알 수 있다. 따라서 위와 같은 과정을 1개가 남을때까지 반복하면 두 값은 각각 $N, N+1$번째 값일 것이다.
  - 문제에서는 $N$번째 수를 요구했으므로, 더 작은 수를 출력하자.

💻 풀이
#

코드 (python):

def Query(s, idx):
 """
 질문 "? s idx"을 하고 입력받는 함수
 """
 print("?", s, idx)
 return int(input())

N = int(input())
A_Lidx = 1
A_Ridx = N # [A_Lidx ~ A_Ridx] 에 정답 후보가 있음
B_Lidx = 1
B_Ridx = N # [B_Lidx ~ B_Ridx] 에 정답 후보가 있음

while A_Ridx > A_Lidx:
 A_mid = (A_Lidx + A_Ridx) // 2
 B_mid = (B_Lidx + B_Ridx) // 2
 A_ret = Query("A", A_mid)
 B_ret = Query("B", B_mid)
 if A_ret <= B_ret:
 A_Lidx = A_mid + 1
 B_Ridx = B_mid
 else:
 A_Ridx = A_mid
 B_Lidx = B_mid + 1

A_ret = Query("A", A_Lidx)
B_ret = Query("B", B_Lidx)
print("!", min(A_ret, B_ret))

🔒

구현 코드 잠금

BOJ 27421 Make a Loop

Tue, 10 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/27421
번역

문제
#

Taro는 장난감 철도 선로 세트를 가지고 놀고 있습니다. 모든 선로는 직각 중심각(90도 각도)을 가진 호 모양이지만, 반지름은 다양합니다. Taro는 이 모든 선로를 사용하여 하나의 루프를 만들려고 합니다. 여기서 선로 세트가 하나의 루프를 형성한다는 것은 모든 선로의 양 끝이 다른 선로와 부드럽게 연결되고, 모든 선로가 직접 또는 간접적으로 다른 모든 선로와 연결되어 있을 때를 의미합니다. Taro가 이것을 달성할 수 있는지 여부를 알려주세요.

BOJ 31498 장난을 잘 치는 토카 양

Tue, 10 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/31498

🧐 관찰 및 접근
#

집 - 토카 - 돌돌이 형태로 있는 것 같다.
매 수행마다 토카는 $B, B-K, B-2*K \cdots$ 만큼 움직이고, 돌돌이는 $D$만큼 계속 움직인다.
토카가 잡힌다면, 그 순간 토카가 움직인 길이는 $D$보다 작을 것이다.
따라서 토카가 어느 순간 잡혔다면, 토카와 돌돌이가 계속 움직인다고 가정하면 돌돌이는 토카보다 훨씬 왼쪽에 있게 된다.
- 따라서 시간에 토카와 돌돌이의 위치에 단조성이 존재한다.
- 이분 탐색을 이용할 수 있겠다.
토카가 집에 도착하지도 못하는 상황, $K$가 0인상황 등 여러가지 예외 상황을 조심하자.

💻 풀이
#

코드 (python):

A, B = map(int, input().split())
C, D = map(int, input().split())
K = int(input())

# 토카가 집에 도착할 수는 있는가?
# B + (B-K) + (B-2K) + ... >= A
if K > 0: # K = 0이면 무조건 도착할 수 있음
 cnt = B // K # B - cnt * K >= 0 인 최대 cnt
 tot = B * (cnt + 1) - K * (cnt * (cnt + 1)) // 2 # B + (B-K) + ... + (B - cnt * K)
 if tot < A:
 print(-1)
 exit(0)

# 토카가 집에 도착하는 타이밍이 돌돌이보다 이른가?
def toka_move(time):
 if K > 0:
 time = min(time, B // K + 1)
 return B * time - K * (time * (time - 1)) // 2

ok, ng = 10**12, 0

# 토카가 집에 도착하는 가장 빠른 타이밍
while ok - ng > 1:
 mid = (ok + ng) // 2
 if toka_move(mid) >= A:
 ok = mid
 else:
 ng = mid

if D*ok < A + C: # 아직 돌돌이가 도착하지 않았다면
 print(ok)
else:
 print(-1)

🔒

구현 코드 잠금

BOJ 13448 SW 역량 테스트

Sun, 08 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/13448

🧐 관찰 및 접근
#

얻는 점수가 $M_i - t * p_i$가 아닌 $M_i$라면, 단순한 배낭문제일텐데..
- 이걸 위해서 $N$에 대한 비트마스킹을 추가하는건 미친짓이다
그런데, 어떤 문제들을 풀기로 결정했다면, 그 문제들에 대해 순서를 정하는건 그리디하게 되지 않나?
- 문제 $i, j$가 있다고 하자.
- $i \rightarrow j$로 풀면 $(M_i - t * P_i) + (M_j - (t + R_i)*P_j)$ 점을 얻게 되고
- $j -> i$로 풀면 $(M_j - t*P_j) + (M_i - (t + R_j) * P_i)$ 점을 얻게 된다.
- 위에서 아래 식을 빼면 $P_i * R_j - P_j * R_i$ 이고, $i \rightarrow j$가 이득이기 위해선 이게 양수여야하므로
- $\frac{P_i}{R_i} \geq \frac{P_j}{R_j}$로 정렬하는 그리디 전략이 유효하다.
  - 그렇다면 이 순서로 냅색 DP를 수행하자.

💻 풀이
#

코드 (C++):

void solve(){
 int N, T; cin >> N >> T;
 vector<Problem> Prob(N);
 rep(i, 0, N) cin >> Prob[i].M;
 rep(i, 0, N) cin >> Prob[i].P;
 rep(i, 0, N) cin >> Prob[i].R;
 sort(all(Prob), [](Problem &A, Problem &B){
 return A.P * B.R > B.P * A.R;
 });

 vector<ll> DP(T+1);
 for(auto [M, P, R]: Prob) rrep(t, 0, T+1){
 if(t - R < 0) break;
 DP[t] = max(DP[t], DP[t - R] + (M - P*t));
 }
 ll ans = 0;
 rep(i, 0, T+1) ans = max(ans, DP[i]);
 cout << ans;
}

🔒

구현 코드 잠금

BOJ 26857 Cell Game

Sun, 08 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/26857
번역

문제 번역
#

두 형제 Aldo와 Bondan은 COVID-19 팬데믹 상황이 악화되어 도시가 다시 봉쇄되면서 집에 갇혀 있습니다. 그들은 학기를 마치고 방학 중이지만, 집 밖으로 나갈 수 없다면 무슨 방학을 즐길 수 있을까요? 하지만 지루함은 창의성을 불러일으킵니다. 그들은 지루한 방학 동안 새로운 게임을 만들었습니다.

BOJ 26969 Bribing Friends

Sun, 08 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/26969
번역

문제 번역
#

Bessie는 “소 유전체학: 다큐멘터리"를 보고 싶지만, 혼자 가고 싶지 않습니다. 불행히도, 그녀의 친구들은 함께 갈 만큼 열정적이지 않습니다! 따라서 Bessie는 친구들이 영화관에 함께 가도록 뇌물을 줘야 합니다. 그녀는 두 가지 뇌물 수단을 가지고 있습니다: 무니(mooney)와 아이스크림 콘입니다.

BOJ 31760 Joys of Trading

Sun, 08 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/31760
번역

문제
#

Apolyanka와 Büdelsdorf는 최근 접촉하게 된 두 개의 작은 신석기 시대 마을입니다. $1$부터 $N$까지 번호가 매겨진 $N$개의 자원이 있으며, 각 마을은 서로 다른 효율성을 가지고 이들 자원을 독립적으로 생산할 수 있습니다. 자원 $i$를 한 단위 생산하기 위해, Apolyanka는 $A_i$ 인시(person-hours)가 필요하고, Büdelsdorf는 $B_i$ 인시가 필요합니다. 현재 Apolyanka는 주어진 각 시간 기간에 자원 $i$를 $U_i$ 단위 생산하고 있으며, Büdelsdorf는 $W_i$ 단위를 생산하고 있습니다.

BOJ 30208 휴가 나가기

Sat, 07 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/30208

🧐 관찰 및 접근
#

업무들의 순서때문에, 자유롭게 선택하지 못하는 경우들이 생긴다.
- 이게 어떤 느낌이지?
- 예제 입력 1의 순서는 다음과 같다.
  - $1 \rightarrow 2 \rightarrow 3$을 보자.
    - $1$까지 수행해서 중요도 $w_1$, 처리시간 $t_1$을 얻을 수 있다.
    - $2$까지 수행해서 중요도 $w_1 + w_2$, 처리시간 $t_1 + t_2$를 얻을 수 있다.
    - $3$까지 수행해서 $\cdots$
  - 저렇게 물건을 만들고 나면, 세개중에서 택1을 하는것 빼고는 배낭문제와 동일해진다.
    - 트리 dfs로 냅색을 잘 돌면서 DP를 할 수 있을 것 같다.
    - 근데 안에서 분기가 일어나면…
      - 0이 아닌 모든 $p_i$들은 모두 다르다
      - 라는 문장이 입력에 있다.

💻 풀이
#

코드 (C++):

void dfs(int cur, int root, int w, int t){
 w += W[cur];
 t += T[cur];
 bags[root].push_back({w, t});
 for(auto nxt: links[cur]) dfs(nxt, root, w, t);
}

void solve(){
 cin >> N >> S;
 rep(i, 1, N+1) cin >> W[i];
 rep(i, 1, N+1) cin >> T[i];
 rep(i, 1, N+1){
 int p; cin >> p;
 links[p].push_back(i);
 }

 for(auto nxt: links[0]) dfs(nxt, nxt, 0, 0);
 rep(i, 0, N+2) rep(j, 0, S+1) KS[i][j] = 1e9;
 KS[0][0] = 0;
 rep(i, 0, N+1) rep(j, 0, S+1) {
 KS[i+1][j] = min(KS[i+1][j], KS[i][j]);
 for(auto [w, t]: bags[i]){
 int nxt = min(S, j + w);
 // }
 KS[i+1][nxt] = min(KS[i+1][nxt], KS[i][j] + t);
 }
 }


 if(KS[N+1][S] == 1e9) cout << -1;
 else cout << KS[N+1][S];
}

🔒

구현 코드 잠금

BOJ 30788 Sakura Reflection

Sat, 07 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/30788

🧐 관찰 및 접근
#

대칭이동을 어떻게 수학적으로 표현할 수 있을까??
- 쉬운거부터 해보자. 원래 점이 $(x, y)$에 있었다면
  - $90\degree$ 직선에 대칭시키면 $(-x, y)$
  - $45\degree$ 직선에 대칭시키면 $(y, x)$
  - $60\degree$ 직선에 대칭시키면 $y = \sqrt{3}x$에 대칭인거니까… 아니 이거 너무 까다로운데?
  - 행렬연산은 하기 싫은데..
- 각도를 기준으로 생각해보는것도 좋겠다. 극좌표계처럼, 원래 점이 $0\degree$에 있었다면
  - $60\degree$에 대해 대칭시키면 $120\degree$에
  - $120\degree$에 대해 대칭시키면 $240\degree$에
  - 이런 느낌인 것 같다.
  - 그렇다면 예제 1번은 $0\degree \rightarrow 120\degree \rightarrow 330 \degree \rightarrow 60 \degree \rightarrow 0$ 인거 같다!
    - $45\degree = 225\degree$라고 생각하고, 가까운 곳을 찾아서 두배로 넘기고, 360으로 모듈러를 취하자.
자, 이제 한번씩 써서 0도로 돌아오는걸 어떻게 만들지?
- $15\degree$로 만들 수 있는건 $30\degree$
- $x\degree$를 $a$에 대칭이동시키면 $(2a - x) \degree$가 되는 것 같다!
- 이걸 또 $b$에 대칭이동시키면 $(2b - (2a - x))\degree$ 인거같고.. 그러면 플마로 바뀌어가면서 더해지니까 결국 모듈러 360에 대해 두 그룹으로 나눈 합을 일정하게 맞출 수 있는지에 대한 문제로 바뀐다.

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<int> A(N);
 rep(i, 0, N) cin >> A[i];

 if(N%2){
 cout << "NO";
 return;
 }

 int sum = 0;
 for(auto x: A) sum += x;
 sum %= 360;
 DP[0][0][0] = true;
 rep(i, 0, N) rrep(j, 0, N) rep(k, 0, 360) if(DP[i][j][k]){
 int nxt = (k + A[i]*2) % 360;
 DP[i+1][j+1][nxt] = true;
 DP[i+1][j][k] = true;
 }

 if(DP[N][N/2][sum] || DP[N][N/2][(sum + 180) % 360]){
 cout << "YES\n";
 vector<bool> used(N);
 int ci = N, cj = N/2, cs = sum;
 if(!DP[N][N/2][sum]) cs = (sum + 180) % 360;
 while(cj){
 int prv = (cs - A[ci-1]*2) % 360;
 if(prv < 0) prv += 360;
 if(DP[ci-1][cj - 1][prv]){
 used[ci-1] = true;
 ci--;
 cj--;
 cs = prv;
 }
 else ci--;
 }
 vector<int> v1, v2;
 rep(i, 0, N){
 if(used[i]) v1.push_back(i+1);
 else v2.push_back(i+1);
 }
 rep(i, 0, N/2){
 cout << v1[i] << ' ' << v2[i] << ' ';
 }
 }
 else cout << "NO";
}

🔒

구현 코드 잠금

BOJ 31265 훈련

Sat, 07 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/31265

🧐 관찰 및 접근
#

이해가 조금 어려운데, 결국 $N$개의 훈련 상황에서 $d$개의 훈련 가운데 하나를 계속 고르고, 훈련 시간의 합을 최대화 하고싶다.
- 배낭 문제와 비슷해보인다.
- $d$개의 선택지가 $N$번 주어지고, 훈련시간 = 무게의 합을 최대화 해야한다.
어? 나이브하게 하면 터지나?
- 각 단계마다 해야하는 연산량은 $M * d_i$이다.
- 총 연산량은 $\sum\limits_{i = 1}^N M * d_i \leq 1000 M$ 이니 괜찮을 것 같다.
아니!!!!!!!! 왜틀렸나 했네
- 각 훈련 상황에서 적어도 하나의 훈련을 골라 훈련 계획에 넣으려고 한다.
- 한 훈련을 여러번 쓰지 않게 $M$에 대해 역순으로 돌면서, 잘 처리하자.

💻 풀이
#

코드 (C++):

void solve(){
 cin >> N >> M;
 rep(i, 0, N){
 cin >> D[i];
 tv[i].resize(D[i]);
 }
 rep(i, 0, N) rep(j, 0, D[i]) cin >> tv[i][j];
 knapsack[0][0] = true;
 rep(i, 1, N+1) for(auto t: tv[i-1]) rrep(j, 0, M+1) if(j - t >= 0 && (knapsack[i-1][j-t] || knapsack[i][j-t])) knapsack[i][j] = true;

 rrep(j, 0, M+1) if(knapsack[N][j]){
 cout << j;
 return;
 }
 cout << -1;
}

🔒

구현 코드 잠금

BOJ 16225 제271회 웰노운컵

Fri, 06 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/16225

🧐 관찰 및 접근
#

약간 게임이론적이네.
- $(A_i, B_i), (A_j, B_j)$ 두가지를 고른다.
- 이때, $B_i > B_j$라면 $A_j$, $B_i < B_j$라면 $A_i$를 얻게된다.
직관적인것들을 생각해보자.
- $A_i$가 크고, $B_i$가 작은것들이 있으면 좋겠다.
  - 위 친구들을 $A_i$가 작거, $B_i$가 큰 친구들이랑 매칭시켜서 없애버리면 좋다.
- $B$가 가장 작은 문제는 언제나 내가 풀게 된다.
  - $B$가 가장 큰 문제는 언제나 상대가 풀게 된다.
  - 이쪽에서 출발해볼까?
- $B$에 대한 오름차순으로 정렬해보자. 그러면 버릴 문제를 하나 고를 수 있다.
- 일단 예제를 $B$에 대한 오름차순으로 정렬한 후, $A$만 남기면
  - $(2, 4, 8, 6)$ 이 된다.
    - 이때 2를 택하고 4를 버려고, 8을 택하고 6을 버리면 10이 된다.
  - 여러개로 생각해보니, 약간 올바른 괄호 문자열 맛으로 되는데…
    - 20만 $O(N^3)$ DP는 안된다이
    - $\text{DP}[i][j]$: $i$번째까지 봤을때, 여는괄호가 $j$개일때 최댓값 이라고 하면 $O(N^2)$도 된다만…
  - 근데 열리는 괄호는, 생각보다 빠르게 열어줘야한다.
    - 1번을 먹었으니, $(2, 3)$중에 하나는 무조건 열어야 한다.
      - $2$를 먹었다면, $3, 4, 5$중 하나는 무조건 열어야 한다.
      - $3$을 먹었다면, $2, 4, 5$중 하나는 무조건 먹어야 한다.
    - $k$개 먹었다면, $2 \leq i \leq 2*k + 1$ 범위 내에서 한개를 더 먹어줘야한다.
      - 이때 최댓값을 먹어줘야하고, 점 업데이트가 있으니 세그먼트 트리로 되겠다.
        
        세그워킹 ㄱ.ㄱ

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<pii> A(N);
 rep(i, 0, N) cin >> A[i].first;
 rep(i, 0, N) cin >> A[i].second;
 sort(all(A), [](pii a, pii b){
 return a.second < b.second;
 });
 vector<ll> v;
 rep(i, 0, N) v.push_back(A[i].first);

 ST.init(N);
 rep(i, 0, N) ST.set(i, v[i]);
 ST.build();

 ll ans = v[0];
 rep(i, 1, N/2){
 auto [val, idx] = ST.seg_walk(1, i*2);
 ans += val;
 ST.update(idx, 0);
 }
 cout << ans << '\n';
}

🔒

구현 코드 잠금

BOJ 7008 Double Trouble

Fri, 06 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/7008
번역

문제
#

Alice Catherine Morris와 그녀의 여동생 Irene Barbara는 자주 이메일을 주고받습니다. 항상 도청을 경계하며 통신 내용을 비밀로 유지하고자, 그들은 메시지를 두 단계로 암호화합니다. 모든 비알파벳 문자를 제거하고 모든 문자를 대문자로 변환한 후:

각 문자를 알파벳에서 s 위치 뒤의 문자로 치환합니다 (1 <= s <= 25) - 이를 s만큼의 시프트라고 합니다.
단계 1의 결과를 m개의 문자로 된 그룹으로 나누고 각 그룹의 문자들을 역순으로 배열합니다 (5 <= m <= 20). 메시지의 길이가 m으로 나누어떨어지지 않으면, 마지막 k개(m보다 작은)의 문자들을 역순으로 배열합니다.

예를 들어, s = 2이고 m = 6이라고 가정합시다. 평문이 “Meet me in St. Louis, Louis.“라면, 불필요한 문자를 제거하고 대문자로 변경하면:

BOJ 11920 버블 정렬

Thu, 05 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/11920

🧐 관찰 및 접근
#

배열 $[3, 4, 1, 2, 7, 6]$이 있다고 하자. 처음 한바퀴를 돌면 어떻게 되지?
- $[3, 1, 2, 4, 6, 7]$이 된다.
  - 이걸 어떻게 해석할 수 있을까?
  - 가장 큰 수는 맨 오른쪽에 고정된다.
  - 다른 수들은, 오른쪽에 붙어있수가 자기보다 작은것들을 왼쪽으로 다 밀고, 오른쪽으로 간다.
    - 오큰수? 스택? 그런맛인데 이거
  - 두번하면 어떻게?
- $[1, 2, 3, 4, 6, 7]$이 된다.
  - 나 5 안썼었구나 ㅋㅋ 이런
  - 값을 두개정도 들고있다가..? 뭔가 그런느낌…? $K$번 진행한다고 하면, 값을 $K$개정도 들고있다가, 들고있는 값중 젤 작은거보다 작으면 그대로 통과시키고, 그것보다 크다면? 어떻게 되는거지?
$[5, 7, 4, 3, 6, 8, 1, 2]$를 해보자.
- $[5, 4, 3, 6, 7, 1, 2, 8]$
- $[4, 3, 5, 6, 1, 2, 7, 8]$
- 두개 들고있다가 큰거 만나면 작은값 빼버려서 튀면 되는듯??

💻 풀이
#

코드 (C++):

void solve(){
 int N, K; cin >> N >> K;
 vector<int> A(N);
 rep(i, 0, N) cin >> A[i];
 vector<int> ans;
 priority_queue<int, vector<int>, greater<int>> PQ;
 rep(i, 0, N){
 PQ.push(A[i]);
 if(PQ.size() > K){
 ans.push_back(PQ.top());
 PQ.pop();
 }
 }
 while(!PQ.empty()){
 ans.push_back(PQ.top());
 PQ.pop();
 }
 for(auto x: ans) cout << x << " ";
}

🔒

구현 코드 잠금

BOJ 28433 게리맨더링

Thu, 05 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/28433

🧐 관찰 및 접근
#

수열을 원하는 개수의 연속된 구간으로 나누어서
- 구간의 합이 양수인 개수 - 구간의 합이 음수인 개수를 양수로 만들자.
직관적으로 생각해보자.
- 지금까지의 합이 양수면 -> 걍 잘라버리는게 이득이다.
- 지금까지의 합이 음수면 -> 이게 좀 고민이네
  - 다음 놈이 음수면 -> 계속 먹으면 되는데, -100 -100 -100 1 -100 같은 경우에는 한번에 큰덩이로 먹는게 이득일수도 있지 않나?
  - 일단 양수/음수는 묶어서 생각할 수 있을거같고, 음수 친구를 왼쪽/오른쪽으로 보내서 양수 덩어리에 합류시킬지 말지만 고민하면 되는것같다.
- 그렇다면 양수 / 양수 / 음수 / 양수 / 음수 / 양수 이렇게 생겼을텐데, 이제는 음수인 것이 두개 이상 붙어서 등장하지 않는다.
  - 양수 개수 > 음수 개수라면 1을 출력하면 된다!
  - 양수 개수 = 음수 개수라면 한 칸이 결합 가능한지 생각하면 된다!
  - 양수 개수 < 음수 개수라면 두 칸이 결합 가능한지 생각하면 된다!
    - 이게 두번 확인해야해서 문제지만, 결합 가능하면 무조건 결합한다는 방식이 그리디하게 가능하다. 직관적이긴 하네
- 라고!!!!!!!! 생각했지만!!!!!!!!! 틀렸다.
  - $[2, -1, -1, 2, -1, -1]$ 의 경우.. $(2, -1), (-1, 2), (-1, -1)$로 묶으면 된다. 그러니까 맘대로 묶으면 안된다는건데….
    - 그리디 문제 추천받아서 풀던거라 여기서 DP로 틀진 않았고, 솔직히 평소같았으면 세그DP로 튀었을듯

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<ll> v;
 ll sum = 0;
 rep(i, 0, N){
 ll x; cin >> x;
 if(x != 0) v.push_back(x);
 sum += x;
 }
 if(v.size() == 0){
 cout << "NO\n";
 return;
 }

 ll cur = 0;
 int pcnt = 0, ncnt = 0;
 for(auto x: v){
 if(x > 0){
 if(cur <= 0 && cur +x > 0) cur += x;
 else{
 if(cur > 0) pcnt++;
 if(cur < 0) ncnt++;
 cur = x;
 }
 }
 else{
 if(cur > 0 && cur + x <= 0){
 if(cur > 0) pcnt++;
 if(cur < 0) ncnt++;
 cur = x;
 }
 else{
 cur += x;
 }
 }
 // cout << "cur: " << cur << " pcnt: " << pcnt << " ncnt: " << ncnt << "\n";
 }
 if(cur > 0) pcnt++;
 if(cur < 0) ncnt++;
 cout << (pcnt > ncnt ? "YES" : "NO") << "\n";
}

🔒

구현 코드 잠금

BOJ 18830 하이퍼 수열과 하이퍼 쿼리

Wed, 04 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/18830

🧐 관찰 및 접근
#

11차원인게 조금 이슈이므로, 간단하게 3차원정도로 생각해보자.
- 2차원이면 그냥 누적합 배열에서 $S(a_2, b_2) - S(a_1, b_2) - S(a_2, b_1) + S(a_1, b_1)$이었던 것이 기억난다.
- $a_1, b_1, c_1, a_2, b_2, c_2$가 주어진다.
- $a_1 \leq \alpha \leq a_2, b_1 \leq \beta \leq b_2, c_1 \leq \gamma \leq c_2$ 인 어쩌구에 대해 합을 출력한다.
- 이를 누적합으로 생각하면, $S(a_2, b_2, c_2) - S(a_1, b_2, c_2) - S(a_2, b_1, c_2) - S(a_2, b_2, c_1) + S(a_1, b_1, c_2) + S(a_1, b_2, c_1) + S(a_2, b_1, c_1) - S(a_1, b_1, c_1)$ 인 것 같다! 아님말고
- 암튼 $n$차원일때 누적합 배열을 구해둔다면 $2^n$의 시간복잡도로 계산할 수 있는 것 같다.
- 쿼리가 4만개이므로 $40000 * 2048 = 81920000$이므로 충분히 돌 것 같다.
- 그런데 누적합 배열을 만드는게 $O(2^n * mno...w)$ 라서 이게 20억인데…
  - 포함배제로 구하지 말고, 차원에 대해서 구하고 밀어버리자.

💻 풀이
#

코드 (C++):

const int cdim = 11;
using v11 = array<int, cdim>;
v11 dim, sz;
int totSz;
vector<ll> A, pfsum;

int point_to_idx(const v11 &point){
 int idx = 0;
 rep(d, 0, cdim) idx += point[d] * sz[d];
 return idx;
}

vector<ll> make_prefix_sum(int cd = 0, v11 cp = {}){
 vector<ll> res;
 if(cd == cdim){
 int idx = point_to_idx(cp);
 res.push_back(A[idx]);
 return res;
 }

 rep(i, 0, dim[cd]){
 cp[cd] = i;
 vector<ll> tmp = make_prefix_sum(cd+1, cp);
 if(res.empty()) res = tmp;
 else{
 rep(j, 0, tmp.size()) res.push_back(res[(i-1) * sz[cd] + j] + tmp[j]);
 }
 }
 cp[cd] = 0;

 return res;
}

void solve(){
 rep(i, 0, cdim) cin >> dim[i];
 sz[cdim-1] = 1;
 rrep(d, cdim-1, 0) sz[d] = sz[d+1] * dim[d+1];
 totSz = sz[0] * dim[0];
 A.resize(totSz);
 pfsum.resize(totSz, 0);
 rep(i, 0, totSz) cin >> A[i];

 pfsum = make_prefix_sum();

 int Q; cin >> Q;
 while(Q--){
 v11 L, R;
 rep(d, 0, cdim) cin >> L[d];
 rep(d, 0, cdim) cin >> R[d];
 rep(d, 0, cdim) L[d]--, R[d]--;

 ll ans = 0;
 rep(mask, 0, (1<<cdim)){
 v11 point = R;
 bool add = true, flag = true;

 rep(d, 0, cdim) if(mask & (1<<d)){
 point[d] = L[d]-1;
 add = !add;
 if(point[d] < 0){
 flag = false;
 break;
 }
 }
 if(!flag) continue;

 int idx = point_to_idx(point);
 if(add) ans += pfsum[idx];
 else ans -= pfsum[idx];
 }
 cout << ans << "\n";
 }
}

🔒

구현 코드 잠금

BOJ 24452 交易計画 (Trade Plan)

Wed, 04 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/24452
번역

문제 번역
#

JOI 연방국에는 1부터 N까지 번호가 매겨진 N개의 도시와, 1부터 M까지 번호가 매겨진 M개의 도로가 있다. 도로 i (1 ≦ i ≦ M)는 도시 Ui와 도시 Vi를 양방향으로 연결하고 있다.

JOI 연방국은 1부터 K까지 번호가 매겨진 K개의 주(州)로 이루어져 있다. 도시 j (1 ≦ j ≦ N)는 주 Sj에 속해 있다. 또한, 모든 주는 적어도 하나의 도시를 포함한다.

BOJ 28068 I Am Knowledge

Wed, 04 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/28068

🧐 관찰 및 접근
#

지금 어떤 책을 읽을 수 있고, $a_k <= b_k$라면, 읽지 않을 이유가 없다.
나머지 $a_k > b_k$들인 책들은 어차피 읽을수록 즐거움이 감소만 하므로, $a_k$가 큰거부터 차례대로 읽으면 되지 않을까? 어떻게 그리디하게 가야하지?
- 두 책 $i, j$가 있다고 해보자.
- 이때, 두 책을 $i \rightarrow j$로 읽기 위해선
  - $F \geq a_i$
  - $F - a_i + b_i \geq a_j \rightarrow F \geq a_i + a_j - b_i$
  - 따라서 $F \geq \max(a_i, a_i + a_j - b_i) = \text{Cost}_{i \rightarrow j}$
- 같은 방식으로, $j \rightarrow i$로 읽기 위해선
  - $F \geq \max(a_j, a_i + a_j - b_j) = \text{Cost}_{j \rightarrow i}$
- 이 때, $b_i \geq b_j$라고 가정하자.
  - $a_i < a_i + (a_j - b_j)$
  - $a_i + a_j - b_i \leq a_i + a_j - b_j$
  - 이 두 식이 성립하므로, 언제나 $\text{Cost}_{i \rightarrow j} \leq \text{Cost}_{j \rightarrow i}$
  - 따라서 $b$의 내림차순으로 정렬 후 그리디가 성립한다.

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<pii> v1, v2;
 rep(i, 0, N){
 int a, b; cin >> a >> b;
 if(a <= b) v1.push_back({a, b});
 else v2.push_back({a, b});
 }
 sort(all(v1));
 sort(all(v2), [](pii &p1, pii &p2){
 return p1.second > p2.second;
 });
 ll cur = 0;
 for(auto &p: v1){
 if(cur < p.first){
 cout << 0;
 return;
 }
 cur -= p.first;
 cur += p.second;
 }
 for(auto &p: v2){
 if(cur < p.first){
 cout << 0;
 return;
 }
 cur -= p.first;
 cur += p.second;
 }
 cout << 1;
}

🔒

구현 코드 잠금

BOJ 20136 멀티탭 스케줄링 2

Tue, 03 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/20136

🧐 관찰 및 접근
#

그리디하게, 뽑아야할때 곧 쓸만한걸 남기고, 나중에 쓸만한걸 뽑으면 되지 않을까?
- 증명해보자.
현재 $N$개의 구멍이 꽉차있고, $A$를 새로 꽂아야한다고 가정하자.
가장 나중에 쓰는걸 뽑는 전략 $G$가 있고, 어떤 최적의 전략 $Opt$가 있다고 가정하자.
- 이제 $G$가 $Opt$보다 나쁘지 않음을 보이면 된다.
어느 순간, $A$를 꽂기 위해 $G$는 $X$를, $Opt$는 $Y$를 뽑았다.
- 이때, 이후에 $X$가 먼저 등장한다면, $G$는 한번 더 뽑/꼽을 수행해야하고, $Opt$는 아니다.
- $Y$가 먼저 등장했다면, $Opt$는 뽑/꼽을 수행해야 하고, $G$는 아니다.
- 그런데, $G$의 전략 특성상 $Y$보다 $X$가 늦게 등장해야하므로, 언제나 $Opt$보다 $G$가 나쁘지 않다.

💻 풀이
#

코드 (C++):

void solve(){
 int N, K; cin >> N >> K;
 vector<queue<int>> nxt(K+1);
 vector<int> A(K);
 rep(i, 0, K) cin >> A[i];
 rep(i, 0, K) nxt[A[i]].push(i);
 rep(i, 1, K+1) nxt[i].push(1e9);
 set<pii> st; // (nxt use, val)
 vector<bool> inuse(K+1, false);

 int ans = 0;
 rep(i, 0, K){
 int val = A[i];
 if(inuse[val]){ // 이미 꽂혀있다면
 st.erase({i, val});
 }
 // 꽂혀있지 않다면
 else if((int)st.size() < N){ // 남은 자리가 있으면
 inuse[val] = true;
 }
 else{ // 남은 자리가 없으면
 ans++;
 pii old = *st.rbegin();
 st.erase(old);
 inuse[old.second] = false;
 inuse[val] = true;
 }
 nxt[val].pop();
 if(!nxt[val].empty()) st.insert({nxt[val].front(), val});
 }
 cout << ans << '\n';
}

🔒

구현 코드 잠금

BOJ 28448 광기의 PS

Tue, 03 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/28448

🧐 관찰 및 접근
#

한 문제당 광기는 $KT$만큼 쌓이고, 해결했을때 $\text{min}(KT, 5K)$만큼 빠지므로 $T \leq 5$라면 문제를 푸는데 광기가 안쌓인다.
- 어라? 아니네. $KT \leq L$ 조건도 필요하다.
  - 아 이건 문제조건에 있네.
- 암튼 이 친구들은 어차피 T시간 걸려서 풀기만 하면 상관이 없다.
나머지 문제들에 대해, 어차피 문제를 풀어서 쌓이는 광기의 합은 일정하다.
- 그러니까, 문제를 해결해서 광기를 줄이는걸 힘내야하지 않을까?
- 그러면 광기를 많이 해소할 수 있는 문제를 먼저 풀어야하는 거 같은데…

💻 풀이
#

코드 (C++):

void solve(){
 ll N, L; cin >> N >> L;
 vector<pll> v;

 ll ans = 0;
 rep(i, 0, N){
 ll K, T; cin >> K >> T;
 ans += T;
 if(T <= 5) continue;
 v.push_back({K, T});
 }
 sort(all(v), [](pll a, pll b){
 return min(a.first * a.second, 5 * a.first) > min(b.first * b.second, 5 * b.first);
 });
 ll cur = 0;
 for(auto [K, T]: v){
 if(cur + K*T > L){
 ll rest = cur + K*T - L;
 ans += rest;
 cur -= rest;
 }
 cur += K*T;
 cur -= min(K*T, 5*K);
 }
 cout << ans;
}

🔒

구현 코드 잠금

BOJ 31055 A Graph Problem

Tue, 03 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/31055
번역

문제 번역
#

Bessie는 수학 지식을 향상시키기 위해 그래프 이론 강좌를 수강하고 있는데, 다음 문제에서 막혔습니다. 그녀를 도와주세요!

연결된 무방향 그래프가 주어집니다. 정점은 $1\dots N$으로, 간선은 $1\dots M$으로 라벨링되어 있습니다 ($2\le N\le 2\cdot 10^5$, $N-1\le M\le 4\cdot 10^5$).

그래프의 각 정점 $v$에 대해 다음 과정을 수행합니다:

BOJ 18180 Saba1000kg

Mon, 02 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/18180
번역

문제 번역
#

바이킹 락 운동에는 다양한 흐름이 존재한다. 올드 아이슬란드 그래니트 락, 미들 데니쉬 더스티 바이킹 락, 레이트 핀게일 다크 그린 락, 피오르드 볼더 아발란체 락 등, 인기 있는 흐름의 전체 목록을 나열하면 이 페이지를 여러 번 가득 채울 정도이다. 스칸디나비아 고등교육부는 이러한 흐름들이 서로 어떻게 영향을 주는지 연구하고 있다. 그들은 현재 대규모 실험을 계획 중이며, 적절히 선발된 자원봉사자들을 무인도들로 구성된 군도에 배치하여 상대적으로 긴 시간 동안 그들의 음악적 스타일과 선호도가 서로 미치는 영향을 관찰하고자 한다.

BOJ 21932 To be Connected, or not to be, that is the Question

Mon, 02 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/21932
번역

문제 번역
#

문제 설명
#

무방향 그래프가 주어지고, 각 노드에는 양의 정수 값이 연결되어 있습니다. 임계값(threshold)이 주어지면, 그래프의 노드들은 두 그룹으로 나뉩니다: 하나는 임계값 이하의 값을 가진 노드들로 구성되고, 다른 하나는 나머지 노드들로 구성됩니다. 이제 서로 다른 그룹에 속한 두 노드를 연결하는 모든 간선을 제거하여 얻은 원래 그래프의 부분 그래프를 고려합니다. 두 노드 그룹이 모두 비어있지 않을 때, 주어진 그래프가 연결되어 있는지 여부와 관계없이 결과 부분 그래프는 연결이 끊어집니다.

BOJ 3830 교수님은 기다리지 않는다

Mon, 02 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/3830

🧐 관찰 및 접근
#

두 값의 차이를 트리 형태로 저장한다고 생각하자.
- 간선에 가중치가 있는 트리가 될 것이다.
- 두 값 $a, b$가 같은 트리에 있다면 비교 가능하고, 그렇지 않다면 비교 불가능하다.
- 하지만 이 경우 트리가 직선형이 되면, 최악의 경우 $O(N)$이 걸린다.
우리는 이러한 경우에 UnionFind에서 경로 압축을 하는 방법을 배웠다.
- 결국 루트까지의 간선 가중치 합을 저장해서 이용하면 된다.

💻 풀이
#

코드 (C++):

void solve(){
 while(1){
 int N, M; cin >> N >> M;
 if(N + M == 0) break;
 UnionFind uf(N);
 while(M--){
 char op; cin >> op;
 if(op == '!'){
 int a, b, w; cin >> a >> b >> w;
 uf.merge(a-1, b-1, w);
 }
 else{
 int a, b; cin >> a >> b;
 auto [ra, wa] = uf.find(a-1);
 auto [rb, wb] = uf.find(b-1);
 if(ra != rb) cout << "UNKNOWN\n";
 else cout << wb - wa << '\n';
 }
 }
 }
}

🔒

구현 코드 잠금

BOJ 9938 방 청소

Mon, 02 Feb 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/9938

🧐 관찰 및 접근
#

더 자세히 생각해보면, $(1, 2), (3, 4), (2, 3)$의 술병이 있는 경우, $1, 2, 3, 4$ 4개의 서랍중 3개의 서랍에 술이 들어갈 수 있다는 것을 알 수 있다.
- $A_i, B_i$를 보면서 분리 집합으로 묶어버린 뒤, 그 집합의 크기에 여유가 있다면 술병을 정리할 수 있다.

💻 풀이
#

코드 (C++):

void solve(){
 int N, L; cin >> N >> L;
 UnionFind UF(L);
 rep(i, 0, N){
 int a, b; cin >> a >> b;
 a--; b--;
 UF.merge(a, b);
 if(UF.val[UF.find(a)] < UF.cnt[UF.find(a)]){
 cout << "LADICA\n";
 UF.add(a, 1);
 }
 else{
 cout << "SMECE\n";
 }
 }
}

🔒

구현 코드 잠금

BOJ 2463 비용

Sat, 31 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/2463

🧐 관찰 및 접근
#

간선에 가중치가 주어진 무향 그래프가 있다.
- 모든 간선의 가중치는 서로 다르다.
$u$와 $v$사이의 최소 가중치 간선을 그래프에서 계속 제거해나가면서 $\text{Cost}(u, v)$를 구한다.
- $u, v$사이의 경로는 최대 가중치 간선만 남아있다.
  - MST를 최댓값으로 하면 된다!
- 최댓값부터 MST를 진행하면서, 간선이 연결될때 양쪽 그룹의 크기의 곱만큼의 $\text{Cost}$ 관계를 계산하면서 구현할 수 있어보인다.

💻 풀이
#

코드 (C++):

void solve(){
 int N, M; cin >> N >> M;
 vector<array<int, 3>> edges;
 mint sum = 0;
 rep(i, 0, M){
 int u, v, w; cin >> u >> v >> w;
 edges.push_back({w, u, v});
 sum += w;
 }
 sort(all(edges), greater<array<int, 3>>());
 UnionFind UF(N+1);
 mint ans = 0;
 for(auto [w, u, v]: edges){
 if(UF.find(u) != UF.find(v)){
 ans += sum * UF.cnt[UF.find(u)] * UF.cnt[UF.find(v)];
 UF.merge(u, v);
 }
 sum -= w;
 }
 cout << ans << '\n';
}

🔒

구현 코드 잠금

BOJ 25567 줄 세우기

Fri, 30 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/25567

🧐 관찰 및 접근
#

구간합?을 하려면 결국 완성된 배열이 있으면 좋을거같은데..
근데 줄이 다를때만 합치니까, 결국 완성된 줄은 고정적으로 존재한다!
오프라인으로 잘 돌면서 처리하면 되는거같다.
줄의 맨앞과 맨뒤가 어딘지 잘 관리하고, 모든 줄이 합쳐지지는 않을 수 있으니 이를 주의하자.

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 int sz = 0;
 vector<vector<int>> lines;
 rep(i, 0, N){
 int cnt; cin >> cnt;
 vector<int> line(cnt);
 rep(j, 0, cnt) cin >> line[j];
 lines.push_back(line);
 sz += cnt;
 }

 vector<array<int, 3>> Queries; // {query, a, b}
 int Q; cin >> Q;
 rep(i, 0, Q){
 int op, a, b; cin >> op >> a >> b;
 Queries.push_back({op, a, b});
 }

 // lineId[x] = i : x번 사람이 i번째 줄에 속함
 vector<int> lineId(sz+1);
 rep(i, 0, N) for(auto x: lines[i]) lineId[x] = i;

 UnionFind UF(N), UFrev(N);
 vector<int> nxt(N, -1);
 for(auto [op, a, b]: Queries){
 if(op == 2) continue;
 int lineA = lineId[a];
 int lineB = lineId[b];
 if(UF.find(lineA) != UF.find(lineB)){
 // lineA 뒤에 lineB 붙이기
 int tailA = UFrev.find(lineA);
 int headB = UF.find(lineB);
 nxt[tailA] = headB;
 UF.merge(lineA, lineB);
 UFrev.merge(lineB, lineA);
 }
 }

 vector<int> mergedLineId(sz+1);
 vector<int> mergedLineIdx(sz+1);
 vector<vector<ll>> pfsum(N);

 rep(i, 0, N) if(UF.find(i) == i){
 vector<int> order;
 int cur = i;
 while(cur != -1){
 for(auto x: lines[cur]) order.push_back(x);
 cur = nxt[cur];
 }

 for(int j = 0; j < (int)order.size(); j++){
 mergedLineId[order[j]] = i;
 mergedLineIdx[order[j]] = j;
 }
 pfsum[i].resize(order.size()+1);
 rep(j, 0, order.size()) pfsum[i][j+1] = pfsum[i][j] + order[j];
 }

 // 쿼리 처리
 UnionFind UF2(N);
 for(auto [op, a, b]: Queries){
 int lineA = lineId[a];
 int lineB = lineId[b];
 if(op == 1){
 if(UF2.merge(lineA, lineB)) cout << "YES\n";
 else cout << "NO\n";
 }
 else{
 if(UF2.find(lineA) != UF2.find(lineB)){
 cout << "-1\n";
 continue;
 }
 int mergedLine = mergedLineId[a];
 int idxA = mergedLineIdx[a];
 int idxB = mergedLineIdx[b];
 if(idxA > idxB) swap(idxA, idxB);
 cout << pfsum[mergedLine][idxB+1] - pfsum[mergedLine][idxA] << "\n";
 }
 }
}

🔒

구현 코드 잠금

BOJ 2887 행성 터널

Fri, 30 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/2887

🧐 관찰 및 접근
#

누가봐도 MST를 짜야하는거같은데..
행성 두개에 대해 모두 생각하면 간선의 개수가 $N^2$개가 된다…
그런데, 생각해보면 만약 행성 $A, B, C$가 있고, 세개 모두 $x$를 기준으로 연결했다고 하자.
- $x_A < x_B < x_C$라면, $x_A$와 $x_C$의 관계를 신경 쓸 필요가 있을까?
  - 없다!!
- 따라서, $x, y, z$ 각각에 대해 정렬한 간선 $3N$개정도를 이용해서 MST를 짜자.

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<array<ll, 4>> planets;
 rep(i, 0, N){
 int x, y, z; cin >> x >> y >> z;
 planets.push_back({x, y, z, i});
 }
 vector<array<ll, 3>> edges;
 sort(all(planets), [](auto &a, auto &b){
 return a[0] < b[0];
 });
 rep(i, 0, N-1) edges.push_back({abs(planets[i][0]-planets[i+1][0]), planets[i][3], planets[i+1][3]});
 sort(all(planets), [](auto &a, auto &b){
 return a[1] < b[1];
 });
 rep(i, 0, N-1) edges.push_back({abs(planets[i][1]-planets[i+1][1]), planets[i][3], planets[i+1][3]});
 sort(all(planets), [](auto &a, auto &b){
 return a[2] < b[2];
 });
 rep(i, 0, N-1) edges.push_back({abs(planets[i][2]-planets[i+1][2]), planets[i][3], planets[i+1][3]});
 sort(all(edges));
 UF.init(N);
 ll ans = 0;
 for(auto [w, u, v]: edges) if(UF.merge(u, v)) ans += w;
 cout << ans << '\n';
}

🔒

구현 코드 잠금

BOJ 4792 레드 블루 스패닝 트리

Fri, 30 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/4792

🧐 관찰 및 접근
#

파란색 간선을 $k$개, 빨간색 간선을 $(N-1) - k$개 이용해서 MST를 짜야하는데..
- 일단 파란색 간선 $k$개를 결정하면 빨간색은 그냥 유파를 다해버리면 되니까, 파란색 간선을 잘 고르는게 중요하다.
- 나이브하게 한다면 $\binom{\binom{N}{2}}{k}$인가? 간선 개수는 그렇다 쳐도, $k$개를 고르는게 너무 큰디…
- 작은 문제부터 차근히 풀어보자.
$k = 0$
- 이라면 모든 간선들로 스패닝트리가 만들어지는지 확인하는 문제로 바뀐다.
$k = 1$
- 위와 같은 그래프가 있었다고 생각하자.
- 파란 간선 1개를 $1 - 2$ 같은걸 골라버리면 불가능해지는 문제가 생긴다. 잘 골라야 한다.
- 음.. 빨간색으로 미리 다 합쳐놓고, 나머지를 연결할 개수 이상의 파란간선은 필요한거 같은데..
- 그런데, 이미 MST가 잘 있다면, 빨간 간선을 파란 간선으로 대체하는게 꽤 자유로운가? 이것만 되면 큰 문제가 없는데?
$k > 1$
- 주황색이 이미 만들어진 MST, 나머지를 남은 간선이라고 하자.
- 어떤 파란색 간선을 하나 쓰고싶으면, 두 정점으로 가는 경로에 있는 빨간색을 끊어버리고 파란색으로 새로 연결하면 된다!
- 이게 안되는 경우는 이미 그 두 정점으로 가는 경로가 다 파란색 간선만으로 연결된 경우인데..
  - 아하, 분리집합을 하나 더 관리하는걸로 쉽게 풀 수 있는 것 같다.

💻 풀이
#

코드 (C++):

void solve(){
 while(1){
 int N, M, K; cin >> N >> M >> K;
 if(N + M + K == 0) break;
 vector<pii> Redges, Bedges;
 rep(i, 0, M){
 char color; cin >> color;
 int u, v; cin >> u >> v;
 u--; v--;
 if(color == 'R') Redges.push_back({u, v});
 else Bedges.push_back({u, v});
 }
 UnionFind UF(N), BUF(N);

 // 일단 파란색 간선을 최소로 쓸때 되는지 확인
 int cnt = 0;
 for(auto [u, v]: Redges) UF.merge(u, v);
 for(auto [u, v]: Bedges) if(UF.merge(u, v)){
 cnt++;
 BUF.merge(u, v);
 }
 if(cnt > K){
 cout << 0 << '\n';
 continue;
 }

 // 빨간 간선을 하나하나 파란색으로 바꾸기
 for(auto [u, v]: Bedges) if(BUF.merge(u, v)) cnt++;
 if(cnt < K){
 cout << 0 << '\n';
 continue;
 }
 cout << 1 << '\n';
 }
}

🔒

구현 코드 잠금

BOJ 1043 거짓말

Thu, 29 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/1043

🧐 관찰 및 접근
#

지민이는 모든 파티에 참여해야하므로, 진실을 아는 사람이 있는 파티의 모든 사람은 진실을 알게 된다.
- 모든 파티에 대해 진실을 알게 된 사람을 확인한 후, 진실을 아는사람이 없는 파티들의 수를 세면 된다.
- 유니온 파인드, 분리 집합으로 해결하자.

💻 풀이
#

코드 (C++):

void solve(){
 int N, M; cin >> N >> M;
 vector<vector<int>> parties;
 UnionFind UF(N+1); // 0은 진실을 아는 사람
 
 int cnt; cin >> cnt;
 rep(i, 0, cnt){
 int a; cin >> a;
 UF.merge(0, a);
 }

 rep(i, 0, M){
 cin >> cnt;
 vector<int> party(cnt);
 rep(j, 0, cnt) cin >> party[j];
 parties.push_back(party);
 rep(j, 0, cnt-1) UF.merge(party[j], party[j+1]);
 }
 
 int ans = 0;
 for(auto party: parties){
 bool flag = true;
 for(auto p: party) if(UF.find(p) == 0) flag = false;
 if(flag) ans++;
 }
 cout << ans;
}

🔒

구현 코드 잠금

BOJ 10775 공항

Thu, 29 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/10775

🧐 관찰 및 접근
#

1번 게이트가 제일 쓰기 좋아보인다.
그러므로 1번 게이트를 아낀다고 생각하면, 모든 비행기를 도킹시킬때 갈 수 있는 최댓값으로 도킹시키면 되는 것 같다.
- 이를 나이브하게 구현하면 한번당 $O(G)$가 걸릴 것이다.
```
100000
100000
100000
100000
100000
...
```
  - 과 같은 테스트케이스를 생각해보면 된다.
따라서 $\text{calc}(g_i) = g_i$ 보다 작거나 같은 살아있는 게이트의 최댓값을 빠르게 찾으면 된다.
- 이는 유니온파인드로 빠르게 수행 가능하다!
- merge할때 자신보다 작은 값을 가리키게 하자.

💻 풀이
#

코드 (C++):

void solve(){
 int G, P; cin >> G >> P;
 UF.init(G+1);
 int ans = 0;
 while(P--){
 int g; cin >> g;
 int rt = UF.find(g);
 if(rt == 0) break;
 UF.merge(rt, rt-1);
 ans++;
 }
 cout << ans << "\n";
}

🔒

구현 코드 잠금

BOJ 1647 도시 분할 계획

Thu, 29 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/1647

🧐 관찰 및 접근
#

집 (정점)과 길 (간선)이 있다.
- 마을 두개로 분리해야한다.
  - 이 때, 간선의 가중치의 합을 최소화해야한다.
이미 두 집이 한 마을 안에 있다면, 둘이 연결할 필요가 없다.
- 이미 다른 우회로로 갈 수 있기 때문
연결하던 도중 마을이 두개가 남았다면 끝내면 된다.
- 크루스칼 알고리즘으로 덩어리가 두개가 남을때까지 반복하면 되겠다.

💻 풀이
#

코드 (C++):

void solve(){
 int N, M; cin >> N >> M;
 vector<tuple<int, int, int>> edges; // weight, u, v
 rep(i, 0, M){
 int u, v, w; cin >> u >> v >> w;
 edges.emplace_back(w, u, v);
 }
 UF.init(N+1);
 sort(all(edges));
 int ans = 0;
 for(auto &[w, u, v]: edges){
 if(UF.group == 3) break;
 if(UF.merge(u, v)) ans += w;
 }
 cout << ans << "\n";
}

🔒

구현 코드 잠금

BOJ 1734 교통 체계

Thu, 29 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/1734

🧐 관찰 및 접근
#

무향 그래프 $G = (V, E)$가 주어진다.
여기서 두가지 쿼리가 주어진다.
- 간선 $e \in E$ 하나를 없앴을 때, 정점 $A, B$의 연결성 판정
- 정점 $v \in V$ 하나를 없앴을 때, 정점 $A, B$의 연결성 판정
- 각각 살펴보자.
먼저, 문제조건에 의해 컴포넌트는 하나이므로 A, B는 기본적으로 연결되어있다고 판단하자.

BOJ 4195 친구 네트워크

Thu, 29 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/4195

🧐 관찰 및 접근
#

누가 봐도 유니온파인드 스타일이다.
문자열을 그대로 유니온 파인드에 넣긴 곤란하니, map 혹은 dict를 이용하자.
유니온 파인드를 구현할 때, 합을 잘 구해줘야한다.
- 분리 집합을 포레스트 모양이라고 생각할때, 각 트리의 루트노드에서 트리의 크기를 관리할 수 있도록 하면 쉽게 구현할 수 있다.

💻 풀이
#

코드 (C++):

void solve(){
 int Q; cin >> Q;
 UF.init(Q*2);
 map<string, int> mp;
 while(Q--){
 string A, B; cin >> A >> B;
 int a, b;
 if(mp.find(A) == mp.end()) mp[A] = mp.size();
 if(mp.find(B) == mp.end()) mp[B] = mp.size();
 a = mp[A];
 b = mp[B];
 UF.merge(a, b);
 cout << UF.cnt[UF.find(a)] << "\n";
 }
}

🔒

구현 코드 잠금

BOJ 10671 Grass Cownoisseur

Wed, 28 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크:
번역

문제
#

Farmer John은 소들의 방목 패턴을 더 잘 관리하기 위해 농장 전체에 일방통행 소 길들을 설치했습니다. 농장은 N개의 목초지로 구성되어 있으며, 편의상 1부터 N까지 번호가 매겨져 있고, 각 일방통행 소 길은 한 쌍의 목초지를 연결합니다. 예를 들어, 목초지 X에서 목초지 Y로 연결되는 길이 있다면, 소들은 X에서 Y로는 이동할 수 있지만 Y에서 X로는 이동할 수 없습니다.

BOJ 10891 Cactus? Not cactus?

Wed, 28 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/10891

🧐 관찰 및 접근
#

어떤 정점이 최대 한개의 사이클에만 속해있다면, 해당 그래프는 정점 선인장이다.
- $\text{DP}[i]$ : 정점 $i$의 부모와 정점 $i$의 자식을 잇는 tree edge가 아닌 간선의 수라고 정의하자.
- 어떤 그래프가 정점 선인장일 필요충분조건은 $\forall i$ 에 대해 $\text{DP}[i] \leq 1$인 것이다.
- 이는 DFS+누적합처럼 계산할 수 있다.

💻 풀이
#

코드 (C++):

void dfs(int c, int p, int d){
 depth[c] = d;
 par[c] = p;
 DP[c] = 0;

 for(auto n: links[c]){
 if(n == p) continue;
 if(depth[n] == 0){
 dfs(n, c, d+1);
 DP[c] += DP[n];
 }
 else if(depth[n] < depth[c]) DP[c]++;
 else DP[par[c]]--;
 }
}

void solve(){
 cin >> N >> M;
 rep(i, 0, M){
 int u, v; cin >> u >> v;
 links[u].push_back(v);
 links[v].push_back(u);
 }
 dfs(1, -1, 1);
 bool isCactus = true;
 rep(i, 1, N+1) if(DP[i] > 1) isCactus = false;
 if(isCactus) cout << "Cactus";
 else cout << "Not cactus";
}

🔒

구현 코드 잠금

BOJ 10891 Cactus? Not cactus?

Wed, 28 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/10891

🧐 관찰 및 접근
#

어떤 정점이 최대 한개의 사이클에만 속해있다면, 해당 그래프는 정점 선인장이다.
- $\text{DP}[i]$ : 정점 $i$의 부모와 정점 $i$의 자식을 잇는 tree edge가 아닌 간선의 수라고 정의하자.
- 어떤 그래프가 정점 선인장일 필요충분조건은 $\forall i$ 에 대해 $\text{DP}[i] \leq 1$인 것이다.
- 이는 DFS+누적합처럼 계산할 수 있다.

💻 풀이
#

코드 (C++):

void dfs(int c, int p, int d){
 depth[c] = d;
 par[c] = p;
 DP[c] = 0;

 for(auto n: links[c]){
 if(n == p) continue;
 if(depth[n] == 0){
 dfs(n, c, d+1);
 DP[c] += DP[n];
 }
 else if(depth[n] < depth[c]) DP[c]++;
 else DP[par[c]]--;
 }
}

void solve(){
 cin >> N >> M;
 rep(i, 0, M){
 int u, v; cin >> u >> v;
 links[u].push_back(v);
 links[v].push_back(u);
 }
 dfs(1, -1, 1);
 bool isCactus = true;
 rep(i, 1, N+1) if(DP[i] > 1) isCactus = false;
 if(isCactus) cout << "Cactus";
 else cout << "Not cactus";
}

🔒

구현 코드 잠금

BOJ 14675 단절점과 단절선

Wed, 28 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/14675

🧐 관찰 및 접근
#

트리에서의 단절점과 단절선을 생각해보자.
- 트리에서 모든 간선은 단절선이다.
  - 사이클 없는 연결 그래프니까
- 트리에서 리프노드를 제외한 모든 노드는 단절점이다.
  - 위와 이유가 같다. 우회경로로 쓸 back edge가 없다.

💻 풀이
#

코드 (C++):

void solve(){
 cin >> N;
 rep(i, 0, N-1){
 int u, v;
 cin >> u >> v;
 links[u].push_back(v);
 links[v].push_back(u);
 }
 cin >> Q;
 while(Q--){
 int t, k; cin >> t >> k;
 if(t == 1) cout << ((int)links[k].size() == 1 ? "no\n" : "yes\n");
 else cout << "yes\n";
 }
}

🔒

구현 코드 잠금

BOJ 14908 구두 수선공

Wed, 28 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/14908

🧐 관찰 및 접근
#

직관적으로 생각해보자
- 어떤 작업의 보상금 $S_i$가 크다면, 빠르게 작업을 수행하는게 좋다.
- 어떤 작업을 완료하는데 걸리는 시간 $T_i$가 작다면, 빠르게 작업을 수행하는게 좋다.
  - 이 두가지를 어떻게 동시에 활용할 수 있을까?
어떤 정답 $Opt$가 존재한다고 가정해보자.
- 이때, $Opt$의 순서중 가운데 두 작업 $W_i, W_{i+1}$을 바꾼다고 해보자.
  - 이 때, 바뀐 순서 $Opt'$가 $Opt$보다 나을 수 있을까?
  - 두 작업을 바꾸면, $Opt' = Opt + S_i * T_{i+1} - S_{i+1} * T_i$가 된다.
  - 다시말해, $S_i * T_{i+1} - S_{i+1} * T_i$ 이 음수라면 더 나은 해법을 찾을 수 있다.
  - 따라서 $S_i * T_{i+1} - S_{i+1} * T_i > 0$인 방향,
  - 즉 $\frac{S_i}{T_i} \geq \frac{S_{i+1}}{T_{i+1}}$ 의 순서로 정렬하면 최적해가 된다.

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 vector<array<int, 3>> ans; // S, T, idx;
 rep(i, 0, N){
 int S, T; cin >> S >> T;
 ans.push_back({T, S, i+1});
 }
 sort(all(ans), [](const array<int, 3> &a, const array<int, 3> &b){
 if(a[0]*b[1] == a[1]*b[0]) return a[2] < b[2];
 return a[0]*b[1] > a[1]*b[0];
 });
 for(auto &p: ans) cout << p[2] << ' ';
}

🔒

구현 코드 잠금

BOJ 16367 TV Show Game

Wed, 28 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/16367
번역

문제 번역
#

Mr. Dajuda는 TV 쇼 프로그램으로 유명한 사람으로, 가끔 시청자들에게 흥미로운 게임을 제안하고 상품을 상으로 제공합니다. 이번 주에 그가 제안한 게임은 다음과 같이 설명할 수 있습니다.

무대 위의 k개(k > 3)의 램프는 게임 시작 시 모두 꺼져 있습니다. 편의상 램프는 1부터 k까지 번호가 매겨져 있습니다. 각 램프는 빨간색 또는 파란색의 색상을 가지고 있습니다. 그러나 램프의 색상은 켜지기 전까지는 알 수 없습니다. 게임 참가자들은 무작위로 세 개의 램프를 선택하고 그 색상을 예측하도록 요청받습니다. 그런 다음 각 참가자는 선택한 램프의 예측된 색상이 기록된 종이를 게임 진행자인 Mr. Dajuda에게 제출합니다. 모든 램프가 켜지면 각 참가자는 자신이 예측한 색상 중 몇 개가 램프의 실제 색상과 일치하는지 확인합니다. 두 개 이상의 색상이 일치하면 상품을 받게 됩니다.

BOJ 1761 정점들의 거리

Wed, 28 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/1761

🧐 관찰 및 접근
#

트리에서, 두 정점 사이의 경로는 유일하다.
- 해당 경로는 두 정점의 LCA를 지난다.
- 두 점 사이의 거리는 $d(u) + d(v) - 2*d(\text{LCA}(u, v))$로 계산할 수 있다.

💻 풀이
#

코드 (C++):

void dfs(int cur, int _par){
 for(auto [nxt, w]: links[cur]){
 if(nxt == _par) continue;
 dist[nxt] = dist[cur] + w;
 depth[nxt] = depth[cur] + 1;
 par[nxt][0] = cur;
 dfs(nxt, cur);
 }
}

int LCA(int u, int v){
 if(u == v) return u;
 if(depth[u] < depth[v]) swap(u, v);
 int diff = depth[u] - depth[v];
 rep(i, 0, 16) if((diff >> i) & 1) u = par[u][i];
 if(u == v) return u;
 rrep(i, 16, 0){
 if(par[u][i] != par[v][i]){
 u = par[u][i];
 v = par[v][i];
 }
 }
 return par[u][0];
}

ll getDist(int u, int v){
 int lca = LCA(u, v);
 return dist[u] + dist[v] - 2 * dist[lca];
}

void solve(){
 cin >> N;
 rep(i, 0, N-1){
 int u, v, w; cin >> u >> v >> w;
 links[u].push_back({v, w});
 links[v].push_back({u, w});
 }

 dfs(1, -1);
 rep(j, 1, 16) rep(i, 1, N+1) par[i][j] = par[par[i][j-1]][j-1];
 cin >> Q;
 while(Q--){
 int u, v; cin >> u >> v;
 cout << getDist(u, v) << '\n';
 }
}

🔒

구현 코드 잠금

BOJ 3176 도로 네트워크

Wed, 28 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/3176

🧐 관찰 및 접근
#

도로가 N-1개인걸 보니 트리겠구만
- 이때 경로상에서 가장 짧은 도로의 길이와 가장 긴 도로의 길이를 출력하라는데…
- HLD를 써도 되지만, sparse table에서의 RMQ처리처럼 진행해도 큰 문제가 없겠다.

💻 풀이
#

코드 (C++):

void solve(){
 cin >> N;
 rep(i, 0, N-1){
 int u, v, w; cin >> u >> v >> w;
 links[u].push_back({v, w});
 links[v].push_back({u, w});
 }
 dfs(1, -1, 0);
 rep(j, 1, 20) rep(i, 1, N+1) if(par[i][j-1]){
 par[i][j] = par[par[i][j-1]][j-1];
 mnDist[i][j] = min(mnDist[i][j-1], mnDist[par[i][j-1]][j-1]);
 mxDist[i][j] = max(mxDist[i][j-1], mxDist[par[i][j-1]][j-1]);
 }
 int Q; cin >> Q;
 while(Q--){
 int u, v; cin >> u >> v;
 auto [mn, mx] = calc(u, v);
 cout << mn << ' ' << mx << '\n';
 }
}

🔒

구현 코드 잠금

BOJ 3648 아이돌

Wed, 28 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/3648

🧐 관찰 및 접근
#

모든 심사위원에 대해 (and) 각 심사위원별로 표 두개중 하나를 만족해야 한다. (or)
- 따라서 $(A \lor B) \land (C \lor D) \land \cdots$ 의 2-sat 문제로 변환 가능하다!
모델링만 잘 해보자.
- 가능한 변수의 개수 $= 1000 *2 = 2000$ 에 대해
  - $i$ 번 참가자가 진출: $2*i$, 진출 실패: $2*i+1$로 모델링하자.
1번 참가자인 상근이는 무조건 통과해야 한다.
- $\neg x \to x$ 를 만족하면 되므로, $1 \to 0$을 추가하자.

💻 풀이
#

코드 (C++):

void solve(){
 int N, M; 
 
 while(cin >> N >> M){
 DirectedGraph dg(2*N);
 rep(i, 0, M){
 int u, v; cin >> u >> v;
 if(u > 0) u = 2*(u-1);
 else u = 2*(-u-1)+1;
 if(v > 0) v = 2*(v-1);
 else v = 2*(-v-1)+1;
 dg.add_2sat_edge(u, v);
 }
 dg.add_2sat_edge(0, 0);
 cout << (dg.is2SAT() ? "yes\n" : "no\n");
 }

🔒

구현 코드 잠금

BOJ 4013 ATM

Wed, 28 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/4013

🧐 관찰 및 접근
#

그래프가 DAG라면 위상정렬을 하면서 DP를 진행할 수 있을텐데..
- 같은 정점을 여러번 들릴 수 있으므로, 어떤 정점이 사이클 안에 들어있다면 해당 사이클 내의 ATM을 모두 들릴 수 있다!
- 서로 자유롭게 이동 가능한 관계라면 모두 자유롭게 들릴 수 있으므로, 이를 SCC로 묶어 DAG로 만들자.

💻 풀이
#

코드 (C++):

void solve(){
 cin >> N >> M;
 DirectedGraph graph(N+1);
 rep(i, 0, M){
 int u, v; cin >> u >> v;
 graph.add_edge(u, v);
 }
 DirectedGraph dag = graph.getCompressedGraph();
 int sz = dag.V;
 vector<int> val(sz), DP(sz, -1e9), indeg(sz, 0);
 rep(i, 1, N+1){
 int X; cin >> X;
 val[graph.sccId[i]] += X;
 }
 int S, P; cin >> S >> P;
 S = graph.sccId[S];
 DP[S] = val[S];
 rep(u, 0, sz) for(auto &v: dag.links[u]) indeg[v]++;
 queue<int> Q;
 rep(i, 0, sz) if(indeg[i] == 0) Q.push(i);
 while(!Q.empty()){
 int cur = Q.front(); Q.pop();
 for(auto nxt: dag.links[cur]){
 DP[nxt] = max(DP[nxt], DP[cur] + val[nxt]);
 indeg[nxt]--;
 if(indeg[nxt] == 0) Q.push(nxt);
 }
 }
 int ans = 0;
 rep(i, 0, P){
 int X; cin >> X;
 X = graph.sccId[X];
 ans = max(ans, DP[X]);
 }
 cout << ans << '\n';
}

🔒

구현 코드 잠금

BOJ 23569 Friendship Graphs

Mon, 26 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/23569
번역

문제 번역
#

문제 설명
#

사람들 간의 상호작용이 주어질 때, 정점이 사람들이고 두 사람이 서로 친구인 경우에만 그들 사이에 간선이 있는 그래프를 정의할 수 있습니다. 이러한 그래프를 소셜 네트워크라고 하며, 예를 들어 대학의 학생들이나 작은 마을의 주민들과 같은 모든 사람들의 집합에 대해 잘 정의됩니다. 최근 몇 년간 소셜 네트워크를 분석하는 완전한 과학 분야가 생겨났는데, 이는 사람들과 그들의 행동에 대한 많은 흥미로운 측면들이 이 친구 관계 그래프의 속성으로 가장 잘 이해되기 때문입니다.

BOJ 30690 선로 조립

Mon, 26 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/30690

🧐 관찰 및 접근
#

암튼 트리가 있다
- 간선 하나를 떼고 다시 연결해서, 가장 많은 간선을 지나가고싶다.
- 간선 하나를 떼고 다시 연결해서, 트리의 지름을 최대로 하고 싶다.
- 쪼개진 두개의 트리에서, 각각의 지름 + 1이 답이다.
- 트리를 쓰는 트리 문제
  - 해당 문제에서, 해당 서브트리를 제외한 트리의 지름을 구할 수 있으면 되는 것 같다.
  - 이는 리루팅과 부모깊이, 다른 자식의 깊이 두개정도를 잘 들고있으면 가능하겠다.
    - 다른 자식의 지름도 들고있어야 한다!!
예제 트리 그림

💻 풀이
#

코드 (C++):

int N, Q;
vector<int> links[200010];
int depth[200010];
vector<pii> childs[200010]; // {mxDepth, nodeIdx}
vector<pii> childs2[200010]; // {mxDiam, nodeIdx}
int diam[200010], upDepth[200010], upDiam[200010];

void dfs1(int cur, int par){
 vector<pii> ret;
 ret.push_back({0, cur});
 for(auto nxt: links[cur]){
 if(nxt == par) continue;
 depth[nxt] = depth[cur] + 1;
 dfs1(nxt, cur);
 diam[cur] = max(diam[cur], diam[nxt]);

 ret.push_back({childs[nxt][0].first + 1, nxt});
 sort(all(ret), greater<pii>());
 if((int)ret.size() > 3) ret.pop_back();

 childs2[cur].push_back({diam[nxt], nxt});
 sort(all(childs2[cur]), greater<pii>());
 if((int)childs2[cur].size() > 2) childs2[cur].pop_back();
 }
 childs[cur] = ret;
 if((int)ret.size() >= 2) diam[cur] = max(diam[cur], ret[0].first + ret[1].first);
 if((int)ret.size() >= 1) diam[cur] = max(diam[cur], ret[0].first);
}

void dfs2(int cur, int par, int mxUp){
 for(auto nxt: links[cur]){
 if(nxt == par) continue;
 vector<int> candidates;
 candidates.push_back(mxUp);
 for(auto [d, idx]: childs[cur]) if(idx != nxt) candidates.push_back(d);
 sort(all(candidates), greater<int>());

 if((int)candidates.size() >= 2) upDiam[nxt] = max(upDiam[nxt], candidates[0] + candidates[1]);
 if((int)candidates.size() >= 1) upDiam[nxt] = max(upDiam[nxt], candidates[0]);
 for(auto [d, idx]: childs2[cur]) if(idx != nxt) upDiam[nxt] = max(upDiam[nxt], d);
 upDiam[nxt] = max(upDiam[nxt], upDiam[cur]);
 dfs2(nxt, cur, candidates[0] + 1);
 }
}

void solve(){
 cin >> N >> Q;
 rep(i, 0, N-1){
 int u, v; cin >> u >> v;
 links[u].push_back(v);
 links[v].push_back(u);
 }

 dfs1(1, -1);
 dfs2(1, -1, 0);

 // rep(i, 1, N+1) cout << diam[i] << " "; cout << "\n";
 // rep(i, 1, N+1) cout << upDiam[i] << " "; cout << "\n";
 while(Q--){
 int u, v; cin >> u >> v;
 if(depth[u] < depth[v]) swap(u, v);
 cout << diam[u] + upDiam[u] + 1 << "\n";
 }
}

🔒

구현 코드 잠금

BOJ 19581 두 번째 트리의 지름

Sun, 25 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/19581

🧐 관찰 및 접근
#

가중치 없는 트리인줄 알고, 당연히 지름-1이 답이 아닌가? 했더니 가중치가 있었다
가중치가 있는 트리라면, 우리가 원래 쓰던 DFS두번이라는 방법은 쉽지 않을것같다
- 가장 긴 트리의 지름과, 두번째로 긴 트리의 지름이 아예 관계 없는 곳에 있을 수도 있지 않을까?
- 아닌가?
- 트리의 지름과 두번째 트리의 지름이 끝 정점을 공유하지 않는다고 하자. 그렇다면, 위 그림과 같이 압축해서 나타낼 수 있다.
  - 이 때, $a + b = D_1 \geq c + d = D_2$라 하자.
    - 일반성을 잃지 않고 $a \geq b, c \geq d$라 하자.
  - 서로 공유하는 정점 하나가 있는 경우
    - $a + c \geq D_1/2 + D_2/2 \geq D_2$
    - 이므로, a와 c를 지나는 경로가 우리가 가정한 두번째 지름보다 더 크거나 같다.
      - 더 큰 경우 모순이고
      - 같은 경우 $a+c$를 두번째 지름으로 택해도 아무 문제가 없다.
  - 서로 공유하는 정점이 없는경우 (다른 서브트리에 나타낼 수 있는 경우)
    - $a + c + e + f \geq D_1/2 + D_2/2 + e + f > D_2$
    - 이므로, $D_2$의 경로는 두번째 트리의 지름이 아니다.
- 따라서, 트리의 두번째 지름의 한 끝점은 트리의 지름의 한 끝점과 같다.
DFS를 돌려서 트리의 지름 양 끝 점을 찾고, 거기서부터 두번째지름을 한번씩 찾아주자.

💻 풀이
#

코드 (C++):

vector<pii> dfs(int cur, int par){
 vector<pii> v;
 v.push_back({0, cur});

 for(auto [nxt, w]: links[cur]){
 if(nxt == par) continue;
 auto nv = dfs(nxt, cur);
 rep(i, 0, min(2, (int)nv.size())){
 v.push_back({nv[i].first + w, nv[i].second});
 }
 sort(all(v), greater<pii>());
 while(v.size() > 2) v.pop_back();
 }

 return v;
}

void solve(){
 cin >> N;
 rep(i, 0, N-1){
 int u, v, w; cin >> u >> v >> w;
 links[u].push_back({v, w});
 links[v].push_back({u, w});
 }

 int L = dfs(1, -1)[0].second; // 트리의 지름의 한쪽 끝

 int ans = 0;
 auto ret = dfs(L, -1);
 ans = max(ans, ret[1].first); // 두번째 트리의 지름 후보 1

 int R = ret[0].second; // 트리의 지름의 다른쪽 끝
 ret = dfs(R, -1);
 ans = max(ans, ret[1].first); // 두번째 트리의 지름 후보 2

 cout << ans << "\n";
}

🔒

구현 코드 잠금

BOJ 32144 트리를 쓰는 트리 문제

Sun, 25 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/32144

🧐 관찰 및 접근
#

문제에 내 이름이 나와서 기분이 좋다.
서브트리를 하나 잡아서, 그 서브트리의 루트와 그 부모와의 연결을 끊고 서브트리의 임의의 정점과 방금 끊은 부모를 연결하는 연산을 할 수 있다.
- 직관적으로, 해당 서브트리에서 줄 수 있는 길이의 가중치가 깊이에서 지름으로 바뀜을 알 수 있다.
- Tree DP를 이용한 트리의 지름 구하기 방법을 이용하면 좋을 것 같다.
- 위와 같은 경우같은게 발생할 것 같다.
- 두번째로 작은 트리의 지름과 마찬가지로, 기존 지름의 양 끝 점중 한 점은 유지된다.
  - …인줄알았는데 안된다.
  - 다음과 같이 서브노드 안에 기존 트리의 지름이 다 있는 경우도 있다…
- 결국 문제에서도 말하는 것처럼 문제를 부분트리와 그 나머지로 보면, 리루팅이 가능하지 않을까?
리루팅을 이용해서, 다음과 같은 정보를 저장하자.
- 서브트리의 지름
- 해당 서브트리에서 가장 깊은 깊이 두개 (리루팅용)
- 해당 노드에서 위로 갔을때, 가장 깊은 길이
- 이는 dfs를 이용해서 구현 가능하고, 시간복잡도는 $O(N)$이다.
디버깅을 위한 예제 2번 그림

💻 풀이
#

코드 (C++):

int N;
vector<int> links[300005];
vector<pii> max_depth[300005];
int diam[300005];
int updepth[300005], updiam[300005];

vector<pii> dfs(int cur, int par){
 vector<pii> v;
 v.push_back({0, cur});
 for(auto nxt: links[cur]){
 if(nxt == par) continue;
 auto nv = dfs(nxt, cur);
 diam[cur] = max(diam[cur], diam[nxt]);
 v.push_back({nv[0].first + 1, nxt});
 sort(all(v), greater<pii>());
 while(v.size() > 2) v.pop_back();
 }
 if(v.size() >= 2) diam[cur] = max(diam[cur], v[0].first + v[1].first);
 else diam[cur] = max(diam[cur], v[0].first);
 max_depth[cur] = v;

 // cout << "cur: " << cur << " diam: " << diam[cur] << " max_depth: ";
 // for(auto p: v) cout << "(" << p.first << "," << p.second << ") ";
 // cout << '\n';
 return v;
}

void dfs2(int cur, int par){
 for(auto nxt: links[cur]){
 if(nxt == par) continue;

 updepth[nxt] = updepth[cur] + 1;
 if(max_depth[cur][0].second != nxt) updepth[nxt] = max(updepth[nxt], max_depth[cur][0].first + 1);
 else if(max_depth[cur].size() >= 2) updepth[nxt] = max(updepth[nxt], max_depth[cur][1].first + 1);
 dfs2(nxt, cur);
 }
}

void solve(){
 cin >> N;
 rep(i, 2, N+1){
 int p; cin >> p;
 links[p].push_back(i);
 links[i].push_back(p);
 }

 dfs(1, -1);
 dfs2(1, -1);
 rep(i, 2, N+1) cout << max(diam[1], updepth[i] + diam[i]) << "\n";
}

🔒

구현 코드 잠금

BOJ 1154 팀 편성

Sat, 24 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/1154

🧐 관찰 및 접근
#

A / B팀으로 나누는걸 보면 당연히 이분그래프를 떠올릴 수 있겠는데..
- 같은 그룹의 학생들끼리는 모두 서로 아는 사이여야 한다?
- 우리가 아는 이분그래프의 정의랑 뭔가 느낌이 다르다!
저 말을 다시한번 생각해보자
- 같은 그룹의 학생이다 -> 서로 아는사이이다
- 이 문장의 대우명제는?
  - 서로 모르는 사이이다 -> 다른 그룹의 학생이다
- 그렇다면, 그래프의 간선을 뒤집어버리자!
  - $N$은 최대 1000이므로, 간선 $M = N^2$개는 충분히 계산할 수 있다.
  - 이렇게 간선을 뒤집은 그래프를 여 그래프, 혹은 complement graph라고 한다.

💻 풀이
#

코드 (C++):

void solve(){
 cin >> N;
 while(1){
 int u, v; cin >> u >> v;
 if(u == -1 && v == -1) break;
 know[u][v] = know[v][u] = true;
 }

 bool isBipartite = true;
 vector<int> color(N+1, 0);
 rep(i, 1, N+1) if(color[i] == 0){
 queue<int> Q;
 Q.push(i);
 color[i] = 1;
 while(!Q.empty()){
 int cur = Q.front(); Q.pop();
 rep(nxt, 1, N+1){
 if(cur == nxt) continue;
 if(know[cur][nxt]) continue;
 if(color[nxt] == 0){
 color[nxt] = (color[cur] == 1 ? 2 : 1);
 Q.push(nxt);
 }
 else if(color[nxt] == color[cur]){
 isBipartite = false;
 break;
 }
 }
 }
 }
 if(!isBipartite){
 cout << -1;
 return;
 }
 vector<int> team1, team2;
 rep(i, 1, N+1){
 if(color[i] == 1) team1.push_back(i);
 else team2.push_back(i);
 }

 cout << 1 << "\n";
 for(auto x: team1) cout << x << " "; cout << -1 << "\n";
 for(auto x: team2) cout << x << " "; cout << -1 << "\n";
}

🔒

구현 코드 잠금

BOJ 2263 트리의 순회

Sat, 24 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/2263

🧐 관찰 및 접근
#

이진 트리의 인오더와 포스트오더가 주어졌을 때, 프리오더를 구하자.
- 인오더: (왼쪽 -> 루트 -> 오른쪽)
- 포스트오더: (왼쪽 -> 오른쪽 -> 루트)
- 프리오더: (루트 -> 왼쪽 -> 오른쪽)
그렇다면, 어떤 한 서브트리에 대해, 포스트오더를 이용해서 루트를 찾을 수 있다. (맨 마지막 값)
- 그리고 이를 기점으로 인오더에서 왼쪽에 있는 모든 수는 왼쪽 서브트리, 나머지는 오른쪽 서브트리에 있다고 생각할 수 있다.
한 서브트리에서 루트노드의 값을 알아냈을 때, 인오더에서의 그 인덱스를 빠르게 찾을 수 있다면 왼쪽/오른쪽 서브트리로의 분할이 용이하다!
- map을 이용하면 $O(NlogN)$에 해결할 수 있겠다.

💻 풀이
#

코드 (C++):

int N;
vector<int> inorder, postorder;
map<int, int> in_idx;

void preorder(int in_s, int in_e, int post_s, int post_e){
 if(in_s > in_e) return;
 int root = postorder[post_e];
 cout << root << ' ';
 int idx = in_idx[root];
 int sz = idx - in_s;
 preorder(in_s, idx-1, post_s, post_s + sz - 1); // 왼쪽 서브트리
 preorder(idx+1, in_e, post_s + sz, post_e - 1); // 오른쪽 서브트리
}

void solve(){
 cin >> N;
 inorder.resize(N);
 postorder.resize(N);
 rep(i, 0, N) cin >> inorder[i];
 rep(i, 0, N) cin >> postorder[i];
 rep(i, 0, N) in_idx[inorder[i]] = i;

 preorder(0, N-1, 0, N-1);
}

🔒

구현 코드 잠금

BOJ 5214 환승

Sat, 24 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/5214

🧐 관찰 및 접근
#

나이브하게 생각해볼까?
- 인접 리스트로 간선을 저장한다고 생각하면, $M\binom{K}{2} \approx MK^2$ 개의 정보가 저장된다.
- 그러면 BFS의 시간복잡도는 $O(V+E)$ 니까 조금 곤란한데…
- 잘 생각해보면, (1, 2, 3, 4), (2, 3, 4, 5) 하이퍼튜브가 있다고 가정하면, 겹치는 정보가 너무나도 많다!
  - 첫 하이퍼튜브를 타고 2, 3, 4번 역에 1회만에 도착했다면, 두번째 하이퍼튜브에서 2, 3, 4번이 서로를 움직일 필요가 없다.
  - 하이퍼튜브는 최대 1000개 존재한다.
  - 또한 한 역은 최대 1000개의 하이퍼튜브에 속한다.
    - 하이퍼튜브만 따로 정리해서, 그 안에서 움직이면 되지 않을까?

💻 풀이
#

코드 (C++):

void solve(){
 cin >> N >> K >> M;
 rep(i, 0, M){
 rep(j, 0, K){
 int x; cin >> x;
 inhyper[x].push_back(i);
 hypertube[i].push_back(x);
 }
 }

 rep(i, 1, N+1) dist[i] = -1;
 dist[1] = 1;
 queue<int> q;
 q.push(1);
 while(!q.empty()){
 int cur = q.front(); q.pop();
 if(cur == N) break;
 for(int htube : inhyper[cur]){
 for(int nxt : hypertube[htube]){
 if(dist[nxt] == -1){
 dist[nxt] = dist[cur] + 1;
 q.push(nxt);
 }
 }
 hypertube[htube].clear(); // 이미 방문한 하이퍼튜브는 볼일이 없다
 }
 }
 cout << dist[N] << '\n';
}

🔒

구현 코드 잠금

BOJ 5639 이진 검색 트리

Sat, 24 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/5639

🧐 관찰 및 접근
#

이진 검색 트리의 전위 순회 결과를 이용해서 후위 순회 결과를 찾아내자!
- 트리가 만들어져 있다면, 후위 순회를 하는건 쉬울텐데…
- 전위 순회는 (루트 - 왼쪽서브트리 - 오른쪽서브트리)를 방문한다.
  - 왼쪽 서브트리의 값은 언제나 루트보다 작고, 오른쪽 서브트리의 값은 언제나 루트보다 크므로
  - 50 (루트) --- 30 (왼쪽 서브트리) 24 5 28 45 --- 98 (오른쪽 서브트리) 52 60
  - 첫 입력에 대해, 이렇게 생각할 수 있지 않을까?
  - 그리고 각 서브트리 또한 이진 검색트리이므로, 이를 재귀적으로 수행할 수 있다.
  - 예를 들어, 왼쪽 서브트리에 대해서
  - 30 (루트) --- 24 (왼쪽 서브트리) 5 28 --- 45 (오른쪽 서브트리)
  - 위와 같이 말이다!
- 그렇다면, 재귀를 이용해서 트리를 구축하고 후위순회만 하면 끝난다.

💻 풀이
#

코드 (C++):

vector<int> v;

struct Node{
 int val = -1;
 Node* left = nullptr;
 Node* right = nullptr;
 Node(int s, int e){
 val = v[s];
 if(s == e) return;

 int idx = e+1;
 rep(i, s+1, e+1){
 if(v[i] > val){
 idx = i;
 break;
 }
 }
 
 if(s+1 <= idx-1) left = new Node(s+1, idx-1);
 if(idx <= e) right = new Node(idx, e);
 }
};

void postorder(Node* node){
 if(node == nullptr) return;
 postorder(node->left);
 postorder(node->right);
 cout << node->val << '\n';
}

void solve(){
 int x;
 while(cin >> x) v.push_back(x);
 Node* root = new Node(0, v.size()-1);
 postorder(root);
}

🔒

구현 코드 잠금

BOJ 19641 중첩 집합 모델

Fri, 23 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/19641

🧐 관찰 및 접근
#

$A_{left} < B_{left} < B_{right} < A_{right}$라면 두 노드를 포함관계라고 한다.
이는 트리를 dfs적으로 접근하면서, 트리에 들어가는 시간 / 나가는 시간을 기록함으로써 얻어낼 수 있다.

💻 풀이
#

코드 (C++):

int N;
vector<int> links[100010];
int start[100010], ed[100010];
int timer = 1;

void dfs(int cur, int par){
 start[cur] = timer++;
 for(auto nxt: links[cur]) if(nxt != par) dfs(nxt, cur);
 ed[cur] = timer++;
}

void solve(){
 cin >> N;
 rep(i, 0, N){
 int node; cin >> node;
 while(true){
 int x; cin >> x;
 if(x == -1) break;
 links[node].push_back(x);
 }
 sort(all(links[node]));
 }

 int S; cin >> S;
 dfs(S, -1);
 rep(i, 1, N+1) cout << i << ' ' << start[i] << ' ' << ed[i] << '\n';
}

🔒

구현 코드 잠금

BOJ 2132 나무 위의 벌레

Fri, 23 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/2132

🧐 관찰 및 접근
#

트리에서 특정 경로 위에서 노드들의 가중치의 합
- 트리의 경로란, 하나의 간선을 두번 지나지 않으며 $a_i \in V, (a_i, a_{i+1}) \in E$ 를 만족하는 집합
- 다시말해, 그냥 특정 간선을 두번 타지 않고 갈 수 있는 시점~종점의 길
어떻게 구할지 생각해보자
- 어떤 점 $a_0$에서 경로를 시작한다고 해보자.
- 그 다음에 갈 수 있는 점은 $a_0$의 자식중 한곳에만 갈 수 있다.
  - 한 자식한테 들어간다면, 다시 나올수가 없기 때문에
- 그 자식을 $a_1$이라고 한다면, 마찬가지로 그 자식중 한곳에만 갈 수 있다.
- 어? 이거 DFS아닌가?
DFS처럼 할 수 있는 것 같다.
- 그러면 자식중에 어디로 가야하는가?
  - 물론 가장 열매를 많이 먹을 수 있는 곳으로!

💻 풀이
#

코드 (C++):

int N;
vector<int> links[10010];
int val[10010];

int dfs(int cur, int par){
 int ret = 0;
 for(auto nxt: links[cur]){
 if(nxt == par) continue;
 ret = max(ret, dfs(nxt, cur));
 }
 return ret + val[cur];
}

void solve(){
 cin >> N;
 rep(i, 1, N+1) cin >> val[i];
 rep(i, 0, N-1){
 int u, v; cin >> u >> v;
 links[u].push_back(v);
 links[v].push_back(u);
 }

 int ans = 0, idx = 1;
 rep(i, 1, N+1){
 int res = dfs(i, -1);
 if(res > ans){
 ans = res;
 idx = i;
 }
 }
 cout << ans << ' '<< idx << '\n';
}

🔒

구현 코드 잠금

BOJ 23086 두 반으로 나누기

Fri, 23 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/23086

🧐 관찰 및 접근
#

그래프와 간선이 주어졌을때, 특정 시점에 이분 그래프인가?를 찾는 문제이다.
- 이분그래프를 판정하는데에는 $O(N+M)$의 시간이 걸린다.
- 직관적으로 생각해보면, 리스트에 쓰인 차례대로 친한 친구를 절교시킬 수 있으므로, 리스트를 뒤집어서 하나씩 간선을 이어가며 해당 그래프가 이분 그래프인지 판정하는 방법을 쓸 수 있을 것이다.
  - 이때 시간 복잡도는 $O(K(N+M))$이다.
    - 이는 너무 느리다!
문제 상황을 조금 더 관찰해보자.
- $\text{ans}$개의 친한 친구 쌍을 절교시켜 이분 그래프가 성립하도록 했다면, $\text{ans}+1$개의 쌍을 절교시켰을때도 마찬가지로 이분그래프일 것이다.
  - $0 \leq a \leq K$인 $a$에 대해, 이분그래프가 성립하는지는 단조성이 존재한다!
    - **매개변수 탐색(파라메트릭 서치)**가 가능하다.

💻 풀이
#

코드 (C++):

int N, M, K;
vector<pair<int, int>> links[100010]; // (nxt, idx)
vector<int> prohibit_list;
int color[100010]; // 0: unvisited, 1: group A, 2: group B
bool prohibited[200010];

bool isBipartite(int cnt){
 rep(i, 1, M+1) prohibited[i] = false;
 rep(i, 0, cnt) prohibited[prohibit_list[i]] = true;
 rep(i, 1, N+1) color[i] = 0;
 rep(i, 1, N+1) if(color[i] == 0){
 queue<int> Q;
 Q.push(i);
 color[i] = 1;

 while(!Q.empty()){
 int cur = Q.front(); Q.pop();
 for(auto [nxt, idx]: links[cur]){
 if(prohibited[idx]) continue;
 if(color[nxt] == 0){
 color[nxt] = (color[cur] == 1 ? 2 : 1);
 Q.push(nxt);
 }
 else if(color[nxt] == color[cur]){
 return false;
 }
 }
 }
 }
 return true;
}

void solve(){
 cin >> N >> M >> K;
 rep(i, 1, M+1){
 int u, v; cin >> u >> v;
 links[u].push_back({v, i});
 links[v].push_back({u, i});
 }
 rep(i, 0, K){
 int p; cin >> p;
 prohibit_list.push_back(p);
 }

 // 모두 금지했을때 이분 그래프인가?
 if(!isBipartite(K)){
 cout << -1;
 return;
 }

 // 파라메트릭 서치
 int ok = K, ng = -1;
 while(ok - ng > 1){
 int mid = (ok + ng) >> 1;
 if(isBipartite(mid)) ok = mid;
 else ng = mid;
 }
 cout << ok << "\n";
 int groupA_sz = 0, groupB_sz = 0;
 isBipartite(ok);
 rep(i, 1, N+1) color[i] == 1 ? groupA_sz++ : groupB_sz++;
 cout << min(groupA_sz, groupB_sz) << ' ' << max(groupA_sz, groupB_sz) << "\n";
}

🔒

구현 코드 잠금

BOJ 34830 호현이와 파이썬

Fri, 23 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/34830

🧐 관찰 및 접근
#

문제 상황을 차근차근 살펴보자
- $a, b$가 있을 때, $a - b$ 를 한번 지나가면 된다.
- $a, b, c$가 있을 때, $a - b, b- c, c-a$를 한번씩 지나가야한다.
- $a, b,c ,d$가 있을 때, $a-b, a-c, a-d, b-c, b-d, c-d$를 한번씩 지나가야 한다.
- 이를 그래프 이론으로 해석할 수 있지 않을까?
그래프가 있고, 각 간선을 한번씩 지나되, 시점과 종점이 달라도 된다
- 한붓그리기가 가능한가?
- 이제 이 문제는 오일러 경로를 가능하게 하는 문제로 바뀐다.
- 오일러 경로는, 홀수점이 두개 이하일때 가능하다.
정점이 $N$개 있다고 하면, 그래프는 완전그래프이므로 각 정점에 붙어있는 간선은 $N-1$개이다.
- $N$이 홀수라면, 모든 $N$개의 정점은 짝수점이다.
- $N$이 짝수라면, 모든 $N$개의 정점은 홀수점이다.
  - 따라서, $N-2$개의 점들을 연결해서 홀수점이 2개가 되도록 만드는것이 최적이다.

💻 풀이
#

코드 (C++):

void solve(){
 ll N; cin >> N;
 ll ans = N * (N-1) / 2;
 if(N%2 == 0) ans += N/2 - 1;
 cout << ans;
}

BOJ 32607 Museum Visit

Thu, 22 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/32607
번역

흐로닝언 박물관 방문 문제
#

흐로닝언 박물관에서는 매일이 다릅니다. 어떤 날은 좋고 평화롭고 조용해서, 하루 종일 아름다운 그림, 조각, 그리고 다른 예술 작품들을 감상할 수 있습니다. 다른 날들은 더 바쁜데, 주말이나 공휴일에는 서두르는 방문객들, 높아진 입장료, 그리고 소리지르는 아이들로 박물관이 가득 찹니다. 이러한 불편함은 매우 다양합니다: 어떤 바쁜 날은 추가 학생 할인(studentenkorting) 덕분에 더 나을 수 있고, 어떤 조용한 날은 지진 위험 때문에 더 나빠질 수 있습니다.

BOJ 12858 Range GCD

Wed, 21 Jan 2026 00:00:00 +0000

📝 문제 정보
#

링크: https://www.acmicpc.net/problem/12858

🧐 관찰 및 접근
#

$\text{gcd}(n, n+1)$은 몇일까?
- $G = gcd(n, n+1)$이 어떤 소수 $p$를 약수로 가진다고 하자.
  - 이때 $p$는 간격 $p$마다 한개씩 존재한다.
    - $p = 2$면 $p$를 약수로 가진 수는 $2$칸마다 존재한다.
  - 따라서 연속된 두 수는 어떤 공약수인 소수 $p$를 가질 수 없다!
- 따라서 $\text{gcd}(n, n+1) = 1$임을 알 수 있다.
같은 방법으로, $\text{gcd}(a, b) = \text{gcd}(a, b-a)$ 임도 알 수 있다.
- 유클리드 호제법에서도 알 수 있듯이!
구간 쿼리지만, Lazy하게 연산하기는 쉽지 않아보인다.
- 하지만 $\text{gcd}(x_a, x_{a+1}, x_{a+2}, \dots, x_b)$ 를
- $\text{gcd}(x_a, x_{a+2} - x_{a+1}, x_{a+3} - x_{a+2}, \dots, x_b - x_{b-1})$
- 이라고 생각하면, 바뀌는 수는 생각보다 많지 않다!
Lazy한 합 연산과 최대공약수에 대한 그냥 세그먼트 트리로 풀 수 있지 않을까?
- 사실 Lazy부분도 구간 덧셈, 점 쿼리이므로 그냥 세그로 바꿀 수 있지만, 귀찮으니까 ㅋㅋ

💻 풀이
#

코드 (C++):

void solve(){
 int N; cin >> N;
 LazySegmentTree LST(N);
 ST.init(N-1);

 vector<ll> A(N);
 rep(i, 0, N) cin >> A[i];
 rep(i, 0, N) LST.set(i, A[i]);
 LST.build();
 rep(i, 0, N-1) ST.set(i, abs(A[i+1] - A[i]));
 ST.build();

 int Q; cin >> Q;
 while(Q--){
 ll op, a, b; cin >> op >> a >> b;
 a--; b--;
 if(op){
 LST.update(a, b, op);
 if(a-1 >= 0) ST.update(a-1, abs(LST.query(a-1, a-1) - LST.query(a, a)));
 if(a+1 < N) ST.update(a, abs(LST.query(a+1, a+1) - LST.query(a, a)));
 }else{
 cout << gcd(LST.query(a, a), ST.query(a, b-1)) << '\n';
 }
 }
}

🔒

구현 코드 잠금

Problem Solving on Jiho Kim

BOJ 24535 둘레길

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 32527 Insane Drift

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 11385 씽크스몰

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 14958 Rock Paper Scissors

📝 문제 정보 #

번역 #

문제 #

BOJ 20176 Needle

📝 문제 정보 #

번역 #

문제 #

BOJ 25456 궁금한 시프트

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 32453 Efficient Slabstones Rearrangement

📝 문제 정보 #

문제 #

BOJ 5638 수문

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 1739 도로 정비하기

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 11111 두부장수 장홍준 2

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 14587 도미노 (Large)

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 30478 Candy Rush

📝 문제 정보 #

문제 #

BOJ 30880 쿼리는 락이 아니다

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 11493 동전 교환

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 35108 게국지

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 15309 스킬 트리

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 23887 프린트 전달

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 34609 Secret Lilies and Roses

📝 문제 정보 #

문제 #

BOJ 1006 습격자 초라기

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 28359 수열의 가치

📝 문제 정보 #

🧐 관찰 및 접근 #

💻 풀이 #

BOJ 5916 농장 관리

📝 문제 정보 #

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

번역
#

문제
#

📝 문제 정보
#

번역
#

문제
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

문제
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

문제
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

문제
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#

💻 풀이
#

📝 문제 정보
#

🧐 관찰 및 접근
#