이진 검색 (binary search)

• 시간복잡도
  • 이분 탐색 : O(logN)
• 정의
  • 항목들을 두 그룹으로 나누고 각 요소를 비교하는 단계를 거치면서 한 쪽 그룹은 다음 고려 대상에서 제외하는 방법
• 특징
  • 오름차순이나 알파벳 순 등으로 이미 정렬되어 있어야 함
  • 분할 정복(Divide and Conquer) 전략의 예
  • 각 단계마다 남아있는 항목이 절반이 됨
  • 작업의 양이 데이터의 양이 증가하는 것에 비해 천천히 증가함
• 구성
  • 단계의 수(비교 횟수)
    • 전체 항목 크기를 2로 나눠 항목 크기가 1에 도달하게 되는 횟수
  • 2를 거듭지곱했을 때 전체 항목의 수가 되도록 하는 지수
• 사례
  • 로그 : 어떤 수를 2로 나눠 1에 도달하기 까지의 횟수 or 2를 거듭제곱해서 그 수까지 도달하기 까지의 횟수
  • 스포츠 경기의 단계별 토너먼트
  <aside> 💡 [예] 약 2만개의 이름이 포함된 전화번호가 있을 때, 20,000은 $2^{14}$(16,384) 와 $2^{15}$(32,768)의 사이에 있기 때문에 14~15번 사이에 특정 전화번호를 찾을 수 있다.
• </aside>

더 알아보기 (요약)

• 설명
  • 처음 중간의 값을 임의의 값으로 선택하여, 그 값과 찾고자 하는 값의 크고 작음을 비교하는 방식
  • 처음 선택한 중앙값이 만약 찾는 값보다 크면 그 값은 새로운 최댓값이 되며, 작으면 그 값은 새로운 최솟값이 된다.
• 장점
  • 검색이 반복될 때마다 목표값을 찾을 확률은 두 배가 되므로 속도가 빠르다.
• 단점
  • 검색 원리상 정렬된 리스트에만 사용할 수 있다.
• 의사코드

BinarySearch(A[0..N-1], value, low, high) {
  **if** (high < low)
    **return** -1 *// not found*  
	mid = (low + high) / 2
  **if** (A[mid] > value)
    **return** BinarySearch(A, value, low, mid-1)
  **else** **if** (A[mid] < value)
    **return** BinarySearch(A, value, mid+1, high)
  **else**
    **return** mid *// found*
}

• high와 low를 지정

binarySearch(A[0..N-1], value) {*//k*  
	low = 0
  high = N - 1
  **while** (low <= high) {
      mid = (low + high) / 2
      **if** (A[mid] > value)
          high = mid - 1
      **else** **if** (A[mid] < value)
          low = mid + 1
      **else** 
          **return** mid *// found k*  
	}
  **return** -1 *// not found k*
}

분할 정복(Divide and conquer)

• 그대로 해결할 수 없는 문제를 작은 문제로 분할하여 문제를 해결하는 방법
• 예) 퀵정렬 (quick sort), 병합 정렬 (merge sort), 고속 푸리어 변환 (FFT) 문제 등
• 대표적인 사례: 하노이의 탑

장점

• 어려운 문제를 간단하게 해결할 수 있다.

단점

• 스택에 많은 데이터를 담고 있어 스택 오버플로가 발생하거나 메모리를 과하게 사용하게 된다.
• 재귀적으로 많은 함수호출이 이루어지면 오버헤드가 발생할 수 있다.
• 문제를 쪼개는 방법 자체가 상당히 어려울 수 있다.

재귀함수로의 표현

function F(x):
  if F(x)의 문제가 간단 then:
    return F(x)을 직접 계산한 값
  else:
    x를 y1, y2로 분할
    F(y1)과 F(y2)를 호출
    return F(y1), F(y2)로부터 F(x)를 구한 값

빠른 실행이나 문제 해결 순서 선택을 위해, 재귀호출을 사용하지 않고 스택, 큐 등의 자료구조로 분할 정복법을 구현할 수 있다.

참고자료

• Branch and Bound - Binary Search
• 이진 검색 알고리즘
• 분할 정복 알고리즘
• 분할 정복

문제 설명

1와 0로 채워진 표(board)가 있습니다. 표 1칸은 1 x 1 의 정사각형으로 이루어져 있습니다. 표에서 1로 이루어진 가장 큰 정사각형을 찾아 넓이를 return 하는 solution 함수를 완성해 주세요. (단, 정사각형이란 축에 평행한 정사각형을 말합니다.)

예를 들어

1 2 3 4

가 있다면 가장 큰 정사각형은

1 2 3 4

가 되며 넓이는 9가 되므로 9를 반환해 주면 됩니다.

제한사항

• 표(board)는 2차원 배열로 주어집니다.
• 표(board)의 행(row)의 크기 : 1,000 이하의 자연수
• 표(board)의 열(column)의 크기 : 1,000 이하의 자연수
• 표(board)의 값은 1또는 0으로만 이루어져 있습니다.

입출력 예

board answer

입출력 예 설명

입출력 예 #1

위의 예시와 같습니다.

입출력 예 #2

| 0 | 0 | 1 | 1 |

| 1 | 1 | 1 | 1 |

로 가장 큰 정사각형의 넓이는 4가 되므로 4를 return합니다.

package LV2;

public class H12905 {
    public int solution(int [][]board)
    {
        // 최소 크기가 1인 정사각형을 찾기 위한 초기값 설정
        int answer = 0;

        // 행과 열의 크기를 저장
        int row = board.length;
        int col = board[0].length;

        // 만약 행 또는 열의 크기가 1이라면 가장 큰 정사각형의 크기는 board의 최대값이 된다.
        if(row < 2 || col < 2){
            for(int i=0; i<row; i++)
                for(int j=0; j<col; j++)
                    // 만약 1을 찾았다면, 그 자체가 가장 큰 정사각형이므로 1을 반환한다.
                    if(board[i][j] == 1)
                        return 1;
        }

        // 동적 프로그래밍을 이용하여 각 위치에서 만들 수 있는 최대 정사각형의 한 변의 길이를 구한다.
        for(int i=1; i<row; i++){
            for(int j=1; j<col; j++){
                /* 현재 위치의 값이 1이고,
                 * 현재 위치를 오른쪽 하단 모서리로 하는 정사각형이 만들어질 수 있다면
                 * (왼쪽, 위쪽, 왼쪽 위 대각선 위치 중 최소값 + 1)을 현재 위치에 저장한다. */
                if(board[i][j] == 1){
                    board[i][j] = Math.min(board[i-1][j], Math.min(board[i][j-1], board[i-1][j-1])) + 1;
                    // 가장 큰 정사각형 한 변의 길이를 갱신한다.
                    answer = Math.max(answer, board[i][j]);
                }
            }
        }
        // 가장 큰 정사각형의 넓이를 반환한다.
        return answer*answer;
    }
}

동적 프로그래밍 (Dynamic Programming, DP)을 이용해 문제를 해결한다.

각 위치에서 만들 수 있는 정사각형의 한 변의 최대 길이를 저장하여, 가장 큰 정사각형을 찾아 그의 넓이를 반환한다.

한 위치에서 만들 수 있는 정사각형의 한 변의 길이는 해당 위치의 왼쪽, 위, 왼쪽 위 대각선 위치 중 최소값 + 1로 구할 수 있다.

이 과정을 반복하여 가장 큰 정사각형을 찾는다.

문제 설명

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

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

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

package LV2;

public class H178870 {
    public int[] solution(int[] sequence, int k) {
        int[] answer = new int[2];  // 정답을 담을 배열
        int start = 0;  // 부분 수열의 시작 인덱스
        int end = 0;  // 부분 수열의 끝 인덱스
        int sum = 0;  // 현재 부분 수열의 합
        int min_length = Integer.MAX_VALUE;  // 최소 길이 저장 (최소 길이부터 시작하여 값이 작아지면 갱신)

        while (end < sequence.length) {  // 배열의 끝에 도달할 때까지 반복
            sum += sequence[end++];  // 끝 인덱스의 값을 합에 더하고 끝 인덱스를 한 칸 이동

            while (sum >= k) {  // 부분 수열의 합이 k 이상일 동안 반복
                if (sum == k && end - start < min_length) {  // 합이 k와 같고, 현재 길이가 최소 길이보다 작으면
                    min_length = end - start;  // 최소 길이 갱신
                    answer[0] = start;  // 시작 인덱스 저장
                    answer[1] = end - 1;  // 끝 인덱스 저장 (end는 이미 한 칸 이동했으므로 -1)
                }
                sum -= sequence[start++];  // 시작 인덱스의 값을 합에서 빼고 시작 인덱스를 한 칸 이동
            }
        }

        return answer;  // 시작 인덱스와 끝 인덱스가 저장된 배열 반환
    }
}

부분 수열의 합이 k와 같은 모든 부분 수열 중에서 가장 짧은 것을 찾는 문제를 해결한다.

부분 수열의 시작과 끝 인덱스를 각각 start와 end로 설정하고, 이들을 움직여가며 부분 수열의 합을 구해 나간다.

합이 k 이상이 되면 시작 인덱스를 이동하면서 합에서 그 값을 뺀다.

이 과정에서 합이 k와 같고 부분 수열의 길이가 현재 최소 길이보다 작으면 그 값을 갱신하고 해당 인덱스를 저장한다.