1. ๋ฌธ์ ์ค๋ช
2. ์ ๊ทผ ๋ฐฉ์
ํด๋น ์ ๋ ฅ ๊ฐ๋ค๋ก ์ค๋ฆ์ฐจ์ ๋ฒ๋ธ ์ ๋ ฌ์ ํ์ ๋, ๊ณผ์ฐ ์ธ๊ณฝ Loop ๋ช ๋ฒ๋ง์ ์ ๋ ฌ์ด ์์ฑ๋ ์ง ํ์๋ฅผ ์ถ๋ ฅํ๋ ๋ฌธ์ ์ด๋ค. ํด๋น ๋ฌธ์ ๋ฅผ ๋ฒ๋ธ ์ ๋ ฌ๋ฅผ ์ง์ ๊ตฌํํด์ ํผ๋ค๋ฉด, ๋ฐ์ดํฐ ํฌ๊ธฐ๊ฐ 500,000 ์ด๋ฏ๋ก, 10^10์ด ๋์ด ์๊ฐ์ด๊ณผ๊ฐ ๋ ๊ฒ์ด๋ค. ๋ฐ๋ผ์ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ์๊ฐํด์ผ ํ๋ค.
๊ฐ์ด ์ค๋ฅธ์ชฝ์์ ์ผ์ชฝ์ผ๋ก ์ด๋ํ๋ ๊ฒ์ ์ธ๊ณฝ Loop ํ ๋ฒ๋น ์ต๋ ํ ๋ฒ ์ผ์ด๋๋ค.
์ฐ๋ฆฌ๋ ํ์ฌ ์กฐํ ์ค์ธ ์์์ ์ค๋ฅธ์ชฝํธ ์์๋ฅผ ๋น๊ตํด์ ์ผ์ชฝ์ด ๋ ํฌ๋ฉด ์๋ฆฌ๋ฅผ ๋ฐ๊พผ๋ค. ๋ฐ๋ผ์ ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ ์ด๋์ ํ๋ฒ์ ์ธ๊ณฝ Loop ๋น N๋ฒ์ด ์ผ์ด๋ ์ ์์ง๋ง, ์ค๋ฅธ์ชฝ์์ ์ผ์ชฝ ์ด๋์ ํ ๋ฒ์ ์ธ๊ณฝ Loop ๋น ์ต๋ 1๋ฒ์ด ์ผ์ด๋๋ค. ์ด๊ฒ์ ์ด์ฉํด์ ๋ฌธ์ ๋ฅผ ํ๋ฉด ๋๋ค.
์ ์ผ ๋ง์ด ์ค๋ฅธ์ชฝ์์ ์ผ์ชฝ์ผ๋ก ์ด๋ํ ํ์๋งํผ, ์ธ๊ณฝ Loop๊ฐ ๋์๋ค๋ ๊ฒ์ด๊ณ ์ด๊ฒ์ ์ถ๋ ฅํ๋ฉด ๋๋ค.
- Node ํด๋์ค๋ฅผ ๋ง๋ค์ด์
์ ๋ ฌ ์ Index
์value
๋ฅผ ์ ์ฅํ๋ค. ์ด๊ฒ์ผ๋ก ๋ฐฐ์ด์ ๋ง๋ ๋ค. - Arrays.sort()๋ ์๊ฐ๋ณต์ก๋๊ฐ O(nlogn)์ด๊ธฐ ๋๋ฌธ์ ์ด๋ฅผ ์ด์ฉํ์ฌ ๋ฐฐ์ด์ ์ ๋ ฌํ๋ค.
์ ๋ ฌ ์ Index
-์ ๋ ฌ ํ Index
๋ก ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋ํ ํ์๋ฅผ ๊ตฌํ๋ค.- ์ ๋ ฌ์ด ์๋ฃ๋ ์ดํ์๋ ๋ฒ๋ธ ์ ๋ ฌ์ ์ ๋ถ ์ ๋ ฌ ๋์๋์ง ํ์ธ์ ์ํด ์ธ๊ณฝ Loop๊ฐ ํ ๋ฒ ๋ ๋์์ผ ํ๋ค ๋ฐ๋ผ์
์ต๋๋ก ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ ์ด๋ ํ์
+1 ์ ํด์ค์ผ ํ๋ค.
3. ์ฝ๋ ๋ถ์
import java.io.*;
import java.util.Arrays;
import java.util.Comparator;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int N = Integer.parseInt(br.readLine());
Node [] nodes = new Node[N];
for (int i = 0; i < N; i++) {
Node now = new Node(i, Integer.parseInt(br.readLine()));
nodes[i] = now;
}
Arrays.sort(nodes, Comparator.comparingInt(o -> o.value));
int max = 0;
for (int i = 0; i < N; i++) {
max = Math.max(max, nodes[i].idx - i);
}
System.out.println(++max);
}
}
class Node {
int idx;
int value;
public Node(int idx, int value) {
this.idx = idx;
this.value = value;
}
}