[๋ฐฐ์ด] 12. ๋ฉํ ๋ง
์ค๋ช
ํ์๋ค ๋ฐ ์ ์๋์ ๋ฐ ํ์๋ค์ ์ํ์ ์๋ฅผ ํฅ์์ํค๊ธฐ ์ํด ๋ฉํ ๋ง ์์คํ ์ ๋ง๋ค๋ ค๊ณ ํฉ๋๋ค.
๋ฉํ ๋ง์ ๋ฉํ (๋์์ฃผ๋ ํ์)์ ๋ฉํฐ(๋์์ ๋ฐ๋ ํ์)๊ฐ ํ ์ง์ด ๋์ด ๋ฉํ ๊ฐ ๋ฉํฐ์ ์ํ๊ณต๋ถ๋ฅผ ๋์์ฃผ๋ ๊ฒ์ ๋๋ค.
์ ์๋์ M๋ฒ์ ์ํํ ์คํธ ๋ฑ์๋ฅผ ๊ฐ์ง๊ณ ๋ฉํ ์ ๋ฉํฐ๋ฅผ ์ ํฉ๋๋ค.
๋ง์ฝ Aํ์์ด ๋ฉํ ์ด๊ณ , Bํ์์ด ๋ฉํฐ๊ฐ ๋๋ ์ง์ด ๋์๋ค๋ฉด, Aํ์์ M๋ฒ์ ์ํํ ์คํธ์์ ๋ชจ๋ Bํ์๋ณด๋ค ๋ฑ์๊ฐ ์์์ผ ํฉ๋๋ค.
M๋ฒ์ ์ํ์ฑ์ ์ด ์ฃผ์ด์ง๋ฉด ๋ฉํ ์ ๋ฉํฐ๊ฐ ๋๋ ์ง์ ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ๊ฐ ์ด ๋ช ๊ฐ์ง ์ธ์ง ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.
์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ๋ฐ ํ์ ์ N(1<=N<=20)๊ณผ M(1<=M<=10)์ด ์ฃผ์ด์ง๋ค.
๋ ๋ฒ์งธ ์ค๋ถํฐ M๊ฐ์ ์ค์ ๊ฑธ์ณ ์ํํ ์คํธ ๊ฒฐ๊ณผ๊ฐ ํ์๋ฒํธ๋ก ์ฃผ์ด์ง๋ค. ํ์๋ฒํธ๊ฐ ์ ์ผ ์์์๋ถํฐ 1๋ฑ, 2๋ฑ, ...N๋ฑ ์์ผ๋ก ํํ๋๋ค.
๋ง์ฝ ํ ์ค์ N=4์ด๊ณ , ํ ์คํธ ๊ฒฐ๊ณผ๊ฐ 3 4 1 2๋ก ์ ๋ ฅ๋์๋ค๋ฉด 3๋ฒ ํ์์ด 1๋ฑ, 4๋ฒ ํ์์ด 2๋ฑ, 1๋ฒ ํ์์ด 3๋ฑ, 2๋ฒ ํ์์ด 4๋ฑ์ ์๋ฏธํฉ๋๋ค.
์ถ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ์ง์ ๋ง๋ค ์ ์๋ ์ด ๊ฒฝ์ฐ๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
์์ ์ ๋ ฅ 1
4 3
3 4 1 2
4 3 2 1
3 1 4 2
์์ ์ถ๋ ฅ 1
3
<<๋์ ํ์ด>>
ใ ใ ์ผ๋จ ์ ์ฒด์ ์ธ ํํ๋ฅผ ์๊ฐํด์ ํ์ด ๋ณด์์ง๋ง 4์ค for๋ฌธ์ ๋ด๊ฐ ์ฌ๋ฐ๋ฅด๊ฒ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋์ง ๋ชจ๋ฅด๊ฒ ๋ค.
ํ์ง๋ง ์ผ๋จ ๋์ ๋ ผ๋ฆฌ๋๋ก ํ์ด๋ ๋ณด์์ง๋ง
์ด๋ ๊ฒ ์ค๋ฅ๊ฐ ๋ฌ๋ค.
๋ถ์ํ ๊ฒฐ๊ณผ ๋ด๊ฐ ๋ฉ์๋๋ฅผ ์ ๋ชป ์ด์ฉํ๊ณ ์๋ ๊ฒ ๊ฐ๋ค ใ ใ
์๊ฐ๋ ๋ง์ด ์ง๋๊ณ ํด์ ๋ด๊ฐ ํ๋ ธ๋ค๋ ๊ฒ์ ์ธ์ ํ๊ณ ๊ฐ์ฌ๋ ํ์ด๋ฅผ ๋ณด๊ธฐ๋ก ํ๋ค!
import java.util.ArrayList;
import java.util.Scanner;
class Main {
public int solution(int tsn, int stn, int[][] arr) {
ArrayList<Integer> list = new ArrayList<>();
int answer = 0;
for (int i = 1; i <= stn; i++) {
for (int j = 0; j < tsn; j++) {
for (int k = 0; k < stn; k++) {
if (list.contains(arr[j][k])) {
list.remove(arr[j][k]);
}
if (arr[j][k] == i) {
for (int l = k + 1; l < stn; l++) {
list.add(arr[j][l]);
}
}
}
}
answer += list.size();
list.clear();
}
return answer;
}
public static void main(String[] args) {
Main T = new Main();
Scanner in = new Scanner(System.in);
int stn = in.nextInt();
int tsn = in.nextInt();
int[][] arr = new int[tsn][stn];
for (int i = 0; i < tsn; i++) {
for (int j = 0; j < stn; j++) {
arr[i][j] = in.nextInt();
}
}
System.out.println(T.solution(tsn, stn, arr));
}
}
-๊ฐ์ฌ๋ ํ์ด-
import java.util.Scanner;
class Main {
public int solution(int tsn, int stn, int[][] arr) {
int answer = 0;
for (int i = 1; i <= stn; i++) {
for (int j = 1; j <= stn; j++) {
int cnt = 0;
for (int k = 0; k < tsn; k++) {
int pi = 0, pj = 0;
for (int l = 0; l < stn; l++) {
if (arr[k][l] == i) pi = l;
if (arr[k][l] == j) pj = l;
}
if (pi < pj) cnt++;
}
if (cnt == tsn) answer++;
}
}
return answer;
}
public static void main(String[] args) {
Main T = new Main();
Scanner in = new Scanner(System.in);
int stn = in.nextInt();
int tsn = in.nextInt();
int[][] arr = new int[tsn][stn];
for (int i = 0; i < tsn; i++) {
for (int j = 0; j < stn; j++) {
arr[i][j] = in.nextInt();
}
}
System.out.println(T.solution(tsn, stn, arr));
}
}
์ฅ ??? ์ด๊ฒ ๋ญ๋..
๊ฐ์ฌ๋๋ 4์ค for๋ฌธ์ ์ด์ฉํ๋ค ใ ใ
๋ฌผ๋ก ๋ด๊ฐ ์๊ฐํ๋ ์ฌ๊ณ ์ ํ๋ฆ๊ณผ๋ ๋ค๋ฅธ๋ฐฉํฅ์ด๊ธดํ๋ค..
์ฒซ ๋ฒ์งธ ์ด์ค for๋ฌธ์ ์ง์ ์ง์์ ๋์ด๋ค. ์๋ฅผ ๋ค๋ฉด, i =3 j =2 ์ด๋ ๊ฒ ๋๊ณ ๊ทธ ๋ค์ ์ด์ค ํฌ๋ฌธ์ผ๋ก ๋๋ฆฌ๋ฉด์ ์ด๋ ๊ฒ ๋์ด๋ ๋ฌธ์ ์๋?
๋ฌธ์ ๊ฐ ์๋ค๋ฉด cnt ++ ํ๊ณ ์ด tsn๋งํผ ์ํ ์น ๋๊น์ง ์ฑ๋ฆฝํ๋ฉด ์ต์ข answer++ ํ๋ฉด์ ๊ฒฝ์ฐ์ ์๋ฅผ ์ฆ๊ฐ ์ํจ๋ค.
ํํ.. ์ผ๋จ ๋๋ ์ด ๋ฌธ์ ํ์ด๊ฐ ์๊ฐ์ด ์ ๋์ง ์์๋ค. ๊ฐ์ฌ๋์ด ํ๋ ์ฌ๊ณ ์ ํ๋ฆ์ ์ดํดํ๊ณ ๋ด ๊ฒ์ผ๋ก ๋ง๋ค๊ธฐ ์ํด ๋ ธ๋ ฅํ์.
<<์ถ๊ฐ ๊ณต๋ถ>>
ArrayList์ ๋ฉ์๋ ์ค contains์ remove ์ฌ์ฉ๋ฒ
contains
ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(1,2,3));
System.out.println(list.contains(1)); //list์ 1์ด ์๋์ง ๊ฒ์ : true
System.out.println(list.indexOf(1)); //1์ด ์๋ index๋ฐํ ์์ผ๋ฉด -1
remove
ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(1,2,3));
list.remove(1); //index 1 ์ ๊ฑฐ
list.clear(); //๋ชจ๋ ๊ฐ ์ ๊ฑฐ
๋ด๊ฐ ํ์๋ ๋ฐฉ์์์ ์ด๋ฅผ ์ด์ฉํ์๋๋ฐ, remove ๋ฉ์๋๋ฅผ ์๋ชป ํ์ฉํ ๊ฒ์ด๋ค.
remove(1)๋ฅผ ํ๊ฒ ๋๋ฉด index 1๋ฒ ์๋ฆฌ๋ฅผ ์ ๊ฑฐํ๋ ๊ฒ์ด๋ค.
๋ง์ฝ, ์ด๋ฅผ ํ์ฉํ๋ ค๋ฉด indexOf ๋ฉ์๋๋ฅผ ์ด์ฉํด์ index ๊ฐ์ ์ฐพ์ ๋ค์ ๊ทธ ๊ฐ์ remove์ ๋ฃ์ผ๋ฉด ๋๋ค.
์ค๋๋ ํ ์ ๋ฐฐ์ด๋ค ใ ใ