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

연속된 부분 수열의 합

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

프로그래머스

 

- 문제

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

• 기존 수열에서 임의의 두 인덱스의 원소와 그 사이의 원소를 모두 포함하는 부분 수열이어야 합니다.
• 부분 수열의 합은 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의 부분 수열로 만들 수 있는 값입니다.

입출력 예

sequencekresult

[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]를 반환합니다.

 

 

 

- 풀이

- O(n^2) 시간초과 (이중 반복문을 사용하여 모든 가능한 부분 수열을 검사하는 방식)

function solution(sequence, k) {
    var answer = [];
    let arr = [];
    for(let i = 0 ; i < sequence.length; i++){
        let sum = 0;
        let tempArr = [];
        for(let j = i; j < sequence.length; j++){
            tempArr.push({idx: j, val: sequence[j]});
            sum += sequence[j];
            if(sum == k) {
                if(answer.length == 0 || answer.length > tempArr.length){
                    arr = tempArr;
                    break;
                }
            }
            if(sum > k) {
                break;
            }
        }
    }
    console.log(arr)
    answer.push(arr[0].idx, arr[arr.length - 1].idx)
    return answer;
}

 

- 누적 합을 활용

function solution(sequence, k) {
    const sumIndices = new Map(); // 누적 합을 저장할 맵
    let sum = 0; // 현재까지의 누적 합
    let minLength = Infinity; // 최소 길이
    let result = [-1, -1]; // 결과를 저장할 배열

    for (let i = 0; i < sequence.length; i++) {
        sum += sequence[i];

        if (sum === k) {
            // 현재까지의 누적 합이 k와 같다면 결과 갱신
            if (i < minLength) {
                minLength = i;
                result = [0, i];
            }
        } else if (sumIndices.has(sum - k)) {
            // 현재까지의 누적 합에서 k를 뺀 값이 맵에 있다면 결과 갱신
            const startIndex = sumIndices.get(sum - k) + 1;
            const length = i - startIndex;
            if (length < minLength) {
                minLength = length;
                result = [startIndex, i];
            }
        }

        if (!sumIndices.has(sum)) {
            // 맵에 현재 누적 합을 저장
            sumIndices.set(sum, i);
        }
    }

    if (result[0] === -1) {
        return []; // 부분 수열이 없을 경우 빈 배열 반환
    }

    return result;
}

 

- 투포인터

function solution(sequence, k) {
    let answer = [];
    let lt = 0; // 왼쪽 포인터
    let rt = 0; // 오른쪽 포인터
    let minLength = Infinity; // 최소 길이
    let sum = sequence[0]; // 초기 누적 합

    while (rt < sequence.length && lt <= rt) {
        if (sum === k) {
            const length = rt - lt + 1;
            if (length < minLength) {
                minLength = length;
                answer = [lt, rt];
            }
            // 왼쪽 포인터를 오른쪽으로 이동하며 누적 합 갱신
            sum -= sequence[lt];
            lt++;
        } else if (sum < k) {
            // 누적 합이 k보다 작으면 오른쪽 포인터를 오른쪽으로 이동하며 누적 합 갱신
            rt++;
            if (rt < sequence.length) {
                sum += sequence[rt];
            }
        } else { // sum > k
            // 누적 합이 k보다 크면 왼쪽 포인터를 오른쪽으로 이동하며 누적 합 갱신
            sum -= sequence[lt];
            lt++;
        }
    }

    // minLength가 초기값인 Infinity일 경우 부분 수열이 없는 경우이므로 빈 배열 반환
    if (minLength === Infinity) {
        return [];
    }

    return answer;
}