[๋ฐฑ์ค] ๐ง 1071 ์ํธ
๐ ๋์ด๋
๐ง Platinum 5
๐ ๋ฌธ์ 
https://www.acmicpc.net/problem/1071


๐ ํ์ด
์ฝ๋ฉ ํ ์คํธ ๊ณต๋ถ๋ฅผ ํ๋ฉด์ ์ฌ์ฌ ์ฌ๋ฌ๊ฐ์ง ์๊ณ ๋ฆฌ์ฆ์ ๋ํด์ ๊ฐ์ด ์กํ๊ธฐ ์์ํ๊ณ , ๊ณจ๋๊ฐ ํ๋ฆฌ๊ธฐ ์์ํด์ ๊ธฐ๋ ๋น์ ์ธ ๋๋์ผ๋ก ํ๋ ํฐ๋ ๋ฌธ์ ๋ฅผ ๋์ ํด๋ณด์๋ค.
์ฒ์ ์ด ๋ฌธ์ ๋ฅผ ๋ณด์๋ง์ ํ ์๊ฐ์ ์ผ๋จ ์ ๋ ฌ์ ํด๋ณด์๋ผ๋ ์๊ฐ์ด์๋ค.
๊ทธ๋์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ณ์ฐํด๋ณด๋ ๋จ์ํ๊ฒ Arrays.sort ๋ฅผ ์ฌ์ฉํด๋ o(n^2) = 1์ต โ 1์ด๋ผ ์ ๋ ฌ์ ํ๊ณ  ์์ํ๋ค.
๊ทธ๋ฆฌ๊ณ  n๊ฐ์ ์ซ์๊ฐ ๋ค์ด์ค๋ฉด nํฌ๊ธฐ์ ๋ฐฐ์ด์ ๋ง๋ค์ด์ ์์ ์์๋๋ก ์ซ์๋ฅผ ์ฑ์๋ฃ์๋ค.
์ด๋ ๋ค์์ผ๋ก ๋ค์ด์ค๋ ์ซ์๊ฐ ์ด์  ๊ฐ+1์ด๋ผ๋ฉด int index๋ผ๋ ๋ณ์์ ๊ทธ ์ฃผ์๊ฐ์ ์ง์ด๋ฃ์ํ, ๊ทธ ๋ค์ ์์น์ ์ซ์๋ฅผ ์ง์ด๋ฃ์๋ค.
๊ทธ๋ฆฌ๊ณ  index๋ ๊ธฐ๋ณธ์ ์ผ๋ก final int notExist = 10001 ๋ผ๋ ์์๋ฅผ ๋ง๋ค์ด์ ์ด๊ธฐํ๋ฅผ ํด์ฃผ์๋๋ฐ, ๋ง์ฝ ์ซ์๋ฅผ ๋ฃ๊ธฐ ์ ์ index ๊ฐ์ด notExist๊ฐ ์๋๋ผ๋ฉด index ์ด์  ์ฃผ์์ ์๋ ๊ฐ๊ณผ ๋น๊ตํด์ ์ด์  ์ฃผ์์ ๊ฐ + 1 ์ด ์๋๋ผ๋ฉด ๋ฃ์ผ๋ฉด์ index ๋ฅผ notExist ๋ก ์ด๊ธฐํํด์ฃผ๊ณ , ๊ฐ์์ ๋ค์ ์ถ๊ฐ๋ก ๋ฃ์ด์ฃผ์๋ค.
๋ฐ๋ผ์ ๋ค์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ์ ์์ ์ผ๋ก ์๋ํ์๋ค.

ํ์ง๋ง ์ด๋ฐ์์ ํ์ด์๋ ์์ง ํ๊ฐ์ง ๋ฐ๋ก๊ฐ ๋จ์์์๋ค.
๊ทธ ๋ฐ๋ก๋ ๋ฐ๋ก ๋ค์๊ณผ ๊ฐ์ด index์ ๊ฐ์ด ์ฑ์์ง์ง ์์ ์ํ๋ก ์ข
๋ฃ๋๋ ๊ฒ์ด์๋ค.

์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ์ฌ ๋ง์ฝ index != notExist ์ด๋ฉด ๊ฐ์ฅ ์ฒ์๋ถํฐ ๋ง์ง๋ง ์ฃผ์์ ์ซ์ - 1 ๊ฐ ๋์ค๋ ์ฃผ์๊ฐ์ ์ฐพ์์ index์ ๋นผ์ฃผ๊ณ , ๊ทธ ์ฃผ์๊ฐ๋ถํฐ i๊น์ง ๋ง์ง๋ง ์ฃผ์์ ์ซ์๋ฅผ ๋ฃ์ด์ฃผ๊ณ , index๋ถํฐ๋ ๊ทธ ์ซ์์ -1๋ฅผ ํ๊ฐ์ ๋๊น์ง ๋ฃ์ด์ฃผ์๋ค.
์ดํ ์ถ๋ ฅ์ ๋ง์ง๋ง ์ฃผ์ - 1 ๊น์ง ์ถ๋ ฅํ๋ ๋ต์ด ๋์๋ค.
ํ๋ ํฐ๋ ๋ฌธ์ ๋ฅผ ํ๊ณ ๋๋ ์ ์ ์๊ฐ๋ณด๋ค ๊ทธ๋ ๊ฒ ์ด๋ ต์ง๋ ์๊ณ , ์ ๋๋ก ์๊ณ ๋ฆฌ์ฆ์ ํ์ ํ ํ ํ๋ฉด ์๊ฐ๋ณด๋ค ์ฝ๊ฒ ํ๋ฆฐ๋ค๋ ๊ฒ์ด์๋ค.
์ฒ์์ผ๋ก ํ์ด๋ณธ ํ๋ ํฐ๋ ๋ฌธ์ ์ฌ์ ํ๋ณตํ๋ค. ๐
๐ Code
package BOJ.Greedy;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
public class N1071 {
    static int[] input;
    static int[] output;
    static final int notExist = 10001;
    static int N;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        N = Integer.parseInt(br.readLine());
        st = new StringTokenizer(br.readLine());
        input = new int[N];
        output = new int[N + 1];
        Arrays.fill(output, notExist);
        for (int i = 0; i < N; i++) {
            input[i] = Integer.parseInt(st.nextToken());
        }
        Arrays.sort(input);
        SortDict();
    }
    static void SortDict() {
        int index = notExist;
        int curindex = 0;
        if (N != 0) {
            output[curindex++] = input[0];
        }
        for (int i = 1; i < N; i++) {
            if (index == notExist) {
                if (output[curindex - 1] + 1 != input[i]) {
                    output[curindex] = input[i];
                    curindex++;
                } else {
                    index = curindex++;
                    output[curindex++] = input[i];
                }
            } else {
                if (output[index - 1] + 1 != input[i]) {
                    output[index] = input[i];
                    index = notExist;
                } else {
                    output[curindex++] = input[i];
                }
            }
        }
        if (index != notExist) {
            int flag = index - 1;
            while (flag >= 0 && output[flag] + 1 == output[N]) {
                flag--;
            }
            flag++;
            int count = index - flag;
            for (int i = index + 1; i < N + 1; i++) {
                output[flag++] = output[N];
            }
            for (int i = 0; i < count; i++) {
                output[flag++] = output[N] - 1;
            }
        }
        ShowAll();
    }
    static void ShowAll() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < N; i++) {
            sb.append(output[i] + " ");
        }
        System.out.println(sb);
    }
    static void ShowTest() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < N + 1; i++) {
            if (output[i] == notExist) {
                sb.append(". ");
            } else {
                sb.append(output[i] + " ");
            }
        }
        System.out.println(sb);
    }
}
package (์ด๋ฆ); ๋ฅผ ๋๊ณ , class ์ด๋ฆ์ Main์ผ๋ก ๋ณ๊ฒฝํ๋ฉด ๋๋ค.
๊ฐ์ธ ๊ณต๋ถ ๊ธฐ๋ก์ฉ ๋ธ๋ก๊ทธ์
๋๋ค.
ํ๋ฆฌ๊ฑฐ๋ ์ค๋ฅ๊ฐ ์์ ๊ฒฝ์ฐ ์ ๋ณดํด์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค.๐