๋ฌธ์
<๋ฌธ์ ์ค๋ช >
ํธ๋ญ ์ฌ๋ฌ ๋๊ฐ ๊ฐ์ ๊ฐ๋ก์ง๋ฅด๋ ์ผ ์ฐจ์ ๋ค๋ฆฌ๋ฅผ ์ ํด์ง ์์ผ๋ก ๊ฑด๋๋ ค ํฉ๋๋ค. ๋ชจ๋ ํธ๋ญ์ด ๋ค๋ฆฌ๋ฅผ ๊ฑด๋๋ ค๋ฉด ์ต์ ๋ช ์ด๊ฐ ๊ฑธ๋ฆฌ๋์ง ์์๋ด์ผ ํฉ๋๋ค. ํธ๋ญ์ 1์ด์ 1๋งํผ ์์ง์ด๋ฉฐ, ๋ค๋ฆฌ ๊ธธ์ด๋ bridge_length์ด๊ณ ๋ค๋ฆฌ๋ ๋ฌด๊ฒ weight๊น์ง ๊ฒฌ๋ฅ๋๋ค.
โป ํธ๋ญ์ด ๋ค๋ฆฌ์ ์์ ํ ์ค๋ฅด์ง ์์ ๊ฒฝ์ฐ, ์ด ํธ๋ญ์ ๋ฌด๊ฒ๋ ๊ณ ๋ คํ์ง ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, ๊ธธ์ด๊ฐ 2์ด๊ณ 10kg ๋ฌด๊ฒ๋ฅผ ๊ฒฌ๋๋ ๋ค๋ฆฌ๊ฐ ์์ต๋๋ค. ๋ฌด๊ฒ๊ฐ [7, 4, 5, 6] kg์ธ ํธ๋ญ์ด ์์๋๋ก ์ต๋จ ์๊ฐ ์์ ๋ค๋ฆฌ๋ฅผ ๊ฑด๋๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๊ฑด๋์ผ ํฉ๋๋ค.
๊ฒฝ๊ณผ ์๊ฐ | ๋ค๋ฆฌ๋ฅผ ์ง๋ ํธ๋ญ | ๋ค๋ฆฌ๋ฅผ ๊ฑด๋๋ ํธ๋ญ | ๋๊ธฐ ํธ๋ญ |
0 | [] | [] | [7,4,5,6] |
1~2 | [] | [7] | [4,5,6] |
3 | [7] | [4] | [5,6] |
4 | [7] | [4,5] | [6] |
5 | [7,4] | [5] | [6] |
6~7 | [7,4,5] | [6] | [] |
8 | [7,4,5,6] | [] | [] |
๋ฐ๋ผ์, ๋ชจ๋ ํธ๋ญ์ด ๋ค๋ฆฌ๋ฅผ ์ง๋๋ ค๋ฉด ์ต์ 8์ด๊ฐ ๊ฑธ๋ฆฝ๋๋ค.
solution ํจ์์ ๋งค๊ฐ๋ณ์๋ก ๋ค๋ฆฌ ๊ธธ์ด bridge_length, ๋ค๋ฆฌ๊ฐ ๊ฒฌ๋ ์ ์๋ ๋ฌด๊ฒ weight, ํธ๋ญ ๋ณ ๋ฌด๊ฒ truck_weights๊ฐ ์ฃผ์ด์ง๋๋ค. ์ด๋ ๋ชจ๋ ํธ๋ญ์ด ๋ค๋ฆฌ๋ฅผ ๊ฑด๋๋ ค๋ฉด ์ต์ ๋ช ์ด๊ฐ ๊ฑธ๋ฆฌ๋์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์.
<์ ํ ์กฐ๊ฑด>
- bridge_length๋ 1 ์ด์ 10,000 ์ดํ์ ๋๋ค.
- weight๋ 1 ์ด์ 10,000 ์ดํ์ ๋๋ค.
- truck_weights์ ๊ธธ์ด๋ 1 ์ด์ 10,000 ์ดํ์ ๋๋ค.
- ๋ชจ๋ ํธ๋ญ์ ๋ฌด๊ฒ๋ 1 ์ด์ weight ์ดํ์ ๋๋ค.
<์ ์ถ๋ ฅ ์>
bridge_length | weight | truck_weights | return |
2 | 10 | [7,4,5,6] | 8 |
100 | 100 | [10] | 101 |
100 | 100 | [10,10,10,10,10,10,10,10,10,10] | 110 |
https://programmers.co.kr/learn/courses/30/lessons/42583
๋ฌธ์ ํ์ด
๋ค๋ฆฌ ์์ ์๋ ํธ๋ญ์ on_bridge๋ผ๋ ํ์ ์ ์ฅํด์ ํํํฉ๋๋ค. ์ด๋ ์ ์ฅํ๋ ๊ฐ์ ํธ๋ญ์ ๋ฌด๊ฒ์ ๋๋ค. ๋ํ ๋๊ธฐํ๊ณ ์๋ ํธ๋ญ ์ค ๊ฐ์ฅ ์์ ์ธ๋ฑ์ค๋ฅผ ๊ฐ๋ฆฌํค๋ next_truck๊ณผ ๋ค๋ฆฌ ์ ํธ๋ญ๋ค์ ๋ฌด๊ฒ ์ดํฉ์ ์ ์ฅํ๋ weight_sum ๋ณ์๊ฐ ํ์ํฉ๋๋ค.
์๋ฅผ ๋ค์ด bridge_length = 2, weight = 10, truck_weights = {7, 4, 5, 6}์ด ์ฃผ์ด์ก์ ๋ answer์ ๋ฐ๋ผ on_bridge์ ๊ฐ์ ๋ค์๊ณผ ๊ฐ์ด ๋ฐ๋๋๋ค.
answer | on_bridge | truck_weights[next_truck] | weight_sum |
0 | [0, 0] | 7 | 0 |
1 | [0, 7] | 4 | 7 |
2 | [7, 0] | 4 | 7 |
3 | [0, 4] | 5 | 4 |
4 | [4, 5] | 6 | 9 |
5 | [5, 0] | 6 | 5 |
6 | [0, 6] | 6 | |
7 | [6] | 6 | |
8 | [] | 0 |
on_bridge์ ์์๊ฐ ์์ ๋๊น์ง ๋ค์์ ๋ฐ๋ณตํฉ๋๋ค.
1. answer์ 1์ ๋ํ๊ณ on_bridge์ ๋งจ ์ ์์๋ฅผ popํ๋ฉฐ weight_sum์์ ๋ฌด๊ฒ๋ฅผ ๋นผ์ค
2. ๋๊ธฐ ํธ๋ญ์ด ๋จ์ ์๋ ๊ฒฝ์ฐ
1) ๋ค๋ฆฌ ์์ ์ฌ๋ผ๊ฐ ์ ์๋ ๊ฒฝ์ฐ
on_bridge์ ํด๋น ํธ๋ญ ๋ฌด๊ฒ๋ฅผ pushํ๊ณ weight_sum์ ํธ๋ญ์ ๋ฌด๊ฒ๋ฅผ ๋ํจ
2) ๋ค๋ฆฌ ์์ ๋ชป์ฌ๋ผ๊ฐ๋ ๊ฒฝ์ฐ
on_bridge์ 0์ push ํจ
์์ค์ฝ๋
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
|
// ๋ค๋ฆฌ๋ฅผ ์ง๋๋ ํธ๋ญ
#include <string>
#include <vector>
#include <queue>
using namespace std;
int solution(int bridge_length, int weight, vector<int> truck_weights) {
int answer = 0;
int next_truck = 0; // ๋๊ธฐ ํธ๋ญ ์ค ๋งจ ์์ ํธ๋ญ์ ์ธ๋ฑ์ค
int weight_sum = 0; // ๋ค๋ฆฌ ์์ ์๋ ํธ๋ญ์ ๋ฌด๊ฒ ํฉ
queue<int> on_bridge; // ๋ค๋ฆฌ ์์ ์๋ ํธ๋ญ
for (int i = 0; i < bridge_length; i++)
on_bridge.push(0);
while (!on_bridge.empty()) {
answer++;
weight_sum -= on_bridge.front();
on_bridge.pop();
// ๋๊ธฐ ํธ๋ญ์ด ์๋ ๊ฒฝ์ฐ
if (next_truck < truck_weights.size()) {
if (weight_sum + truck_weights[next_truck] <= weight) {
weight_sum += truck_weights[next_truck];
on_bridge.push(truck_weights[next_truck]);
next_truck++;
}
else {
on_bridge.push(0);
}
}
}
return answer;
}
|
cs |
๊ณต๋ถํ ๊ฒ์ ์ ๋ฆฌํ ๋ด์ฉ์ ๋๋ค. ์์ ํ ๋ถ๋ถ์ด ์๋ค๋ฉด ์๋ ค์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค :)
'Algorithm > ํ๋ก๊ทธ๋๋จธ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค / C++] ์ ๊ตญ์ฌ์ฌ ํ์ด (0) | 2020.08.16 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค / C++] ํ๋ฆฐํฐ ํ์ด (0) | 2020.08.16 |
[ํ๋ก๊ทธ๋๋จธ์ค / C++] ๊ธฐ๋ฅ๊ฐ๋ฐ ํ์ด (0) | 2020.08.13 |
[ํ๋ก๊ทธ๋๋จธ์ค / C++] ์ฃผ์๊ฐ๊ฒฉ ํ์ด (0) | 2020.08.04 |
[ํ๋ก๊ทธ๋๋จธ์ค / C++] ์นดํซ ํ์ด (0) | 2020.07.30 |