https://www.acmicpc.net/problem/20055
๋ฌธ์
๊ธธ์ด๊ฐ N์ธ ์ปจ๋ฒ ์ด์ด ๋ฒจํธ๊ฐ ์๊ณ , ๊ธธ์ด๊ฐ 2N์ธ ๋ฒจํธ๊ฐ ์ด ์ปจ๋ฒ ์ด์ด ๋ฒจํธ๋ฅผ ์์๋๋ก ๊ฐ์ธ๋ฉฐ ๋๊ณ ์๋ค. ๋ฒจํธ๋ ๊ธธ์ด 1 ๊ฐ๊ฒฉ์ผ๋ก 2N๊ฐ์ ์นธ์ผ๋ก ๋๋์ด์ ธ ์์ผ๋ฉฐ, ๊ฐ ์นธ์๋ ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด 1๋ถํฐ 2N๊น์ง์ ๋ฒํธ๊ฐ ๋งค๊ฒจ์ ธ ์๋ค.
๋ฒจํธ๊ฐ ํ ์นธ ํ์ ํ๋ฉด 1๋ฒ๋ถํฐ 2N-1๋ฒ๊น์ง์ ์นธ์ ๋ค์ ๋ฒํธ์ ์นธ์ด ์๋ ์์น๋ก ์ด๋ํ๊ณ , 2N๋ฒ ์นธ์ 1๋ฒ ์นธ์ ์์น๋ก ์ด๋ํ๋ค. i๋ฒ ์นธ์ ๋ด๊ตฌ๋๋ Ai์ด๋ค. ์์ ๊ทธ๋ฆผ์์ 1๋ฒ ์นธ์ด ์๋ ์์น๋ฅผ "์ฌ๋ฆฌ๋ ์์น", N๋ฒ ์นธ์ด ์๋ ์์น๋ฅผ "๋ด๋ฆฌ๋ ์์น"๋ผ๊ณ ํ๋ค.
์ปจ๋ฒ ์ด์ด ๋ฒจํธ์ ๋ฐ์ค ๋ชจ์ ๋ก๋ด์ ํ๋์ฉ ์ฌ๋ฆฌ๋ ค๊ณ ํ๋ค. ๋ก๋ด์ ์ฌ๋ฆฌ๋ ์์น์๋ง ์ฌ๋ฆด ์ ์๋ค. ์ธ์ ๋ ์ง ๋ก๋ด์ด ๋ด๋ฆฌ๋ ์์น์ ๋๋ฌํ๋ฉด ๊ทธ ์ฆ์ ๋ด๋ฆฐ๋ค. ๋ก๋ด์ ์ปจ๋ฒ ์ด์ด ๋ฒจํธ ์์์ ์ค์ค๋ก ์ด๋ํ ์ ์๋ค. ๋ก๋ด์ ์ฌ๋ฆฌ๋ ์์น์ ์ฌ๋ฆฌ๊ฑฐ๋ ๋ก๋ด์ด ์ด๋ค ์นธ์ผ๋ก ์ด๋ํ๋ฉด ๊ทธ ์นธ์ ๋ด๊ตฌ๋๋ ์ฆ์ 1๋งํผ ๊ฐ์ํ๋ค.
์ปจ๋ฒ ์ด์ด ๋ฒจํธ๋ฅผ ์ด์ฉํด ๋ก๋ด๋ค์ ๊ฑด๋ํธ์ผ๋ก ์ฎ๊ธฐ๋ ค๊ณ ํ๋ค. ๋ก๋ด์ ์ฎ๊ธฐ๋ ๊ณผ์ ์์๋ ์๋์ ๊ฐ์ ์ผ์ด ์์๋๋ก ์ผ์ด๋๋ค.
- ๋ฒจํธ๊ฐ ๊ฐ ์นธ ์์ ์๋ ๋ก๋ด๊ณผ ํจ๊ป ํ ์นธ ํ์ ํ๋ค.
- ๊ฐ์ฅ ๋จผ์ ๋ฒจํธ์ ์ฌ๋ผ๊ฐ ๋ก๋ด๋ถํฐ, ๋ฒจํธ๊ฐ ํ์ ํ๋ ๋ฐฉํฅ์ผ๋ก ํ ์นธ ์ด๋ํ ์ ์๋ค๋ฉด ์ด๋ํ๋ค. ๋ง์ฝ ์ด๋ํ ์ ์๋ค๋ฉด ๊ฐ๋งํ ์๋๋ค.
- ๋ก๋ด์ด ์ด๋ํ๊ธฐ ์ํด์๋ ์ด๋ํ๋ ค๋ ์นธ์ ๋ก๋ด์ด ์์ผ๋ฉฐ, ๊ทธ ์นธ์ ๋ด๊ตฌ๋๊ฐ 1 ์ด์ ๋จ์ ์์ด์ผ ํ๋ค.
- ์ฌ๋ฆฌ๋ ์์น์ ์๋ ์นธ์ ๋ด๊ตฌ๋๊ฐ 0์ด ์๋๋ฉด ์ฌ๋ฆฌ๋ ์์น์ ๋ก๋ด์ ์ฌ๋ฆฐ๋ค.
- ๋ด๊ตฌ๋๊ฐ 0์ธ ์นธ์ ๊ฐ์๊ฐ K๊ฐ ์ด์์ด๋ผ๋ฉด ๊ณผ์ ์ ์ข ๋ฃํ๋ค. ๊ทธ๋ ์ง ์๋ค๋ฉด 1๋ฒ์ผ๋ก ๋์๊ฐ๋ค.
์ข ๋ฃ๋์์ ๋ ๋ช ๋ฒ์งธ ๋จ๊ณ๊ฐ ์งํ ์ค์ด์๋์ง ๊ตฌํด๋ณด์. ๊ฐ์ฅ ์ฒ์ ์ํ๋๋ ๋จ๊ณ๋ 1๋ฒ์งธ ๋จ๊ณ์ด๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ N, K๊ฐ ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์๋ A1, A2, ..., A2N์ด ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
๋ช ๋ฒ์งธ ๋จ๊ณ๊ฐ ์งํ ์ค์ผ๋ ์ข ๋ฃ๋์๋์ง ์ถ๋ ฅํ๋ค.
์ ํ
- 2 ≤ N ≤ 100
- 1 ≤ K ≤ 2N
- 1 ≤ Ai ≤ 1,000
ํ์ด
// Authored by : seondal
// Co-authored by : -
// #include <bits/stdc++.h>
#include <iostream>
#include <vector>
#include <deque>
using namespace std;
int solution(int n, int k, deque<int> &belt) {
int turn=0;
deque<bool> robot (n, false); // i๋ฒ ์นธ ์์ ๋ก๋ด ์กด์ฌ์ฌ๋ถ๋ฅผ ์๋ ค์ฃผ๋ ๋ฒกํฐ
while(true) {
// 4. ๋ด๊ตฌ๋๊ฐ 0์ธ ์นธ์ ๊ฐ์๊ฐ k๊ฐ ์ด์์ด๋ผ๋ฉด ๊ณผ์ ์ข
๋ฃ
int zeroEndur = 0;
for(int i=0; i<2*n; i++)
if(belt[i]==0) zeroEndur++;
if(zeroEndur >= k)
break;
// ํด ์์ !
turn++;
// 1. ๋ฒจํธ ํ์ ์ํค๊ธฐ
belt.push_front(belt.back());
belt.pop_back();
robot.push_front(robot.back()); // ๋ฒจํธ ํ์ ๊ณผ ํจ๊ป ๋ก๋ด๋ ํ์ ํ๋ค (๋ก๋ด์ ๊ฐ๋งํ ์์ผ๋ฏ๋ก ๋ด๊ตฌ๋์ ์ํฅ ์์ค)
robot.pop_back();
robot[n-1] = false; // ๋ก๋ด ๋ด๋ ค๋๊ธฐ
// 2. ๋ก๋ด ์ด๋์ํค๊ธฐ (๋ด๊ตฌ๋์ ์ํฅ์ ์ฃผ๋ ์ด๋)
for(int i=n-2; i>=0; i--) {
// n-2๋ฒ ๋ฒจํธ๋ถํฐ 0๋ฒ ๋ฒจํธ๊ฐ์ง ํ์ผ๋ฉฐ ๋ก๋ด ์ด๋์ํค๊ธฐ ("๋จผ์ ์ฌ๋ผ๊ฐ ๋ก๋ด๋ถํฐ" ์ด๋ํ๋ฏ๋ก ๊ฑฐ๊พธ๋ก ๋ฃจํ๋ฅผ ๋์์ผํ๋ค)
if(robot[i] && !robot[i+1] && belt[i+1]>0) {
// ๋ก๋ด์ด ํด๋น ์์น์ ์๊ณ , ๊ฐ๋ ค๋ ์์น์ ๋ก๋ด์ด ์๊ณ , ๊ฐ๋ ค๋ ์์น์ ๋ด๊ตฌ๋๊ฐ ๊ด์ฐฎ๋ค๋ฉด ๋ก๋ด ์ด๋
robot[i] = false;
robot[i+1] = true;
belt[i+1]--;
if(i+1 == n-1) // ๋์ฐฉํ๊ณณ์ด ๋งจ ๋์ด๋ผ๋ฉด ๋ก๋ด ๋ด๋ฆผ
robot[i+1] = false;
}
}
// 3. ๋ก๋ด ์ฌ๋ฆฌ๊ธฐ (๋ด๊ตฌ๋์ ์ํฅ ใ
)
if(!robot[0] && belt[0]>0) { // ์ฌ๋ฆฌ๋ ์์น์ ๋ก๋ด์ด ์๊ณ ๋ด๊ตฌ๋๊ฐ ๊ด์ฐฎ๋ค๋ฉด
robot[0] = true;
belt[0]--;
}
}
return turn;
}
int main() {
ios_base :: sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
int n, k;
cin >> n >> k;
deque<int> belt (2*n); // i๋ฒ ์นธ์ ์๋ ๋ฒจํธ์ ๋ด๊ตฌ๋
for(int i=0; i<2*n; i++)
cin >> belt[i];
cout << solution(n, k, belt);
return 0;
}
/*
*/
'๐ฒ Altu-Bitu > ๊ตฌํ&์๋ฎฌ๋ ์ด์ ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ S4][C++] ๋ฐฑ์ค 1244๋ฒ: ์ค์์น ์ผ๊ณ ๋๊ธฐ (0) | 2022.10.17 |
---|---|
[BOJ S3][C++] ๋ฐฑ์ค 2503๋ฒ: ์ซ์ ์ผ๊ตฌ (2%, 4%) (0) | 2022.10.06 |
[BOJ S1][C++] ๋ฐฑ์ค 20923๋ฒ: ์ซ์ ํ ๋ฆฌ๊ฐ๋ฆฌ ๊ฒ์ (0) | 2022.09.30 |
[BOJ][C++] ๋ฐฑ์ค 14891๋ฒ: ํฑ๋๋ฐํด (0) | 2022.09.20 |
[BOJ S3][C++] ๋ฐฑ์ค 1213๋ฒ: ํฐ๋ฆฐ๋๋กฌ ๋ง๋ค๊ธฐ (0) | 2022.09.19 |