2023. 6. 25. 21:34ใCoding Test/Programmers
๐๋ฌธ์ ๋ณด๋ฌ๊ฐ๊ธฐ
๐จ๐ปํ์ด ๊ณผ์
ํ(Queue)๋ฅผ ํตํด ๋ค๋ฆฌ ์์ ์๋ ํธ๋ญ๋ค์ ๊ด๋ฆฌํฉ๋๋ค. ํธ๋ญ์ด ๊ฐ์ง๋ ์ ๋ณด๋ ๋ค๋ฆฌ ์ง์ ์๊ฐ(enterTime)๊ณผ ํธ๋ญ ๋ฌด๊ฒ(weight)์ ๋๋ค.
struct Truck
{
Truck(int enterTime, int weight) : _enterTime(enterTime), _weight(weight) { }
int _enterTime;
int _weight;
};
๊ฒฝ๊ณผ ์๊ฐ(elapsedTime), ๋ค๋ฆฌ ์ ํธ๋ญ๋ค์ ์ด ๋ฌด๊ฒ ํฉ(weightSum)๋ ๊ฐ์ด ๊ด๋ฆฌํ๋ฉฐ, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ํธ๋ญ ๊ด๋ฆฌ์ ๋ค์ด๊ฐ๋๋ค.
int elapsedTime = 1;
int weightSum = 0;
queue<Truck> trucksOnBridge;
๊ธฐ๋ณธ์ ์ธ ์๊ณ ๋ฆฌ์ฆ ํ๋ฆ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- ๋ค๋ฆฌ ์์ ํธ๋ญ์ด ์๊ฑฐ๋, ๋ค๋ฆฌ ์์ ์๋ก ํธ๋ญ์ ์ฌ๋ฆด ์ ์๋ค๋ฉด, ์๋ก์ด ํธ๋ญ์ ๋ค๋ฆฌ ์์ ์ฌ๋ฆฝ๋๋ค.
- ์ด ๋, ์ง์ ์๊ฐ์ ์ ์ฅํด ๋์ต๋๋ค. ๋์ค์ ๋์ฐฉ ์๊ฐ ๊ณ์ฐํ ๋ ์ฌ์ฉํ ์์ ์ ๋๋ค.
๊ฒฝ๊ณผ ์๊ฐ์ 1์ด์ฉ ์ฆ๊ฐ์ํค๋ฉด์ ์๋ฎฌ๋ ์ด์ ์ ๋๋ฆฌ๊ธฐ์๋ ๋๋ฌด ๋นํจ์จ์ ์ด๋ผ๊ณ ์๊ฐํ์ต๋๋ค. ํธ๋ญ์ ๋์ฐฉ ์๊ฐ์ ๊ณ์ฐํ ์๋ง ์๋ค๋ฉด, 1์ด์ฉ ์๋ฎฌ๋ ์ด์ ์ ๋๋ ค๋ ๋์ง ์์ผ๋๊น์. ๊ทธ๋์ ์ ๋ ํธ๋ญ์ ๋์ฐฉ ์๊ฐ์ ๊ณ์ฐํ๋ ๋ฐฉ์์ผ๋ก ์ ๊ทผํ์์ต๋๋ค. ํธ๋ญ์ ๋์ฐฉ ์๊ฐ ๊ณต์์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
"๋์ฐฉ ์๊ฐ" = "๋ค๋ฆฌ ์ง์
์๊ฐ" + "๋ค๋ฆฌ์ ๊ธธ์ด"
์ด ๊ณ์ฐ์ ์ํด ์ง์ ์๊ฐ์ ์ ์ด ๋์ ์ฑ, ๋ค๋ฆฌ์ ์ง์ ์ํจ ๊ฒ์ ๋๋ค. ๋ค๋ฆฌ์ ์ถ๊ฐ๋ก ํธ๋ญ์ ๋ ์ฌ๋ฆด ์ ์๋ค๋ฉด, ๊ณ์ ๋ฃ์ด์ฃผ์ธ์.
๋ง์ฝ ๋ ์ฌ๋ฆด ์ ์๋ค๋ฉด, ๋ค๋ฆฌ ์ ๋งจ ์ ํธ๋ญ์ ๋นผ๋ด์ด ๋์ฐฉ ์๊ฐ์ ๊ณ์ฐํ์ฌ ๊ทธ ์๊ฐ์ผ๋ก ๊ฒฝ๊ณผ ์๊ฐ์ ์ด๊ธฐํ ์์ผ ์ฃผ๋ฉด ๋ฉ๋๋ค. ๋ค๋ง, ๋ค๋ฆฌ ๊ธธ์ด๊ฐ ๋๋ฌด ๊ธธ์ด ๊ณ์ฐํ ๋์ฐฉ ์๊ฐ๊ณผ ํ์ฌ ๊ฒฝ๊ณผ ์๊ฐ์ด ์ ๋ง์ ์ ์์ผ๋ฏ๋ก, ๋ ์ค ํฐ ๊ฐ์ผ๋ก ์ด๊ธฐํ ํด์ค๋๋ค.
๋ค๋ฆฌ ์ ๋งจ ์ ํธ๋ญ์ ๋นผ๋ธ ํ์ ๋ฐ๋ก ๋ค์ ํธ๋ญ์ ์ฌ๋ฆฌ๋ฉด ์ ๋ฉ๋๋ค. ์ฌ๋ฆด ์ ์๋์ง ํ์ธ ํ, ์ฌ๋ฆด ์ ์๋ค๋ฉด ๋ค์ ๋งจ ์ ํธ๋ญ์ ๋นผ๋ด์ด ๊ณ์ฐ ํ ๊ฐฑ์ ํ๋ ๊ณผ์ ์ ๊ฑฐ์ณ์ผ ํฉ๋๋ค.
๊ณ์ฐ ๊ณผ์ ์ ๋ฌด์ฌํ ๋ง์ณค๋ค๋ฉด, ํ์ฌ ํธ๋ญ์ ๋ค๋ฆฌ์ ์ฌ๋ฆฌ๋ฉด ๋๊ฒ ์ง์.
๋ชจ๋ ํธ๋ญ์ ๋ค๋ฆฌ์ ์ฌ๋ ธ๋ค๋ฉด, ๋ค๋ฆฌ ์์ ํธ๋ญ์ด ์์ ๋๊น์ง ๋์ฐฉ ์๊ฐ์ ๊ณ์ฐํ์ฌ ๊ฐฑ์ ํด์ฃผ๋ฉด ๋ฉ๋๋ค.
โ๏ธ์์ค ์ฝ๋ ๋ฐ ๊ฒฐ๊ณผ
#include <vector>
#include <queue>
using namespace std;
struct Truck
{
Truck(int enterTime, int weight) : _enterTime(enterTime), _weight(weight) { }
int _enterTime;
int _weight;
};
int solution(int bridge_length, int weight, vector<int> truck_weights) {
int elapsedTime = 1;
int weightSum = 0;
queue<Truck> trucksOnBridge;
for (int i = 0; i < truck_weights.size(); i++) {
int truckWeight = truck_weights[i];
// #1. ๋ค๋ฆฌ ์์ ํธ๋ญ์ด ์๊ฑฐ๋, ํธ๋ญ์ ๋ ์ฌ๋ฆด ์ ์์ผ๋ฉด ์ฌ๋ฆฌ๊ธฐ
if ((trucksOnBridge.empty()) or (weightSum + truckWeight <= weight)) {
trucksOnBridge.emplace(elapsedTime++, truckWeight);
weightSum += truckWeight;
continue;
}
// #2. ๋ค๋ฆฌ ์์ ๋งจ ์ ํธ๋ญ์ ๋นผ๋ด์ด ๋์ฐฉ ์๊ฐ ๊ณ์ฐ ํ, ์ ๋ณด ๊ฐฑ์ ํ๊ธฐ
Truck frontTruck = trucksOnBridge.front();
trucksOnBridge.pop();
elapsedTime = max(frontTruck._enterTime + bridge_length, elapsedTime);
weightSum -= frontTruck._weight;
// #3. ๋ค๋ฆฌ์ ๋ค์ ํธ๋ญ์ ์ค์์ ๋ ์ต๋ ํ์ค์ ๋์ผ๋ฉด, ํ์ฌ ๋ฃจํ๋ฅผ ๋ค์ ๋ฐ๋ณตํ์ฌ #2๋ฒ ๋ก์ง ์คํ
bool isOverWeight = weight < (weightSum + truckWeight);
if (isOverWeight) {
i -= 1;
continue;
}
// #4. ๋ค๋ฆฌ ์ ๋งจ ์ ํธ๋ญ์ ๋์ฐฉ ์ง์ ์ ๋ณด๋๋ค๋ฉด, ์๋ก ์ค์ ํธ๋ญ์ ๋ค๋ฆฌ ์์ ์ฌ๋ฆฌ๊ธฐ
trucksOnBridge.emplace(elapsedTime, truckWeight);
weightSum += truckWeight;
elapsedTime++;
}
// #5. ๋ค๋ฆฌ ์์ ๋จ์ ์๋ ํธ๋ญ๋ค์ ๋์ฐฉ ์๊ฐ ๊ณ์ฐํ๊ธฐ
while (!trucksOnBridge.empty()) {
Truck truck = trucksOnBridge.front();
trucksOnBridge.pop();
elapsedTime = truck._enterTime + bridge_length;
}
return elapsedTime;
}
'Coding Test > Programmers' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Programmers] Lv2. ํ๋ฐฐ์์ | C++ (0) | 2023.06.26 |
---|---|
[Programmers] Lv2. ๊ฐ์ฅ ํฐ ์ | C++ (0) | 2023.06.26 |
[Programmers] Lv2. [1์ฐจ] ํ๋ ์ฆ4๋ธ๋ก | C++ (0) | 2023.06.24 |
[Programmers] Lv2. [3์ฐจ] ํ์ผ๋ช ์ ๋ ฌ | C++ (0) | 2023.06.24 |
[Programmers] Lv2. ๋ฐฉ๋ฌธ ๊ธธ์ด | C++ (0) | 2023.06.24 |