๋ณธ๋ฌธ์œผ๋กœ ๋ฐ”๋กœ๊ฐ€๊ธฐ
728x90
๐Ÿ”—๋ฌธ์ œ ๋ณด๋Ÿฌ๊ฐ€๊ธฐ
 

ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค

์ฝ”๋“œ ์ค‘์‹ฌ์˜ ๊ฐœ๋ฐœ์ž ์ฑ„์šฉ. ์Šคํƒ ๊ธฐ๋ฐ˜์˜ ํฌ์ง€์…˜ ๋งค์นญ. ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค์˜ ๊ฐœ๋ฐœ์ž ๋งž์ถคํ˜• ํ”„๋กœํ•„์„ ๋“ฑ๋กํ•˜๊ณ , ๋‚˜์™€ ๊ธฐ์ˆ  ๊ถํ•ฉ์ด ์ž˜ ๋งž๋Š” ๊ธฐ์—…๋“ค์„ ๋งค์นญ ๋ฐ›์œผ์„ธ์š”.

programmers.co.kr

 

๐Ÿ‘จ‍๐Ÿ’ปํ’€์ด ๊ณผ์ •

 

๋‹ค์Œ ๋ฌธ์ œ ์ง€๋ฌธ ๋ถ€๋ถ„์ด ๋ฌด์Šจ ๋ง์ธ์ง€ ํ—ท๊ฐˆ๋ ค, ์ดํ•ดํ•˜๋Š” ๋ฐ์— ์‹œ๊ฐ„์ด ์ข€ ๊ฑธ๋ ธ์Šต๋‹ˆ๋‹ค.

"๋‹จ, ์šฐ๋ฐ•์ˆ˜์—ด ๊ทธ๋ž˜ํ”„์˜ ๊ฐ€๋กœ์ถ• ๊ธธ์ด๋ฅผ ๋ฏธ๋ฆฌ ์•Œ ์ˆ˜ ์—†๊ธฐ ๋•Œ๋ฌธ์—
๊ตฌ๊ฐ„์˜ ์‹œ์ž‘์€ ์Œ์ด ์•„๋‹Œ ์ •์ˆ˜, ๊ตฌ๊ฐ„์˜ ๋์€ ์–‘์ด ์•„๋‹Œ ์ •์ˆ˜๋กœ ํ‘œํ˜„ํ•ฉ๋‹ˆ๋‹ค.
์ด๋Š” ๊ฐ๊ฐ ๊บพ์€์„  ๊ทธ๋ž˜ํ”„๊ฐ€ ์‹œ์ž‘ํ•˜๋Š” ์ ๊ณผ ๋๋‚˜๋Š” ์ ์˜ x์ขŒํ‘œ์— ๋Œ€ํ•œ ์ƒ๋Œ€์ ์ธ ์˜คํ”„์…‹์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค."

 

๊ตฌํ•œ ์šฐ๋ฐ•์ˆ˜์—ด์˜ ๋งˆ์ง€๋ง‰ ์ขŒํ‘œ(์œ„ ์˜ˆ์ œ๋กœ ๋ณด๋ฉด (5, 1))์˜ x๊ฐ’์„ LX๋ผ๊ณ  ํ•œ๋‹ค๋ฉด, ์ฃผ์–ด์ง„ ๊ตฌ๊ฐ„ [a, b]๋Š” [0 + a, LX + b]๋ฅผ ์˜๋ฏธํ•˜๋Š” ๊ฑฐ์˜€์Šต๋‹ˆ๋‹ค.

 

 

์˜ˆ๋ฅผ ๋“ค์–ด, ์œ„ ์˜ˆ์ œ์—์„œ LX๋Š” 5์ž…๋‹ˆ๋‹ค. (5, 1)์ด ๋งˆ์ง€๋ง‰ ์šฐ๋ฐ•์ˆ˜์—ด ์ขŒํ‘œ์ด๊ธฐ ๋•Œ๋ฌธ์ด์ฃ .

  • range๊ฐ€ [0, 0]์œผ๋กœ ์ฃผ์–ด์กŒ๋‹ค๋ฉด, [0 + 0, 5 + 0]์ด๋ฏ€๋กœ [0, 5]์ธ ์ „์ฒด ๊ตฌ๊ฐ„์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.
  • range๊ฐ€ [0, -1]๋กœ ์ฃผ์–ด์กŒ๋‹ค๋ฉด, [0 + 0, 5 - 1]์ด๋ฏ€๋กœ [0, 4] ๊ตฌ๊ฐ„ ๋„“์ด๋ฅผ ๊ตฌํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค.
  • range๊ฐ€ [2, -3]์œผ๋กœ ์ฃผ์–ด์กŒ๋‹ค๋ฉด, [0 + 2, 5 - 3]์ด๋ฏ€๋กœ [2, 2] ๊ตฌ๊ฐ„ ๋„“์ด๋ฅผ ๊ตฌํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค.
  • range๊ฐ€ [3, -3]์œผ๋กœ ์ฃผ์–ด์กŒ๋‹ค๋ฉด, [0 + 3, 5 - 3]์ด๋ฏ€๋กœ [3, 2]์ž…๋‹ˆ๋‹ค. ์ž˜๋ชป๋œ ๊ตฌ๊ฐ„์ด๋ฏ€๋กœ -1์ž…๋‹ˆ๋‹ค.

 

x๊ฐ€ ์‹ค์ˆ˜ ์˜์—ญ์ด ์•„๋‹Œ ์ •์ˆ˜ ์˜์—ญ์ด๊ธฐ์—, ์ •์ ๋ถ„ ๋„“์ด๋Š” ์‚ฌ๋‹ค๋ฆฌ๊ผด ํ˜•ํƒœ๋กœ ๋‚˜ํƒ€๋‚˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

 

๊ฐ ๋…ธ๋ž€์ƒ‰ ๋น—๊ธˆ ์นœ ์˜์—ญ์˜ ๋„“์ด๋ฅผ ๊ตฌํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค.

 

x๊ฐ€ 0๋ถ€ํ„ฐ ์šฐ๋ฐ•์ˆ˜์—ด์˜ ๋งˆ์ง€๋ง‰ x๊ฐ’๊นŒ์ง€์˜ ๊ฐ ์‚ฌ๋‹ค๋ฆฌ๊ผด ๋„“์ด๋ฅผ ๋ˆ„์ ํ•ด์„œ ์ €์žฅํ•œ ํ›„, ์ฃผ์–ด์ง„ range์— ์˜ํ•ด ๊ตฌํ•ด์ง„ ๊ตฌ๊ฐ„ [a, b]์— ๋Œ€ํ•ด, \( f(b) - (a)\)์˜ ๋„“์ด๋ฅผ ๊ตฌํ•ด์ฃผ๋ฉด ๋ฉ๋‹ˆ๋‹ค.

 

โœ๏ธ์†Œ์Šค ์ฝ”๋“œ ๋ฐ ๊ฒฐ๊ณผ

#include <vector>
using namespace std;

vector<double> solution(int k, vector<vector<int>> ranges) {
    vector<double> cummulativeSum { 0.0 };
    
    while (true) {
        int nextK = (k % 2 == 0) ? k / 2 : (k * 3) + 1;
        double area = static_cast<double>(k + nextK) / 2;
        cummulativeSum.emplace_back(cummulativeSum.back() + area);
        k = nextK;

        if (k == 1)
            break;
    }
    
    vector<double> answer;

    for (const auto& range : ranges) {
        int leftX = range[0], rightX = cummulativeSum.size() - 1 + range[1];

        if (rightX < leftX) {
            answer.emplace_back(-1.0);
            continue;
        }

        double area = cummulativeSum[rightX] - cummulativeSum[leftX];
        answer.emplace_back(area);
    }

    return answer;
}

 

 

728x90
๋ฐ˜์‘ํ˜•