๋ฌธ์ ์ค๋ช
๋น๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ์์ด์ด ์ฃผ์ด์ง ๋, ๋ค์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๋ถ๋ถ ์์ด์ ์ฐพ์ผ๋ ค๊ณ ํฉ๋๋ค.
- ๊ธฐ์กด ์์ด์์ ์์์ ๋ ์ธ๋ฑ์ค์ ์์์ ๊ทธ ์ฌ์ด์ ์์๋ฅผ ๋ชจ๋ ํฌํจํ๋ ๋ถ๋ถ ์์ด์ด์ด์ผ ํฉ๋๋ค.
- ๋ถ๋ถ ์์ด์ ํฉ์
k
์ ๋๋ค. - ํฉ์ด
k
์ธ ๋ถ๋ถ ์์ด์ด ์ฌ๋ฌ ๊ฐ์ธ ๊ฒฝ์ฐ ๊ธธ์ด๊ฐ ์งง์ ์์ด์ ์ฐพ์ต๋๋ค. - ๊ธธ์ด๊ฐ ์งง์ ์์ด์ด ์ฌ๋ฌ ๊ฐ์ธ ๊ฒฝ์ฐ ์์ชฝ(์์ ์ธ๋ฑ์ค๊ฐ ์์)์ ๋์ค๋ ์์ด์ ์ฐพ์ต๋๋ค.
์์ด์ ๋ํ๋ด๋ ์ ์ ๋ฐฐ์ด sequence
์ ๋ถ๋ถ ์์ด์ ํฉ์ ๋ํ๋ด๋ ์ ์ k
๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๋ถ๋ถ ์์ด์ ์์ ์ธ๋ฑ์ค์ ๋ง์ง๋ง ์ธ๋ฑ์ค๋ฅผ ๋ฐฐ์ด์ ๋ด์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ด๋ ์์ด์ ์ธ๋ฑ์ค๋ 0๋ถํฐ ์์ํฉ๋๋ค.
์ ํ์ฌํญ
- 5 ≤
sequence
์ ๊ธธ์ด ≤ 1,000,000- 1 ≤
sequence
์ ์์ ≤ 1,000 sequence
๋ ๋น๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์์ต๋๋ค.
- 1 ≤
- 5 ≤
k
≤ 1,000,000,000k
๋ ํญ์sequence
์ ๋ถ๋ถ ์์ด๋ก ๋ง๋ค ์ ์๋ ๊ฐ์ ๋๋ค.
์ ์ถ๋ ฅ ์
sequence | k | result |
---|---|---|
[1, 2, 3, 4, 5] | 7 | [2, 3] |
[1, 1, 1, 2, 3, 4, 5] | 5 | [6, 6] |
[2, 2, 2, 2, 2] | 6 | [0, 2] |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
[1, 2, 3, 4, 5]์์ ํฉ์ด 7์ธ ์ฐ์๋ ๋ถ๋ถ ์์ด์ [3, 4]๋ฟ์ด๋ฏ๋ก ํด๋น ์์ด์ ์์ ์ธ๋ฑ์ค์ธ 2์ ๋ง์ง๋ง ์ธ๋ฑ์ค 3์ ๋ฐฐ์ด์ ๋ด์ [2, 3]์ ๋ฐํํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
[1, 1, 1, 2, 3, 4, 5]์์ ํฉ์ด 5์ธ ์ฐ์๋ ๋ถ๋ถ ์์ด์ [1, 1, 1, 2], [2, 3], [5]๊ฐ ์์ต๋๋ค. ์ด ์ค [5]์ ๊ธธ์ด๊ฐ ์ ์ผ ์งง์ผ๋ฏ๋ก ํด๋น ์์ด์ ์์ ์ธ๋ฑ์ค์ ๋ง์ง๋ง ์ธ๋ฑ์ค๋ฅผ ๋ด์ [6, 6]์ ๋ฐํํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #3
[2, 2, 2, 2, 2]์์ ํฉ์ด 6์ธ ์ฐ์๋ ๋ถ๋ถ ์์ด์ [2, 2, 2]๋ก 3๊ฐ์ง ๊ฒฝ์ฐ๊ฐ ์๋๋ฐ, ๊ธธ์ด๊ฐ ์งง์ ์์ด์ด ์ฌ๋ฌ ๊ฐ์ธ ๊ฒฝ์ฐ ์์ชฝ์ ๋์จ ์์ด์ ์ฐพ์ผ๋ฏ๋ก [0, 2]๋ฅผ ๋ฐํํฉ๋๋ค.
๋ฌธ์ ํ์ด๋ฅผ ์ํ ํฌํฌ์ธํธ ์๊ณ ๋ฆฌ์ฆ ์ค๋ช
์ด๋ฐ์์ผ๋ก ํฌ์ธํฐ(index๊ฐ์ ๊ฐ๊ณ ์์) 2๊ฐ๋ฅผ ํ์ฉํด์ ์ด๋ํด๊ฐ๋ฉฐ ํฌ์ธํฐ๊ฐ์ ํด๋นํ๋ ๋ฐฐ์ด์ ์๋ฅผ ๋ํ ๋ ์์ฃผ ์ฐ์ธ๋ค.
k = 5 ์ด๋ฏ๋ก ๊ณ์ ๋ํด๋ณธ๋ค.
์ด๋๋ right ํฌ์ธํฐ ๊ฐ์ ++ ํด์ฃผ๊ณ ,
sum = sequence[left] + sequence[right]
์ด๋ฐ์์ผ๋ก ๊ณ์ ๋ํ๋ ๊ฒ์ด๋ค.
sum = 1+1+1+2 = 5 ์ด๋ฏ๋ก k๊ฐ ๋ฌ์ฑ!
์ ๋ต ํ๋ณด๊ตฐ์ 0(left๊ฐ)๊ณผ 3(right๊ฐ)์ ์ ์ฅ
์ด๋๋ ์ด์ left ๊ฐ์ ์ฎ๊ฒจ์ ๋ค์ ๋ํด์ ๋น๊ตํด๋ณด๋ ๊ฒ์ด๋ค.
left ํฌ์ธํฐ๋ฅผ ์ฎ๊ฒผ์ผ๋ ๊ธฐ์กด์ ๊ฐ์ ํฉ๊ณ์์ ๋นผ์ฃผ๋ ์์ ์ด ํ์ํ๋ค.
์ด๋ฐ์์ผ๋ก ๋๊ฐ์ ํฌ์ธํฐ๋ฅผ ํ์ฉํด์ ๋ฌธ์ ๋ฅผ ํธ๋ ๊ฒ์ด๋ค.
๋ฌธ์ ํ์ด
์์ ์๊ณ ๋ฆฌ์ฆ์ ์กฐ๊ธ ์์ฉํด๋ณด๊ฒ ๋ค.
1๏ธโฃ ์ฐ์ ์ด์ฐจํผ ์ฒ์์ left๊ฐ 0์ด๋๊น right ํฌ์ธํฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ฐจ๋ก๋๋ก ํฉ๊ณ๋ฅผ ๋ํด์ค๋ค.
2๏ธโฃ sum์ด k์ ๊ฐ์ผ๋ฉด, right ํฌ์ธํฐ์์ left ํฌ์ธํฐ๋ฅผ ๋นผ์ ์์์ ๊ธธ์ด๋ฅผ ์ ์ฅํด๋๊ณ , ์ด๊ฒ์ ๊ธฐ์ค์ผ๋ก ์งง์ ๊ฒ์ ๋ต์๋ค๊ฐ ๋ฃ๋๋ค.
( ์ด์ฐจํผ ์์ฐจ์ ์ผ๋ก ๋ฐ๋ณต๋๋ฏ๋ก, ๊ฐ์ ๊ธธ์ด ์ผ๋๋ ์๋์ผ๋ก left์ธ๋ฑ์ค๊ฐ ๋ ์์ ๊ฒ์ ๋ด์๋๊ฒ ๋๋ค )
์ ๋ต
class Solution {
public int[] solution(int[] sequence, int k) {
int[] answer = new int[2];
// ํฌ ํฌ์ธํธ ์ ์ธ
int left = 0;
int right = 0;
// ํฉ๊ณ๊ฐ
int sum = 0;
int size = sequence.length;
for(right = 0; right<sequence.length; right++){
//์ฐจ๋ก๋๋ก ๋ํด์ค
sum += sequence[right];
//sum์ด k๋ณด๋ค ํฌ๋ค๋ฉด, left๋ฅผ ํ ์นธ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋
while(right<sequence.length && sum > k){
// ์ด๋ํ ๊ฐ์ ๋นผ์ค๋ค
sum -=sequence[left];
left++;
}
// sum์ด ๊ฐ์ผ๋ฉด
if (sum == k){
// ์์๊ฐ ๊ธธ์ด ๋น๊ต ํ ์งง์ ๊ฒ์ ๋ต์๋ค ๋ฃ๋๋ค
if (size > right - left){
size = right - left;
answer[0] = left;
answer[1] = right;
}
}
}
return answer;
}
}