๋ฌธ์
18869๋ฒ: ๋ฉํฐ๋ฒ์ค โ ก
M๊ฐ์ ์ฐ์ฃผ๊ฐ ์๊ณ , ๊ฐ ์ฐ์ฃผ์๋ 1๋ถํฐ N๊น์ง ๋ฒํธ๊ฐ ๋งค๊ฒจ์ง ํ์ฑ์ด N๊ฐ ์๋ค. ํ์ฑ์ ํฌ๊ธฐ๋ฅผ ์๊ณ ์์๋, ๊ท ๋ฑํ ์ฐ์ฃผ์ ์์ด ๋ช ๊ฐ์ธ์ง ๊ตฌํด๋ณด๋ ค๊ณ ํ๋ค. ๊ตฌ์ฑ์ด ๊ฐ์๋ฐ ์์๋ง ๋ค๋ฅธ ์ฐ์ฃผ์ ์
www.acmicpc.net
ํ์ด
์ ๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด์๋ ์ขํ ์์ถ์ ์ฌ์ฉํด์ผํ๋ค.
์ขํ ์์ถ์ ๋ํ ๋ฌธ์ ๋ฅผ ํ๋ ํ์ด๋ณด๋ฉด ์ข๋ค.
18870๋ฒ: ์ขํ ์์ถ
์์ง์ ์์ N๊ฐ์ ์ขํ X1, X2, ..., XN์ด ์๋ค. ์ด ์ขํ์ ์ขํ ์์ถ์ ์ ์ฉํ๋ ค๊ณ ํ๋ค. Xi๋ฅผ ์ขํ ์์ถํ ๊ฒฐ๊ณผ X'i์ ๊ฐ์ Xi > Xj๋ฅผ ๋ง์กฑํ๋ ์๋ก ๋ค๋ฅธ ์ขํ Xj์ ๊ฐ์์ ๊ฐ์์ผ ํ๋ค. X1, X2, ..., XN์
www.acmicpc.net
์ขํ ์์ถ์ ํ๋ฉด ์๋์ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์จ๋ค.
์ฆ, ํน์ ๋ฐฐ์ด์ ์์๋ง๋ค ๊ทธ ์์๋ณด๋ค ์์ ์์๊ฐ ๋ช๊ฐ์ธ์ง(์ค๋ณต์ ์ ๊ฑฐํ๊ณ )๋ฅผ ์ ์ ์๋ ๊ฒฐ๊ณผ๊ฐ ๋์จ๋ค.
1000
๋ณด๋ค ์์ ์์๋ 999
ํ ๊ฐ ์ด๋ฏ๋ก 1000
์ ํด๋นํ๋ ์์น๋ 1
๋ก ๋ณ๊ฒฝ๋๊ณ
999
๋ณด๋ค ์์ ์์๋ ์์ผ๋ฏ๋ก 999
์ ํด๋นํ๋ ์์น๋ 0
์ผ๋ก ๋ณ๊ฒฝ๋๋ค.
๐ก ์ขํ ์์ถ์ ์ด๋ ต๊ฒ ์๊ฐํ ํ์๊ฐ ์๋๊ฒ,
๋ฐฐ์ด์ ์ค๋ณต์ ์ ๊ฑฐํ๊ณ ์ ๋ ฌ์ํจ๋ค์ ์ด๋ถํ์ํด์ ์ธ๋ฑ์ค๋ฅผ ๊ตฌํ๋ฉด
๊ทธ ๊ฐ์ด ํด๋น ์์๋ณด๋ค ์์ ์์์ ๊ฐ์์์ ์ ์ ์๋ค.
๊ทธ๋ฌ๋ฉด ๋ฉํฐ๋ฒ์ค ๋ฌธ์ ์ ์์ ์ ์ ์ฉํด๋ณด์.
๊ฐ ์ฐ์ฃผ๋ฅผ ์ขํ์์ถํ ๊ฒฐ๊ณผ๋ ์์ ๊ฐ๋ค.
์ขํ ์์ถ์ ํ ๊ฒฐ๊ณผ๊ฐ ๊ฐ์ ๋, ๊ท ๋ฑํ ์ฐ์ฃผ์์ ์ฝ๊ฒ ํ์ ํ ์ ์๋ค.
๋ฐ๋ผ์, ์ฐ๋ฆฌ๊ฐ ํด์ผํ ๊ฒ์
๊ฐ ์ฐ์ฃผ๋ฅผ ์ขํ์์ถํ ๋ฐฐ์ด์ ์ ์ฅํ๊ณ , ๋ฐฐ์ด๋ผ๋ฆฌ equals()
ํ์ง ๋น๊ตํ๊ณ ๊ฐ๋ค๋ฉด ํ๋์ฉ ์นด์ดํธ ํด์ฃผ๋ฉด ๋๋ค!
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
public class Main {
int M;
int N;
int[][] spaces;
public static void main(String[] args) throws IOException {
new Main().sol();
}
private void sol() throws IOException {
setUp();
// ๊ฐ ์ฐ์ฃผ๋ฅผ ์ขํ ์์ถ์ ํ๋ค.
for (int[] space : spaces) {
compress(space);
}
System.out.println(getCnt());
}
private void setUp() throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] input = br.readLine().split(" ");
M = Integer.parseInt(input[0]);
N = Integer.parseInt(input[1]);
spaces = new int[M][N];
for (int i = 0; i < M; i++) {
input = br.readLine().split(" ");
for (int j = 0; j < N; j++) {
spaces[i][j] = Integer.parseInt(input[j]);
}
}
}
private void compress(int[] space) {
int[] cloned = space.clone();
// ์ด๋ถ ํ์์ ์ํ ์ค๋ณต ์ ๊ฑฐ์ ์ ๋ ฌ ์์
int[] arr = Arrays.stream(cloned).sorted().distinct().toArray();
for (int i = 0; i < N; i++) {
// Java ์์ ์ ๊ณตํ๋ ์ด๋ถํ์ ๋ฉ์๋๋ฅผ ์ฌ์ฉํด๋ ๋๋ค.
// space[i] = Arrays.binarySearch(arr, space[i]);
space[i] = bs(arr, space[i]);
}
}
private int bs(int[] arr, int target) {
int left = 0, right = arr.length;
while (left < right) {
int mid = (left + right) / 2;
if (target <= arr[mid]) {
right = mid;
} else {
left = mid + 1;
}
}
return left;
}
private int getCnt() {
int cnt = 0;
for (int i = 0; i < M-1; i++) {
for (int j = i+1; j < M; j++) {
if (Arrays.equals(spaces[i], spaces[j])) {
cnt++;
}
}
}
return cnt;
}
}