투포인터 (연속된 부분의 수열의 합.)

문제

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

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

내 답안

queue 를 사용.

public static int[] solution(int[] sequence, int k) {
  int[] answer = new int[2];
  int[] extendedSequence = new int[sequence.length + 1];
  System.arraycopy(sequence, 0, extendedSequence, 0, sequence.length);
  extendedSequence[sequence.length] = 0;

  Deque<Integer> q = new ArrayDeque<>();
  int sum = 0;
  int start = 0, end = 0;
  int result = sequence.length;

  for (int i = 0; i < extendedSequence.length; i++) {
    while (sum > k) {

      int temp = q.pollFirst();
      sum -= temp;
      start++;

    }

    if (sum == k && end - start < result) {
      answer[0] = start;
      answer[1] = end;
      result = end - start;
    }

    q.offerLast(extendedSequence[i]);
    sum += extendedSequence[i];
    end = i;
  }

  // return answer
  return answer;
}

 

모범 답안.

출처 : https://ksb-dev.tistory.com/302

투포인터 

 

 

투포인터란, 두 가지의 포인터를 사용해 배열에서 조건과 일치하는 연속된 부분을 찾을 수 있는 방법입니다.

조건에 맞춰 서로 다른 두 가지의 포인터를 움직여야 합니다.

 

        

부분 수열이 [0, 3]가 되었습니다.

새로운 원소가 추가되었습니다.

기존의 부분 수열의 합에서 새로운 원소인 4를 더합니다.

그 합은 10입니다.

이번에는 부분 수열의 합이 k보다 크기 때문에 left를 움직입니다.

부분 수열이 [2, 3]가 되었습니다.

원소가 삭제되었습니다.

기존의 부분 수열의 합에서 2를 뺍니다.

그 합은 7입니다.

드디어 조건에 맞는 경우를 찾았습니다. 때문에, 정답 후보에 저장시켜둡니다.

 

아직 모든 조건을 탐색하지 못했습니다.

이 경우 right를 먼저 움직이되, right가 끝에 도달한 경우에는 left를 움직여야 합니다.

아직 right가 끝에 도달하지 못했으므로 right를 움직입니다.

 

모범 답안 1

class Solution {
  public int[] solution(int[] sequence, int k) {
    int left = 0;
    int right = 0;
    int partitionSum = sequence[0]; // 부분 수열의 합

    int n = sequence.length;

    List<SubSequence> subs = new ArrayList<>();
    while (true){
      // 현재 부분 수열의 합과 k가 일치하는 left와 right를 저장함
      if(partitionSum == k){
        subs.add(new SubSequence(left, right));
      }
      if(left == n && right == n) break;

      if(partitionSum <= k && right < n){
        right++;
        // 새로운 원소가 추가되었으므로, right에 위치하는 값을 부분 수열 합에 더함
        if(right < n) partitionSum += sequence[right];
      } else {
        // 기존의 left의 위치한 원소를 부분 수열의 합에서 제외
        if(left < n) partitionSum -= sequence[left];
        left++;
      }
    }

    // 조건에 가장 일치하는 부분 수열을 맨 앞으로 정렬
    subs.sort(SubSequence::compareTo);

    return new int[]{subs.get(0).left, subs.get(0).right};
  }

  private class SubSequence implements Comparable<SubSequence>{
    int left, right, size;

    public SubSequence(int left, int right) {
      this.left = left;
      this.right = right;
      this.size = right - left;
    }

    @Override
    public int compareTo(SubSequence o) {
      if(this.size == o.size){
        return this.left - o.left;
      }
      return this.size - o.size;
    }
  }
}

 

모범답안 2

class Solution {
  public int[] solution(int[] sequence, int k) {
    int[] answer = new int[2];
    int size = Integer.MAX_VALUE;
    int s = 0;
    int e = 0;
    int sum = sequence[s];
    while(s<sequence.length&&e<sequence.length){
      if(sum<k){
        e++;
        if(e==sequence.length)break;
        sum+=sequence[e];
      }
      else if(sum>k){
        sum-=sequence[s++];
      }
      else{
        if(size > e-s){
          size = e-s;
          answer[0] = s;
          answer[1] = e;
        }
        sum-=sequence[s++];
        e++;
        if(e==sequence.length)break;
        sum+=sequence[e];
      }
    }
    //
    return answer;
  }
}

 

3

import java.util.*;
class Solution {
  public int[] solution(int[] sequence, int k) {
    int size = sequence.length;

    int left = size - 1;
    int right = size - 1;

    int tmp = sequence[size-1];
    int[] answer;
    while(left <= right) {
      if (left == right && tmp != k) tmp += sequence[--left];
      else if (tmp < k) {
        tmp += sequence[--left];
      } else if (tmp > k) {
        tmp -= sequence[right--];
      } else if (left > 0 && sequence[left-1] == sequence[right]) {
        left--;
        right--;
      } else {
        answer = new int[] {left, right};

        return answer;
      }
    }
    return new int[] {};
  }
}