๋ฌธ์
์ง๋ฏผ์ด๋ N๊ฐ์ ๋ฌผ๋ณ์ ๊ฐ์ง๊ณ ์๋ค. ๊ฐ ๋ฌผ๋ณ์๋ ๋ฌผ์ ๋ฌดํ๋๋ก ๋ถ์ ์ ์๋ค. ์ฒ์์ ๋ชจ๋ ๋ฌผ๋ณ์๋ ๋ฌผ์ด 1๋ฆฌํฐ์ฉ ๋ค์ด์๋ค. ์ง๋ฏผ์ด๋ ์ด ๋ฌผ๋ณ์ ๋ ๋ค๋ฅธ ์ฅ์๋ก ์ฎ๊ธฐ๋ ค๊ณ ํ๋ค. ์ง๋ฏผ์ด๋ ํ ๋ฒ์ K๊ฐ์ ๋ฌผ๋ณ์ ์ฎ๊ธธ ์ ์๋ค.ย
ํ์ง๋ง, ์ง๋ฏผ์ด๋ ๋ฌผ์ ๋ญ๋นํ๊ธฐ๋ ์ซ๊ณ , ์ด๋์ ํ ๋ฒ๋ณด๋ค ๋ง์ด ํ๊ธฐ๋ ์ซ๋ค. ๋ฐ๋ผ์, ์ง๋ฏผ์ด๋ ๋ฌผ๋ณ์ ๋ฌผ์ ์ ์ ํ ์ฌ๋ถ๋ฐฐํด์, K๊ฐ๋ฅผ ๋์ง ์๋ ๋น์ด์์ง ์์ ๋ฌผ๋ณ์ ๋ง๋ค๋ ค๊ณ ํ๋ค.
๋ฌผ์ ๋ค์๊ณผ ๊ฐ์ด ์ฌ๋ถ๋ฐฐ ํ๋ค. ๋จผ์ ๊ฐ์ ์์ ๋ฌผ์ด ๋ค์ด์๋ ๋ฌผ๋ณ ๋ ๊ฐ๋ฅผ ๊ณ ๋ฅธ๋ค. ๊ทธ ๋ค์์ ํ ๊ฐ์ ๋ฌผ๋ณ์ ๋ค๋ฅธ ํ ์ชฝ์ ์๋ ๋ฌผ์ ๋ชจ๋ ๋ถ๋๋ค. ์ด ๋ฐฉ๋ฒ์ ํ์ํ ๋งํผ ๊ณ์ ํ๋ค.
์ด๋ฐ ์ ์ฝ ๋๋ฌธ์, N๊ฐ๋ก K๊ฐ๋ฅผ ๋์ง์๋ ๋น์ด์์ง ์์ ๋ฌผ๋ณ์ ๋ง๋๋ ๊ฒ์ด ๋ถ๊ฐ๋ฅํ ์๋ ์๋ค. ๋คํํ๋, ์๋ก์ด ๋ฌผ๋ณ์ ์ด ์ ์๋ค. ์์ ์์ ์ฌ๋ ๋ฌผ๋ณ์ ๋ฌผ์ด 1๋ฆฌํฐ ๋ค์ด์๋ค.
์๋ฅผ ๋ค์ด, N=3์ด๊ณ , K=1์ผ ๋๋ฅผ ๋ณด๋ฉด, ๋ฌผ๋ณ 3๊ฐ๋ก 1๊ฐ๋ฅผ ๋ง๋๋ ๊ฒ์ด ๋ถ๊ฐ๋ฅํ๋ค. ํ ๋ณ์ ๋๋ค๋ฅธ ๋ณ์ ๋ถ์ผ๋ฉด, 2๋ฆฌํฐ๊ฐ ๋ค์ด์๋ ๋ฌผ๋ณ ํ๋์, 1๋ฆฌํฐ๊ฐ ๋ค์ด์๋ ๋ฌผ๋ณ ํ๋๊ฐ ๋จ๋๋ค. ๋ง์ฝ ์์ ์์ ํ ๊ฐ์ ๋ฌผ๋ณ์ ์ฐ๋ค๋ฉด, 2๋ฆฌํฐ๊ฐ ๋ค์ด์๋ ๋ฌผ๋ณ ๋ ๊ฐ๋ฅผ ๋ง๋ค ์ ์๊ณ , ๋ง์ง๋ง์ผ๋ก 4๋ฆฌํฐ๊ฐ ๋ค์ด์๋ ๋ฌผ๋ณ ํ ๊ฐ๋ฅผ ๋ง๋ค ์ ์๋ค.
์
๋ ฅ
์ฒซ์งธ ์ค์ N๊ณผ K๊ฐ ์ฃผ์ด์ง๋ค. N์ 10^7๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๊ณ , K๋ 1,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์์ ์์ ์ฌ์ผํ๋ ๋ฌผ๋ณ์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ์ ๋ต์ด ์์ ๊ฒฝ์ฐ์๋ -1์ ์ถ๋ ฅํ๋ค.
์์
โ
์
๋ ฅ 1
โ
์ถ๋ ฅ 1
โ
์
๋ ฅ 2
โ
์ถ๋ ฅ 2
โ
์
๋ ฅ 3
โ
์ถ๋ ฅ 3
์์ฑ ์ฝ๋
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
| public class Main {
public static void main(String[] args) throws IOException {
// 1. ๋ณ์ ์ ์ธ ๋ฐ ์ด๊ธฐํ
PriorityQueue<Integer> pq = new PriorityQueue<>();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
int k = Integer.parseInt(st.nextToken());
int count = 0, result = 0, amount = 1;
// 2. ๋ฌผ๋ณ ํฌ๊ธฐ ๊ตฌํ๊ธฐ
while (n > 0) {
if ((n & 1) == 1) {
pq.add(amount);
count++;
}
amount *= 2;
n /= 2;
}
// 3. ์กฐ๊ฑด์ ๋ง์กฑํ ๋๊น์ง ๊ฐ์ฅ ์์ ๋ฌผ๋ณ ๋ ๊ฐ๋ฅผ ํฉ์นจ
while (count > k) {
if (pq.size() >= 2) {
// ๊ฐ์ฅ ์์ ๋ ๊ฐ ๋ฌผ๋ณ ๊บผ๋ด๊ธฐ
int first = pq.poll();
int second = pq.poll();
// ๊บผ๋ธ ๋ ๋ฌผ๋ณ์ด ๊ฐ์ผ๋ฉด ์นด์ดํธ ๋ค์ด
if (first == second) {
pq.add(first + second);
count--;
continue;
}
// ๊ตฌ๋งคํด์ผ ํ๋ ๋ฌผ๋ณ ์ ๋์
result += (second - first);
// ์ฑ์ด ๋ฌผ๋ณ์ ๋ค์ ์ ์ฌ
pq.add(second);
pq.add(second);
}
}
// 4. ์ถ๋ ฅ
System.out.println(result);
}
}
|
- ์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํ์ฌ
Greedy
์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํ์๋ค.
ํ๊ณ
- ์ฐ์ ์์ ํ๊ฐ ๋ด๋ถ์ ์ผ๋ก ์ด๋ป๊ฒ ๋์ํ๋์ง๋ ๋ค์ ๋ธ๋ก๊ทธ์์ ํ์ธํ์๋ค.
- https://coding-factory.tistory.com/603
- ๋๋จธ์ง ์ฐ์ฐ์ ๋นํธ ์ฐ์ฐ์๋ฅผ ํตํด ํจ์จ์ ์ผ๋ก ๊ฐ์ ํ์๋ค.
if (n & 1 == 1)
๊ณผ if (n % 2 == 1)
์กฐ๊ฑด ๋ชจ๋ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ๊ธฐ๋ํ ์ ์๋ค.- ๋นํธ ์ฐ์ฐ์๋ฅผ ํตํ ๋ฐฉ๋ฒ์ด
CPU
๋ช
๋ น์ด ์์ค์์ ์ต์ ํ๋๋ฏ๋ก ๋ ๋น ๋ฅด๋ค๊ณ ํ๋ค.