[๋ฐฑ์ค] ๐ง 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
์ผ๋ก ๋ณ๊ฒฝํ๋ฉด ๋๋ค.
๊ฐ์ธ ๊ณต๋ถ ๊ธฐ๋ก์ฉ ๋ธ๋ก๊ทธ์
๋๋ค.
ํ๋ฆฌ๊ฑฐ๋ ์ค๋ฅ๊ฐ ์์ ๊ฒฝ์ฐ ์ ๋ณดํด์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค.๐