https://www.acmicpc.net/problem/1946
ํ๋ฆฐ ์ฝ๋
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int T = scan.nextInt();
for(int tc=0; tc<T; tc++) {
int N = scan.nextInt(); // ์ง์์ ์ซ์
int[][] arr = new int[N][2]; // ๊ฐ ์ง์์์ ์๋ฅ, ๋ฉด์ ์ฑ์
int count = N; // ์ ๋ฐํ ์ ์๋ ์ ์
์ฌ์์ ์ต๋ ์ธ์์
for(int i=0; i<N; i++) {
arr[i][0] = scan.nextInt();
arr[i][1] = scan.nextInt();
}
// ์ง์์ ๋ณ๋ก ์๋ฅ or ๋ฉด์ ์ฌ์ฌ ํ๋จํ๊ธฐ
for(int i=0; i<N; i++) {
boolean docu = true; // ์๋ฅ์ฌ์ฌ ํ๋จ
boolean pt = true; // ๋ฉด์ ์ฌ์ฌ ํ๋จ
for(int j=0; j<N; j++) { // ์๋ฅ์ฌ์ฌ ์ฑ์ ํ๋จ
if(arr[i][0] < arr[j][0]) { // ์์ ๋ณด๋ค ์๋ฅ ์ฑ์ ์ด ๋จ์ด์ง๋ ์ธ์์ด ์์๊ฒฝ์ฐ(์ซ์๊ฐ ๋ ํด๊ฒฝ์ฐ)
docu = false;
break;
}
}
for(int j=0; j<N; j++) { // ๋ฉด์ ์ฌ์ฌ ์ฑ์ ํ๋จ
if(arr[i][1] < arr[j][1]) { // ์์ ๋ณด๋ค ๋ฉด์ ์ฑ์ ์ด ๋จ์ด์ง๋ ์ธ์์ด ์์๊ฒฝ์ฐ(์ซ์๊ฐ ๋ ํด๊ฒฝ์ฐ)
pt = false;
break;
}
}
// ์๋ฅ, ๋ฉด์ ์ฑ์ ๋ชจ๋ ์์ ๋ณด๋ค ๋จ์ด์ง๋ ์ธ์์ด ์์๊ฒฝ์ฐ => ์ ๋ฐ X
if(docu == true && pt == true) {
count --;
}
}
System.out.println(count);
}
scan.close();
}
}
ํ์ด
๋ฌธ์ ๋ฅผ ์ดํดํ๋๋ฐ์๋ ์ค๋๊ฑธ๋ ธ๋ค... ์ ๋ ฅ๋ฐ๋๊ฒ ์ ์๊ฐ ์๋ ์์ ๋ฑ์์ด๋ค.
๋ฐ๋ผ์ ์ ๋ ฅ์ด 1, 5๊ฐ ์๋ค๋ฉด 5๊ฐ ์๋ 1์ด ๋ ๋์ ์ฑ์ ์ด๋ค.(์์)
๋ฌธ์ ์์ ์ง์์ A์ ๋ค๋ฅธ ๋ชจ๋ ์ง์์ B์ ์๋ฅ์ฌ์ฌ ์ฑ์ ๊ณผ ๋ฉด์ ์ํ ์ฑ์ ์ ๋น๊ตํ์๋, ์ฑ์ ์ค ์ ์ด๋ ํ๋๊ฐ ๋ค๋ฅธ ์ง์์๋ณด๋ค ๋จ์ด์ง์ง ์์์ผ ์ ๋ฐ์ ํ๋ค. ์ง์์๊ฐ 5๋ช ์ธ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ค์ด๋ณด์.
A: 3 2
B: 1 4
C: 4 1
D: 2 3
E: 5 5
A, B, C, D, E 5๋ช ์ ์ง์์๊ฐ ์๊ณ , ์๋ฅ์ ๋ฉด์ ์ฑ์ ์ด ์์ ๊ฐ์๋, ์์์ ์ง์์ E๋ ๊ฒฐ์ฝ ์ ๋ฐ๋์ง ์๋๋ค.
์ซ์๊ฐ ๋ฑ์๋ฅผ ์๋ฏธํ๋ฏ๋ก, E์ ์๋ฅ ์ฑ์ ๊ณผ ๋ฉด์ ์ฑ์ ์ ๋ค๋ฅธ ์ง์์๋ค์ ๋นํด ๋ชจ๋ ๋จ์ด์ง๋ค.
์ง์์๊ฐ 7๋ช ์ธ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ค์ด๋ณด๋ฉด,,
A: 3 6
B: 7 3
C: 4 2
D: 1 4
E: 5 7
F: 2 5
G: 6 1
์์ ๊ฐ์ด ์์๋,
์ง์์ A๋ ์ง์์ D์ ๋น๊ตํ์ ๋, ์๋ฅ์ฑ์ ๊ณผ ๋ฉด์ ์ฑ์ ์ด ๋ชจ๋ ๋จ์ด์ง๋ฏ๋ก ์ ๋ฐ์ ํ ์ ์๋ค.
์ง์์ B๋ ์ง์์ C์ ๋น๊ตํ์ ๋, ์๋ฅ์ฑ์ ๊ณผ ๋ฉด์ ์ฑ์ ์ด ๋ชจ๋ ๋จ์ด์ง๋ฏ๋ก ์ ๋ฐ์ ํ ์ ์๋ค.
์ง์์ E๋ ์ง์์ D์ ๋น๊ตํ์ ๋, ์๋ฅ์ฑ์ ๊ณผ ๋ฉด์ ์ฑ์ ์ด ๋ชจ๋ ๋จ์ด์ง๋ฏ๋ก ์ ๋ฐ์ ํ ์ ์๋ค.
์ง์์ F๋ ์ง์์ D์ ๋น๊ตํ์ ๋, ์๋ฅ์ฑ์ ๊ณผ ๋ฉด์ ์ฑ์ ์ด ๋ชจ๋ ๋จ์ด์ง๋ฏ๋ก ์ ๋ฐ์ ํ ์ ์๋ค.
๋ฐ๋ผ์ ์ ๋ฐ ํ ์ ์๋ ์ธ์์ C, D, G 3๋ช ์ ์ง์์์ด๋ค.
์ ์ฝ๋์์๋, ์๋ฅ ์ฑ์ ๊ณผ ๋ฉด์ ์ฑ์ ์ ๋ฐ๋ก๋ฐ๋ก ๋น๊ตํ๊ณ , ๋น๊ต ์กฐ๊ฑด๋ ํ๋ ธ๋ค.
ํ๋ฆฐ ์ฝ๋2
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int T = scan.nextInt();
for(int tc=0; tc<T; tc++) {
int N = scan.nextInt(); // ์ง์์ ์ซ์
int[][] arr = new int[N][2]; // ๊ฐ ์ง์์์ ์๋ฅ, ๋ฉด์ ์ฑ์
int count = N; // ์ ๋ฐํ ์ ์๋ ์ ์
์ฌ์์ ์ต๋ ์ธ์์
for(int i=0; i<N; i++) {
arr[i][0] = scan.nextInt();
arr[i][1] = scan.nextInt();
}
// ์ง์์ ๋ณ๋ก ์๋ฅ, ๋ฉด์ ์ฑ์ ๋น๊ต
for(int i=0; i<N; i++) {
boolean flag = true;
for(int j=0; j<N; j++) {
// ์ง์์ A์ ์ฑ์ ์ด ๋ค๋ฅธ ์ด๋ค ์ง์์ B์ ์ฑ์ ์ ๋นํด ์๋ฅ, ๋ฉด์ ์ฑ์ ์ด ๋ชจ๋ ๋จ์ด์ง๋
// ์ซ์๊ฐ ํฐ๊ฒ ๋ฑ์๊ฐ ๋ฎ์.
if(arr[i][0] > arr[j][0] && arr[i][1] > arr[j][1]) {
flag = false;
break;
}
}
// ์๋ฅ, ๋ฉด์ ์ฑ์ ๋ชจ๋ ์์ ๋ณด๋ค ๋จ์ด์ง๋ ์ธ์์ด ์์๊ฒฝ์ฐ => ์ ๋ฐ X
if(!flag)
count --;
}
System.out.println(count);
}
scan.close();
}
}
์ ์ฝ๋๋ ์ง์์๋ค ๋ผ๋ฆฌ ๋น๊ต๋ฅผ ํด์, ๋ง์ฝ ์ง์์ A๊ฐ ์์์ ์ง์์๋ณด๋ค ์๋ฅ ์ฑ์ , ๋ฉด์ ์ฑ์ ์ด ๋ชจ๋ ๋จ์ด์ง๊ฒฝ์ฐ
// ์ง์์ A์ ์ฑ์ ์ด ๋ค๋ฅธ ์ด๋ค ์ง์์ B์ ์ฑ์ ์ ๋นํด ์๋ฅ, ๋ฉด์ ์ฑ์ ์ด ๋ชจ๋ ๋จ์ด์ง๋
// ์ซ์๊ฐ ํฐ๊ฒ ๋ฑ์๊ฐ ๋ฎ์.
if(arr[i][0] > arr[j][0] && arr[i][1] > arr[j][1]) {
flag = false;
break;
}
์ ๋ฐ๋ ์ ์์ผ๋ฏ๋ก count--๋ฅผ ํด์ฃผ์๋๋ฐ ...
์๊ฐ ์ด๊ณผ๊ฐ ๋ฐ์ํ๋ค ...
์ง์์์ ์ซ์๊ฐ ์ต๋ 100,000๋ช ์ด๋ฏ๋ก ๋ชจ๋ ์ง์์์๋ฅผ ๋น๊ตํ๊ธฐ์ ์๊ฐ์ด๊ณผ๊ฐ ๋ฐ์ํ๋ค ..
์ต์ข ์ฝ๋
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int T = scan.nextInt();
for(int tc=0; tc<T; tc++) {
int N = scan.nextInt(); // ์ง์์ ์ซ์
int[][] arr = new int[N][2]; // ๊ฐ ์ง์์์ ์๋ฅ, ๋ฉด์ ์ฑ์
int count = 1; // ์ ๋ ฌ์ ์ฒซ ๋ฒ์งธ ์ฌ๋์ ์๋ ์ฑ์ฉ
for(int i=0; i<N; i++) {
arr[i][0] = scan.nextInt();
arr[i][1] = scan.nextInt();
}
// ์ ๋ ฌ - Comparator
Arrays.sort(arr, new Comparator<int[]>() {
@Override
public int compare(int[] arr1, int[] arr2) { // ์๋ฅ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ ์ํํ๋ค.
return Integer.compare(arr1[0], arr2[0]);
}
});
int pivot = arr[0][1]; // ์ฒซ ๋ฒ์งธ ์ง์์์ ๋ฉด์ ์ฑ์ ์ด ๊ธฐ์ค์ด ๋๋ค.
for(int i=1; i<N; i++) {
if(arr[i][1] < pivot) { // ๋ฉด์ ์ฑ์ ์ด ๊ทธ ์ ์ ๋ฐ๋ ์ง์์ ๋ณด๋ค ๋ฐ์ด๋ ๊ฒฝ์ฐ => ์ ๋ฐ
pivot = arr[i][1]; // ๋ค์ ํฉ๊ฒฉ์๋ฅผ ํ๋ณํ๊ธฐ ์ํด ์ ์ ์ ๋ฐ๋ ์ง์์์ ๋ฉด์ ์ฑ์ ์ ์ฅ
count ++;
}
}
System.out.println(count);
}
scan.close();
}
}
ํ์ด
๋ฌธ์ ์์ ๋์์ฐจ ์์ด ๊ฒฐ์ ๋๋ค๊ณ ๊ฐ์ ํด์ ํ ์ฑ์ ์ ์ ๋ ฌ์ ํ๊ณ , ๋๋จธ์ง ์ฑ์ ์ผ๋ก ๋น๊ต๋ฅผ ํด์ผ ํ ๊ฒ ๊ฐ๋ค๋ ์๊ฐ์ ๋ค์์ง๋ง,, ๊ฒฐ๊ตญ ํด๊ฒฐ์ ๋ชปํ๋ค.
์ ํ์ด๋ ์ง์์์ ์๋ฅ ์์์ ๋ฉด์ ์์์ค ์๋ฅ ์์๋ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ์ ํ๊ณ , ๋ฉด์ ์์๋ก ์ง์์๊ฐ ์ ๋ฐ์ด ๋ ์ ์๋์ง ์๋์ง ํ๋จํ๋ค.
N = 7 ์ ๊ธฐ์ค์ผ๋ก ์๋ฅผ ๋ค๋ฉด์ ๋ณด์.
์ ๊ทธ๋ฆผ์ ๋ณด๋ฉด, ์๋ฅ ์์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์์ ์ ๋ ฌํ๋ค.
์ฒซ ๋ฒ์งธ ์ง์์์ ๊ฒฝ์ฐ ์๋ฅ ์์๋ก 1์์ด๊ธฐ ๋๋ฌธ์, ๋ฌด์กฐ๊ฑด ์ ๋ฐ์ด ๋๋ค.
๋ฐ๋ผ์ ๋ ๋ฒ์งธ ์ง์์๋ถํฐ ๋น๊ต๋ฅผ ํด์ฃผ๋ฉด ๋๋ค.
์ด ๋, ์๋ฅ ์์์ ๊ฒฝ์ฐ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ด๋ฏ๋ก, ์๋๋ก ๊ฐ์๋ก ๋ฐ๋ฆฌ๊ฒ(๋จ์ด์ง๊ฒ) ๋๋ค.
๋ฐ๋ผ์ ๋น๊ต๋ฅผ ์งํํ ๋, ๊ฐ์ฅ ์ต๊ทผ ์ฑ์ฉ๋ ์ง์์์ ๋ฉด์ ์์๋ณด๋ค ๋์ ์ง์์๋ฅผ ์ฐพ์์ผ ํ๋ค.
๋ ๋ฒ์งธ ์ง์์์ ๊ฒฝ์ฐ, ์ฒซ ๋ฒ์งธ ์ง์์๋ณด๋ค ์๋ฅ ์์๋ ๋จ์ด์ง๊ณ ๋ฉด์ ์์๋ ๋จ์ด์ง๋ค. ๋ฐ๋ผ์ ์ ๋ฐ X
์ธ ๋ฒ์งธ ์ง์์์ ๊ฒฝ์ฐ ๋ง์ฐฌ๊ฐ์ง ๋ ๋ค ๋จ์ด์ง๋ฏ๋ก ์ ๋ฐ X
๋ค ๋ฒ์งธ ์ง์์์ ๊ฒฝ์ฐ, ์๋ฅ ์์๋ ๋จ์ด์ง๋ ๋ฉด์ ์์์์ ์ฑ์ ์ด ๋์ผ๋ฏ๋ก ์ ๋ฐ์ด ๋๋ค.
๋ค์ฏ๋ฒ์งธ ์ง์์์ ๊ฒฝ์ฐ, ๋ฉด์ ์์๊ฐ ๊ผด์ฐ์ด๋ฏ๋ก ๋น์ฐํ ์ ๋ฐ X
์ฌ์ฏ๋ฒ์งธ ์ง์์์ ๊ฒฝ์ฐ, ๋ฉด์ ์์๊ฐ 1์์ด๋ฏ๋ก ์ ๋ฐ์ด ๋๋ค.
๋ง์ง๋ง ์ง์์์ ๊ฒฝ์ฐ, ๋ฉด์ ์์์์ ์ด์ ์ ์ฑ์ฉ๋ ๋ค ๋ฒ์งธ, ์ฌ์ฏ๋ฒ์งธ ์ง์์๋ณด๋ค ๋จ์ด์ง๋ฏ๋ก ์ ๋ฐ X
๋ฐ๋ผ์ ์ด ์ฑ์ฉ์๋ 3๋ช ์ด๋ค.
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค] 1543๋ฒ: ๋ฌธ์ ๊ฒ์(๊ทธ๋ฆฌ๋, ์์ ํ์) (0) | 2020.02.03 |
---|---|
[๋ฐฑ์ค] 2399๋ฒ: ๊ฑฐ๋ฆฌ์ ํฉ (0) | 2020.01.29 |
[๋ฐฑ์ค] 2903๋ฒ: ์ค์ ์ด๋ ์๊ณ ๋ฆฌ์ฆ (0) | 2020.01.29 |
[๋ฐฑ์ค] 1080๋ฒ: ํ๋ ฌ(๊ทธ๋ฆฌ๋) (0) | 2020.01.28 |
[๋ฐฑ์ค] 2745๋ฒ: ์ง๋ฒ ๋ณํ (0) | 2020.01.28 |
๋๊ธ