์๋ ํ์ธ์! Eric ์ ๋๋ค!
์ค๋ ํ์ด๋ณผ ๋ฌธ์ ๋ ๋ฐฑ์ค 1946๋ฒ
์ ์ ์ฌ์ ๋ฌธ์ ์ ๋๋ค.
ํด๋น๋ฌธ์ ๋ ๊ทธ๋ฆฌ๋ ์ ํ์ผ๋ก ํ์ด๋ณด์์ต๋๋ค.

์ฐ์ ์์์์ ๋์จ ๊ฐ์ ์ ๋ ์ค๋๋ ๊ทธ๋ฆผ์ผ๋ก ๊ทธ๋ ค์ ๋ฌธ์ ๋ฅผ ํ์ด ๋ณด์์ต๋๋ค.
๊ทธ๋ฆฌ๋ ์ ํ์์ ์ฐ์ ๊ฐ๊ฐ์ test ์ผ์ด์ค๋ง๋ค
์ ๋ A๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ฆฌ๋ฅผ ์ฐ์ ํ์์ต๋๋ค. ( Comparble ์ด์ฉ)
๊ทธ๋ฌ๋ฉด B ๊ธฐ์ค์ด ์๋ค๊ฐ๋คํ๋ฉด์ ์ ๋ ฌ์ด ์๋์ด ์์ํ ๋ฐ์,
์ฌ๊ธฐ์์ ์ฐ์ A๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์์ด ๋์ด์์ผ๋ฏ๋ก,
ํ๋ํ๋ ๋ด๋ ค๊ฐ๋ฉด์ ๋ณด๋ฉด
(1 ,4) ์ (2, 3) ์ ๋น๊ตํ๋ฉด (2, 3) ์ด A๋ญํฌ์์๋ ๋น๋ก ์ง๊ณ ์์ง๋ง, B๋ญํฌ์์๋ (1, 4)์ 4 ๋ณด๋ค ๋ฑ์๊ฐ ์ข์ผ๋
cnt + ์ ํด์ฃผ์์ต๋๋ค.
๋ง์ฐฌ๊ฐ์ง๋ก
( 2 ,3 ) ๊ณผ (3, 2)๋ก ๋ด๋ ค๊ฐ์๋ B๋ญํฌ๊ฐ 2๋ก ๋ ์ข์ผ๋ฏ๋ก cnt+ ์ ํด์ฃผ์์ต๋๋ค.
์ด๋ฐ์์ผ๋ก ํ๋ฉด ์ฒซ๋ฒ์งธ ์ผ์ด์ค์์๋
(5, 5) ๋ง ํ๋ฝ!
๋๋ฒ์งธ ์ผ์ด์ค๋ฅผ ๋ณด๋ฉด
( 1, 4) ๋ ( 2 , 5) ๋ฅผ ๋น๊ตํด๋ณด๋ฉด ( 2, 5)๋ (1, 4) ๋ณด๋ค A๋ญํฌ๋ ์์ข๊ณ , B๋ญํฌ๋ ์์ข์์ ํ๋ฝ!
(3, 6) ๋ ๋ง์ฐฌ๊ฐ์ง ์ด์ ๋ก ํ๋ฝ!
๋ฐ๋ฉด์, (1, 4)์ (4, 2)๋ B๋ญํฌ์์ ๋ ์ข์ ์ ์ ์ด๋ฏ๋ก ํฉ๊ฒฉ cnt+
์ด๋ฐ์์ผ๋ก ์ฝ๋๋ฅผ ์์ฑํด๋ณด๋ฉด..!

์ฝ๋
์ฝ๋๋ก ๊ตฌํํด๋ณด๋ฉด..!
import java.io.BufferedReader; | |
import java.io.IOException; | |
import java.io.InputStreamReader; | |
import java.util.ArrayList; | |
import java.util.Arrays; | |
import java.util.Collections; | |
import java.util.StringTokenizer; | |
public class N1946 { | |
public static void main(String[] args) throws IOException { | |
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); | |
int tc = Integer.parseInt(br.readLine()); | |
ArrayList<Candidate> arr; | |
StringTokenizer st; | |
for (int i = 0; i < tc; i++) { | |
int N = Integer.parseInt(br.readLine()); | |
arr = new ArrayList<>(); | |
for (int j = 0; j < N; j++) { | |
st = new StringTokenizer(br.readLine()); | |
int rankA = Integer.parseInt(st.nextToken()); | |
int rankB = Integer.parseInt(st.nextToken()); | |
arr.add(new Candidate(rankA, rankB)); | |
} | |
System.out.println(solution(arr, N)); | |
} | |
br.close(); | |
} | |
public static int solution(ArrayList<Candidate> arr, int N) { | |
int cnt = 0; | |
Collections.sort(arr); | |
int min = Integer.MAX_VALUE; | |
for (Candidate ob : arr) { | |
if (ob.rankB < min) { | |
min = ob.rankB; | |
cnt++; | |
} | |
} | |
return cnt; | |
} | |
} | |
class Candidate implements Comparable<Candidate> { | |
int rankA; | |
int rankB; | |
public Candidate(int rankA, int rankB) { | |
this.rankA = rankA; | |
this.rankB = rankB; | |
} | |
@Override | |
public int compareTo(Candidate o) { | |
// rankA๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ | |
return this.rankA - o.rankA; | |
} | |
} | |

์ด์ ์ ์ ์ฌ์ ๋ฌธ์ ์์ต๋๋ค.
P.S
๋ฌธ์ ๋ฅผ ํ๋ค๋ณด๋
์ ๋ ์ผ๋ฅธ ๊ฐ๋ฐ ์ ์ ์ฌ์์ด
๋๊ณ ์ถ๋ค์ฌ...
'๐ป ๊ฐ๋ฐ๊ณต๋ถ > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Eric's ๋ฐฑ์ค] 1759๋ฒ - ์ํธ ๋ง๋ค๊ธฐ - JAVA (2) | 2023.02.11 |
---|---|
[Eric's ๋ฐฑ์ค] 2583๋ฒ - ์์ญ ๊ตฌํ๊ธฐ - Java (0) | 2023.02.11 |
[Eric's ๋ฐฑ์ค] 2217๋ฒ - ๋กํ - Java (0) | 2023.02.08 |
[Eric's ๋ฐฑ์ค] 11727๋ฒ - 2 x n ํ์ผ๋ง 2 - Java (0) | 2023.02.08 |
[Eric's ๋ฐฑ์ค] 11726๋ฒ - 2 x n ํ์ผ๋ง - Java (0) | 2023.02.07 |