์ฝ”๋”ฉํ…Œ์ŠคํŠธ

[๋ฐฐ์—ด] 12. ๋ฉ˜ํ† ๋ง

์‹œํ๋ฆฌํ‹ฐ์ง€ํ˜ธ 2023. 12. 22. 22:57
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์— ๋„ฃ์œผ๋ฉด ๋œ๋‹ค.

 

์˜ค๋Š˜๋„ ํ•œ ์ˆ˜ ๋ฐฐ์šด๋‹ค ใ…‹ใ…‹