jihyung1997

[diamond1][해설미확인,분류확인] boj2586 소방차 (아이디어만)

끄응끄응 — Sat, 18 Apr 2026 15:24:18 +0900

아이디어만 생각해두고 언젠가 풀려고 했는데 백준이 서비스 종료한다고 해서 아이디어만이라도 적어두려고 한다.. 구현하고 수많은 디버깅을 뚫기에는 이제 알고리즘 문제 풀 시간이 없을 것 같다...

이 문제를 풀 때 수많은 아이디어가 떠올랐던 것 같지만 현재 가장 유력한 아이디어는 다음과 같다.

우선 위와 같이 소방차를 1번부터 맨왼쪽 호스로 차례로 연결한다. 그럼 모든 소방차는 왼쪽 호스로 쏠린 상태일 것이다.

그러나 그런 상태는 절대로 정답이 아닐 것이다.

그렇다면 위와같은 상태에서 소방차와 호스사이에 칸을 띄워야 할 것이다. 예를들어 소방차 2번부터 한칸을 띄우면 아래와 같이 된다.

위와 같은 상태를 편의상 아래와 같이 나타낸다 치자.

즉 1번소방차, 2번소방차 사이의 1의 의미는 1번과 2번사이에 1칸을 띄웠다는 것이다.

위와 같은 경우는 아래와 같이 될 것이다.

그럼 이제 다시 처음으로 돌아와서, 아래와 같은 경우는 어떻게 띄워야 할까?

한 번 계산에 한칸씩 띄운다고 가정했을 때, 한칸 띄웠을 때 가장 소방차와 호스간의 간격의 합이 크게 줄어드는 부분을 띄우면 된다. 그 이유를 알아보자. 위와 같은 상황에서, 4~5번 사이를 띄운다고 치자. 그럼 아래와 같이 된다. 일단 아래는 간격총합이 줄어들긴 한다. (소방차5번, 호스7 번이 최적의 짝인데, 7번에 가까워졌기 때문)

3~4번 사이를 띄우면 아래와 같이 된다. 이때는 소방차4, 소방차5 의 호스의 간격총합이 줄어든다.

반면 0~1번, (소방차1번의 왼쪽)을 띄우면 아래와 같이 된다.이 때 소방차1번의 최적 호스는 1번이였는데 2번으로 갔으므로 간격총합은 증가한다.

위와 같은 예시를 살펴보면 , 소방차 사이 간격 어디를 띄우냐에 따라 총합이 증가할 수도, 감소할 수도 있다는 것을 알 수 있다. 그렇다면 왜 가장 총합이 가장 크게 감소하는 부분을 띄우면 될까? 직관적으로 보면 당연히 그리디 하게 띄우는게 타당해 보이지만, 의심할 만한 포인트가 있다.

어느 간격을 띄우냐에 따른 간격총합 변화량이 아래와 같다고 생각해보자.

우선 4~5번, 3~4번까지는 간격총합이 점차 감소한다. 그러나, 2~3번 사이에선 다시 증가한다. 즉 3번 소방차의 호스간격이 증가한 것이다. 다시 1~2번 사이를 띄우면 크게 총합이 감소한다. 즉 2번 소방차의 간격이 크게 감소한 것이다. 0~1번 사이를 띄우면 다시 증가하므로, 1번 소방차의 간격이 증가한 것이다.

그럼 이제 직관적으로 3~4번을 띄울지, 1~2번을 띄울지 고민이 될 것이다. 3~4번을 띄우는 이유는 3,4,5번소방차를 띄우는 과정에서 어떤 소방차의 호스 간격도 증가하지 않기 때문이고, 1~2번을 띄우는 이유는 간격총합이 가장 크게 감소하기 때문이다.

즉 1~2번 을 띄우는데 주저하게 되는 이유는 바로 3번 소방차의 간격이 증가하기 때문이다. 그러나 걱정하지 않아도 된다.

1~2번을 띄우면 2,3,4,5번 소방차가, 3~4번을 띄우면 4,5번 소방차가 띄워지게 된다. 즉 4,5번 소방차는 공통으로 띄워진다. 그럼 차이는 2,3번 소방차가 띄워지냐 마냐인데, 만약 3번소방차 간격이 증가하는게 무서워 띄우지 않게 된다면, 2번소방차는 평생 못띄우게 된다. 1~2번을 띄우고 3번은 이제 더이상 안건들이면 되므로, 특정 소방차의 간격이 증가하는 것은 무시하고 전체 간격총합이 가장 크게 감소하는 사이를 띄우면 된다.

또한 한가지 매우 중요한 점은 간격총합이 가장 크게 줄어드는 소방차 사이를 띄웠으면 이제 더이상은 그 지점보다 왼쪽의 구간은 띄워선 안된다는 것이다. 위에서는 1~2번 사이의 간격이 가장 크게 줄었다. 그래서 1~2번을 띄웠다고 치자. 그 다음 띄울때 만약 1~2번 보다 왼쪽의 지점을 띄우게 된다면, 간격은 늘어나게 될 것이다.

만약 위와 같은 상황이고 3~4번을 띄우는게 최적이라고 치자. 그럼 여기서 2번 3번의 호스를 오른쪽으로 옮기면 간격총합이 증가한다는 것을 알 수 있다. 따라서 다음 번 띄울 때는 3~4번 보다 왼쪽의 지점 ( 0~1 OR 1~2 OR 2~3) 을 띄우면 안된다.

그럼 이제 우리는 소방차를 가장 왼쪽의 호스로 몰아 연결한 뒤, 어느 지점을 띄워야 할지 찾은 뒤 , 다음 번에는 그 지점보다 오른쪽부터 어디를 띄울지 탐색하면 된다. 그러나 이 경우는 최악의 경우 N + N - 1 + N - 2 + ... 1 이 되므로 O(N^2) 이 된다.

그럼 어떠헥 이 문제를 해결할 수 있을 까? 아래와 같은 경우가 있다고 치자.

이 경우 간격총합이 감소하는 구간과 증가하는 구간이 있다. 이 구간을 따로 저장한다.

위와 같은 경우 1~3 구간, 5 ~8 구간, 11 ~13 구간 이 감소하는 구간, 나머지 구간은 증가하는 구간이다.

우리는 여기서 감소하는 구간의 가장 오른쪽 구간만 띄워보면 된다는 것을 알 수 있다. 1~3구간에서는 3번지점이 , 5~8 에서는 8번 지점이 가장 간격총합이 크게 감소하기 때문이다.

우리가 원래 지점 별로 간격총합을 검사할 때는 22번을 검사 (모든 점의 갯수) 해야 하지만, 이렇게 감소하는 구간의 가장 오른쪽만 조사한다면 3번만 검사하면 된다.

한 간격을 띄울 때 간격 총합의 변화량은 어떻게 계산할까? 다음과 같이 한칸씩 오른쪽으로 띄울 때, 현재 전체 총합에서 가장 호스의 왼쪽, (b1) 과 오른쪽 (b4)만 고려하면 되므로, 변화량 계산의 시간복잡도는 O(1)이 될 것이다.

자, 그러나 여전히 감소 구간의 오른쪽을 검사해도, 최악의 경우에는 한번 검사할 때마다 O(N)번씩 검사해야 할 수도 있다,.

그러나 그렇지 않다.

위의 그림은 소방차와 연결된 호스를 한칸 오른쪽으로 옮길 때 의 양상을 나타낸 것이다.

우부터 좌로 훑어보면 맨오른쪽 소방차는 호스를 오른쪽으로 이동하면 간격 총합이 증가한다. (증가구간)

두번째 소방차는 호스를 이동하면 감소구간에서 증가구간으로 스위칭 하는 과정이므로, 간격총합이 증가할지 감소할지 모른다. 계산해봐야 한다.

3~4번째 소방차는 오른쪽으로 이동시 확실히 간격총합이 감소한다.

여기서 아까 설명했듯이 간격총합을 최소로 하는 포인트를 찾을 때는 감소구간들에서 맨 왼쪽만 고려하면 된다.

또한 여기서 시간복잡도를 O(N^2)이 아니라는 것을 증명하기 위해 매우 중요한 포인트는, 감소구간의 맨 오른쪽 부분이 다음 간격시에는 무조건 스위칭 구간이 된다는 것이다.

위와 같이 왼쪽은 한칸 띄우기 전이고, 한칸 띄운뒤는 오른쪽과 같이 된다. 여기서 감소구간의 맨오른쪽은 스위칭 구간이 된것을 알 수 있다. 이유는 단순하다. 띄우기 전 구간에서 3번째 소방차가 3번째호스에서 스위칭 구간이였는데, 그 소방차보다 왼쪽에 있는 2번소방차가 띄운 후 3번 호스와 매칭되면서 반드시 스위칭 구간이 된다. 핵심은 감소구간의 오른쪽 구간은 스위칭 구간이고, 감소구간의 맨 오른쪽 지점은 현재 스위칭 지점보다 왼쪽에 있기 때문에 반드시 다음에 스위칭 구간이 된다.

그럼 다음과 같은 사실을 알 수 있다.

1. 한칸을 띄울때의 간격총합이 최소로 감소하는 지점은 각 감소구간의 맨왼쪽 지점으로 좁혀진다.

2.감소구간의 맨 오른쪽 지점은 다음 번에 반드시 스위칭 구간이 된다.

만약 N이 10만 개고, 감소구간이 100개, 각각의 감소구간은 1000개의 소방차로 이루어져있다고 생각하자.

각 시행에서 어디를 띄울지는 각 감소구간의 맨 왼쪽, 즉 100개만 고려하면 된다. 그리고 그 시행이 끝날 때마다, 각 감소구간의 맨오른쪽은 무조건 스위칭 구간이 된다. 즉 , 각 감소구간의 소방차수가 한개씩 감소한다. 즉 500번 시행 한다면, 각 감소구간은 500개의 소방차로 이루어져있을 것이다. 1000번 시행시는 감소구간이 없어져 있을 것이다.

즉 위의 두가지 특성으로, O(N)으로 구할 수 있다.

각 시행시 어디를 띄울지 특정한다면, 이제 그 지점의 왼쪽은 더이상 고려하지 않아도 되므로, 그 지점~ 맨오른쪽의 지점들만 고려하면 된다.

또한 유의할 점은, 스위칭 구간은 감소구간의 맨오른쪽뿐만 아니라, 감소구간의 중간에서도 불쑥 나타날 수 있다.

몇번 띄웠을 때 각각의 소방차에서 스위칭 구간이 나타나는지는, 투포인터(혹은 슬라이딩 윈도우?)로 알 수 있다.

투포인터로 n번째 소방차가 m번째 호스와 매칭시 스위칭 구간임을 알아내면, n + 1번 소방차는 최소 m번째 이상의 호스와 매칭시 스위칭 구간이므로 m번째부터 고려한다. 또한 n번째 소방차가 m번째 호스와 매칭시 m-n만큼 간격을 띄웠을 때 매칭됨을 유의한다.

요약:

1. 각 소방차의 사이 지점을 탐색, 그 지점들을 집합으로 하는 감소구간, 증가구간, 스위칭구간(집합갯수 1개) 를 구분한다.

2. 각 소방차마다 몇칸을 띄웠을 때(호스를 오른쪽으로 몇칸 이동했을 때) 스위칭 구간이 되는지 알아낸다. O(N)

3.각 감소구간의 맨 왼쪽을 띄워보면서, 어느 지점을 뜨웟을 때 간격총합이 가장 크게 감소하는지 찾는다. 이제 다음 띄울 때는 그 지점부터 고려한다.(그 지점의 왼쪽부분은 더이상 고려대상 X) . 그 후 감소한 간격총합을 토대로 정답을 업데이트

4. 이제 그 지점을 띄웠을 때, 그 지점부터 맨 오른쪽 까지 구간중 어느 지점이 스위칭 구간이 되는지는 2번에서 알아냈으므로, 그걸 토대로 감소구간을 새로 업데이트. (이때 최소 감소구간 갯수 이상의 소방차가 감소구간에서 스위칭 구간으로 전환)

5.2~4번 구간을 반복한다. 만약어떤 지점에서도 간격총합이 감소하지 않을 경우, 사이클을 멈춘다.

[diamond5][ 풀이, 분류 미확인] boj18444 우체국3

끄응끄응 — Sun, 29 Mar 2026 05:27:01 +0900

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

아이디어도 어려웠고, 특히 한번도 구현해보진 않은 희소배열의 아이디어를 기억 깊숙한 곳에서 꺼내기가 힘들었다..

+ 구현도 상당히 복잡했고,, 제일 큰 이슈는 java로는 시간제한을 지킬 수 없는 문제여서 수없는 삽질을 하였다...

Wow

처음 생각한 아이디어는 누적합을 이용한 dp 였다.

위와 같이 dp는 시작지점, 끝지점, 그 사이의 우체국 갯수 (시작 , 끝 점은 우체국 반드시 포함) 을

state로 한다.

dp[2][6][3] = Math.min(dp[2][5][2], dp[2][4][2], dp[2][3][2]) 의 점화식을 가질 것이다.

end 지점이 e번이고 시작지점이 s번, 우체국 갯수가 p개인 dp를 구하고자 할 때 , n-1, n- 2... 가 end지점, 우체국갯수가 p - 1 개, start지점은 s번인 dp들을 참고해야 할 것이다.

dp[s][e][p] 를 구할 때 dp[s][e - 1][p], dp[s][e - 2][p]... dp[s][e - p + 1][p]... 만큼 참고해야 하므로 최대, e번 계산해야하고, 최대 N번이 된다. 이 과정을 N(s에 대해) * N (e에 대해)* P(우체국갯수)에 반복하므로, 시간복잡도는 거의 O(N^4)이다.

어떻게 하면 이걸 줄일 수 있을 까...

한참을 고민하다가, 희소배열의 개념이 떠올랐다. 사실 문제를 보자마자 생김새가 예전에 풀었던 감시카메라 문제와 유사해서 희소배열도 잠깐 떠올린 것 같지만 , dp에 꽂혀서 금세 잊혀졌었다. 그러다가 dp[s][e][p] 에 대해,

dp[s][e][p] 를 dp[s][m][p1] 와 dp[m][e][p2] (p1 + p2 = p ) 로 나타낼 수 있지 않을 까 생각하던중, 거듭제곱을 활용한 희소배열이 생각이 났다. 희소배열을 사용하면서 분할 정복도 사용이 될 것이다.

우선, 희소배열을 생각하기 전 분할정복은 다음과 같다. dp[1][10][5] 를 구성할 수 있는 요소로는 dp[1][5][3], dp[5][10][3] 이 있을 것이다.

또한 아래와 같이 dp[1][3][3], dp[3][10][3] 과 같은 경우도 있을 것이다.

dp[1][10][5] = Math.min(dp[1][5][3] + dp[5][10][3], dp[1][6][3] + dp[6][10][3], dp[1][7][3] + dp[7][10][3] ....

dp[1][8][10] + dp[8][10][3]) 으로 생각 할 수 있을 것이다.

그런데 여기서 의문이 들 수도 있다. 왜 dp[1][4][2] + dp[4][10][4]와 같은 경우는 생각하지 않는가?

아래와 같이 말이다. 결국 dp[1][4][2] + dp[4][10][4] 는 범위를 조정하면 dp[1][5][3] + dp[5][10][3] 로도 나타낼 수 있다.

따라서 우체국 수는 3으로 고정시킬 수 있다.

분할정복은 대충 이렇게 하는 거라는 걸 알았지만, 위와같이 dp[s][e][cnt] = dp[s][m][cnt1] + dp[m][e][cnt2] 의 형태로 구하려한다면, 여기서도 어김없이 O(N ^4)의 시간복잡도이다.

여기서 희소배열의 아이디어가 쓰인다.

위에서 dp[s][e][5] 은 dp[s][m][3] + dp[m][e][3] 에서 m을 조정하며 얻은 최솟값이라는 걸 알았다.

그렇다면, dp[s][e][9] 는? dp[s][m][5] + dp[m][e][5] 를 조정하며 얻은 최솟값이다.

마찬가지로 dp[s][e][17] 은 dp[s][m][9] + dp[m][e][9]에서 계산할수 있다.

이런식으로 2 * p - 1 씩 증가시키며 계산하면, 구간안의 우체국 수가 2 , 3 , 5 , 9 , 17, 33 , 65 , 129 ... 일때의 dp을 구할 수 있다.

이때 모든 구간 s, e에 대해 구한다고 하면, s, e, m 을 조정하면서 구하므로, 이때 O(N^3), 이걸 2,3,5...129,257 까지 구한다 하면 O( N^3 * log2(257)) 이 된다.

왜 이렇게 구했을까?

dp[s][e][111] 을 구해야 한다고 생각해보자. 우선 위에서 구한 2 , 3 , 5 , 9 , 17, 33 , 65 , 129 ... 중 65와 33 을 결합한다고 생각해보자. dp[s][e][97] 은 dp[s][m][65] + dp[m][e][33] 에서 s,e,m을 조정하며 모든 구간에 대한 우체국 수가 97일 때를 구할 수 있다. 97까지 구했으면 111까지 14개의 우체국이 남았다.

여기서 dp[s][e][97 + 9 - 1] 은 dp[s][m][97] + dp[m][e][9] 로 구할 수 있다.

dp[s][e][105 + 5 - 1] 은 dp[s][m][105] + dp[m][e][5]

dp[s][e][109 + 3 - 1] 은 dp[s][m][109] + dp[m][e][3] 이런식으로 구할 수 있다.

65 + 33 -> 97

97 + 9 -> 105

105 + 5 -> 109

109 + 3 -> 111

결국 여기서 111까지 구하기 위해선 65, 33 , 9 , 5 , 3 만 필요했다.

즉 우체국수를 2,3,5,9... 257 까지 구해놓으면 여기서 적절하게 조합해 모든 수를 만들 수 있다.

각각의 우체국수에 대해 O(N^3)의 시간복잡도이므로, 결국 O(N^3 * (log2(257))로 구할 수 있다.

즉 모든 dp[s][e][p]에서 p를 1,2,3,4,... 우체국 최대갯수 까지 구하는게 아니라, 2, 3,5,9, ... 식으로 띄엄띄엄 구해서, 이 수들을 조합하는 식으로 구할 수 있는 것이다.

최대 우체국수가 111개 였으면, 위와 같이 모든 s,e에 대해 dp[s][e][111]을 구했다. 그런데 마을은 원형을 이루고 있다.

위와 같이 dp[s][e][111]에 대해 구했으면, 빨간 부분은 이제 우체국이 들어설 수 없는 구역이다. 이 구역에는 양끝 s, e 에만 우체국이 있으므로, 누적합을 이용해 빨간색 구간 마을의 우체국 거리 합을 구할 수 있다.

dp[s][e][111] + 빨간구간 거리합 까지 합하면, 이제 원형의 모든 마을에 대해 우체국까지 최소거리를 구할 수 있다.

모든 s,e에 대해 이뤄지므로 추가적으로 O(N^2 ) 이 이뤄지게 된다. (누적합을 통한 계산은 거의 O(1)이다).

역추적은 적당히 재귀 dfs를 이용해 돌리면 된다..

이렇게 아이디어를 내보았다.

아이디어를 떠올린 것 까지는 분위기가 좋았다. 그러나 구현이 매우 까다로웠고, 구현 성공후, java로는 도저히 안돌려지길래 gpt한테 그대로 c++로 옮겨달라고 해서 해결하였다. java로 안되서 얼마나 오래 삽질했는지 정신이 아찔해진다.

그렇다고 합니다. 사실 c++로 돌려서 채점을 돌리다가 75프로에서 WA가 나서, 디버깅까지 하면 내 멘탈이 못버티겠다 하고, 구글링을 해서 반례를 찾았는데, 이 반례는 알고보니 java에서 한참 삽질하면서 이미 고쳤지만, c++로 옮기면서 미쳐 놓친 부분이였다. 마을이 같은 곳에 있을 때 마을의 위치대신 인덱스로 역추적을 하게 만드는 부분이였다.

  package boj18444;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main2 {
static int N;
static int posts;
static long L;

static long[] P;
static long [] sum;
static long [][][][] trace; // s, e , cnt    :    mid, cnt1 , cnt2
static long [][][] dp; // s , e , cnt
static List<Long> ansL = new ArrayList<Long>();
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
N = Integer.parseInt(st.nextToken());posts = Integer.parseInt(st.nextToken());L = Long.parseLong(st.nextToken());
P = new long [N + 1]; sum = new long[N + 1]; trace = new long[N + 1][N + 1][N + 1][3]; dp = new long[N + 1][N + 1][N + 1];
st = new StringTokenizer(br.readLine());
for(int i = 1 ; i <= N; i++) {
P[i] = Long.parseLong(st.nextToken());
sum[i] = P[i] + sum [i - 1];
}
if(posts == 1) {
long ans1 = Long.MAX_VALUE; int ansi = 0;
for(int n = 1 ; n <= N ; n++) {
long res = (P[n] + L / 2);
long mid = res >= L ?  res - L : res;
int mi = 0 ; int l = 1 ; int r = N;
while(l <= r) {
int m = (l + r) / 2;
if(P[m] <= mid) {
mi = m;
l = m + 1;
}else {
r = m - 1;
}
}

long sum1 = 0 ; long sum2 = 0 ; long sum3 = 0;
if(n <= mi) {
   sum1 = sum[mi] - sum[n - 1] - (mi - n + 1) * P[n];
   sum2 =   (N- (mi + 1) + 1) * P[n] + (L * (N - mi) - (sum[N] - sum[mi]));   // mi + 1 ~ N
   sum3 =  n * P[n] - sum[n];   // 1 ~ n2
//   System.out.println(sum1 + " " + sum2 + " " + sum3);

}else {
  sum1 = sum[N] - sum[n - 1] - (N - n + 1) * P[n];
  sum2 = mi * (L - P[n]) + sum[mi];
  sum3 = (n - (mi + 1) + 1) * P[n] - (sum[n] - sum[mi]);  // mi + 1 ~ n2
}
if(sum1 + sum2 + sum3 < ans1) {
ans1 =  sum1 + sum2 + sum3;
ansi = n;
}

}

System.out.println(ans1);System.out.println(P[ansi]);

return;
}
for(int i = 0 ; i <= N ; i++) {
for(int j = 0 ; j <= N ; j++) {
Arrays.fill(dp[i][j], Long.MAX_VALUE / 2);
}
}

for(int i = 1 ; i <= N ; i++) {
for(int j = i + 1 ; j <= N ; j++) {
dp[i][j][2] = getS(i,j);
//System.out.println (dp[i][j][2] + " " +  i   + "  " +  j );
}
}
List<Integer> pows = new ArrayList<Integer>();

for(int pow = 2 ; pow <= 300 ; pow = 2 * pow - 1) {
pows.add(pow);
}

for(int pow = 2 ; pow <= 150 ; pow = 2 * pow - 1) {        // N ^ 3 * log2N

for(int i = 1 ; i <= N ; i++) {
for(int j = i + 1 ; j <= N ; j++) {
for(int m = pow + i - 1 ; m <= j + 1 - pow ; m++) {
// if(m - i + 1 < pow ||   j - m + 1 < pow ) continue;

if(dp[i][m][pow] + dp[m][j][pow] < dp[i][j][2 * pow - 1]) {
trace[i][j][2 * pow - 1] = new long[] {m, pow , pow};
dp[i][j][2 * pow - 1] = dp[i][m][pow] + dp[m][j][pow];
}

}
}
}
}

int pow = 0;
int psum = 0;
for(int i = pows.size() - 1 ; i>= 0 ; i--) {
if(pows.get(i) <= posts) {
psum = pows.get(i) ;    break;
}
}
while(psum < posts) {
for(int i = pows.size() - 1 ; i>= 0 ; i--) {
if(pows.get(i) + psum - 1 <= posts) {
pow = pows.get(i); break;
}
}

for(int i = 1 ; i <= N ; i++) {
for(int j = i + 1 ; j <= N ; j++) {
for(int m = pow + i - 1 ; m <= j + 1 - psum ; m++) {
//if(m - i + 1 < pow ||   j - m + 1 < psum ) continue;
if( dp[i][m][pow] + dp[m][j][psum] < dp[i][j][pow + psum - 1]) {
dp[i][j][pow + psum - 1] = dp[i][m][pow] + dp[m][j][psum];
trace[i][j][pow + psum - 1] = new long[] {m, pow , psum};

}

}
}
}
psum = psum + pow - 1;

}

long ans = Long.MAX_VALUE ;

int anss = 0 ; int anse = 0 ;
for(int i = 1 ; i <= N ; i++) {
for(int j = i + 1 ; j <= N ; j++) {
long res =  getS2(j,i)+ dp[i][j][posts];
if(res < ans) {
ans = res;
anss = i ; anse = j;

}

}
}

System.out.println(ans);
  makeList(anss , anse , posts);

  Set<Long> ansS = new HashSet<Long>();
  ansS.addAll(ansL);
  ansL = new ArrayList<Long>(ansS);
  Collections.sort(ansL);
StringBuilder sb = new StringBuilder();
for(long idx : ansL) sb.append(idx + " ");
System.out.println(sb);

}

public static long getS(int n1 , int n2) {
long mid = (P[n1] + P[n2]  ) /2;
if(posts == 1) {
long res = (P[n1] + L / 2);
mid = res >= L ?  res - L : res;
}
int mi = 0 ; int l = 1 ; int r = N;
while(l <= r) {
int m = (l + r) / 2;
if(P[m] <= mid) {
mi = m;
l = m + 1;
}else {
r = m - 1;
}
}
//System.out.println(  n1 + "  " + n2 + " m " + mi);
long sum1 = sum[mi] - sum[n1 - 1] - (mi - n1 + 1) * P[n1] ;
long sum2 =  (n2 - (mi + 1) + 1) * L - (sum[n2] - sum[mi] )      - (n2 - (mi + 1) + 1) * (L - P[n2]) ;
return sum1 + sum2;

}

public static long getS2(int n1 , int n2) {
long dist = L - P[n1] + P[n2]; long mid = 0;
if(P[n1] + dist / 2 >= L) {
mid = P[n1] + dist / 2 - L;
}
else mid = P[n1 ] + dist  / 2;

int mi = 0 ; int l= 1 ; int r = N;
while(l <= r) {
int m = (l + r) / 2;
if(P[m] <= mid) {
mi = m;
l = m + 1;
}else {
r = m - 1;
}
}
long sum1 = 0 ; long sum2 = 0 ; long sum3 = 0;
if(n1 <= mi) {
   sum1 = sum[mi] - sum[n1 - 1] - (mi - n1 + 1) * P[n1];
   sum2 =   (N- (mi + 1) + 1) * P[n2] + (L * (N - mi) - (sum[N] - sum[mi]));   // mi + 1 ~ N
   sum3 =  n2 * P[n2] - sum[n2];   // 1 ~ n2
//   System.out.println(sum1 + " " + sum2 + " " + sum3);

}else {
  sum1 = sum[N] - sum[n1 - 1] - (N - n1 + 1) * P[n1];
  sum2 = mi * (L - P[n1]) + sum[mi];
  sum3 = (n2 - (mi + 1) + 1) * P[n2] - (sum[n2] - sum[mi]);  // mi + 1 ~ n2

}
// System.out.println(n1 + " " + n2 + " mi "  + mi + " mid " + mid +  " res " + (sum1 + sum2 + sum3));
return sum1 + sum2 + sum3;

}
    static void makeList(int s , int e , int cnt) {
     if(cnt == 2) {
     ansL.add(P[s]); ansL.add(P[e]);
     return ;
     }
     int mid = (int)trace[s][e][cnt][0];
     int cnt1 = (int)trace[s][e][cnt][1];
      int cnt2= (int)trace[s][e][cnt][2];
      makeList(s, mid , cnt1); makeList(mid, e , cnt2);

    }

}

[platinum3][풀이미확인, 분류확인]32115 돌 놓기 게임 (체감 : 플레1 ~2)

끄응끄응 — Tue, 24 Mar 2026 16:32:48 +0900

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

아무리 봐도 플레3은 아닌 문제였다. 아이디어 발상도 흔하지 않아 떠올리기 어렵고, 구현도 내 기준 쉽지 않았다..

게임이론에서 쓰이는 이상한 알고리즘이 있는데 그 알고리즘이면 안 푸려고 분류를 확인하였다.. (보면서 얼떨결에 그리디라는 것도 알게 되어 큰 힌트가 된듯)

위와 같은 경우를 생각해보자. (초록색: 점수 검정색: 흑or백)

흑 과 백이 번갈아 가며 자기의 색깔과 인접한 빈칸에 둘때 다음과 같은 생각은 어렵지 않게 할 수 있다.

같은 색깔이 둘러싸고 있는 구간은 다른 색깔이 침범할 수 없다.

위와 같이 묶인 그룹에는 다른 색깔이 침범할 수 없다. 예를 들어 2번 그룹 (백으로 둘러싸임)에 흑이 들어갈 수 없다. 백은 백끼리 흑은 흑끼리 인접하면서 확장해 나가야 하기 때문.

그럼 위의 그룹들 안의 0을 채워넣는 것은 가장 나중에 해도 될 것이다. 1번과 2번의 영역 싸움을 하지 않아도 되기 때문이다.

그렇다면 우리가 고민해야 할 부분은 다음 부분들이다.

빨간 부분들은 이제 흑과 백이 자리 선점을 위해 치열하게 경쟁하는 구간이 될 것이다.

이제 진짜 어려운 문제는 위와 같은 구간에서 어떻게 백과 흑이 최선을 다해 점수를 획득하게 하느냐 이다.

우선 직관적으로 생각해보자. 2번 구간에서 흑이 가장 쉽게 먹을 수 있는 점수는 2,14,10,12,8 점 순이다.

즉 오른쪽에서 멀어질 수록 먹기힘든 점수가 된다. 그런데 만약 먹기 힘든 점수인데 그 점수가 매우 크다면? 위험을 무릅쓰고 라도 점수를 먹으러 갈 것이다.

흑 부터 시작하므로 , 일단 흑이 먹어야 할 점수는 3번구간의 15점이라는 것은 당연하다. 15점은 가장 큰 수이고, 지금 안먹으면 백에게 빼앗기기 때문이다.

그럼 흑은 일단 15점을 먹었고, 다음 턴에 백은 1번구간, 2번구간 중 어디에 두어야 할까? 2번에 두어야 할 것 같다. 지금 2번에 두게되면, 10점은 확정적으로 먹을 수 있게 된다. 아래와 같은 순서대로 결국 백이 10점을 먹게 된다.

그렇다면, 구간의 딱 중간을 먹기 위해서, (10점) 먼저 돌을 두면 되겠구나! 생각이 든다.

그러나 또 한편으론 의심이 든다. 일단 10점을 먹기 위해서 8점부분에 돌을 두긴 두었는데, 10점으로 가는데, (8점 -> 12 점 -> 10점) 먹는 점수보다, 다른 구간을 먼저 선점하는게 이득일 수도 있지 않을까?

예를 들면 다음과 같다.

위와 같은 경우에 백이 10점을 먹기위해 8점 -> 12점 -> 10점을 먹는 것보다 아래구간의 20점 -> 20점 을 먹는게 이득 아닌가?

그러나 그렇지 않다. 아래의 20점 구간은 안전지대로, 아직 백의 것이 확정인 상태이다. 즉 , 흑이 20점을 먹기위해 공격이 들어오면(흑이 초록5번에 두면) 그 때 백도 공격에 나서면 된다.(초록1에 둔다).

현 상황에서, 구간의 갯수가 홀수 일때 백이 먼저 돌을 둠으로써 자기의 영역이 된다고 확정지을 수 있는 구간은 중간 부분이다. (10점) . 그렇다면, 여러 구간들에서 중간부분의 점수를 구하고, 점수가 큰 부분부터 흑과 백이 번갈아가며 차지하려 할 것이다.

위와 같이 말이다. (구간길이가 1인 경우는 중간이 곧 구간)

그렇다면 구간의 갯수가 짝수인 경우는 어떻게 할까?

아래와 같은 경우를 생각해보자.

그렇다면 다음과 같은 과정을 겪게 될 것이다. (흑 : 파랑 , 백: 빨강)

우선 흑은 4점짜리에 먼저 둔다고 치자. 그 이유는, 다음 턴에 백이 1점에 두게 되지 않으면 흑이 21점을 먹을 수 있기 때문이다.

이제 백은 방어하기 위해 1점에 두게 된다.

그 다음 마찬가지 이유로 다시 흑이 20점에 두게 되고, 백은 방어를 위해 21점에 두게 된다.

이와 같은 식으로 반복하면, 짝수인 구간에서는 정확히 영역이 반으로 나뉘게 된다. (명쾌하다)

짝수인 경우에, 누가 먼저 두느냐에 따라 선점할 수 있는 구간이 없고 (구간의 절반인 구간이 홀수와 달리 없기때문) 공격이 들어오면 충분히 방어할 수 있기 때문이다.

그렇다면 결론적으로, 구간 길이가 홀수 인경우에 , 중간인 부분을 먼저 돌을 둠으로써 선점하면, 그 다음구간은 짝수가 되므로, 무조건 반으로 나뉘게 된다. 이해가 쉽게 그림으로 보자.

백의 차례에서 백이 가장 먼저 돌을 두면, 나머지 구간 (12, 10 , 14 ,2 ) 은 길이가 짝수가 되므로, 그다음부터는 백과 흑의 영역이 정확히 반으로 나뉘게 된다.

그럼 이제 짝수구간이 되면 알아서 반반으로 나뉜다는 걸 알았으니, 어떻게 하면 되겠는가?

구간 길이가 홀수인경우에만, 가운데 부분이 큰 순서대로 서로 선점해 나가면 될 것이다. 위의 경우, 백이 먼저 돌을 둠으로써 , 10 점 부분이 백의 영역이 된 것처럼 말이다.

결론적으로, 빈 구간은 다음과 같이 채워질 것이다. (파란점 흑 , 빨간점 백)

또 그 이후 파란 구간 ( 같은 돌로 둘러싸인 구간은 알아서 같은 돌로 채워짐) 도 채운다.

이제 다 채웠다.

요약하면 다음과 같다.

1. 1번과 2번이 대치하는 구간을 찾기.

2. 그 구간의 길이가 홀수이면, 우선순위큐에 가운데 값을 넣는다. 짝수라면, 절반 씩 구간을 채운다.

3. 우선순위큐에서 꺼내가면서, 흑백흑백흑... 순서로 가운데 값이 큰 구간부터 돌을 채우고, 구간의 나머지 부분은 짝수가 되므로, 절반씩 구간을 채운다.

4. 나머지 구간( 같은 돌로 둘러싸인 구간) 은 같은 돌로 채운다.

구현도 결코 쉽지 않으며, 아이디어도 어려웠는데 왜 플레3인지 의문을 가지며, 글을 마친다.

[platinum3][해설, 분류 미확인] boj2315 가로등 끄기

끄응끄응 — Mon, 23 Mar 2026 16:19:24 +0900

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

경계값을 잘 생각하고, 누적합 적용하면 그렇게 어렵진 않았었던 dp문제다.

우선 마징가가 어떤 경향을 가지고 움직일지 생각해보자.

시작점에서 왼쪽으로 갔을 때 두가지 방법이 있다.

1. 왼쪽이동(파란색)

2. 오른쪽이동(초록색) : 이미 지나온 시작점에서 멈추는 것은 의미없다. 즉 아래 경우는 고려하지 않는다. 켜진 불을 끄러가야 하기 때문에 이미 꺼진불은 고려할 필요가 없다. 따라서 켜진불이 있을 때까지 , 즉 오른쪽으로 5번까지 이동한다. (위에서 처럼)

그다음 2번에 있을 경우, 아래와 같이 1번 또는 5번으로 이동할 것이다.

간단히 보면 한번 움직일 때마다 켜진 불이 있을 때까지 좌 또는 우로 이동한다고 볼 수 있다 ! 또한 현재위치는 항상 그동안 꺼진 불의 집합( 빨간 체크) 의 맨왼쪽 or 맨 오른쪽에 존재한다는 것을 알 수 있다 !

그렇다면, 경계값을 빨간체크 집합의 맨왼쪽 or 맨오른쪽으로 둘 수 있다. 따라서 dp의 state는 다음과 같다.

dp[idxL][idxR][0,1 (왼쪽 or 오른쪽] = 낭비된 전력의 최솟값

또 유의해야 할 사항은 idxL ~ idxR 까지 모든 구간이 꺼져있다는 것이다.

경우를 따져가며 점화식을 어떻게 세울지 생각해보자.

우선 dp[2][5][0 (왼쪽)] 을 구하기 위한 경우들을 생각해보자. 즉, dp[2][5][0] 에서 사람은 2에 있다.

우선 왼쪽으로 계속 가고 잇었던 경우를 생각해보자. 이 경우는 dp[3][5][0] 인 상태에서 왼쪽으로 이동한 것이다. 이상태에서 3~ 2로 올때 소요시간 동안 , 구간(3~5)를 제외한 나머지 W의 합만큼 전력이 소모될 것이다,

dp[2][5][0] = (2~3사이 소요 시간) * (3~5 제외 나머지 W 합) + dp[3][5][0] .

또 다음과 같은 경우도 있다.

3~5구간에서 오른쪽에 있었을 경우, 5 -> 4 -> 3 -> 2 로 2번까지 갈 수도 있다.

이경우도 위와 같이 생각하면 아래와 같은 점화식이 나온다.

dp[2][5][0] = (2~5사이 소요 시간) * (3~5 제외 나머지 W 합 =(1번, 2번 W합) ) + dp[3][5][1( 오른쪽)] .

경미한 의심거리가 생긴다.

dp[4][5][1] 에서도 2번까지 갈 수도 있지 않은가? 굳이 dp[3][5][1]만 생각해야 하는가?

위와 같은 경우이다. 그런데 이런 상황은 고려할 필요가 없다. dp[4][5][1] 에서 5 ->4->3 순으로 가는데, 3번에 도착했을 때는

dp[3][5][0] 인 상태이기 때문이다. 아래와 같다. 결국 dp[3][5][1] 외의 다른 dp[n][5][1]의 경우는 고려할 필요가 없는 것이다. 왼쪽으로 가다가 dp[3][5][0] 이 되기 때문이다.

그럼 결과 적으로 다음과 같다.

Case1: (2~3사이 소요 시간) * (3~5 제외 나머지 W 합 = (1,2번 W합)) + dp[3][5][0] .

Case2: (2~5사이 소요 시간) * (3~5 제외 나머지 W 합 =(1번, 2번 W합) ) + dp[3][5][1( 오른쪽)]

dp[2][5][0] = min(Case1, Case2).

또 한가지는 dp[2][5][0] 을 구할 때, dp[3][4][0] 과 같은 경우도 고려할 필요 없는가이다. 그러나 아래의 왼쪽의 경우만 가능하다.오른쪽의 경우는 이미 2~5를 다껐는데 같은 구간을 한번더 되돌아오는 것이므로 불가능하다.

왼쪽의 경우는 결국 dp[3][5][1] 에서 출발하는 셈이 되므로, 고려할 필요 없다.

결국 dp[2][5][0] 은 dp[3][5][0] , dp[3][5][1] 만 고려하면 된다.

dp[2][5][1] 도 마찬가지로 정확히 좌우 대칭을 해서 생각하면 된다. dp[2][4][0] , dp[2][4][1] 만 생각하면 될 것이다.

[platinum3][해설,분류 미확인] 24515 히히 못가

끄응끄응 — Mon, 23 Mar 2026 01:53:57 +0900

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

소마 면접 준비로 너무 바빠서 브론즈로 스트릭을 연명하였고... 드디어 면접이 끝나 문제풀이를 시작할 수 있게 되었다.

나름 면접에서 내 장점을 어필하려고 최선을 다했고, 워낙 대단한 분들이 많기 때문에 결과가 어떻든 납득할 수 있을 것 같다...

매우 특이한 다익스트라 문제였다. 처음엔 dp 인줄 알고 경계값 문제로 고민했지만... 생각해보니 다익으로 간단히 (구현은 힘들지만) 해결 가능하다.

우선 R은 좌측 맨위, J 는 우측 맨아래에 있는데 이둘을 못만나게 하려면 어떻게 이어야 할까?

파란 집합 중 아무 점에서 시작하고, 빨간 집합 중 아무 점으로 도착하면 무조건 R , J 를 나눌 수 있다.

그렇다면, R , J 를 나눌 수 있는 영역들은 다음과 같다.

1.파란 점들 중 아무거나 포함한 영역

2. 빨간 점들 중 아무거나 포함한 영역

3. 1번과 2번을 잇는 나머지 영역들

1 + 2 + 3 의 영역이면 R, J를 나눌 수 있을 것이다.

시작지점과 도착지점이 명확하고, 최소한의 영역으로 가야한다... 그리고 1번 2번 3번의 모든 영역들은 모두 연결되어 있어야 한다....

이 부분에서 직관적으로 다익스트라가 떠오를 수 있다. 한 영역에서 다른 영역으로 가는 것은 간선으로 생각하고, 그때의 간선의 비용은 다른영역의 넓이 라고 생각할 수 있다.

그림으로 한번에 보면 이렇다. 4,5,9 에 대해서만 생각해보면 다음과 같다.

즉 오른쪽과 같이 그래프로 나타낼 수 있게 된 것이다. 또한 다음간선으로 갈때는 다음으로 가

는 영역의 넓이만큼 더할 것이다.

처음 pq에는 파란 점을 포함하는 1번, 2번 , 6번 영역을 넣고 시작하고 초기 Cost는 각각 7 , 4 , 4 이다. 그 후 위와 같이 각 영역을 노드로 두고, 다음 영역으로 갈때와, 그때의 비용 (다음 영역의 넓이) 를 간선비용으로 취급하고 다익스트라를 실행한다.

도착지점은 영역 3 , 8 , 9 , 7 중 아무곳이나 도착하면 종료. 그때가 최소 비용으로 R , J 를 분리시킬 수 있다.

즉 시작지점과 도착지점이 지정되어 있고, 그 사이를 모두 이어야 하며, 각 영역 사이의 관계는 그래프로 나타낼 수 있으므로, 다익스트라로 구할 수 있는 것이다.

신박한 다익스트라 문제였다.

[platinum3][해설, 분류 미확인] 10919 선물상자

끄응끄응 — Fri, 13 Mar 2026 18:47:59 +0900

아이디어도 쉽지 않았고, 무엇보다 멍청한 판단으로 구현에서 심각하게 고생한 문제였다. 소마 면접 준비가 한창인데 왜 이걸 붙잡고 있었을까... ㅋㅋㅋ

우선 아이디어를 생각해보자. N 이 10000000이라는걸 보자마자 원형 애드훅?이라는 건 직감했는데, 이걸 어떻게 해결할지 생각하는게 쉽지 않았다. (사실 순수 애드훅도 아니였다)

우선 선물을 배달할 때 한바퀴를 돌지, 반바퀴 (N / 2)되는 지점 전 까지만 돌고 다시 돌아갈지 구분해야 겠다는 생각은 금방 들었다.

그 이유는 어렵지 않다. 우선 반바퀴 이상을 도는 순간, 밑 처럼 시계방향 으로 순회할 때 5번까지 갔다면, 다시 반시계로 돌아가는 것보다(파란색) 그대로 시계방향으로 한바퀴(초록색) 으로 도는게 빠르기 때문이다.

그럼 만약 한바퀴를 한번도 돌지 않으면 어떻게 배달하게 될까?

아래에처럼 배치되어 있고, K = 1 이라면 아래처럼 배달하게 될 것이다. 5번에서는 1,2,3번과 다른 방향으로 왕복하는 이유는 한바퀴를 돌지 않는다는 가정하이기 때문이다. (01,2,3,4,5 번 순으로 오면 결국 6,7,8로 돌아가 한바퀴 돌기때문)

결국, 시계방향으로 왕복하던, 반시계로 왕복하던, half를 넘냐 안넘냐가 관건이다. half를 넘는 순간, 한바퀴를 돌게 되는 것이고, 한바퀴를 한번도 안돌때는 위처럼 half기준으로 위치한 기준에 따라 시계 반시계 방향이 정해진다.

그럼이제 저렇게 half 를 넘기전으로 왕복할 때는 어떻게 할 것인가? 이 부분은 어렵지 않다.

우선 다음과 같이 배치되있을 때 시계->반시계로 왕복한다고 치면 어떻게 이동할 것인가?

K = 2 일때 위에 처럼 원점에 가까운 순서대로 묶으면서 갈 수도 있겠지만, 이는 최선의 선택이 아니다.

최선의 선택은 가장 먼 거리 (이를테면 4번 , 5번) 왕복을 최소화 하기 때문에, 먼 거리부터 2개씩 묶어서 왕복하는게 최선이다. 어떻게 보면 그리디 하다고 할 수 있다.

결국 위처럼 묶는게 최선일 것이다. 가장 먼거리 부터 K개씩 묶어가며 세가면 되는 것이다.

이때 i번째에서 i , i - 1 ... i - K + 1 개를 묶을 때, 이때 이동 거리는 2 * Distance[i] 가 된다 . (Distance[i] : 0부터 i까지 거리)

즉 위의 경우 4,5번을 묶는다면 0~5번까지 2번 왕복하는 것이다. 그러면 i - K , 위에서는 3번째 부터 0 번째까지는 이미 계산해 놓은 대로 카운트가 되있을 것이다. 여기서 어렵지 않게 Dp를 생각할 수 있고,

점화식은 dp[i] = 2 * Distance[i] - dp[i - K] 가 된다.왼쪽에 대해선 저렇게 했으니, 오른쪽도 마찬가지로 점화식을 이용해 Dp를 구할 수 있다.

자, 그럼 이제 한바퀴를 한번도 안돌 때는, Ldp[3] + Rdp[2] 가 답이 될 것이다. (half를 넘기는 일은 없으므로)

그럼 이제 진짜 문제는 한바퀴를 도는 경우가 있을 때이다. 한 바퀴를 돌때는 어떻게 해야 할까?

우선 이걸 고민하기 전에 왜 한바퀴를 돌아야 하는 가를 생각해야 한다.

위와 같이 있고 K = 3 이라고 생각해보자.

만약 한바퀴를 돌지 않고, (1,2,3) , (4,5) 이런식으로 묶어 가게 된다면 거의 두바퀴를 돈거나 다름이 없게 많이 돌게 된다.

만약 한바퀴만 돌게 된다면 아래처럼 한바퀴 돈후, 원점과 가까운 부분은 왕복하면, 훨씬 최적화된 방법이다.

이렇듯 half지점을 지나며, 존재하는 팀들을 묶을 때는 한바퀴 도는게 유리할 수도 있다. ( 물론 상황에 따라 유리하지 않을 수도 있다.) 한바퀴 돈다는 것은 모든 좌 또는 우 왕복 보다 더 거리가 멀다.

그럼 여기서 당연히 떠오르는 의문이 있다. 2바퀴, 3바퀴는 어떤가? 아래처럼 만약 K = 4 이고, L 이 매우큰데, 선물받을 사람이 half중심으로 오밀조밀 배치되어 있으면, 2바퀴를 돌아야 겠다는 생각이 들 수도 있다. 그러나 그렇지 않다. 아래의 경우 2바퀴를 돌게되면 오른쪽 처럼 2개로 묶이게 될텐데, (2바퀴돌며 8개를 전달하게 되므로) 그럼 한 묶음은 half를 넘지 않게 된다. 즉 , 이 묶음일때는 한 바퀴를 돌지 않고, 왕복만 하는게 더 최적이라는 것이다. 쉽게 말하면 한바퀴를 돌게 되는경우는 half를 포함하게 되는 경우인데, half를 포함하는 묶이는 경우는 딱한번 밖에 없으므로 한바퀴만 돌 수 있다는 것이다.

이제 1바퀴 초과는 돌지 않게 된다는 것을 알게 되었다. 한바퀴를 돌때는 다음과 같이 4가지의 경우로 묶일 수 있다. (K = 4 )인 경우

이제 거의 다 왔다. 그럼 각각의 묶인 경우, 다음과 같이 묶였을 경우

result = 한바퀴 + Ldp[i - 1] + Rdp[i + K - 1-1] 로 된다.

이렇게 K 가지의 경우의 result를 따지며, result의 최솟값을 구한다.

마지막으로 , 한바퀴를 아예 안돌때의 경우도 고려해 result = LDP[i] + RDp[i + 1] 의 경우의 최솟값도 구해야 한다. (편의상 인덱싱은 신경쓰지 않았다.)

정리하자면

1.각 시계방향 반시계방향으로의 dp를 계산하고,

2. half를 포함하는 K 개끼리의 묶음을 구했을 때 그 묶음의 좌우에 대한 dp + 한바퀴를 고려하고 (한바퀴 돌때)

3.한점 i 의 좌우에 대한 dp를 고려하면 (한바퀴 안돌때)

최솟값을 구할 수 있다.

아이디어가 떠올랐다고 하여도, 전달 좌표가 0에 있을 때는 dp를 고려하지 않고, 그렇게 됬을 때 K가 전체 전달 장소 수보다 클때는 좌우 DP를 고려하지 않는등 수많은 예외사항이 기다리고 있다. 해결하느라 밤새 애를 먹었다. 다시는 보지말자...

[platinum3] [풀이,분류 미확인]boj8903 장비

끄응끄응 — Tue, 10 Mar 2026 18:51:20 +0900

이 문제는 플레 3치곤 생각보다 쉬웠다. 비트마스킹 + 브루트포스로 접근이 가능하기도 하고 (최대 열크기가 5이하이기 때문)

그리디하게 K에 따라 항목별로 무엇을 택할지 정하면 되기 때문이다.

우선 K = 5일때 생각해보자.

4 2
30 30 30 30 0
50 0 0 0 0
0 50 0 50 10
0 0 50 0 20

다음과 같은 경우 1열 ~5열까지 돌면서 그대의 최댓값일때의 행의 장비를 선택하면 된다.

만약 1열, 4열이 둘다 그 열에서 최댓값이면? 개의치 않아도 된다. 2열, 4열 이 최댓값이라, 1,3,5열에서 각각 장비를 하나씩 선택하면 장비를 4개 선택했는데, 이때가 최대이므로, 나머지 한개는 아무거나 선택하면 된다.

그럼 K > 5 일 경우엔? K= 5일때도 최댓값을 선택할 수 있는데 K > 5 일땐 고민할 필요도 없이 각열마다 최댓값을 뽑으면 된다.

아래와 같은 경우이다.

그럼이제 K = 4일때는 어떻게 해야 할까? 여기선 문제가 좀 있다. 4개만 뽑을 수 있으므로, 일단 장비3개는 각열마다 최댓값을 뽑을 수 있는데 , 나머지 1개는 어떻게 해야 할까? 바로 2개열의 합의 최댓값을 구하는 것이다. 다음과 같이 3,4,5열을 각 한열의 최댓값을 뽑았을 경우, 나머지 1열,2열의 합의 최댓값을 뽑아야 한다. 즉 5C3(5개중 3개열 선택) 해서 이때는 한개의 열의 최댓값, 나머지 열은 두개의 열 합의 최댓값 을 구하면 된다. 즉 완전탐색으로 구하는 것이다.

그러면 K = 3일때는? 이때는 조건이 좀 많아진다.

(2,2,1) : 열2개 합 Max + 열2개합Max + 열1개합Max -> 5C2 * 3C2 1C1 / 2! :

(3,1,1) -> 5C3 * 2C1 * 1C1 / 2!

이런식으로 구하면 된다.

그럼 우선 할 일은 모든 경우의 수 즉 00000 , 00001 , 00010 , 00011 ... 11111 모든 경우의 수에 대한 열의 합의 값을 만드는 것이다. 즉 O(2^5 * 10000 ) 이 될 것이다. 위의 경우 bitMax[10001] = 50, bitMax[01010] = 100

(백트래킹으로 구한다)

또한 이제 K 일때 1~K까지 의 5자리 비트에 대해 합이 11111이 되도록 하는 모든 경우의 수를 구한다.

예시로 K = 2 이면, b[0] = 10111 b[1] = 01000 or b[0] = 10000 b[1] = 011111 이런 식으로 말이다.

이것또한 백트래킹으로 구했다. 그 뒤, B1, B2 , ... Bk 의 비트들에 대해 bitMax[Bk] 의 값들의 총합을 구하고 이값의 총합이 답이다.

유일한 자바 정답자!!

[platinum3][풀이, 분류 미확인] boj5461 고용

끄응끄응 — Mon, 9 Mar 2026 16:55:09 +0900

재미있는 우선순위 큐 문제였다.

사람마다 최저 임금 Si와 기술 비용 Qi 가 있을 때 , Qi * K 를 했을 때 최저임금을 넘어야 한다.

그런데, 모든 사람에게는 K가 같아야 한다.

각 사람마다 Ki = Si / Qi 라고 하면, 그 사람의 비용 >= Qi * Ki = Si 가 되어야 한다.

각 사람마다 Ki가 다를 수 있는데, 이 문제에선 K가 모든 사람에게 동일하게 적용되어야 한다.

Qi * K = i번째 사람의 비용 이기 때문이다. 즉 모든 사람에겐 동일한 K값이 주어지므로, K는 뽑은 사람중 K값이 가장 큰 사람의 값이어야 한다.

위와 같은 예시가 있을 K는 3.5가 될 것이다. K가 3.5보다 작으면 사람3의 최소비용이 충족되지 않기 때문이다.

즉 사람을 뽑았을 때 뽑은 사람들의 Ki중 최댓값을 고려해야 할 것이다.

총 비용은 (Qi 총합 ) * (Ki 최댓값) 이 될 것이다.

여기서 직관적으로 들 수 있는 생각은 모든 사람들의 Ki값들을 오름차순으로 정렬한 후, 반복문을 돌며 i번째 사람들중 Qi값을 고려하면 될 것이라는 것이다.

i 번째에서 Ki의 값은 K1 ~ Ki-1 값보다 크기 때문에, 무조건 Ki가 최댓값이고, 그렇다면, 이제 총 비용은 (Qi총합) *(Ki최댓값)인데 Ki 최댓값은 정해졌으므로, Qi만 고려하면 된다는 생각이다. 그럼 이제 사람수를 최대로 하면서, 사람수가 같다면 Qi의 총합을 최소로 해야 한다.

이것은 우선순위 큐로 해결이 가능하다.

i번째에서 Q의 값을 내림차순으로 설정한 우선순위큐 (qpq 라 한다). 가 있으면, 일단 i번째의 Qi값을 qpq에 넣는다. 그럼 이대 넣었을 때 Qi의 총합 * (K의 최댓값) > W(가지고 있는 돈의 최댓값) 이라면 pqp에서 한개를 poll한다. 그럼 제일 큰 Q값이빠지므로, 무조건 W보다 작거나 같아진다. Qi의 총합 * (K의 최댓값) <= W 라면 pqp를 poll하지 않는다.

그럼 이제 qpq의 사이즈가 i번째에서 가능한 최대로 고를 수 있는 사람의 수가 된다. 1~K번째까지의 사람들 중 Q가 가장 작은 순서대로, Q의 총합이 (W) / Ki 까지일때의 사람들만 pqp에 남았기 때문이다.

이렇게 하면 i 번째에서 사람의 최댓값을 얻을 수 있고, 만약 최댓값이 기존의 최댓값과 같다면 기존의 pqp의 총합 * 기존의 K최댓값 과 비교해 비용이 낮은 것을 답으로 하면 된다.

비용이 가장 낮을 때 사람들을 출력하기 위해 첫번 째 pq에선 최대 사람수, 그대의 최소 비용을 구한후, 같은 원리의 pq를 다시한번 반복하다가 이미 구한 최대사람수, 최소 비용이 나오면 정답의 pqp에 있는 사람들을 출력하도록 하였다. 또한 k는 정수가 아닐 수도 있으므로, k끼리 비교시 (S1 / Q1 > S2 / Q2)시 (S1 * Q2 > S2 * Q1)식으로 분모가 없도록 비교하였다.(이때 오버플로우 조심하자)

[platinum4] [풀이, 분류 미확인]16156 장애물 달리기

끄응끄응 — Sun, 8 Mar 2026 19:39:01 +0900

이 문제의 어려운 점은 어떻게 처음에 잘 시작해서 다익스트라를 한번만 돌려 끝낼 것이냐 이다.

마지막 열은 어떤 행이든 , 도착만 하면 끝나므로 마지막 열들의 점들을 (1,4) (2,4) ... 한점으로 생각해도 될 것이다.

따라서 마지막 열부터 시작해서 (1,1), (2,1) (3,1 ).... (N, 1)들에 도착할때의 최단 경로들을 카운트하면 다익스트라를 한번만 돌려도 될 것이다.

또한 마지막열에서 그 전열까지의 경로는 초록색 경로는 되지만, 빨간색 경로는 불가능 하다. (1,4)에서 시작하던 (3,4)에서 시작하던, 상관 없는데 굳이 (3,4) 에서 (2,4) -> (1,4) -> (1,3) 을 거쳐가며 구할 필요는 없다.

따라서 다음그림과 같이 나타낼 수 있다.

다음과같이 (2,5,8,10 ) 을 하나의 점으로 나타내고, (1,3) 사이 간선은 거리가 2, (2,3)은 5, ... 으로 나타낼 수 있을 것이다.

그러나 추상적으로 하나의 점으로 나타낸거지 경로를 추적할때 원래 출발점이 몇행인지 알아야 (i,M)에 몇개를 배치할 지 카운트가 가능하므로,

pq에 (1,4)(2,4)(3,4)(4,4)를 넣고 시작한다. 또한 dp[1][4] , dp[2][4] ... dp[4][4] 는 0 으로 시작하게 되면 다익스트라 돌릴때

(1,4) ->(2,4) (3,4) ->(4,4) ... 와 같은 과정을 생략 할 수 있다.

pq에 마지막열을 한꺼번에 넣고 시작하는게 중요했다. 마지막 열의 어떤 행에서 시작하던, 동등하기 때문이다.

이제 저렇게 돌리면서 pq 를 poll 했을 때(i , 1)이면, i 일때 방문했는지 확인하고 방문안했으면 저장해놓은 최단경로의 시작점의 행의 카운트 + 1 하면 된다.

pq는 { 현재 x , 현재 y , 그동안 방문한 총합, 시작 행} 이렇게 저장하면 될 것이다.

[platinum4] [해설, 분류 미확인]boj9446 아이템 제작

끄응끄응 — Fri, 6 Mar 2026 16:39:29 +0900

재밌는 다익스트라 활용 문제였다.

다익스트라의 그리디한 성질을 잘 활용하면 아이디어를 떠올리기 어렵지 않을 것이다.

아이템 조합은 두가지를 조합해 한개를 만드는 것인데, 아이템1 + 아이템2 = 아이템3

이라면 아이템3 가격은 아이템1가격 + 아이템2 가격 인 셈이 될 것이다.

그리디하게 접근하자면, 우선 각 아이템마다 원래의 아이템 가격이 있고, 이제 그 아이템들 끼리 조합해 만든 아이템의 가격중 최소를 구한다.

즉 우선순위큐에 아이템들을 합친값이 원래 가격보다 작다면, 새로운 아이템을 넣는다.

그렇게 아이템들을 우선순위큐에 넣은후,

우선순위큐에서 poll 하면 그게 새로 업데이트된 아이템 가격중 최소의 가격이 될 것이다.

다음과 같이 큐에서 poll한 값이 1번이면, 1번이 지금 합성할 수 있는 아이템 중에 비용합이 최소임이 확정되는 것이다. 그럼 이제 1번을 재료로 하는 4번 , 5번도 새로 업데이트해 우선순위큐에 넣어야 한다.

그런데 이제 불안요소가 있다. 4번 , 5번을 큐에 넣긴 할텐데, 재료가 되는 2번, 3번은 업데이트가 되지 않았는데 그냥 넣어도 되는가? 이다. 그러나 걱정할 필요 없다. 2번이 업데이트되면 2번을 재료로 하는 4번도 새로 업데이트해 우선순위큐에 넣을 것이고, 3번 업데이트시 업데이트된 5번을 새로 넣을 것이기 때문.

그럼 또 한가지 불안요소가 발생한다. 만약 1번 + 2번 합쳐 4번을 큐에 넣었는데, 다음에 poll한 값이 4번이라면? 아직 2번은 채 업데이트도 못했는데? 그것도 걱정할 필요 없다. 4번을 뽑았을 때는 합성아이템중 4번 비용이 최소라는 뜻인데, 2번이 아직 업데이트가 안됬다는 것은 4번비용보다 크다는 뜻이 된다.따라서 나중에 2번을 업데이트 한다 한들 1번과 새로 업데이트 된 2번을 합성하면 현재 뽑은 4번보다 값이 커질 것이므로, 말이 안된다.

뇌절이지만 그럼 또 하나의 불안. 그럼 한가지 아이템이 업데이트될 때마다, 새로 합성되는 아이템들을 모두 업데이트해 큐에 넣어야 하는데, 메모리 시간 초과가 나지 않을까?

사실 이부분으로 좀 헷갈렸는데, 그렇지 않다.

우선순위큐에서 n을 뽑을 때마다 n의 최솟값이 확정된 상태이므로, 이때 n이 재료가 되는 아이템을 모두 업데이트 후큐에 넣는다.

그러나 모든 n은 한번 씩만 업데이트 된다. 위에서 1번이 업데이트 되면 , 4,5번을 업데이트, 2번이 업데이트 되면 4번 업데이트, 3번이 업데이트 되면 5번을 업데이트 한다.

즉 큐에 넣는 횟수는 간선의 수(2*N)만큼이다. 따라서 시간,메모리 초과는 걱정 할 필요 없다.

정리하면 이렇다.

1.dp에 우선 각 아이템의 원래가격을 넣는다.

2.각 아이템 합성된 값이 원래가격보다 작다면, pq(우선순위큐)에 넣는다.

3. 우선순위큐를 poll하면서, poll한 값을 재료로 하는 아이템들 가격을 새로 업데이트하고 pq에 넣는다. 당연히 업데이트 된 가격이 기존 dp값보다 크거나 같으면 넣지 않는다.

4. 이렇게 다익스트라를 종료한 후 dp[1]값 출력