[프로그래머스] 연속된 부분 수열의 합

문제 설명

비내림차순으로 정렬된 수열이 주어질 때, 다음 조건을 만족하는 부분 수열을 찾으려고 합니다.

기존 수열에서 임의의 두 인덱스의 원소와 그 사이의 원소를 모두 포함하는 부분 수열이어야 합니다.
부분 수열의 합은 k입니다.
합이 k인 부분 수열이 여러 개인 경우 길이가 짧은 수열을 찾습니다.
길이가 짧은 수열이 여러 개인 경우 앞쪽(시작 인덱스가 작은)에 나오는 수열을 찾습니다.
수열을 나타내는 정수 배열 sequence와 부분 수열의 합을 나타내는 정수 k가 매개변수로 주어질 때, 위 조건을 만족하는 부분 수열의 시작 인덱스와 마지막 인덱스를 배열에 담아 return 하는 solution 함수를 완성해주세요. 이때 수열의 인덱스는 0부터 시작합니다.

제한사항

• 5 ≤ sequence의 길이 ≤ 1,000,000
  • 1 ≤ sequence의 원소 ≤ 1,000
  • sequence는 비내림차순으로 정렬되어 있습니다.
• 5 ≤ k ≤ 1,000,000,000
  • k는 항상 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]

문제 출처

https://school.programmers.co.kr/learn/courses/30/lessons/178870

생각

• Lv2에 있긴 쉬워보이는데,,,? 했다가 제한 사항을 보고 바로 수긍했다,,, 😇
• 일반적인 for문으로 풀다간 100% 시간 제한에 걸리기 때문에,,,
  • 일단 앞에서부터 하나씩 더해가면서 k 보다 커지면 수열의 앞에서 하나를 빼고
  • k보다 작을 때는 뒤에다 하나를 추가하는 방식으로 코드를 구현했다.
  • k와 같을 때는 수열의 길이를 기준으로 업데이트 할지말지를 판단하였다
• 풀고 나서 찾아보니 이런 알고리즘을 투 포인터 알고리즘 이라고 한다

코드

public class SumSuccessivePartialSeq {
    public int[] solution(int[] sequence, int k) {

        int n = sequence.length, start = 0, end = 0;
        int minLength = Integer.MAX_VALUE;
        int[] result = new int[2];

        int sum = sequence[0];
        while (start < n && end < n) {
            if (sum == k) {
                if (end - start + 1 < minLength) {
                    minLength = end - start + 1;
                    result[0] = start;
                    result[1] = end;
                }
                sum -= sequence[start++];
            } else if (sum < k) {
                if (++end < n) {
                    sum += sequence[end];
                }
            } else {
                // sum > k
                sum -= sequence[start++];
            }
        }
        return result;
    }
}

다른 사람의 풀이

class Solution {
    public int[] solution(int[] sequence, int k) {

        int left = 0, right = -1, sum = 0;
        int length = 1000001, sLeft = 0, sRight = 0;

        while (right < sequence.length) {

            if (sum < k) {
                if (++right < sequence.length)
                    sum += sequence[right];
            } else if (k < sum) {
                sum -= sequence[left++];
            } else {
                if (right - left < length) {
                    length = right - left;
                    sLeft = left;
                    sRight = right;
                }
                sum -= sequence[left++];
            }
        }
        return new int[] { sLeft, sRight };
    }
}

• 똑같이 투 포인터 알고리즘을 사용했지만 조금 차이점이 있었다!
• 나의 풀이는 k와 수열의 합이 같을 때 endPointer를 증가시켰지만, 다른 사람의 풀이는 left 포인터를 증가시켰다

if (end < sequence.length) {
    currentSum += sequence[end];
}

• 위와 같은 확인을 할 필요가 없기 때문에, 다른사람의 풀이가 조금 더 깔끔해 보이는게 아닐까? 라는 생각이 들었다😳😳