๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์
๋ฌธ์ ์์ ์ฃผ์ด์ง ๋งค๊ฐ๋ณ์
- ์์ด์ ๋ํ๋ด๋ ์ ์ ๋ฐฐ์ด `sequence`
- ๋ถ๋ถ ์์ด์ ํฉ์ ๋ํ๋ด๋ ์ ์ `k`
์กฐ๊ฑด์ ๋ง์กฑํ๋ ๋ถ๋ถ ์์ด์ ์์ ์ธ๋ฑ์ค์ ๋ง์ง๋ง ์ธ๋ฑ์ค๋ฅผ ๋ฐฐ์ด๋ก returnํ๋ solution ํจ์๋ฅผ ์์ฑํ๋ ๋ฌธ์
ํฌํฌ์ธํฐ, ์ฌ๋ผ์ด๋ฉ ์๋์ฐ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํผ๋ค.
- start: ์๋์ฐ์ ์์ ์ธ๋ฑ์ค
- end: ์๋์ฐ์ ๋ ์ธ๋ฑ์ค (or ๋ค์ ํ์ํ ์์น)
`ํฌํฌ์ธํฐ`
ํ๋์ ํฌ์ธํฐ๋ ๋ฐฐ์ด์ ์์์, ๋ค๋ฅธ ํ๋๋ ๋ฐฐ์ด์ ๋์ ๊ฐ๋ฆฌํค๋ฉฐ ์์ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ตฌ๊ฐ์ ์ฐพ๋๊ฒ์ด๋ค.
`์ฌ๋ผ์ด๋ฉ ์๋์ฐ ์๊ณ ๋ฆฌ์ฆ`
๋ถ๋ถ ๋ฐฐ์ด, ๋ถ๋ถ ๋ฌธ์์ด ๋ฌธ์ ์์ ์์ฃผ ์ฌ์ฉ๋๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ตฌ๊ฐ์ ์ฐพ๊ฑฐ๋, ๊ณ ์ ๋ ํฌ๊ธฐ ๊ตฌ๊ฐ์ ํฉ๊ณ, ์ต๋๊ฐ, ์ต์๊ฐ ๋ฑ์ ๊ตฌํ ๋ ์ ์ฉํ๋ค. ๊ณ ์ ํฌ๊ธฐ์ ๊ฐ๋ณํฌ๊ธฐ์ ๊ตฌ๊ฐ ๋ชจ๋ ํ์ ๊ฐ๋ฅํ๋ฐ ์ด ๋ฌธ์ ๋ ๋ฐฐ์ด์์ ํฉ์ด k์ธ ๊ฐ์ฅ ์งง์ ๋ถ๋ถ ๋ฐฐ์ด์ ๊ตฌํ๋ ๊ฐ๋ณ ํฌ๊ธฐ ํ์์ ํด์ผ ํ๋ค.
โญ 3. ์ ๋ต์ฝ๋
1. sum์ด k๋ณด๋ค ์์ ๋์ end๊ฐ๋ฅผ ์ฆ๊ฐ์ํค๋ฉด์ ๋ํ๊ธฐ
2. sum์ด k๊ฐ๊ณผ ๊ฐ์ ๋ฐฐ์ด ๊ตฌ๊ฐ์ค len์ด ์ด์ ์ ์ ์ฅํ ๊ธธ์ด๋ณด๋ค ์งง๋ค๋ฉด answer์ start์ end-1๊ฐ์ ์ ์ฅํ๊ณ , ์๋ก์ด ๊ธธ์ด(end-start)๋ฅผ len์ ์ ์ฅ
3. sum์ด k์ด์์ด๋ฏ๋ก, sum์์ sequence[start]๊ฐ์ ๋นผ์ค๋ค.
class Solution {
public int[] solution(int[] sequence, int k) {
int[] answer = new int[2];
int sum = 0;
int start = 0;
int end = 0;
int len = -1;
// start๋ ์์์ ์ด๊ธฐํ ํจ
// ๋์ ํฉ์ด k๋ณด๋ค ์์ ๊ตฌ๊ฐ ์ฐพ๊ธฐ
for (; start < sequence.length; start++) {
while (end < sequence.length && sum < k) {
sum += sequence[end++];
}
// ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ตฌ๊ฐ (๋ถ๋ถ๋ฐฐ์ด) ์ฐพ๊ธฐ
// ๊ทธ์ค์์๋ ๊ฐ์ฅ ์งง์ ๊ธธ์ด๋ฅผ ๊ฐ์ง ๊ตฌ๊ฐ์ ์ ์ฅ
if (sum == k) {
if(len == -1 || len > end - start) {
answer[0] = start;
answer[1] = end-1;
len = end - start;
}
}
sum -= sequence[start];
}
return answer;
}
}
โ len== -1 ํ๋ ์ด์
if(len == -1 || len > end - start)
len์ ํ์ฌ๊น์ง ๋ฐ๊ฒฌ๋ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๋ถ๋ถ ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ์ ์ฅํ๋ค. ์ด๊ธฐ ์ํ์์๋ ๊ธธ์ด๋ฅผ ๋น๊ตํ ๊ธฐ์ค์ด ์๊ธฐ ๋๋ฌธ์ ๋งจ ์์์ len = -1๋ก ์ด๊ธฐํํด์ "์์ง ์ด๋ ํ ๋ถ๋ถ ๋ฐฐ์ด๋ ์ ํ๋์ง ์์๋ค"๋ ๊ฒ์ ์ ์ธ์ ํด์ฃผ์๋ค. ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์ฒซ ๋ฒ์งธ ๋ถ๋ถ ๋ฐฐ์ด์ด ๋ฐ๊ฒฌ๋์์ ๋ ์ด๊ฑธ ๋ฐ๋์ ์ฑํํ๊ฒ ํ๋ ๊ตฌ๋ฌธ์ด๋ค. len == -1์ด ์ฐธ์ด๋ฏ๋ก, ๊ทธ ์๋ answer์ start์end๋ฅผ ์ ์ฅํ๋ ์ฝ๋๊ฐ ์คํ๋๋ค.
โ end-1์ธ ์ด์
answer[1] = end-1;
์์์ sequence[end]์ ๊ฐ์ ๋ํ ํ end๋ฅผ ์ฆ๊ฐ์ํค๋ ๋ก์ง์ด ์๊ธฐ ๋๋ฌธ์ ๋ฃจํ๊ฐ ์ข ๋ฃ๋ ๋ end๋ ํ์ฌ ๋ถ๋ถ ๋ฐฐ์ด์ ๋ง์ง๋ง ์ธ๋ฑ์ค๊ฐ ์๋๋ผ ๊ทธ ๋ค์ ์ธ๋ฑ์ค๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋๋ค. ์ฐ๋ฆฌ๊ฐ ์ฐพ๋ ๋ถ๋ถ ๋ฐฐ์ด์ ์ค์ ๋ง์ง๋ง ์ธ๋ฑ์ค๋๋ `end - 1`์ด๋ค.
while (end < sequence.length && sum < k) {
sum += sequence[end++];
}
๐๐ป ์ข์์ ๊ฐ์ฅ ๋ง์ด ๋ฐ์ ์ฝ๋
์๋ ๋ค๋ฅธ ์ฝ๋๊ฐ ์ข์์ 1์์ธ๋ฐ ์ค๋์ 2์ ์ฝ๋๊ฐ ๋ ๊ฐ๊ฒฐํ๊ณ ์ ์ด ๊ฑฐ ๊ฐ์์ ๊ฐ์ ธ์ด
class Solution {
public int[] solution(int[] sequence, int k) {
int[] result = new int[2];
int left = 0;
int right = 0;
int sum = 0;
int minLength = Integer.MAX_VALUE;
while (right < sequence.length) {
sum += sequence[right];
while (sum >= k) {
if (sum == k && (right - left) < minLength) {
minLength = right - left;
result[0] = left;
result[1] = right;
}
sum -= sequence[left];
left++;
}
right++;
}
return result;
}
}
๐ฆ 4. ๊ฐ์ ์ ํ ๋ฌธ์
'Algorithm > JAVAํ ์คํธ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์์์ฐพ๊ธฐ (์์ ํ์) (47) | 2024.11.21 |
---|---|
์ฝ๋ฉํ ์คํธ ์๊ฐ๋ณต์ก๋ & ๋น ์คํ๊ธฐ๋ฒ ์ ๋ชจ๋ ๊ฒ (5) | 2024.11.02 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์์ ๋ง๋ค๊ธฐ (3) | 2024.10.27 |
[ํ๋ก๊ทธ๋๋จธ์ค] ๋ก๊ทธ์ธ ์ฑ๊ณต? / JAVA(์๋ฐ) ์ฝ๋ (0) | 2024.10.18 |