Programmers, ์ž…๊ตญ์‹ฌ์‚ฌ

2021. 12. 4. 00:03ใ†ETC/Algorithm

๋ฐ˜์‘ํ˜•

๐Ÿ”— ๋ฌธ์ œ ๋งํฌ

์ด๋ถ„ํƒ์ƒ‰ ๊ด€๋ จ ๋ฌธ์ œ!

 

๋ฌธ์ œ ์„ค๋ช…

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๋ถ„์— ๋ชจ๋“  ์‚ฌ๋žŒ์˜ ์‹ฌ์‚ฌ๊ฐ€ ๋๋‚ฉ๋‹ˆ๋‹ค.

 

 

 

๋ฌธ์ œ ํ•ด๊ฒฐ

 

C++

#include <string>
#include <algorithm>
#include <vector>
typedef long long ll;

using namespace std;

long long solution(int n, vector<int> times) {
    sort(times.begin(), times.end());
    ll low = 0, high = times.back() * n;
    
    while (low != high) {
        ll mid = (low + high) / 2;
        ll pos = 0;
        for (int t: times) pos += mid / t;
        if (pos >= n) high = mid;
        else low = mid + 1;
    }
    
    return low;
}

 

๊ฐ€๋Šฅํ•œ ์‹œ๊ฐ„์„ ์ด๋ถ„ ํƒ์ƒ‰์„ ํ†ตํ•ด ๊ตฌํ•ฉ๋‹ˆ๋‹ค.

 

1) ์ฒ˜์Œ ๋ฒ”์œ„๋Š” [0, ๊ฐ€์žฅ ์˜ค๋ž˜ ๊ฑธ๋ฆฌ๋Š” ์‹ฌ์‚ฌ ์‹œ๊ฐ„ * n] ์œผ๋กœ ์„ค์ •ํ•ฉ๋‹ˆ๋‹ค.

2) ๊ฐ€๋Šฅํ•œ ์‹œ๊ฐ„์„ ํƒ์ƒ‰ํ•ฉ๋‹ˆ๋‹ค.

2-1) mid ๊ฐ’์„ ๊ตฌํ•ด mid ์‹œ๊ฐ„ ๋‚ด์— ๋ชจ๋“  ์‹ฌ์‚ฌ๊ฐ€ ์ง„ํ–‰๋  ์ˆ˜ ์žˆ๋Š”์ง€ ํŒ๋‹จํ•ฉ๋‹ˆ๋‹ค.

2-2) ์ด๋•Œ, pos += mid / t ๋Š” ๊ฐ ์‹ฌ์‚ฌ๋Œ€ ๋งˆ๋‹ค ๋ฐ›์„ ์‚ฌ๋žŒ๋“ค์„ ํŒ๋‹จํ•ฉ๋‹ˆ๋‹ค.

2-3) pos >= n , mid ์‹œ๊ฐ„์œผ๋กœ ๊ตฌํ•œ ์ˆ˜์šฉ ์ธ์› (pos)์ด n๋ณด๋‹ค ํฌ๊ฑฐ๋‚˜ ๊ฐ™๋‹ค๋ฉด (๊ฐ€๋Šฅ์„ฑ ์žˆ๋Š” ์ƒํƒœ) ์กฐ๊ธˆ ๋” ์ž‘์€ ๊ฐ’์œผ๋กœ ์‹œ๋„ํ•ฉ๋‹ˆ๋‹ค. (high = mid) 

2-4) else, mid ์‹œ๊ฐ„์œผ๋กœ ๊ตฌํ•œ ์ˆ˜์šฉ ์ธ์›์ด n๋ช… ๋ณด๋‹ค ๋ถ€์กฑํ•˜๋‹ค๋ฉด ๋” ํฐ ๊ฐ’์œผ๋กœ ์‹œ๋„ํ•ฉ๋‹ˆ๋‹ค.

 

 

 

๋ฐ˜์‘ํ˜•