์ ๊ตญ์ฌ์ฌ
https://programmers.co.kr/learn/courses/30/lessons/43238
๋ฌธ์
๋ฌธ์ ์ค๋ช
n๋ช ์ด ์ ๊ตญ์ฌ์ฌ๋ฅผ ์ํด ์ค์ ์์ ๊ธฐ๋ค๋ฆฌ๊ณ ์์ต๋๋ค. ๊ฐ ์ ๊ตญ์ฌ์ฌ๋์ ์๋ ์ฌ์ฌ๊ด๋ง๋ค ์ฌ์ฌํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ๋ค๋ฆ ๋๋ค.
์ฒ์์ ๋ชจ๋ ์ฌ์ฌ๋๋ ๋น์ด์์ต๋๋ค. ํ ์ฌ์ฌ๋์์๋ ๋์์ ํ ๋ช ๋ง ์ฌ์ฌ๋ฅผ ํ ์ ์์ต๋๋ค. ๊ฐ์ฅ ์์ ์ ์๋ ์ฌ๋์ ๋น์ด ์๋ ์ฌ์ฌ๋๋ก ๊ฐ์ ์ฌ์ฌ๋ฅผ ๋ฐ์ ์ ์์ต๋๋ค. ํ์ง๋ง ๋ ๋นจ๋ฆฌ ๋๋๋ ์ฌ์ฌ๋๊ฐ ์์ผ๋ฉด ๊ธฐ๋ค๋ ธ๋ค๊ฐ ๊ทธ๊ณณ์ผ๋ก ๊ฐ์ ์ฌ์ฌ๋ฅผ ๋ฐ์ ์๋ ์์ต๋๋ค.
๋ชจ๋ ์ฌ๋์ด ์ฌ์ฌ๋ฅผ ๋ฐ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์ต์๋ก ํ๊ณ ์ถ์ต๋๋ค.
์ ๊ตญ์ฌ์ฌ๋ฅผ ๊ธฐ๋ค๋ฆฌ๋ ์ฌ๋ ์ n, ๊ฐ ์ฌ์ฌ๊ด์ด ํ ๋ช ์ ์ฌ์ฌํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ด ๋ด๊ธด ๋ฐฐ์ด times๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๋ชจ๋ ์ฌ๋์ด ์ฌ์ฌ๋ฅผ ๋ฐ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์ต์๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- ์ ๊ตญ์ฌ์ฌ๋ฅผ ๊ธฐ๋ค๋ฆฌ๋ ์ฌ๋์ 1๋ช ์ด์ 1,000,000,000๋ช ์ดํ์ ๋๋ค.
- ๊ฐ ์ฌ์ฌ๊ด์ด ํ ๋ช ์ ์ฌ์ฌํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ 1๋ถ ์ด์ 1,000,000,000๋ถ ์ดํ์ ๋๋ค.
- ์ฌ์ฌ๊ด์ 1๋ช ์ด์ 100,000๋ช ์ดํ์ ๋๋ค.
์ ์ถ๋ ฅ ์
n | times | return |
---|---|---|
6 | [7, 10] | 28 |
์ ์ถ๋ ฅ ์ ์ค๋ช
๊ฐ์ฅ ์ฒซ ๋ ์ฌ๋์ ๋ฐ๋ก ์ฌ์ฌ๋ฅผ ๋ฐ์ผ๋ฌ ๊ฐ๋๋ค.
7๋ถ์ด ๋์์ ๋, ์ฒซ ๋ฒ์งธ ์ฌ์ฌ๋๊ฐ ๋น๊ณ 3๋ฒ์งธ ์ฌ๋์ด ์ฌ์ฌ๋ฅผ ๋ฐ์ต๋๋ค.
10๋ถ์ด ๋์์ ๋, ๋ ๋ฒ์งธ ์ฌ์ฌ๋๊ฐ ๋น๊ณ 4๋ฒ์งธ ์ฌ๋์ด ์ฌ์ฌ๋ฅผ ๋ฐ์ต๋๋ค.
14๋ถ์ด ๋์์ ๋, ์ฒซ ๋ฒ์งธ ์ฌ์ฌ๋๊ฐ ๋น๊ณ 5๋ฒ์งธ ์ฌ๋์ด ์ฌ์ฌ๋ฅผ ๋ฐ์ต๋๋ค.
20๋ถ์ด ๋์์ ๋, ๋ ๋ฒ์งธ ์ฌ์ฌ๋๊ฐ ๋น์ง๋ง 6๋ฒ์งธ ์ฌ๋์ด ๊ทธ๊ณณ์์ ์ฌ์ฌ๋ฅผ ๋ฐ์ง ์๊ณ 1๋ถ์ ๋ ๊ธฐ๋ค๋ฆฐ ํ์ ์ฒซ ๋ฒ์งธ ์ฌ์ฌ๋์์ ์ฌ์ฌ๋ฅผ ๋ฐ์ผ๋ฉด 28๋ถ์ ๋ชจ๋ ์ฌ๋์ ์ฌ์ฌ๊ฐ ๋๋ฉ๋๋ค.
โป ๊ณต์ง - 2019๋ 9์ 4์ผ ๋ฌธ์ ์ ์๋ก์ด ํ ์คํธ ์ผ์ด์ค๋ฅผ ์ถ๊ฐํ์์ต๋๋ค. ๋์์ ์ฃผ์ weaver9651 ๋๊ป ๊ฐ์ฌ๋๋ฆฝ๋๋ค.
์ฝ๋
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
long long solution(int n, vector<int> times) {
long long answer = 0;
vector<pair<long long,long long>> time_vec;
sort(times.begin(), times.end());
// setting
for(long long i=0; i<times.size(); i++){
time_vec.push_back(make_pair(times[i],0));
}
// ํ๋ช
์ฉ ๋ฃ๊ธฐ
while(n--){
long long min_idx=0;
for(int i=1; i<time_vec.size(); i++){ // ์ต์๊ฐ ๊ตฌํ๊ธฐ
if(time_vec[i].first+ time_vec[i].second < time_vec[min_idx].first+ time_vec[min_idx].second)
min_idx = i;
}
for(int i=0; i<time_vec.size(); i++){ // ์๊ฐ์ด ์ง๋ฌ์์ ํ์
if(i!=min_idx)
time_vec[i].second-=time_vec[min_idx].second;
if(time_vec[i].second<0) // ๋๊ธฐ ์ค์ธ ์ฌ์ฌ๋
time_vec[i].second =0; // 0์ผ๋ก ์ด๊ธฐํ
}
answer+= time_vec[min_idx].second;
time_vec[min_idx].second = time_vec[min_idx].first; // ๋ค์ด๊ฐ ๊ณณ์ ํ์ฌ ๋จ์ ์๊ฐ ์ด๊ธฐํ
}
// ๋จ์ ์๊ฐ ๋๋ด๊ธฐ
long long max_time = 0;
for(int i=0; i<time_vec.size(); i++){ // ์ต๋๊ฐ ๊ตฌํ๊ธฐ
if(time_vec[i].second > max_time)
max_time = time_vec[i].second;
}
answer+=max_time;
return answer;
}
ํ์ด
time_vec๋ผ๋ ๋ฒกํฐ์ (์๋ ๊ฑธ๋ฆฌ๋ ์๊ฐ, ํ์ฌ ๋จ์ ์๊ฐ)์ ์ ์ฅํ๋ฉด์ ๋ ์๊ฐ์ ํฉ์ด ์ต์์ธ ๋ฐ์คํฌ์ ํ ๋ช ์ฉ ์ง์ด๋ฃ๋ ๋ฐฉ๋ฒ์ด๋ค. ๋ ์๊ฐ์ ํฉ์ด ์ต์๋ผ๋ฉด ์ง๊ธ ๋ฐ์คํฌ์ ๋ค์ด๊ฐ์ผํ๋ ์ฌ๋์ด ์ผ์ ๋๋ง์น๋ ์๊ฐ์ด ๊ฐ์ฅ ๋น ๋ฅด๋ค๋ ์๋ฏธ์ด๋ฏ๋ก ์ด๋ ๊ฒ ์ฝ๋๋ฅผ ๊ตฌํํ์๋ค. ๋ชจ๋ ๋ฐ์คํฌ์ ๋ค์ด๊ฐ ํ์๋ ๋๋ง์น๋ ์๊ฐ์ด ๊ฐ์ฅ ๋๋ฆฐ ์ฌ๋์ ๊ธฐ์ ์ผ๋ก ์ข ๋ฃ ์๊ฐ์ ์ธก์ ํ๋ค.
์ฑ์ ๊ฒฐ๊ณผ
ใ ใ .. ์ ์๋๋์ง ๋ชจ๋ฅด๊ฒ ๋ค. ์๊ฐ ์ด๊ณผ๊ฐ ๋ฌธ์ ๋ผ๋ฉด ์์ ํ ์คํธ 1,2,3์ ๋ง์์ผํ๋๋ฐ ๊ทธ๊ฒ๋ ํ๋ ธ๋ค. ๊ทผ๋ฐ ๋ 9๋ฒ์ ํต๊ณผ ใ ใ ใ ..?
๋ค๋ฅธ ์ฌ๋์ ํ์ด
์ด๋ถ ํ์์ด๋ผ๋ ์นดํ ๊ณ ๋ฆฌ๋ฅผ ๋ณด๊ณ ์๋ ์ด๋ป๊ฒ ์ด๋ถ ํ์์ ์ด์ฉํด์ผํ๋์ง ๊ฐ์ด ์์๋๋ฐ, ์ด๋ฒ ๋ฌธ์ ๋ฅผ ํตํด์ ๊ฐ์ ์ข ์ก์ ๊ฒ ๊ฐ๋ค. ์ด ๋ฌธ์ ๋ ๊ธฐ์ตํด๋ฌ์ผ๊ฒ ๋ค!
๋ค๋ฅธ ์ฌ๋์ ํ์ด๋ฅผ ๋ณด๊ณ ๋ด ๋ฐฉ์๋๋ก ์ฝ๋๋ฅผ ์ ๋ฆฌํด๋ณด์๋ค.
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
unsigned long long solution(int n, vector<int> times) {
unsigned long long answer = 1e18;
sort(times.begin(), times.end());
long long min = 1;
long long max = 1e15;//(long long)times.back()*n; // ๊ฐ์ฅ ๋๋ฆฐ ์ฌ๋์ด ๋ชจ๋ ์ฌ์ฌ
while(min<=max){
long long number=0;
long long mid = (min+max)/2;
for(int i=0; i<times.size(); i++) // ํด๋น ์๊ฐ๋์ ์ฌ์ฌ๋ฅผ ๋๋ผ ์ ์๋ ์ฌ๋ ์
number+=(long long)mid/times[i];
if(number<n)
min = mid+1;
else{
// ๊ฐ๋ฅํ๋ฉด
if(mid<answer) // ๊ฐ์ฅ ์์ ์ ์ฐพ๊ธฐ
answer = mid;
max = mid-1;
}
}
return answer;
}
์ฃผ์ ํ ์
return ๊ฐ์ unsigned long long์ผ๋ก ํ์ง ์์ผ๋ฉด ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํ๋์ง ์ ๋ฐ ๊ฐ๋์ด ํ๋ฆฌ๊ฒ ๋์จ๋ค.
Comment