백준 2230 수 고르기 자바

문제는 다음과 같다.
https://www.acmicpc.net/problem/2230

풀이는 다음과 같다.

1. 투포인터

import java.io.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        //1 ≤ N ≤ 100,000 정렬가능하려나 ㅇㅇ 가능함 2초면 2억번.
        //0 ≤ M ≤ 2,000,000,000
        //0 ≤ |A[i]| ≤ 1,000,000,000 -> int 가능

        int s = 0; //같은 수일 수도 있다
        int e = 0;

        StringTokenizer st1 = new StringTokenizer(br.readLine());
        int N = Integer.parseInt(st1.nextToken());
        int M = Integer.parseInt(st1.nextToken());
        int[] arr = new int[N];
        for(int i = 0 ; i < N ; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }
        Arrays.sort(arr);
        int answer = arr[N-1] - arr[0];

        while(e < N) {
            while(e < N && arr[e] - arr[s] < M) {
                e++;
            }
            if(e >= N) break;

            if(arr[e] - arr[s] == M) {
                answer = M;
                break;
            }
            answer = Math.min(answer, arr[e] - arr[s]);
            s++;
        }

        bw.write(String.valueOf(answer));
        bw.flush();
        bw.close();

    }

}

투포인터 알고리즘을 알고 있다면, 그렇게 어렵지 않다.
s값이 고정되어있을때,
e가 arr[e] - arr[s] >= M 을 만들기 위해 달아난다.

while(e < N && arr[e] - arr[s] < M) {
                e++;
            }

달아나서 arr[e] - arr[s] >= M 값을 만족하게 된다면,
while문을 벗어나고,
다시 s는 arr[e] - arr[s] < M 을 만들기 위해 쫓는다.

s++;

이 과정에서, arr[e] - arr[s] >= M를 만족할때마다
answer = Math.min(answer, arr[e] - arr[s]); 로직으로 기록해준 후
최솟값을 찾아내면 되는것이다.

2. 이분탐색으로 풀 수 있다는데, 지금은 해당 방식에 관해서는
   lower bound 정도밖에 안떠오른다. 한번 생각하고 풀어봐야겠다.