공부중

[알고리즘 정리] 정렬

민딛 — Sat, 11 Nov 2023 00:24:18 +0900

기본 정렬 알고리즘

버블 정렬
삽입 정렬
선택 정렬
합병 정렬

버블 정렬

인접한 두개의 원소를 비교하는 정렬.

인접해서 비교하기 때문에 가장 큰 원소는 배열의 마지막에 위치하게 된다.

각 회전마다 배열에서 제외되는 요소가 배열의 뒤에서부터 추가된다.

시간복잡도는 O(n^2)

private static void bubbleSort(int[] a) {
    for (int i = 0; i < a.length - 1; i++) {
        for (int j = 0; j < a.length - i - 1; j++) {
            if (a[j] > a[j + 1]) {
                int temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
}

삽입 정렬

두번째 원소부터 앞의 원소와 비교하는 정렬.

앞의 원소들을 차례대로 비교하며 삽입 될 위치에 원소를 넣고 뒤의 원소를 한칸씩 뒤로 보낸다.

시간복잡도는 O(n), 역순으로 정렬된 배열이라면 O(n^2)

private static void insertionSort(int[] a) {
    for (int i = 1; i < a.length; i++) {
        int num = a[i]; //비교할 원소
        int j = i - 1; //앞의 원소

        while (j >= 0 && num < a[j]) { //앞의 원소가 더 크다면 바꿔준다
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = num;
    }
}

선택 정렬

첫번째 원소를 두번째부터 마지막까지 비교하며 최소값을 첫번째 위치에,

두번째 원소를 세번째부터 마지막까지 비교하며 최소값을 두번째 위치에 ....

이런 식으로 위치는 정해져 있으며 어떤 원소를 넣을지 찾는 정렬 방법.

불안정 정렬에 속한다.

시간복잡도는 O(n^2)

private static void selectionSort(int[] a) {
    for (int i = 0; i < a.length; i++) {
        int now = i; //전환할 인덱스

        for (int j = i + 1; j < a.length; j++) {
            if (a[j] < a[now]) //최소값이 담긴 인덱스 찾기
                now = j;
        }

        int temp = a[now];
        a[now] = a[i];
        a[i] = temp;
    }
}

병합 정렬

분할 정복 알고리즘.

divide and conquer의 과정을 거친다.

배열의 크기가 1이 될 때까지 나누고, 합치는 과정.

추가 메모리를 사용한다는 특징이 있다.

시간복잡도는 O(nlogn)

private static void mergeSort(int[] a, int left, int right) {
    //main 함수 호출 부분
    //mergeSort(arr, 0, arr.length - 1);
    if (left < right) {
        int mid = (left + right) / 2;

        mergeSort(a, left, mid);
        mergeSort(a, mid + 1, right);

        merge(a, left, mid, right);
    }
}

private static void merge(int[] a, int left, int mid, int right) {
    int[] temp = a.clone();

    int i = left; //왼쪽 배열의 시작 인덱스
    int j = mid + 1; //오른쪽 배열의 시작 인덱스
    int idx = left; //정렬된 값을 넣을 위치 인덱스

    //왼쪽 배열과 오른쪽 배열 비교하며 작은 원소부터 추가
    while (i <= mid && j <= right) {
        if (temp[i] < temp[j]) {
            a[idx++] = temp[i++];
        } else {
            a[idx++] = temp[j++];
        }
    }

    if (mid < i) { //오른쪽 남은 배열 채우기
        for (int k = j; k <= right; k++) {
            a[idx++] = temp[k];
        }
    } else { //왼쪽 남은 배열 채우기
        for (int k = i; k <= mid; k++) {
            a[idx++] = temp[k];
        }
    }
}

[CodeTree Java] 메이즈 러너

민딛 — Mon, 28 Aug 2023 17:32:53 +0900

문제 링크

https://www.codetree.ai/training-field/frequent-problems/problems/maze-runner/description?page=3&pageSize=20

풀이

배열 회전과 위치 갱신이 복잡한 문제였다.

구현 자체는 문제 조건에서 지정한 대로 따라가면 된다.

구현에서 신경을 썼던 부분은 아래와 같다.

모든 사람이 탈출하고 나서 회전하는 경우
배열을 회전하고 나서 사람의 위치를 갱신하는 경우

1번은 모두 탈출했는지 탐색하고 나서 이동과 회전을 진행했는데, 회전할 정사각형의 범위를 0으로 초기화 해줘야 했다.

2번은 인덱스 매칭으로 회전한 위치를 구해야 한다.

처음에는 맵을 회전할때에는

사람과 출구 위치를 맵에 넣음
회전 범위에 따라 회전
회전하면서 사람 위치와 출구라면 새로운 위치로 갱신해줌

이런 로직이었는데 다음과 같은 예시에서 문제가 생겼다.

사람1명	8	사람2명
0	1	2
3	9	출구

이때 위의 로직을 따르면 사람 1명을 먼저 갱신하고 사람 2명의 위치에서 모든 사람의 위치가 하나로 갱신되는 문제가 있었다.

따라서 다음과 같이 로직을 변경했다

사람 수만큼 반복문
현재 사람이 탈출하지 않았고, 회전 범위에 있는지 확인
회전 범위에 있다면 (0,0) 기준으로 위치를 이동
[x][y] -> [y][박스크기 - x - 1] 공식 적용
기준점으로 위치 이동한 만큼 다시 더해줌

이 부분을 조심해서 풀었다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    static class Pos {
        int x, y;
        boolean isOut;

        public Pos(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public Pos(int x, int y, boolean isOut) {
            this.x = x;
            this.y = y;
            this.isOut = isOut;
        }
    }

    static int N, M, K, map[][], copy[][], total;
    static Pos exit; //출구 위치
    static int bx, by, boxSize; //회전할 박스 시작행열, 사이즈 저장
    static Pos[] p; //사람들 좌표 저장

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens = new StringTokenizer(br.readLine());

        N = Integer.parseInt(tokens.nextToken()); //맵
        M = Integer.parseInt(tokens.nextToken()); //사람
        K = Integer.parseInt(tokens.nextToken()); //게임시간

        map = new int[N][N];
        p = new Pos[M];
        total = 0;

        for (int i = 0; i < N; i++) {
            tokens = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                map[i][j] = Integer.parseInt(tokens.nextToken());
            }
        }

        for (int i = 0; i < M; i++) {
            tokens = new StringTokenizer(br.readLine());
            p[i] = new Pos(Integer.parseInt(tokens.nextToken()) - 1,
                    Integer.parseInt(tokens.nextToken()) - 1,
                    false);
        }

        tokens = new StringTokenizer(br.readLine());
        exit = new Pos(Integer.parseInt(tokens.nextToken()) - 1,
                Integer.parseInt(tokens.nextToken()) - 1);
        //end input

        while (K-- > 0) {
            //모든 참가자가 탈출했는지 확인
            if (isAllOut()) break;

            for (int i = 0; i < M; i++) {
                movePeople(i); //모든 참가자 이동
                //이동했는데 출구인지 확인
                if (p[i].x == exit.x && p[i].y == exit.y) {
                    p[i].isOut = true;
                }
            }

            bx = by = boxSize = 0; //모두 탈출하고 회전시킬 경우
            findRect(); //상자 사이즈 찾음

            rotateRect(); //미로 회전
        }

        exit.x++;
        exit.y++;
        System.out.println(total);
        System.out.println(exit.x + " " + exit.y);
    }

    private static boolean isAllOut() {
        for (int i = 0; i < M; i++) {
            if (!p[i].isOut) return false;
        }
        return true;
    }

    private static void rotateRect() {
        //맵 복사
        copy = new int[N][];
        for (int i = 0; i < N; i++) {
            copy[i] = Arrays.copyOfRange(map[i], 0, N);
        }

        //복사한 값을 원본에 돌려서 넣기
        for (int i = bx, x = by; i < bx + boxSize; i++, x++) {
            for (int j = by, y = bx + boxSize - 1; j < by + boxSize; j++, y--) {
                map[i][j] = copy[y][x];

                //내구도 감소
                if (isArea(map[i][j], 1, 10))
                    map[i][j]--;
            }
        }

        //출구 위치 변경
        if (isArea(exit.x, bx, bx + boxSize) && isArea(exit.y, by, by + boxSize)) {
            //(0,0) 기준으로 옮김
            int nx = exit.x - bx;
            int ny = exit.y - by;

            //회전시킴
            //20 -> 00
            //10 -> 01
            //00 -> 02
            //[x][y] -> [y][size-x-1]
            exit.x = ny + bx;
            exit.y = boxSize - nx - 1 + by;
        }

        //사람 위치 변경
        for (int i = 0; i < M; i++) {
            if (p[i].isOut) continue;

            if (isArea(p[i].x, bx, bx + boxSize) && isArea(p[i].y, by, by + boxSize)) {
                int nx = p[i].x - bx;
                int ny = p[i].y - by;

                p[i].x = ny + bx;
                p[i].y = boxSize - nx - 1 + by;
            }
        }
    }

    private static void findRect() {
        for (int size = 2; size <= N; size++) { //만들 수 있는 사각형
            for (int i = 0; i < N - size + 1; i++) {
                for (int j = 0; j < N - size + 1; j++) {
                    //출구가 있는지 확인
                    if (!(isArea(exit.x, i, i + size) && isArea(exit.y, j, j + size))) {
                        continue;
                    }

                    boolean flag = false;
                    //사람이 있는지 확인
                    for (int m = 0; m < M; m++) {
                        if (p[m].isOut) continue; //출구에 있는 참가자 제외

                        Pos now = p[m];
                        if (i <= now.x && now.x < i + size
                                && j <= now.y && now.y < j + size) {
                            flag = true;
                        }
                    }

                    if (flag) {
                        bx = i;
                        by = j;
                        boxSize = size;
                        return;
                    }

                }//end j

            }//end i

        }//end size
    }

    private static void movePeople(int idx) {
        Pos now = p[idx];

        //이미 출구인 경우
        if (now.isOut) return;

        //행이 다르다면 상하로 움직이기
        if (now.x != exit.x) {
            int nx = now.x;
            int ny = now.y;

            if (nx > exit.x) nx--; //위로 이동
            else nx++; //아래로 이동

            if (isRange(nx, ny) && map[nx][ny] == 0) {
                //움직일 수 있음
                now.x = nx;
                now.y = ny;
                p[idx] = now;
                total++;
                return;
            }
        }

        //열이 다르다면 좌우로 움직이기
        if (now.y != exit.y) {
            int nx = now.x;
            int ny = now.y;

            if (ny > exit.y) ny--; //좌로 이동
            else ny++; //우로 이동

            if (isRange(nx, ny) && map[nx][ny] == 0) {
                now.x = nx;
                now.y = ny;
                p[idx] = now;
                total++;
            }
        }
    }

    private static boolean isArea(int x, int min, int max) {
        if (min <= x && x < max) return true;
        return false;
    }

    private static boolean isRange(int x, int y) {
        if (x < 0 || y < 0 || x >= N || y >= N) return false;
        return true;
    }
}

[백준 Java] 1036 36진수

민딛 — Thu, 20 Jul 2023 13:11:27 +0900

문제 링크

https://www.acmicpc.net/problem/1036

풀이

이해하고 푸는데 한참 걸렸다. 진짜.. 진짜 오래 걸렸다 진짜...........

36진법으로 변환할 때 0-9, A-Z에서 해당하는 자리수를 Z로 변환했을 때 가장 큰 차이가 나는 것을 선택해야 한다.

말로 풀어서 설명하기 어려운데, 예를 들어서 예제의 HELLO는 다음과 같이 표현할 수 있다.

H	17 * 36^4
E	14 * 36^3
L	21 * 36^2 + 21 * 36^1
O	24 * 36^0

이것을 Z로 변환했을 때 차이가 가장 큰 값을 찾으려면 아래와 같이 변환하면 된다.

H	(35-17) * 36^4
E	(35-14) * 36^3
L	(35-21) * 36^2 + (35-21) * 36^1
O	(35-24) * 36^0

따라서 0-9, A-Z 값을 저장할 배열을 만들어주고, 해당 인덱스에 맞게 위의 표에 맞게 자리수를 넣어준다.

배열을 정렬해주고 난 후 가장 차이가 큰 수를 K개 더해준다.

간단한 예로 들면,

a = 1
b = 2
z = 10

a + b = 3 //총 합으로 사용

z - a = 9
z - b = 8

이때 a를 선택한다.

총합에 z-a의 차이를 더해주면 a + b -> 3 + (z - a) = 3 + 9 = 12가 된다.

위와 같은 예시로 N만큼 입력을 받고 36진수로 변환해서 일단 모든 숫자의 총합을 구해준다.

Z로 변환했을 때 가장 큰 차이를 가지는 상위 K개가 가지고 있는 차이값을 총합에 더해주면 구하고자 하는 최대값이 된다.

따라서 어떤 문자를 바꿀 것인지는 몰라도 된다.

자바의 long 타입은 50자를 받지 못하기 때문에 BigInteger를 사용한다.

질문게시판에서 반례를 참고했다

2
99999999999999999999999999999999999999999999999999
1
1

답
100000000000000000000000000000000000000000000000000

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int N = Integer.parseInt(br.readLine());

        //0) 초기화
        // 0-9, A-Z의 36진수 값을 저장할 배열 설정
        BigInteger[] digit = new BigInteger[36];
        Arrays.fill(digit, BigInteger.ZERO); //초기화

        //총합
        BigInteger sum = BigInteger.ZERO;

        for (int i = 0; i < N; i++) {
            String str = br.readLine();
            BigInteger cur = new BigInteger(str, 36); //36진수로 변환

            //1) 각 36진수를 총합에 더해줌
            sum = sum.add(cur);

            //2) 한글자씩 Z로 변환했을 때 가중치를 저장
            //ex) YZ라면, digit[Y] += (35 - Y) * 36^1을 저장함
            BigInteger pow = BigInteger.ONE; //지수 값
            for (int j = str.length() - 1; j >= 0; j--) {
                int idx = str.charAt(j) <= '9' ? str.charAt(j) - '0' : str.charAt(j) - 'A' + 10; //digit에 저장할 인덱스 설정
                digit[idx] = digit[idx].add(pow.multiply(BigInteger.valueOf(35 - idx)));
                pow = pow.multiply(BigInteger.valueOf(36)); //다음 자리수로
            }
        }

        //3) digit을 정렬하고 내림차순으로 사용해서 K만큼 더해줌
        //ex) 1+2 = 3을 10+2=12로 변경했을 때, 10-1의 차이인 9만큼 더해줘야 총 합이 됨
        int K = Integer.parseInt(br.readLine());
        Arrays.sort(digit);
        int cnt = 0;
        for (int i = 35; i >= 0 ; i--) {
            if(cnt == K) break;
            sum = sum.add(digit[i]);
            cnt++;
        }

        //4) 출력
        System.out.println(sum.toString(36).toUpperCase());

    }

}

처음에는 하나하나 전부 36 -> 10 -> 36 변환해가면서 구했는데 로직 자체가 틀렸었다.

이런 수 연산같은걸 생각해야 하는 문제가 아직도 어렵다...

[Git] commit 내역에 큰 파일 기록 지우기

민딛 — Fri, 30 Jun 2023 15:22:18 +0900

GitLab에서 GitHub으로 레포지토리를 미러링시 100MB를 넘는 파일이 있다면 에러가 나며 미러링이 안 되는 문제가 있다.

File {파일명} is 105.41 MB; this exceeds GitHub's file size limit of 100.00 MB \nremote: error: GH001: Large files detected.

자세하게는 이런 내용으로 찍힌다. 이것을 지우고 다시 시도해도 기록상에는 남아있기 때문에 전부 지워줘야 한다.

git filter-branch --tree-filter 'rm -f 파일명' HEAD

해당 명령어를 실행하면 아래와 같이 뜬다.

정상적으로 되었으면 원격 레포지토리에 push 해준다.

git push 원격remote명 브랜치명 --force
ex) git push github master --force

[백준 Java] 14499 주사위 굴리기

민딛 — Wed, 28 Jun 2023 16:10:45 +0900

문제 링크

https://www.acmicpc.net/problem/14499

풀이

방향에 따라 움직일 때 마다 주사위의 값을 변경해준다.

주사위가 회전할 때마다 아래와 같이 모양이 변한다

기본	동쪽	서쪽	북쪽	남쪽
2 4 1 3 5 6	2 6 4 1 5 3	2 1 3 6 5 4	1 4 5 3 6 2	6 4 2 3 1 5

따라서 방향이 전환되면 그 방향에 따라 주사위의 위치에 따른 값을 전부 변경해준다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    static int N, M, map[][], ju[];
    static int[][] dir = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}}; //동서북남
    static StringBuilder sb;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens = new StringTokenizer(br.readLine());

        N = Integer.parseInt(tokens.nextToken());
        M = Integer.parseInt(tokens.nextToken());
        map = new int[N][M];

        int x = Integer.parseInt(tokens.nextToken());
        int y = Integer.parseInt(tokens.nextToken());

        int K = Integer.parseInt(tokens.nextToken());

        for (int i = 0; i < N; i++) {
            tokens = new StringTokenizer(br.readLine());
            for (int j = 0; j < M; j++) {
                map[i][j] = Integer.parseInt(tokens.nextToken());
            }
        }

        //주사위 설정
        ju = new int[7];

        tokens = new StringTokenizer(br.readLine());
        sb = new StringBuilder();

        for (int i = 0; i < K; i++) {
            int[] now = roll(x, y, Integer.parseInt(tokens.nextToken()) - 1, sb);
            if(now == null) continue;
            x = now[0];
            y = now[1];
        }

        System.out.print(sb);

    }//end main

    private static int[] roll(int x, int y, int d, StringBuilder sb) {
        //방향대로 다음 위치 확인
        x += dir[d][0];
        y += dir[d][1];

        if (!isRange(x, y)) return null;

        changeJu(d);

        if(map[x][y] == 0){
            map[x][y] = ju[6];
        }else{
            ju[6] = map[x][y];
            map[x][y] = 0;
        }

        sb.append(ju[1]).append("\n"); //가장 윗면의 값 출력

        return new int[]{x, y};

    }

    private static boolean isRange(int x, int y) {
        if (x < 0 || y < 0 || x >= N || y >= M) return false;
        return true;
    }

    private static void changeJu(int d) {
        //굴리는 방향에 따라서 위치를 변경해줌. 1은 가장 윗면, 6은 가장 밑면이 됨
        //기본    1 2 3 4 5 6
        //오른    4 2 1 6 5 3
        //왼쪽    3 2 6 1 5 4
        //위쪽    5 1 3 4 6 2
        //남쪽    2 6 3 4 1 5

        int[] t = ju.clone();

        if (d == 0) { //동
            ju[1] = t[4];
            ju[3] = t[1];
            ju[4] = t[6];
            ju[6] = t[3];
        } else if (d == 1) { //서
            ju[1] = t[3];
            ju[3] = t[6];
            ju[4] = t[1];
            ju[6] = t[4];
        } else if (d == 2) { //북
            ju[1] = t[5];
            ju[2] = t[1];
            ju[5] = t[6];
            ju[6] = t[2];
        } else { //남
            ju[1] = t[2];
            ju[2] = t[6];
            ju[5] = t[1];
            ju[6] = t[5];
        }
    }

}

[백준 Java] 3190 뱀

민딛 — Tue, 27 Jun 2023 16:53:29 +0900

문제 링크

https://www.acmicpc.net/problem/3190

풀이

뱀의 위치를 Queue에 담아서 관리한다. 꼬리가 줄어들어야 할 때, 머리가 늘어날 때 큐의 앞뒤로 삽입 삭제 연산을 해야 하기 때문에 ArrayDeque를 사용했다.

방향은 오른쪽으로 가는 방향에서 시작하여, 오른쪽으로 90도씩 방형을 전환하도록 방향 배열에 설정해두었고, 각 방향 전환이 일어날 때 1씩 더하고 빼는 연산에 모듈러 연산을 적용했다.

while 문 안에서의 연산은 다음과 같다.

머리를 늘린다.
다음 위치가 벽인지, 자기 자신인지 확인한다.
사과가 있는지 확인한다.
사과가 없다면 꼬리 제거
새로운 머리를 넣어준다.
지금 초에 방향 전환이 있는지 확인한다.

이 순서로 진행했다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.StringTokenizer;

public class Main {
    static int N, map[][], time[];

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens;

        N = Integer.parseInt(br.readLine()); //맵 크기
        map = new int[N][N];
        time = new int[10001];

        int K = Integer.parseInt(br.readLine()); //사과의 개수
        int x, y;
        for (int i = 0; i < K; i++) {
            tokens = new StringTokenizer(br.readLine());
            x = Integer.parseInt(tokens.nextToken()) - 1;
            y = Integer.parseInt(tokens.nextToken()) - 1;
            map[x][y] = 1;
        }

        K = Integer.parseInt(br.readLine()); //방향 정보
        char w;
        for (int i = 0; i < K; i++) {
            tokens = new StringTokenizer(br.readLine());
            x = Integer.parseInt(tokens.nextToken());
            w = tokens.nextToken().charAt(0);

            time[x] = w == 'D' ? 1 : -1; //왼쪽 -1, 오른쪽 1 저장
        }

        System.out.println(play());

    }

    private static int play() {
        int res = 0; //게임 진행 시간
        int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; //오른쪽으로 시계방향
        int d = 0; //오른쪽
        ArrayDeque<int[]> pos = new ArrayDeque<>(); //뱀의 모든 위치 저장
        pos.offer(new int[]{0, 0}); //머리
        //자기 자신 표시
        map[0][0] = 999;

        int nx, ny;
        while (true) {
            res++;

            int[] cur = pos.peek();

            //1. 머리 늘리기
            nx = cur[0] + dir[d][0];
            ny = cur[1] + dir[d][1];

            //2. 벽인지, 자기자신인지 확인
            if (!isRange(nx, ny) || map[nx][ny] == 999) break;

            //3. 사과 유무 확인

            if (map[nx][ny] == 0) { //사과를 안먹는 경우
                int[] tail = pos.pollLast();
                map[tail[0]][tail[1]] = 0;
            }
            map[nx][ny] = 999;
            pos.offerFirst(new int[]{nx, ny});
            
            //4. 초마다 방향 전환이 있는지 확인 후 방향을 바꿔줌
            if (time[res] == -1) {
                d = (d + 3) % 4; //빼기로 진행하면 마이너스값이 나오기 때문에 3을 더해서 모듈러 연산
            } else if (time[res] == 1) {
                d = (d + 1) % 4;
            }
        }

        return res;
    }

    private static boolean isRange(int x, int y) {
        if (x < 0 || y < 0 || x >= N || y >= N) return false;
        return true;
    }
}

[백준 Java] 14940 쉬운 최단거리

민딛 — Fri, 23 Jun 2023 17:52:34 +0900

문제 링크

https://www.acmicpc.net/problem/14940

풀이

bfs로 풀었다. 2인 지점에서 시작하고 이동할때마다 가중치를 증가시킨다.

배열은 입력받은 배열 map과 결과를 저장할 배열 res 두개를 사용한다. map에서 1로 갈 수 있는데, res에서 배열 초기값인 0이라면 도달하지 못했기 때문에 -1로 출력한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
    static int N, M, map[][], res[][];

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens = new StringTokenizer(br.readLine());

        N = Integer.parseInt(tokens.nextToken());
        M = Integer.parseInt(tokens.nextToken());

        map = new int[N][M];
        res = new int[N][M];

        Queue<int[]> q = new ArrayDeque<>();
        boolean[][] v = new boolean[N][M];

        for (int i = 0; i < N; i++) {
            tokens = new StringTokenizer(br.readLine());
            for (int j = 0; j < M; j++) {
                map[i][j] = Integer.parseInt(tokens.nextToken());
                if (map[i][j] == 2) {
                    q.offer(new int[]{i, j, 0});
                    v[i][j] = true;
                    map[i][j] = 0;
                }
            }
        }

        bfs(q, v);

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                //map은 1인데 res에 0으로 되어있으면 도달하지 못함
                if (map[i][j] == 1 && res[i][j] == 0) {
                    sb.append(-1);
                } else {
                    sb.append(res[i][j]);
                }
                sb.append(" ");
            }
            sb.append("\n");
        }
        System.out.print(sb);

    }

    private static void bfs(Queue<int[]> q, boolean[][] v) {
        int[][] dir = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

        while (!q.isEmpty()) {
            int[] cur = q.poll();

            for (int d = 0; d < 4; d++) {
                int nx = cur[0] + dir[d][0];
                int ny = cur[1] + dir[d][1];

                if (!isRange(nx, ny) || v[nx][ny] || map[nx][ny] == 0) continue;

                res[nx][ny] = cur[2] + 1;
                v[nx][ny] = true;
                q.offer(new int[]{nx, ny, cur[2] + 1});
            }
        }
    }

    private static boolean isRange(int x, int y) {
        if (x < 0 || y < 0 || x >= N || y >= M) return false;
        return true;
    }
}

[백준 Java] 9461 파도반 수열

민딛 — Fri, 23 Jun 2023 17:12:13 +0900

문제 링크

https://www.acmicpc.net/problem/9461

풀이

수열의 규칙을 찾는다.

1 1 1 2 2 3 4 5 6 7 9 12를 봤을 때, 1 1 1 2 2 까지는 규칙을 찾기 어렵지만, 3부터는 n-1과 n-5의 값이 합쳐진게 답이 된다.

문제에서 P(1)부터 P(10)까지 첫 10개 숫자는 1, 1, 1, 2, 2, 3, 4, 5, 7, 9이다. 라고 되어있기 때문에 각 단계별로 배열을 만든 다음 값을 사용한다.

N이 100까지 들어오기 때문에 배열의 크기를 100으로 잡고, 값이 int 자료형의 범위를 벗어나기 때문에 long을 사용한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        //int 자료형을 사용하면 오버플로우 발생
        long[] dp = new long[101];
        dp[1] = 1;
        dp[2] = 1;
        dp[3] = 1;
        dp[4] = 2;
        dp[5] = 2;
        //이후 값은 dp[n-1] + dp[n-5] 값을 따름
        for (int i = 6; i < dp.length; i++) {
            dp[i] = dp[i-1] + dp[i-5];
        }

        int T = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();

        while(T-- > 0){
            int N = Integer.parseInt(br.readLine());
            sb.append(dp[N]).append("\n");
        }
        System.out.println(sb);
    }
}

[백준 Java] 11724 연결 요소의 개수

민딛 — Fri, 23 Jun 2023 16:44:47 +0900

문제 링크

https://www.acmicpc.net/problem/11724

풀이

유니온 파인드를 사용했다

find : 배열의 값(부모)이 들어온 숫자와 같다면 그 값을 돌려준다. 다르다면 부모의 값을 계속 타고 올라가며 찾는다.
union : find를 사용하여 각 부모를 찾는다. 두 값의 부모가 같다면 false를 돌려준다. 값이 다를 경우 작은 쪽을 부모로 만들어주고 true를 돌려준다

마지막에 N만큼 순회하며 부모의 값을 집합에 넣어주고, 집합의 크기를 출력한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

public class Main {
    static int N, parent[];

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens = new StringTokenizer(br.readLine());

        N = Integer.parseInt(tokens.nextToken());
        int M = Integer.parseInt(tokens.nextToken());

        parent = new int[N];

        initArr();

        for (int i = 0; i < M; i++) {
            tokens = new StringTokenizer(br.readLine());
            union(Integer.parseInt(tokens.nextToken()) - 1, Integer.parseInt(tokens.nextToken()) - 1);
        }

        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < N; i++) {
            set.add(find(i));
        }
        System.out.println(set.size());
    }

    private static void initArr() {
        for (int i = 0; i < N; i++) {
            parent[i] = i;
        }
    }

    private static int find(int a) {
        if (parent[a] == a) return a;
        return find(parent[a]);
    }

    private static boolean union(int a, int b) {
        a = find(a);
        b = find(b);

        if (a == b) return false;

        if (a <= b) parent[b] = a;
        else parent[a] = b;
        return true;
    }
}

[백준 Java] 11403 경로 찾기

민딛 — Thu, 22 Jun 2023 16:49:28 +0900

문제 링크

https://www.acmicpc.net/problem/11403

풀이

2가지 방법으로 풀었다.

dfs

한 행에 대해서 방문 배열 초기화
지금 행과 열이 1이라면 연속되는 곳을 찾기 위해 dfs 호출
dfs 내에서 방문 처리, j에 대해서 연결된 다른 노드를 찾고 시작점과 이어주기 위해 dfs 호출

플로이드 워셜

i와 k가 연결되고, k와 j가 연결된 경우 i와 j를 연결시켜줌

처음에는 플로이드 워셜이 생각 나지 않아 bfs, dfs 여러 방법으로 풀어봤었는데, 가중치가 없더라도 모든 간선을 확인하고, 연속해서 확인해야 하는 경우 플로이드 워셜을 사용하니 훨씬 더 간단하게 풀렸다. 또한 input이 100까지 들어오기 때문에 100^3번 수행한다.

아래는 dfs, 위에는 플로이드 워셜로 풀었는데 둘 다 100^3을 수행해서 메모리와 시간상 별 차이는 없다.

코드 1 - dfs

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    static int N, map[][], res[][];
    static boolean[] v;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens;

        N = Integer.parseInt(br.readLine());
        map = new int[N][N];
        res = new int[N][N];

        for (int i = 0; i < N; i++) {
            tokens = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                map[i][j] = Integer.parseInt(tokens.nextToken());
            }
        }//end input

        for (int i = 0; i < N; i++) {
            v = new boolean[N];

            for (int j = 0; j < N; j++) {
                if(map[i][j] == 1 && !v[j]){
                    dfs(i, j);
                }
            }
        }

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                sb.append(res[i][j]).append(" ");
            }
            sb.append("\n");
        }
        System.out.println(sb);

    }

    private static void dfs(int x, int y) {
        //x, y가 1인 상태
        //y에 연결된 다른 간선 찾아야 함
        v[y] = true;
        res[x][y] = 1;

        for (int i = 0; i < N; i++) {
            if(map[y][i] == 1 && !v[i]){
                //y와 연결된 간선을 시작한 노드와 이어
                dfs(x, i);
            }
        }
    }

}

코드 2 - 플로이드 워셜

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens;

        int N = Integer.parseInt(br.readLine());
        int[][] map = new int[N][N];

        for (int i = 0; i < N; i++) {
            tokens = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                map[i][j] = Integer.parseInt(tokens.nextToken());
            }
        }//end input

        for (int k = 0; k < N; k++) {
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    if (map[i][k] == 1 && map[k][j] == 1) {
                        map[i][j] = 1;
                    }
                }
            }
        }


        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                sb.append(map[i][j]).append(" ");
            }
            sb.append("\n");
        }
        System.out.print(sb);

    }

}

[백준 Java] 16928 뱀과 사다리 게임

민딛 — Thu, 22 Jun 2023 15:07:32 +0900

문제 링크

https://www.acmicpc.net/problem/16928

풀이

bfs로 주사위 6개에 대해서 탐색
시작 위치는 1
배열에 맵의 정보 설정
100이 넘지 않는 경우 맵을 이동하는지 확인 후 갱신해주기

기본 bfs에서 이 조건을 지켜서 풀었다. 처음에는 시작 위치를 0으로 잡았는데, 문제 조건에서 1에서 시작한다고 되어있기 때문에 1로 해야 한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens = new StringTokenizer(br.readLine());

        int N = Integer.parseInt(tokens.nextToken());
        int M = Integer.parseInt(tokens.nextToken());

        int[] map = new int[101];

        int a, b;
        for (int i = 0; i < N + M; i++) {
            tokens = new StringTokenizer(br.readLine());
            a = Integer.parseInt(tokens.nextToken());
            b = Integer.parseInt(tokens.nextToken());

            map[a] = b;
        }

        System.out.println(bfs(map));
    }

    private static int bfs(int[] map) {
        int res = 0;
        Queue<int[]> q = new ArrayDeque<>();
        boolean[] v = new boolean[101];

        q.offer(new int[]{1, 0}); //위치와 횟수
        v[1] = true;

        while (!q.isEmpty()) {
            int[] cur = q.poll();

            //1~6 주사위를 굴림
            for (int d = 1; d <= 6; d++) {
                int next = cur[0] + d;

                if (v[next] || next > 100) continue;

                //도착
                if (next == 100) {
                    res = cur[1] + 1;
                    return res;
                }

                //맵 방향 설정
                if (map[next] != 0) {
                    next = map[next];
                }
                //다음 위치
                v[next] = true;
                q.offer(new int[]{next, cur[1] + 1});

            }
        }

        return res;
    }
}

[백준 Java] 9019 DSLR

민딛 — Thu, 15 Jun 2023 22:08:42 +0900

문제 링크

https://www.acmicpc.net/problem/9019

풀이

bfs 문제인데 L, R 연산 계산하는 법에서 시간이 많이 걸렸다.

Queue에 저장할 class를 선언해주고, 이 안에 D,S,L,R 연산을 추가했다.

이러면 각 연산에서 값이 달라졌어도 cur 값이 유지가 가능하다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens;
        StringBuilder sb = new StringBuilder();

        int T = Integer.parseInt(br.readLine());

        while (T-- > 0) {
            tokens = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(tokens.nextToken());
            int b = Integer.parseInt(tokens.nextToken());

            sb.append(bfs(a, b)).append("\n");
        }
        System.out.println(sb);
    }

    static class Pos {
        int num;
        String order;

        public Pos(int num, String order) {
            this.num = num;
            this.order = order;
        }

        public int D() {
            return (num * 2) % 10000;
        }

        public int S() {
            return num == 0 ? 9999 : num - 1;
        }

        public int L() {
            //1234 -> 2341
            //123 -> 231
            //12 -> 21
            return (num % 1000) * 10 + (num / 1000);
        }

        public int R() {
            //1234 -> 4123
            return (num % 10) * 1000 + (num / 10);
        }

    }

    private static String bfs(int a, int b) {
        //D, S, L, R의 연산을 수행함
        Queue<Pos> q = new ArrayDeque<>();
        q.offer(new Pos(a, ""));
        boolean[] v = new boolean[10000];
        v[a] = true;

        String res = "";

        while (!q.isEmpty()) {
            Pos cur = q.poll();

            if (cur.num == b) {
                res = cur.order;
                break;
            }

            for (int i = 0; i < 4; i++) {
                Pos next;
                if (i == 0) {
                    next = new Pos(cur.D(), cur.order+"D");
                } else if (i == 2) {
                    next = new Pos(cur.S(), cur.order+"S");
                } else if (i == 3) {
                    next = new Pos(cur.L(), cur.order+"L");
                } else {
                    next = new Pos(cur.R(), cur.order+"R");
                }

                if (v[next.num]) continue;
                v[next.num] = true;
                q.offer(next);
            }

        }
        return res;
    }

}

[백준 Java] 17219 비밀번호 찾기

민딛 — Thu, 15 Jun 2023 20:11:53 +0900

문제 링크

https://www.acmicpc.net/problem/17219

풀이

맵에 <사이트, 비밀번호>로 저장하고 찾으면 된다!

혹시나 더 빠르게 푸는 방법이 있나 싶어 백준에 정답 기록을 봤는데 비슷하게 푼 것 같다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens = new StringTokenizer(br.readLine());

        int N = Integer.parseInt(tokens.nextToken());
        int M = Integer.parseInt(tokens.nextToken());

        HashMap<String, String> map = new HashMap<>();

        for (int i = 0; i < N; i++) {
            tokens = new StringTokenizer(br.readLine());
            map.put(tokens.nextToken(), tokens.nextToken());
        }

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < M; i++) {
            sb.append(map.get(br.readLine())).append("\n");
        }
        System.out.print(sb);
    }

}

[백준 Java] 20529 가장 가까운 세 사람의 심리적 거리

민딛 — Tue, 13 Jun 2023 22:23:35 +0900

문제 링크

https://www.acmicpc.net/problem/20529

풀이

처음에는 조합으로 3개를 선택해서 풀었는데 N이 100,000까지 들어오기 때문에 시간 초과가 난다.

심리적 거리가 0이 될 경우는 모두 같은 mbti인 경우이고, N이 32를 넘는 경우 무조건 심리적 거리가 0이 된다.

왜냐하면 N이 32인 경우 서로 다른 mbti가 입력으로 들어왔을 경우 최소 2개씩 중복되는 mbti가 나온다.

따라서 N이 33이라면 2개로 중복된 mbti가 3개가 되기 때문에 이 때 심리적 거리는 0이 된다.

그래서 입력을 받고 N이 32를 넘는 경우에는 검사를 하지 않고 결과를 0으로 출력한다.

N이 32를 넘지 않는 경우에는 조합으로 3개를 선택해서 심리적 거리를 계산한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    static int res;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens;
        StringBuilder sb = new StringBuilder();

        int T = Integer.parseInt(br.readLine());

        while (T-- > 0) {
            int N = Integer.parseInt(br.readLine());
            tokens = new StringTokenizer(br.readLine());

            //32개가 넘으면 무조건 0이 됨. 이미 같은 유형이 2개씩 존재하기 때문
            if (N > 32) {
                sb.append(0).append("\n");
                continue;
            }

            String[] type = new String[N];
            for (int i = 0; i < N; i++) {
                type[i] = tokens.nextToken();
            }

            //조합으로 선택
            res = Integer.MAX_VALUE;
            comb(0, 0, new String[3], type, N);
            sb.append(res).append("\n");

        }
        System.out.print(sb);
    }

    private static void comb(int cnt, int start, String[] s, String[] type, int N) {
        if (cnt == 3) {
            int temp = 0;
            for (int i = 0; i < 4; i++) {
                if (s[0].charAt(i) != s[1].charAt(i)) temp++;
                if (s[0].charAt(i) != s[2].charAt(i)) temp++;
                if (s[1].charAt(i) != s[2].charAt(i)) temp++;
            }
            res = Math.min(res, temp);
            return;
        }

        for (int i = start; i < N; i++) {
            s[cnt] = type[i];
            comb(cnt+1, i+1, s, type, N);
        }
    }
}

[백준 Java] 14890 경사로

민딛 — Sat, 10 Jun 2023 21:53:07 +0900

문제 링크

https://www.acmicpc.net/problem/14890

풀이

SW Expert Academy에서 풀었던 문제이다. 활주로 건설과 같은 문제인데 그때에는 행과 열에 대해서 모두 조사하는 방식이었지만, 이번에는 맵 2개를 선언하여 하나의 맵은 90도 회전한 맵으로 저장하고 두 맵을 한 행씩 조사하는 로직으로 변경했다.

한 행을 검사할 때, 행의 첫번째 값과 카운트를 갱신해둔다.

두번째 요소부터 검사할때 첫번째 행의 값과 같다면 카운트를 증가시키고 넘어간다.

이전 값과 다를 때 차이가 1이 아니라면 이 행은 경사로를 세울 수 없어 false를 리턴한다.

이전값과의 차이가 1이라면 높이가 올라가는 경우, 아니라면 낮아지는 경우에 따라 경사로를 세울 수 있는 조건 확인을 다르게 한다.

높아지는 경우, L만큼 공간을 만들 수 있는지 확인하고 만들 수 없다면 false, 만들 수 있다면 cnt와 prev 값을 갱신한다.

낮아지는 경우, 지금 위치에서 L만큼 위치까지 전부 같은 값인지 확인한다. 다른 값이 있다면 false, 전부 같은 값이라면 경사로를 만들 수 있고, L만큼 만든 다음 위치로 인덱스와 cnt를 조절한다. 이때 이 곳은 경사로를 만들었기 때문에 cnt는 0으로 설정한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    static int N, L, res, map[][], map2[][];

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens = new StringTokenizer(br.readLine());

        N = Integer.parseInt(tokens.nextToken());
        L = Integer.parseInt(tokens.nextToken());
        map = new int[N][N];
        map2 = new int[N][N]; //i,j위치 반전시킨 맵

        for (int i = 0; i < N; i++) {
            tokens = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                map[i][j] = Integer.parseInt(tokens.nextToken());
                map2[j][i] = map[i][j];
            }
        }

        res = 0;

        //기본 맵 행 검사, 회전한 맵 행 검사
        for (int i = 0; i < N; i++) {
            if (checkRow(map[i])) {
                res++;
            }
            if(checkRow(map2[i])){
                res++;
            }
        }

        System.out.println(res);
    }

    private static boolean checkRow(int[] rows) {
        //높이가 달라졌을 때 경사로를 생성할 수 있는지 확인
        int prev = rows[0];
        int cnt = 1;
        for (int i = 1; i < N; i++) {
            if (prev == rows[i]) { //높이가 같은 경우 그냥 증가
                cnt++;
                continue;
            }
            //높이가 다를 때
            if (Math.abs(prev - rows[i]) != 1) {
                //높이 차이가 1이 아니라면 경사로 만들지 못함
                return false;
            }
            //높이 차이가 1일 때
            //높아지는 경우 -> L만큼 공간을 만들 수 있는지 확인
            if (rows[i] - prev == 1) {
                if (cnt >= L) {
                    //경사로 생성
                    cnt = 1;
                    prev = rows[i];
                } else {
                    return false;
                }
            } else {
                //낮아지는 경우
                boolean flag = true;
                for (int j = i + 1; j < i + L; j++) {
                    if (!(j < N && rows[j] == rows[i])) {
                        flag = false;
                        break;
                    }
                }
                if (!flag) {
                    return false;
                } else {
                    //만들 수 있는 경우 만들고 경사로 만든 인덱스 조정하기
                    cnt = 0;
                    i = i + L - 1;
                    prev = rows[i];
                }

            }

        }
        return true;
    }
}

[백준 Java] 14503 로봇 청소기

민딛 — Fri, 9 Jun 2023 23:17:26 +0900

문제 링크

https://www.acmicpc.net/problem/14503

풀이

청소기가 더 이상 움직일 수 없는 조건은 주변 칸이 전부 청소된 상태이고, 후진할 수 없는 경우이다.

while문을 실행하여 더 이상 움직일 수 없는 경우에 대해서 -1 값으로 처리했다.

move 함수는 로봇 청소기가 r, c, d값에 따라 한번 움직이는 함수이다. return값는 각 상황에 따른 새롭게 이동해야 하는 위치와 좌표가 반환된다.

move 함수에서 문제의 조건대로 함수를 실행한다.

개선할 점은 청소할 영역이 한가지만 남았는데, 로봇청소기가 해당 방향을 발견할때까지 뱅뱅 도는 경우이다

1 0 1
1 * 1
1 1 1

로봇 청소기가 *에 있을 때 0인 곳으로만 이동할 수 있는데 저 방향을 발견할때까지 계속 도는 경우가 있다.

어차피 청소하는 칸의 개수만 구하는 것이기 때문에 move 함수를 계속 실행시키는 것이 아니라 한 방향으로만 가야한다면 해당 방향을 바로 갈 수 있도록 return 값을 수정하는 것이 더 효율적인 코드라고 생각된다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main_14503_로봇청소기 {

    static int N, M, res, map[][];
    static int[][] dir = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}}; //북 동 남 서

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens = new StringTokenizer(br.readLine());

        N = Integer.parseInt(tokens.nextToken());
        M = Integer.parseInt(tokens.nextToken());
        map = new int[N][M];

        tokens = new StringTokenizer(br.readLine());
        //처음 위치와 방향
        int r = Integer.parseInt(tokens.nextToken());
        int c = Integer.parseInt(tokens.nextToken());
        int d = Integer.parseInt(tokens.nextToken());

        for (int i = 0; i < N; i++) {
            tokens = new StringTokenizer(br.readLine());
            for (int j = 0; j < M; j++) {
                //0 청소되지 않은 칸, 1 벽
                map[i][j] = Integer.parseInt(tokens.nextToken());
            }
        }

        res = 0;

        while (r != -1 && c != -1 && d != -1) {
            int[] temp = move(r, c, d);
            r = temp[0];
            c = temp[1];
            d = temp[2];
        }

        System.out.println(res);
    }

    private static int[] move(int r, int c, int d) {
        //현재 칸 확인
        if (checkNowArea(r, c)) {
            //청소되지 않았다면 청소
            res++;
            map[r][c] = -1; //청소되었다고 표시
        }

        //주변 4칸 확인
        if (checkAroundArea(r, c)) {//다 청소된 경우
            //후진 가능한지 확인
            int[] temp = isBack(r, c, d);

            //후진 가능하다면 후진, 후진 불가능이면 작동 멈춤
            if (r == temp[0] && c == temp[1] && d == temp[2]) {
                //후진 불가능한 경우 멈춤
                return new int[]{-1, -1, -1};
            }
            //후진 가능한 경우
            return new int[]{temp[0], temp[1], temp[2]};

        } else {//청소되지 않은 칸이 있는 경우
            //방향 반시계로 90도 회전 -> 3 더하고 모듈러
            d = (d + 3) % 4;

            //앞쪽 칸이 청소되지 않은 빈칸이면 전진하고 다시 움직임
            int nx = r + dir[d][0];
            int ny = c + dir[d][1];
            if (isRange(nx, ny) && map[nx][ny] == 0) {//청소되지 않은 칸인 경우
                return new int[]{nx, ny, d}; //한칸 전진
            }
            //그냥 방향만 바꾸고 제자리
            return new int[]{r, c, d};

        }
    }

    private static int[] isBack(int r, int c, int d) {
        //현재 위치에서 후진 할 수 있는지 확인
        //현재 방향의 반대 방향 선택. 2를 더하고 모듈러
        int nd = (d + 2) % 4;
        int nx = r + dir[nd][0];
        int ny = c + dir[nd][1];

        //뒤로 갈 수 있고, 벽이 아닌 경우
        if (isRange(nx, ny) && map[nx][ny] != 1) return new int[]{nx, ny, d};
        return new int[]{r, c, d};

    }

    private static boolean checkAroundArea(int r, int c) {
        //주변에 0이 없다면 true
        for (int d = 0; d < 4; d++) {
            int nx = r + dir[d][0];
            int ny = c + dir[d][1];

            if (isRange(nx, ny) && map[nx][ny] == 0)
                return false;
        }
        return true;
    }

    private static boolean isRange(int x, int y) {
        if (x < 0 || y < 0 || x >= N || y >= M) return false;
        return true;
    }

    private static boolean checkNowArea(int r, int c) {
        if (map[r][c] == 0) return true; //청소되지 않은 칸이라면 true
        return false;
    }
}

[백준 Java] 13458 시험 감독

민딛 — Thu, 1 Jun 2023 22:37:15 +0900

문제 링크

https://www.acmicpc.net/problem/13458

풀이

감독관의 수가 int 자료형 범위를 벗어나기 때문에 long으로 선언

총감독관은 한 시험장마다 한명이기 때문에 응시자 수 - 감독가능수

부감독관은 남은 응시자 수 - 감독가능수를 했을 때 나머지가 0이라면 응시자수 / 감독가능수

나머지가 0이 아니라면 응시자 수 - 감독가능수 + 1을 감독관 수에 더해줌

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine()); //시험장의 개수

        int[] map = new int[N];
        StringTokenizer tokens = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) { //응시자의 수
            map[i] = Integer.parseInt(tokens.nextToken());
        }

        tokens = new StringTokenizer(br.readLine());
        int B = Integer.parseInt(tokens.nextToken()); //총감독관
        int C = Integer.parseInt(tokens.nextToken()); //부감독관

        //총 감독관은 시험장 당 1명
        //부 감독관은 여러명 가능
        //감독관 최소

        long cnt = 0;
        for (int i = 0; i < N; i++) {
            //총감독관
            if (map[i] < B) {//총감독관이 모두 감독 가능
                cnt++;
                continue;
            }
            map[i] -= B;
            cnt++;

            //부감독관
            if (map[i] <= 0) continue;

            int a = map[i] / C;
            int b = map[i] % C;
            if (b != 0) {
                cnt += a + 1;
            } else {
                cnt += a;
            }
        }
        System.out.println(cnt);

    }
}

[백준 Java] 1316 그룹 단어 체커

민딛 — Thu, 25 May 2023 22:53:20 +0900

문제 링크

https://www.acmicpc.net/problem/1316

풀이

결과값이 될 그룹 단어의 개수를 N으로 초기화 한다.

입력 받은 단어의 글자수만큼 반복문을 실행한다.

반복문 안에서 단어를 한글자씩 읽고, map을 활용한다

1) getOrDefault를 사용하여 존재하는 경우 값을 가져오고, 없는 경우 -1로 처리한다.

2) -1인 경우에는 현재 단어가 몇번째 단어인지 인덱스를 같이 넣어준다

3) 값이 존재하는데, 그 값이 현재 단어의 인덱스와 1 차이가 아니라면 그룹 단어가 되지 못하기 때문에 그룹 단어의 수를 감소하고 다음 입력으로 넘어간다.

예를 들어 aba 를 읽었는데 map에서 'a'의 값은 0이다. 현재 인덱스는 2이기 때문에 둘의 차이가 1이 아니다. 따라서 그룹 단어가 되지 못한다.

4) 값이 존재하고, 인덱스 차이가 1이라면 현재 인덱스로 map의 값을 갱신한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());

        int res = N;
        for (int i = 0; i < N; i++) {
            HashMap<Character, Integer> map = new HashMap<>();
            String str = br.readLine();
            for (int j = 0; j < str.length(); j++) {
                char w = str.charAt(j);
                int val = map.getOrDefault(w, -1);
                if(val == -1){ //존재하지 않는 경우
                    map.put(w, j);
                    continue;
                }
                //값이 존재하는 경우 인덱스 비교
                if(j-1 != val){
                    //연속으로 존재하지 않는다 그룹단어가 아님
                    res--;
                    break;
                }
                //값이 존재하고 인덱스가 1개 차이 날 때
                map.replace(w, j);
            }
        }
        System.out.println(res);
    }
}

[Programmers MySQL] 조건에 맞는 도서와 저자 리스트 출력하기

민딛 — Sat, 20 May 2023 17:34:59 +0900

문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/144854

풀이

작가 아이디가 일치하고 경제인 행에 대해서만 조회

코드

select BOOK_ID, AUTHOR_NAME, date_format(PUBLISHED_DATE,"%Y-%m-%d") as PUBLISHED_DATE
from BOOK as b, AUTHOR as a
where CATEGORY = "경제" and b.AUTHOR_ID = a.AUTHOR_ID
order by PUBLISHED_DATE;

[Programmers MySQL] 성분으로 구분한 아이스크림 총 주문량

민딛 — Sat, 20 May 2023 17:28:53 +0900

문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/133026

풀이

조인 실행 후 그룹함수를 적용한다.

그런데 문제 조건에 총주문량이 작은 순서대로 조회하는 SQL 문이라고 적혀있는데 해당 조건을 안 써도 통과가 된다.

그래도 정렬을 추가해서 다시 제출했다.

코드

select INGREDIENT_TYPE, SUM(TOTAL_ORDER) as TOTAL_ORDER
from FIRST_HALF as f join ICECREAM_INFO as i
on f.FLAVOR = i.FLAVOR
group by INGREDIENT_TYPE
order by TOTAL_ORDER;

[Programmers MySQL] 가격대 별 상품 개수 구하기

민딛 — Sat, 20 May 2023 17:16:37 +0900

문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/131530

풀이

그룹화 하여 그룹화 한 대상과 개수를 표시한다

TRUNCATE(대상, 자리수)는 대상을 자리수만큼 보일 수 있게 내림을 한다.

TRUNCATE(12.345, 2)	12.34
TRUNCATE(12.345, 0)	12
TRUNCATE(12.345, -2)	0

마이너스가 붙으면 0이 1의 자리가 되어 12가 나타나고, -2인 경우 3의 자리가 없이 때문에 0이 된다. -1을 하면 10이 나오게 됨

truncate를 PRICE_GROUP라고 지정했기 때문에 이것을 기준으로 그룹 함수를 사용한다.

코드

select truncate(price, -4) as PRICE_GROUP, count(product_id) as PRODUCTS
from product
group by PRICE_GROUP
order by PRICE_GROUP;

[Programmers MySQL] 가격이 제일 비싼 식품의 정보 출력하기

민딛 — Sat, 20 May 2023 16:54:30 +0900

문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/131115

풀이

집계 함수 max를 사용하면 하나의 행만 리턴하기 때문에 최대 가격을 서브 쿼리로 가져오고 해당하는 가격의 상품 정보를 select 한다

코드

select product_id, product_name, product_cd, category, price
from food_product
where price = (
    select max(price)
    from food_product
);

[Programmers MySQL] 가장 비싼 상품 구하기

민딛 — Sat, 20 May 2023 16:45:28 +0900

문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/131697

코드

select MAX(price) as MAX_PRICE
from product

[Programmers MySQL] 조건에 부합하는 중고거래 댓글 조회하기

민딛 — Sat, 20 May 2023 15:46:20 +0900

문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/164673

풀이

첫번째 방법 : 조인

두번째 방법 : 테이블 2개 두고 where로 조건 걸기

어떤 것이 더 효율적인 방법인지 생각해보고 싶다

조인의 경우는 where절에서 필터링을 걸기 때문에 조인을 수행하고 난 뒤면 데이터의 크기가 너무 커지지 않는지 궁금하다.

그리고 두번째 방법을 쓰는 경우 where에서 board_id가 같은 것만 선택하는 것 깜빡하지 않기!!

코드

# 조인
select
    TITLE, 
    b.BOARD_ID, 
    REPLY_ID, 
    r.WRITER_ID, 
    r.CONTENTS, 
    DATE_FORMAT(r.CREATED_DATE, "%Y-%m-%d") as CREATED_DATE
from USED_GOODS_BOARD as b join USED_GOODS_REPLY as r
on b.BOARD_ID = r.BOARD_ID
where YEAR(b.CREATED_DATE) = 2022 and MONTH(b.CREATED_DATE) = 10
order by r.CREATED_DATE, TITLE;

# where
select 
    title, 
    b.board_id, 
    reply_id, 
    r.writer_id, 
    r.contents, 
    date_format(r.created_date, "%Y-%m-%d") as CREATED_DATE
from used_goods_board as b, used_goods_reply as r
where b.board_id = r.board_id
and date_format(b.created_date, "%Y-%m") = '2022-10'
order by r.created_date, title;

[Programmers MySQL] 과일로 만든 아이스크림 고르기

민딛 — Sat, 20 May 2023 15:17:06 +0900

문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/133025

풀이

두가지 방법으로 풀었다.

첫번째는 서브쿼리를 사용하였고, 두번째는 join을 사용했다

코드

# 서브쿼리
select flavor
from first_half
where total_order > 3000 and flavor in (
    select flavor
    from icecream_info
    where ingredient_type = 'fruit_based'
)
order by total_order desc;

# 조인
select first_half.flavor
from first_half join icecream_info
on first_half.flavor = icecream_info.flavor
where total_order > 3000 and ingredient_type = 'fruit_based'
order by total_order desc;

[Programmers MySQL] 3월에 태어난 여성 회원 목록 출력하기

민딛 — Sat, 20 May 2023 14:47:15 +0900

문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/131120

풀이

DATE 타입을 출력하면 1992-03-16 00:00:00으로 나오기 때문에 DATE_FORMAT(DATE_OF_BIRTH, "%Y-%m-%d") as DATE_OF_BIRTH를 사용했다.

%Y	4자리 연도	%y	2자리 연도
%M	영어 월	%m	2자리 월
%D	일+th	%d	2자리 일

DATE 타입에서 월만 가져오려면 MONTH(컬럼명)을 사용한다. 이외에 YEAR(대상), MONTH(대상), DAY() 아니면 DAYOFMONTH()가 있다.

코드

SELECT MEMBER_ID, MEMBER_NAME, GENDER, DATE_FORMAT(DATE_OF_BIRTH, "%Y-%m-%d") as DATE_OF_BIRTH
FROM MEMBER_PROFILE
WHERE GENDER = 'W' 
    and MONTH(DATE_OF_BIRTH) = 3 
    and TLNO is not null
ORDER BY MEMBER_ID;

[백준 Java] 1018 체스판 다시 칠하기

민딛 — Tue, 9 May 2023 21:58:09 +0900

문제 링크

https://www.acmicpc.net/problem/1018

접근 방법

M,N의 크기에서 8*8로 정사각형을 탐색한다.

8*8 정사각형이 만들어지면 그 안에서 WBWBWB, BWBWBW로 시작하는 경우를 생각하여 일치하지 않는 사각형의 개수를 센다.

WBWBWB로 시작했으면 다음 행은 BWBWBW로 탐색해야 하기 때문에, 현재 행이 홀수인지 짝수인지에 따라서 어떤 순서와 비교해야 하는지 설정했다.

또한, 현재 카운트가 최소로 칠해야 하는 사각형의 수를 넘었다면 더이상 탐색할 필요가 없기 때문에 return했다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens = new StringTokenizer(br.readLine());

        int M = Integer.parseInt(tokens.nextToken()); //행
        int N = Integer.parseInt(tokens.nextToken()); //열

        char[][] map = new char[M][N];
        for (int i = 0; i < M; i++) {
            map[i] = br.readLine().toCharArray();
        }

        //8 * 8로 만들 수 있는 정사각형만큼 반복
        int row = M - 8 + 1;
        int col = N - 8 + 1;
        int res = Integer.MAX_VALUE;

        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                res = checkArea(i, j, map, res);
            }
        }
        System.out.println(res);

    }

    private static int checkArea(int row, int col, char[][] map, int res) {
        char[] W = {'W', 'B', 'W', 'B', 'W', 'B', 'W', 'B'};
        char[] B = {'B', 'W', 'B', 'W', 'B', 'W', 'B', 'W'};

        //현재 row행 col열에서 시작하여 8*8의 정사각형 확인
        int wcnt = 0; //W로 시작하는 경우 색칠할 사각형 수
        int bcnt = 0; //B로 시작하는 경우 색칠할 사각형 수

        //해당 정사각형에서 색이 일치하지 않는 사각형 개수 확인
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                char now = map[row + i][col + j];
                if(i%2==0){
                    if(now!=W[j]) wcnt++;
                    if(now!=B[j]) bcnt++;
                }else{
                    if(now!=B[j]) wcnt++;
                    if(now!=W[j]) bcnt++;
                }
                if(wcnt > res && bcnt > res)
                    return res;
            }
        }
        return Math.min(res, Math.min(wcnt, bcnt));
    }
}

[CodeTree Java] 함께가는 열차

민딛 — Tue, 25 Apr 2023 09:15:19 +0900

문제 링크

https://www.codetree.ai/training-field/search/a-train-that-goes-together/description?page=1&pageSize=20&username=

접근 방법

위치가 증가하는 순서로 주어졌기 때문에 배열의 뒤에서부터 탐색한다.

열차의 속도가 같거나 작은 경우는 따라잡지 못하고, 큰 경우에는 따라잡을 수 있다.

반복문을 돌면서 가장 끝 위치의 속도를 저장하고 이 속도보다 작거나 같은 경우 만날 수 없기 때문에 결과값 증가, 열차의 속도를 현재 배열 값으로 갱신한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens;

        int N = Integer.parseInt(br.readLine());

        int[] arr = new int[N];

        for (int i = 0; i < N; i++) {
            tokens = new StringTokenizer(br.readLine());
            Integer.parseInt(tokens.nextToken());
            int speed = Integer.parseInt(tokens.nextToken());

            arr[i] = speed;
        }

        int res = 1;
        int min = arr[N - 1];

        for (int i = N - 2; i >= 0; i--) {
            if(arr[i] <= min){
                res++;
                min = arr[i];
            }
        }

        System.out.println(res);

    }
}

[CodeTree Java] 우유 생산량 경쟁

민딛 — Sun, 23 Apr 2023 22:16:39 +0900

문제 링크

https://www.codetree.ai/training-field/search/milk-production-competition/description?page=3&pageSize=20&username=

접근 방법

100일 만큼의 크기인 days 배열에 소의 이름과 등락값 저장
100일만큼 반복문을 돌면서 우유의 등락값 계산
우유의 최대값을 계산하고 임시 전광판 배열인 temp에서 최대값으로 우유를 생산한 소의 전광판만 1로 표시해줌
이전 전광판과 비교해서 달라졌다면 res++
전광판 갱신

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main_우유생산량경쟁 {

    static final StringB= "Bessie";
    static final StringE= "Elsie";
    static final StringM= "Mildred";

    static class Cows{
        String name;
        int upDown;

        public Cows(String name, int upDown) {
            this.name = name;
            this.upDown = upDown;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens;

        int N = Integer.parseInt(br.readLine());
        Cows[] days = new Cows[101];

        for (int i = 0; i < N; i++) {
            tokens = new StringTokenizer(br.readLine());

            int day = Integer.parseInt(tokens.nextToken());
            String cow = tokens.nextToken();
            int upDown = Integer.parseInt(tokens.nextToken());

            days[day] = new Cows(cow, upDown);
        }

        //가장 처음 날짜는 7갤런씩, 3마리 모두 전광판에 이름을 올림
        int res = 0;
        int[] score = new int[]{7, 7, 7};
        int[] prev = new int[]{1, 1, 1};

        for (int i = 0; i <= 100; i++) {
            if(days[i] == null) continue;

            //우유 등락 계산
            if(days[i].name.equals(B)){
                score[0] += days[i].upDown;
            } else if (days[i].name.equals(E)) {
                score[1] += days[i].upDown;
            }else {
                score[2] += days[i].upDown;
            }

            //최대값 구하기
            int max = Math.max(score[0], Math.max(score[1], score[2]));

            //전광판에 올라갈 최대값만 저장
            int[] temp = new int[3];
            for (int j = 0; j < 3; j++) { //최대값만 저장
                if(score[j] == max) temp[j] = 1;
            }

            //이전 전광판이랑 비교해서 달라졌는지 확인
            boolean flag = false;
            for (int j = 0; j < 3; j++) {
                if(prev[j] != temp[j]) flag = true;
            }
            if(flag) res++;

            //전광판 갱신
            prev = Arrays.copyOf(temp, 3);
        }
        System.out.println(res);
    }
}

[백준 Java] 1439 뒤집기

민딛 — Tue, 18 Apr 2023 19:54:53 +0900

문제 링크

https://www.acmicpc.net/problem/1439

접근 방법

0이 연속되는 횟수와, 1이 연속되는 횟수를 구해서 적은 값을 선택한다

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main_1439_뒤집기 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String num = br.readLine();

        //0과 1이 연속되지 않는 영역 개수 구함

        int prev = num.charAt(0) - '0'; //처음 값

        //처음 영역 설정
        int zero = prev == 0 ? 1 : 0;
        int one = prev == 1 ? 1 : 0;

        for (int i = 1; i < num.length(); i++) {
            int cur = num.charAt(i) - '0';
            if (prev != cur) {
                prev = cur;
                //현재 들어온 값이 0인지 1인지에 따라 영역 선택
                zero += cur == 0 ? 1 : 0;
                one += cur == 1 ? 1 : 0;
            }
        }

        System.out.println(Math.min(zero, one));
    }
}

[CodeTree Java] 두 단어 중 특정 알파벳

민딛 — Mon, 17 Apr 2023 21:32:59 +0900

문제 링크

https://www.codetree.ai/training-field/search/specific-alphabet-of-two-words/submissions?page=3&pageSize=20&username=

접근 방법

한 행에 대해서 양 옆의 문자 중 서로 다른 단어가 나오면 그 단어의 카운트를 집계, 같은 단어가 나온다면 가장 많이 나온 횟수를 갱신하는 것이었다.

문제 이해하는데 시간이 오래 걸려서 스터디원의 도움을 받았다.

fox box의 경우는 f, b 경우에는 겹치지 않기 때문에 1을 추가. o와 x는 둘 다 최대 1번씩 나타나기 때문에 1씩 갱신해준다

bus car의 경우에는 b는 한번 등장했기에 위에서 +1을 해줘서 총 2가 되고, 나머지의 경우도 1로 갱신이 된다.

코드

import java.io.*;
import java.util.StringTokenizer;

public class Main_두단어중특정알파벳 {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        int T = Integer.parseInt(br.readLine());

        int[] res = new int[26];
        int[] cnt1, cnt2;

        String left, right;

        for (int i = 0; i < T; i++) {
            StringTokenizer tokens = new StringTokenizer(br.readLine());
            left = tokens.nextToken();
            right = tokens.nextToken();

            cnt1 = new int[26];
            cnt2 = new int[26];

            for (int j = 0; j < left.length(); j++) {
                cnt1[left.charAt(j)-'a']++;
            }
            for (int j = 0; j < right.length(); j++) {
                cnt2[right.charAt(j)-'a']++;
            }

            for (int j = 0; j < 26; j++) {
                res[j] += Math.max(cnt1[j], cnt2[j]);
            }

        }

        for (int i = 0; i < 26; i++) {
            bw.write(res[i]+"\n");
        }
        bw.flush();
        bw.close();

    }
}

[CodeTree Java] 수의 곱셈

민딛 — Mon, 17 Apr 2023 21:29:22 +0900

문제 링크

https://www.codetree.ai/training-field/search/specific-alphabet-of-two-words/description?page=1&pageSize=20&username=

접근 방법

a, b, c와 세 수를 각각 곱한 값 7개를 만든다

리스트에 담아 큰 수 먼저 정렬, 그 다음으로 홀수를 정렬

정렬을 2번 하는 것이 비효율적이라 생각이 들었다.

스터디원의 얘기를 들어보니 홀수가 없다면 전부 곱하고, 홀수가 있다면 홀수만 계산하는 방법을 선택했다고 한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class Main_수의곱셈 {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer tokens = new StringTokenizer(br.readLine());
        int a = Integer.parseInt(tokens.nextToken());
        int b = Integer.parseInt(tokens.nextToken());
        int c = Integer.parseInt(tokens.nextToken());

        ArrayList<Integer> list = new ArrayList<>();
        list.add(a);
        list.add(b);
        list.add(c);
        list.add(a * b);
        list.add(a * c);
        list.add(b * c);
        list.add(a * b * c);

        //큰 수 정렬
        Collections.sort(list, Collections.reverseOrder());

        //홀수 정렬
        Collections.sort(list, ((x, y) ->{
            if(x%2==1 && y%2==0){
                return x-y;
            }
            return y-x;
        }));

        System.out.println(list.get(0));

    }

}

[백준 Java] 7562 나이트의 이동

민딛 — Sun, 9 Apr 2023 21:27:42 +0900

문제 링크

https://www.acmicpc.net/problem/7562

접근 방법

최단 시간에 도착해야 하기 때문에 bfs

나이트가 갈 수 있는 방향을 8방으로 지정해두고 이동 횟수를 추가하여 진행

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens;

        int T = Integer.parseInt(br.readLine());

        while (T-- > 0) {
            int l = Integer.parseInt(br.readLine());

            int[][] map = new int[l][l];

            tokens = new StringTokenizer(br.readLine());
            int x1 = Integer.parseInt(tokens.nextToken());
            int y1 = Integer.parseInt(tokens.nextToken());

            tokens = new StringTokenizer(br.readLine());
            int x2 = Integer.parseInt(tokens.nextToken());
            int y2 = Integer.parseInt(tokens.nextToken());

            //나이트의 이동 방향 8방
            System.out.println(bfs(x1, y1, x2, y2, l));
        }
    }

    private static int bfs(int x1, int y1, int x2, int y2, int l) {
        int res = -1;
        Queue<int[]> q = new ArrayDeque<>();
        q.offer(new int[]{x1, y1, 0});

        boolean[][] v = new boolean[l][l];
        v[x1][y1] = true;

        while (!q.isEmpty()){
            int[] c = q.poll();

            if(c[0] == x2 && c[1] == y2){
                res = c[2];
                break;
            }

            for (int d = 0; d < 8; d++) {
                int nx = c[0] + dir[d][0];
                int ny = c[1] + dir[d][1];

                if(!isRange(nx, ny, l) || v[nx][ny]) continue;
                v[nx][ny] = true;
                q.offer(new int[]{nx, ny, c[2]+1});
            }
        }
        return res;
    }


    static int[][] dir = {
            {-2, -1}, {-2, 1},
            {-1, -2}, {1, -2},
            {2, -1}, {2, 1},
            {-1, 2}, {1, 2}};

    private static boolean isRange(int x, int y, int l) {
        if (x < 0 || x >= l || y < 0 || y >= l) return false;
        return true;
    }
}

[CodeTree Java] 코드트리 빵

민딛 — Thu, 30 Mar 2023 23:25:54 +0900

문제 링크

https://www.codetree.ai/training-field/frequent-problems/codetree-mon-bread/description?page=3&pageSize=20&username=

접근 방법

위치 배열을 2차원 배열로 사용했다. [사람수][편의점/현위치]

한번 이동할때마다 이 사람이 베이스캠프에 배정되어야 하는지, 편의점에 도착했는지를 확인해야 한다.

자기 차례가 현재 시간보다 크면 더 이상 탐색할 필요가 없다.

이동할때에는 어느 방향으로 가야 하는지를 처음에 몰랐다. 스터디에서 bfs로 가야 하는 방향을 구하려면, 처음에 방향에 대한 값을 그대로 유지하면서 도착지까지 bfs로 구한다. 그래서 q에 넣을 때 처음 4방향이 범위에 맞고 갈 수 있는 방향인지 확인한 다음 큐에 모두 넣었다.

이 부분을 생각하지 못해서(그리고 그 외 코드 오류의 이유로) 44%에서 시간 초과가 났으나 결국 고쳤다!

편의점에 도착했는지 확인할 때,

if (pos[i][0].x == pos[i][1].x && pos[i][0].y == pos[i][1].y)

if (pos[i][0] == pos[i][1])

이 두개가 같은 동작이 되는 줄 알고 후자로 썼다가 메모리 초과가 생겼다. 자바에서 객체에 대한 비교는 메모리 주소를 비교하기 때문에 땡!

또한, 처음에는 베이스캠프를 전부 구해두고 시작하려 했는데 다른 부분과 겹쳐져 오류가 났다. 베이스캠프를 전부 구하고 시작해도 되는지 궁금하다. 다음에 시간이 날 때 한번 풀어봐야겠다.

코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.StringTokenizer;

public class Main {
    static int N, M, map[][], finish;
    static Pos pos[][];
    static int[][] dir = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};

    static class Pos {
        int x, y, d;

        public Pos(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public Pos(int x, int y, int d) {
            this.x = x;
            this.y = y;
            this.d = d;
        }
    }

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens = new StringTokenizer(br.readLine());

        //입력 받기
        N = Integer.parseInt(tokens.nextToken()); //격자 크기
        M = Integer.parseInt(tokens.nextToken()); //사람 수
        map = new int[N][N]; //맵
        pos = new Pos[M][2]; //편의점 위치, 현재 위치

        //map input
        for (int i = 0; i < N; i++) {
            tokens = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                map[i][j] = Integer.parseInt(tokens.nextToken());
            }
        }

        //store input
        for (int i = 0; i < M; i++) {
            tokens = new StringTokenizer(br.readLine());
            pos[i][0] = new Pos(Integer.parseInt(tokens.nextToken()) - 1, Integer.parseInt(tokens.nextToken()) - 1);
        }

        int t = 0;
        finish = 0;
        while (finish < M) {
            move(t++);
        }
        System.out.println(t);

    }

    private static void move(int t) {
        //한 타임마다 모든 사람 이동
        for (int i = 0; i < M; i++) {
            //자기 차례가 되지 않아 격자 밖이라면 더이상 진행 안함
            if (i > t) return;
            //t == i이고 pos 현위치가 null이라면 베이스캠프 배정
            if (i == t && pos[i][1] == null) {
                getBaseCamp(i); //i번째 사람이 가려는 편의점에서 가장 가까운 베이스캠프 정함
            } else { //아니라면 최단 거리로 갈 방향 선택해서 이동
                if(pos[i][1] == null) continue; //이미편의점에 도착한 사람
                int d = goFast(i); //최단 거리로 갈 방향 구해옴
                //이동
                pos[i][1].x += dir[d][0];
                pos[i][1].y += dir[d][1];
                //편의점에 도착했는지 확인
                if (pos[i][0].x == pos[i][1].x && pos[i][0].y == pos[i][1].y) {
                    int cx = pos[i][0].x;
                    int cy = pos[i][0].y;
                    map[cx][cy] = 9; //맵에 방문 못하게 처리
                    pos[i][1] = null; //자신은 비움
                    finish++; //편의점에 도착한 사람 처리
                }
            }

        }

    }

    private static int goFast(int idx) { //현위치
        //현 위치에서 목적지 편의점까지 가장 빠른 방향을 구함
        Pos dest = pos[idx][0]; //도착하고자 하는 곳
        Pos start = pos[idx][1]; //현재 위치
        Deque<Pos> q = new ArrayDeque<>();
        boolean[][] v = new boolean[N][N];

        //4방향 전부 넣음
        for (int d = 0; d < 4; d++) {
            int nx = start.x + dir[d][0];
            int ny = start.y + dir[d][1];
            if(!isRange(nx, ny) || map[nx][ny] == 9) continue;
            q.offer(new Pos(nx, ny, d));
            v[nx][ny] = true;
        }

        int direction = -1;

        while (!q.isEmpty()) {
            Pos cur = q.poll();
            if (cur.x == dest.x && cur.y == dest.y) {
                //목적지 방향을 구함
                direction = cur.d;
                break;
            }

            for (int d = 0; d < 4; d++) {
                int nx = cur.x + dir[d][0];
                int ny = cur.y + dir[d][1];

                if (!isRange(nx, ny) || map[nx][ny] == 9 || v[nx][ny]) continue;
                q.offer(new Pos(nx, ny, cur.d)); //방향 처음 그대로 저장
                v[nx][ny] = true;
            }
        }
        return direction;
    }

    //베이스 캠프 정하기 : bfs, 주어진 방향 순서대로 이동 후 가장 먼저 도착하는 곳이 베이스캠프(상좌우하)
    private static void getBaseCamp(int idx) {
        Pos s = pos[idx][0];
        Deque<Pos> q = new ArrayDeque<>();
        q.offer(s);
        boolean[][] v = new boolean[N][N];
        v[s.x][s.y] = true;

        while (!q.isEmpty()) {
            Pos cur = q.poll();

            for (int d = 0; d < 4; d++) {
                int nx = cur.x + dir[d][0];
                int ny = cur.y + dir[d][1];

                if (!isRange(nx, ny) || map[nx][ny] == 9 || v[nx][ny]) continue;
                //0이면 다음 위치로
                if (map[nx][ny] == 0) {
                    q.offer(new Pos(nx, ny));
                    v[nx][ny] = true;
                }
                //1이면 베이스 캠프 선택 완료
                if (map[nx][ny] == 1) {
                    pos[idx][1] = new Pos(nx, ny); //현재 위치 갱신
                    map[nx][ny] = 9; //맵에서 사용 못하게 처리
                    return;
                }
            }
        }
    }

    private static boolean isRange(int x, int y) {
        if (x < 0 || y < 0 || x >= N || y >= N) return false;
        return true;
    }

}

[백준 Java] 4673 셀프 넘버

민딛 — Fri, 24 Mar 2023 22:13:20 +0900

문제링크

https://www.acmicpc.net/problem/4673

접근 방법

1부터 10000까지 주어진 숫자를 만든다

10000은 10001이 되고, 9999는 9999+9+9+9+9 = 10035이 되기 때문에 숫자 배열을 11000까지 미리 생성해줬다.

만들어진 숫자를 인덱스로 잡아 값을 증가시켜준다.

1부터 10000까지 탐색하면서 0인 곳을 출력하면 됨.

코드

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringBuilder sb = new StringBuilder();
        int sum;
        //9999 -> 9999+9+9+9+9 = 10035
        int[] arr = new int[11000];
        for (int i = 1; i <= 10000; i++) {
            //1~10000까지 숫자를 다 만듦
            sum = 0;
            String str = Integer.toString(i);
            for (int j = 0; j < str.length(); j++) {
                sum += str.charAt(j) - '0';
            }
            sum += i;
            arr[sum]++;
        }
        for (int i = 1; i <= 10000; i++) {
            if(arr[i] == 0){
                sb.append(i).append("\n");
            }
        }
        
        bw.write(sb.toString());
        bw.flush();
        bw.close();
    }
}

[Programmers Java] 이모티콘 할인행사

민딛 — Thu, 23 Mar 2023 21:57:57 +0900

문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/150368

접근 방법

이모티콘 마다 할인율을 dfs로 구함
사용자 수만큼 반복
1. 이모티콘 수만큼 반복
  - 이모티콘 할인율 ≥ 사용자 라면 할인율을 계산해서 지불할 금액에 더함
2. 지불할 금액 ≥ 제한금액이면 이모티콘 플러스 가입
3. 아니라면 판매액에 지불할 금액 더함
결과값이랑 비교
1. 이모티콘 플러스 사용자가 많다면 갱신
2. 이모티콘 플러스 사용자가 같다면 판매액이 더 많은 것 갱신

블라인드 코테에선 못 풀었는데 끝나고 반년 뒤에 푸니까 풀렸다...

할인율을 배열로 선언할 필요 없이 for문의 i를 40 30 20 10으로 줄어들게 해도 된다.

이렇게 작성하는게 더 깔끔하다는걸 우리의 스터디 알고신에게 배움

이모티콘 금액 계산하다가 이모티콘 플러스 가입 금액이 넘으면 반복문 탈출해도 된다. 여기서 시간을 단축시킬 수 있다고 한다. 이것 또한 알고신의 첨언...

코드

class Solution {
    static int len, resEmo, resSell;
    static int[] r = {40, 30, 20, 10};
    static int e[], u[][];
    public static int[] solution(int[][] users, int[] emoticons) {
        e = emoticons;
        u = users;
        len = emoticons.length;
        resEmo = 0;
        resSell = 0;

        //이모티콘마다 할인율 10, 20, 30, 40 중 선택
        dfs(0, emoticons.length, new int[emoticons.length]);

        System.out.println(resEmo+" "+resSell);

        return new int[]{resEmo, resSell};
    }
    private static void dfs(int dept, int len, int[] s){
        //종료조건
        if(dept == len){
            calcMember(s);
            return;
        }

        //이모티콘 선택
        for (int i = 0; i < 4; i++) {
            s[dept] = r[i]; //할인율 선택
            dfs(dept+1, len, s);
        }
    }

    private static void calcMember(int[] s) {

        int emoPlus = 0;
        int totalSell = 0;

        //사용자 수만큼 for, 구매할 사람 선택
        for(int[] user : u){
            int personRate = user[0];
            int limitMoney = user[1];

            //한 사람이 지불할 가격
            int money = 0;
            //살 이모티콘 선택
            for (int i = 0; i < len; i++) {
                if(s[i] >= personRate){ //일정 비율 이상 할인이라면
                    //살 돈 계산
                    money += e[i] * (100-s[i]) / 100;
                }
            }//살 이모티콘 계산 끝

            //이모티콘 플러스 가입 여부 확인
            if(money >= limitMoney){
                //이모티콘 플러스 가입
                emoPlus++;
            }else{
                totalSell += money; //판매 총액 갱신
            }
        }

        //최종 이모티콘 플러스 가입자, 판매총액 비교
        if(resEmo < emoPlus){
            resEmo = emoPlus;
            resSell = totalSell;
        }else if(resEmo == emoPlus && resSell < totalSell){
            resSell = totalSell;
        }
    }
}

[백준 Java] 16953 A → B

민딛 — Thu, 23 Mar 2023 21:50:24 +0900

문제 링크

https://www.acmicpc.net/problem/16953

접근 방법

dfs를 사용한다.
종료 조건은 A,B가 같은 경우 최소 횟수를 갱신하고 리턴
dfs를 타는 부분은 2를 곱할때, 1을 뒤에 붙일때.

input이 10^9까지 들어오기 때문에 long으로 처리했다.
백트래킹은 횟수와 A의 크기를 비교해서 처리했다.

코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    static int res;

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens = new StringTokenizer(br.readLine());

        Long A = Long.parseLong(tokens.nextToken());
        Long B = Long.parseLong(tokens.nextToken());

        res = Integer.MAX_VALUE;

        dfs(A, B, 1);

        System.out.println(res == Integer.MAX_VALUE ? -1 : res);
    }
    private static void dfs(long A, long B, int cnt) {
        if (res < cnt || A > B) { //백트래킹
            return;
        }

        if (B == A) {
            res = Math.min(res, cnt);
            return;
        }
        //2를 곱함
        dfs(A * 2, B, cnt + 1);
        //끝에 1을 붙임
        dfs(Long.parseLong(Long.toString(A) + "1"), B, cnt + 1);
    }
}

[Codetree Java] 꼬리잡기놀이

민딛 — Wed, 22 Mar 2023 22:19:19 +0900

문제 링크

https://www.codetree.ai/training-field/frequent-problems/tail-catch-play/description?page=3&pageSize=20&username=nnindd&discussionRowsPerPage=5&discussionPage=1

접근 방법

큰 순서는 아래와 같다.

1의 위치를 리스트에 저장
k번 게임 실행
- 이동 (M만큼 for)
  - 바뀐 1의 위치 갱신
- 공 던지는 4분면, 행, 열, 방향 구하기
- 공 던지기
  - 맞음
    - 맞았다면 몇번째 사람인지 구하기
      - 맵의 크기만큼 반복문 돌면서 1인 곳 찾기
      - 1이면 해당 팀원 위치 리스트 받아오기
      - 그 리스트에 맞은 사람 위치 있는지 확인
      - 있으면 맵에서 1, 3 변경
      - 있으면 머리 리스트에서 1 위치 갱신
      - 인덱스 제곱 계산해서 반환
  - 안 맞음
    - 공 멈추기 않고 던지기

길다..
우욱..
깔끔하게 작성하려고 함수를 다 빼면서 작성하다가 헷갈려서 생각나는대로 적었다.
input이 적기 때문에 전부 확인해봐도 되었고, 시간복잡도는 O(K*N^2)라니 1000*20^2면.. 할만함

어려웠던 부분

공 던지는 위치를 구하는게 어려웠다.

일정한 크기에 대해서 지정을 하려면 % 연산이 필요하다는걸 알겠는데 어떻게 계산을 해야 할지 몰라서 처음엔 풀지 못했다.

일단 4분면 중 한곳에 위치할 수 있게 하고, 방향에 따라서 N 안에서 어디에 위치하는지...

/ 와 % 를 사용하면 된다는걸 아는데.. 아는데! 항상 헷갈린다..

더 많이 풀어봐야함

지나갈 수 있는 길이 1 2 2 3 4 4 4 이런 형식이 아니라 1 2 2 2 2 3 으로 끝나는 경우를 생각해봐야 한다.

1이 이동할 땐 4인 곳으로 가는 것이 아니라 2가 아닌 곳으로 간다고 생각해야 한다.

이 생각을 듣고 아득해짐......

코드

import java.io.*;
import java.util.*;

public class Main {

    static int N, M, K, map[][], total;
    static ArrayList<int[]> first; //1의 위치
    static int[][] dir = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        StringTokenizer tokens = new StringTokenizer(br.readLine());
        N = Integer.parseInt(tokens.nextToken()); //격자 크기
        M = Integer.parseInt(tokens.nextToken()); //팀의 개수
        K = Integer.parseInt(tokens.nextToken()); //라운드 수

        map = new int[N][N]; //맵
        total = 0;

        first = new ArrayList<>();
        for (int i = 0; i < N; i++) {
            tokens = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                map[i][j] = Integer.parseInt(tokens.nextToken());
                if (map[i][j] == 1) { //1의 위치 저장
                    first.add(new int[]{i, j});
                }
            }
        }//end input

        for (int i = 0; i < K; i++) {
            total += play(i);
        }

        bw.write(total + "");
        bw.flush();
        bw.close();
    }

    private static int play(int k) {
        //이동
        for (int i = 0; i < M; i++) {
            int[] cur = move(first.get(i));
            //바뀐 1의 위치 갱신해주기
            first.set(i, cur);
        }

        //공던짐
        int[] rcd = getRowColDirection(k);
        int area = rcd[0];
        int row = rcd[1];
        int col = rcd[2];
        int d = rcd[3];

        int x = row;
        int y = col;
        int temp = 0;
        while (isRange(x, y)) { //범위 안 벗어날때까지
            if (map[x][y] != 0 && map[x][y] != 4) {
                //맞은 사람 몇번째인지 구하기 + 점수 갱신 + 머리 꼬리 바꾸기
                temp = checkIndex(x, y);
                break;
            }
            //안 맞았으면 다음방향
            x += dir[d][0];
            y += dir[d][1];
        }
        return temp;
    }

    private static int checkIndex(int x, int y) {
        //몇번째 사람인지 구하기

        ArrayList<int[]> list;

        //1인 부분 확인
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (map[i][j] != 1) continue;

                //이 팀원 리스트 불러옴
                list = getTeamPosition(new int[]{i, j});

                //이 팀원 중 이사람이 있는지 확인
                for (int k = 0; k < list.size(); k++) {
                    if (list.get(k)[0] == x && list.get(k)[1] == y) {
                        //머리 꼬리 맵에서 바꾸기
                        int[] front = list.get(0);
                        int[] back = list.get(list.size()-1);
                        int temp = map[front[0]][front[1]];
                        map[front[0]][front[1]] = map[back[0]][back[1]];
                        map[back[0]][back[1]] = temp;

                        //머리 리스트에 머리 변경
                        for (int l = 0; l < first.size(); l++) {
                            int[] head = first.get(l);
                            if(head[0] == front[0] && head[1] == front[1]){
                                first.set(l, back); //꼬리를 머리로 바꿈
                            }
                        }
                        //점수 반환
                        return (k + 1) * (k + 1);
                    }
                }
            }
        }
        return 0;
    }

    private static int[] getRowColDirection(int k) {
        //던진 위치에 따라서 행, 열, 방향을 구함
        // 좌 하 우 상 순서로 0 1 2 3
        int area, row, col, dir; //4변 중 위치, 어느 행/열에 있는지, 공던지는 방향

        area = (k / N) % 4; //4변 중 어디인지 구하기

        if (area == 0) {
            col = 0;
            row = k % N;
            dir = 3;
        } else if (area == 1) {
            row = N - 1;
            col = k % N;
            dir = 0;
        } else if (area == 2) {
            row = N - (k % N) - 1;
            col = N - 1;
            dir = 2;
        } else {
            row = 0;
            col = N - (k % N) - 1;
            dir = 1;
        }

        return new int[]{area, row, col, dir};
    }

    private static int[] move(int[] n1) {
        //팀원 리스트 구함
        ArrayList<int[]> list = getTeamPosition(n1);

        //한명씩 이동 -> 첫번째만 갈 곳 정하고 그 다음부턴 이전의 위치로 변경
        //첫번째 이동
        int[] one = n1;//첫번째가 이동한 위치 저장 (1이 3으로 이동했을 때 4로 덮어씌워지는것 방지)
        for (int d = 0; d < 4; d++) {
            int nx = n1[0] + dir[d][0];
            int ny = n1[1] + dir[d][1];

            //범위 내이고 2가 아닐때
            if (!isRange(nx, ny) || map[nx][ny] == 0) continue;
            if (map[nx][ny] != 2) {
                map[nx][ny] = map[n1[0]][n1[1]]; //1번은 0,2가 아닌 곳으로 이동
                one = new int[]{nx, ny};
                break; //더 볼 것 없음
            }
        }

        int[] next = n1; //다음 사람이 이동할 곳
        //남은 위치 이동
        for (int i = 1; i < list.size(); i++) {
            //위치 이동
            int[] cur = list.get(i);
            map[next[0]][next[1]] = map[cur[0]][cur[1]]; //앞의 사람이 옮겨간 자리에 채우기
            if (i == list.size() - 1) {
                map[next[0]][next[1]] = 3; //마지막 값이라면 1이 덮어씌운 값으로 들어가는 것 방지3 처리
            }
            map[cur[0]][cur[1]] = 4; //자신이 있던 곳 빈곳 처리
            next = cur; //다음 채울 곳 갱신
        }
        //1이 3으로 이동했을 때 마지막에 4로 덮어 씌워지는 것 방지
        map[one[0]][one[1]] = 1;

        //1의 위치 갱신
        return one;
    }

    private static ArrayList<int[]> getTeamPosition(int[] n1) {
        Queue<int[]> q = new ArrayDeque<>(); //방문확인
        q.offer(n1);
        boolean[][] v = new boolean[N][N];
        v[n1[0]][n1[1]] = true;
        ArrayList<int[]> list = new ArrayList<>(); //팀들 위치 저장 리스트
        list.add(n1);

        //bfs로 팀원 위치 구함
        while (!q.isEmpty()) {
            int[] cur = q.poll();

            for (int d = 0; d < 4; d++) {
                int nx = cur[0] + dir[d][0];
                int ny = cur[1] + dir[d][1];

                if (!isRange(nx, ny) || map[nx][ny] == 0 || map[nx][ny] == 4 || v[nx][ny]) continue;
                //나의 값보다 같거나 하나 클때만 이동
                if ((map[cur[0]][cur[1]] == 1 && map[nx][ny] == 2)
                        || (map[cur[0]][cur[1]] == 2 && map[cur[0]][cur[1]] <= map[nx][ny])) {
                    //1이면 2로만 가고, 2라면 같거나 큰곳으로만
                    v[nx][ny] = true;
                    q.offer(new int[]{nx, ny});
                    list.add(new int[]{nx, ny}); //팀원 위치 저장
                }
            }
        }
        return list;
    }

    private static boolean isRange(int x, int y) {
        if (x < 0 || y < 0 || x >= N || y >= N) return false;
        return true;
    }


}

[Error] Permissions 0644 for 'xxx.pem' are too open.

민딛 — Wed, 22 Mar 2023 11:00:42 +0900

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@         WARNING: UNPROTECTED PRIVATE KEY FILE!          @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Permissions 0644 for 'xxx.pem' are too open.
It is required that your private key files are NOT accessible by others.
This private key will be ignored.
Load key "xxx.pem": bad permissions
ubuntu@xxx.p.ssafy.io: Permission denied (publickey).
lost connection

ec2 서버에서 다른 ec2 서버로 이미지를 전송하기 위해 다음과 같은 명령어를 사용함

scp -i xxx.pem test.png ubuntu@xxx.p.ssafy.io:/디렉토리경로

ssh -i xxx.pem 에서도 같은 문제가 발생했다.

pem 키의 권한을 변경해줘야 한다

chmod 400 xxx.pem

chmod 400 xxx.pem
xxx@CLUSTER:~/data$ sh test.sh
test.png                                                     100%  321KB  72.1MB/s   00:00

권한을 변경한 결과 잘 실행됐다.

[백준 Java] 10610 30

민딛 — Tue, 21 Mar 2023 22:50:29 +0900

문제 링크

https://www.acmicpc.net/problem/10610

접근 방법

처음엔 어렵게 생각했는데 30의 배수를 구하는 방법을 생각하면 된다.

끝은 0으로 끝나야 함
각 자리수의 합이 3의 배수여야 한다

그래서 입력 받은 수를 문자열로 받아 char 배열로 만들고 정렬했다.
내림차순으로 접근해서 가장 큰 수를 만들었음.

코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        //0이 포함되어야 30의 배수를 만들 수 있다.
        //각 자리의 합이 3의 배수여야 30의 배수를 만들 수 있다.

        //1. 입력받은 문자열을 0~9까지의 카운트 배열에 입력하고 총합 계산
        String num = br.readLine();

        char[] arr = num.toCharArray();
        Arrays.sort(arr);

        int sum = 0;
        StringBuilder sb = new StringBuilder();

        for (int i = num.length() - 1; i >= 0; i--) {
            sum += arr[i] - '0';
            sb.append(arr[i] - '0');
        }

        //2. 0을 포함하는지, 총합이 3의 배수인지 확인
        System.out.println(num.contains("0") && sum % 3 == 0 ? sb : -1);
    }

}

[백준 Java] 13305 주유소

민딛 — Fri, 17 Mar 2023 21:55:18 +0900

문제 링크

https://www.acmicpc.net/problem/13305

접근 방법

음~
잘못 생각한 방법

거리 중 가장 싼 도시를 고름
그 도시에서 남은 거리 모두 충전
다른 거리는 다음 도시로 가기 위해 필요한 거리 만큼만 저장

➡️ 이랬더니 17점 나옴

올바른 풀이

순서대로 탐색하면서 이전보다 싸면 최소값으로 갱신
해당 도시의 거리만큼 가장 싼 곳에서 충전

처음에 첫번째 도시를 최소값으로 설정하고, 두번째 도시로 가기 위한 비용을 설정해준다.

for문은 2번째 도시부터 N만큼 탐색한다.

탐색하면서 현재 주유비용이 이전보다 싸다면 최소값을 갱신해준다.

다음 도시로 가기 위해 해당 거리는 꼭 충전을 해줘야 하기 때문에 현재 최소값으로 주유한다.

input 반복문을 두번 돌리고 마지막에 다시 반복문을 돌면서 탐색을 했는데, 도시 주유 비용 입력 받으면서 한번에 처리 해도 돼서 코드를 수정했다.

시간은 O(N)이 됨.

코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int N = Integer.parseInt(br.readLine());
        StringTokenizer tokens = new StringTokenizer(br.readLine());

        //도시 사이 거리
        long[] dist = new long[N - 1];
        for (int i = 0; i < N - 1; i++) {
            dist[i] = Integer.parseInt(tokens.nextToken());
        }

        tokens = new StringTokenizer(br.readLine());
        int cost = Integer.parseInt(tokens.nextToken()); //가장 처음 값

        //초기값 설정. 처음 도시는 다음 거리만큼 충전해야 함
        long min = cost;
        long result = min * dist[0];

        //두번째 도시부터 설정
        for (int i = 1; i < N-1; i++) {
            cost = Integer.parseInt(tokens.nextToken());
            min = cost < min ? cost : min; //이전 값이랑 비교해서 싼 값 저장
            result += (min * dist[i]);
        }// end input

        System.out.println(result);

    }
}

[백준 Java] 1946 신입 사원

민딛 — Thu, 16 Mar 2023 22:28:34 +0900

문제 링크

https://www.acmicpc.net/problem/1946

접근 방법

처음에 문제 이해를 못했다.

1차 점수로 정렬해서 1등을 뽑고 2차 첨수로 정렬했을 때 1등의 2차 점수보다 낮은 사람을 다 탈락시키면 되는건가 싶었는데 아니었다.

정올에서 같은 문제가 있어 반례를 확인해볼 수 있었는데, 다음과 같다

잘못 생각했던 부분은 1차 점수로 정렬하고 2차 점수로 재정렬하는 것이 아니었다.

1차 기준으로 정렬 후 2차에서 2차 점수가 가장 높은 것을 갱신해나가면서 그보다 낮은 지원자들을 빼는 방법이었다.

코드

package BOJ;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main_1946_신입사원 {

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens;
        StringBuilder sb = new StringBuilder();

        int T = Integer.parseInt(br.readLine());
        int N;

        while (T-->0){
            N = Integer.parseInt(br.readLine());

            int[][] arr = new int[N][2];

            for (int i = 0; i < N; i++) {
                tokens = new StringTokenizer(br.readLine());
                //서류, 면접
                arr[i][0] = Integer.parseInt(tokens.nextToken());
                arr[i][1] = Integer.parseInt(tokens.nextToken());
            }

            //서류 기준 오름차순 정렬
            Arrays.sort(arr, (a, b) -> a[0]-b[0]);

            int cnt = N;
            int max = arr[0][1]; //서류 1등의 면접 점수 저장
            for (int i = 1; i < N; i++) {
                if(arr[i][1] < max){//현재 1등의 등수보다 i의 면접 등수가 높으면 최대값 변경
                    max = arr[i][1];
                }else{ //현재 1등의 면접 점수보다 낮으면 선발 안 함
                    cnt--;
                }
            }
            sb.append(cnt).append("\n");
        }
        System.out.println(sb);
    }
}

뿌듯함을 느꼈으나 시간이 이렇게까지 많이 걸린다고? 싶었다.

어떤 힘을 조금 빌린 결과 정렬이 꼭 필요하지 않다는 것을 알게 되었다.

1차인 서류 등수를 인덱스로 사용하고 2차 면접 점수를 값으로 사용하면 정렬할 필요가 없어진다.

이런 생각 해내는 뇌..당장훔쳐...

코드2

package BOJ;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main_1946_신입사원 {

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens;
        StringBuilder sb = new StringBuilder();

        int T = Integer.parseInt(br.readLine());
        int N;

        while (T-->0){
            N = Integer.parseInt(br.readLine());

            int[] arr = new int[N+1];

            for (int i = 0; i < N; i++) {
                tokens = new StringTokenizer(br.readLine());
                //서류, 면접
                int idx = Integer.parseInt(tokens.nextToken());
                int val = Integer.parseInt(tokens.nextToken());

                arr[idx] = val;
            }

            //서류 기준 오름차순 정렬
            int top = arr[1];
            int cnt = 1; //서류 1등

            for (int i = 2; i <= N; i++) {
                if(arr[i] < top){
                    top = arr[i];
                    cnt++;
                }
            }
            sb.append(cnt).append("\n");
        }
        System.out.println(sb);
    }
}

만족

[백준 Java] 10162 전자레인지

민딛 — Thu, 16 Mar 2023 21:23:41 +0900

문제 링크

https://www.acmicpc.net/problem/10162

접근 방법

3번 나누고 나머지를 T에 갱신시켜주면 되는 문제.

간단해서 할 설명이 없다.

랭크 꺼놓고 풀었더니 브론즈였을때의 허무함...

코드

package BOJ;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main_10162_전자레인지 {

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();

        int T = Integer.parseInt(br.readLine());
        int[] arr = {300, 60, 10};

        for (int i = 0; i < 3; i++) {
            sb.append(T / arr[i]).append(" ");
            T %= arr[i];
        }

        if (T != 0) {
            sb.delete(0, sb.length()).append(-1);
        }
        System.out.println(sb);

    }
}

[백준 Java] 1789 수들의 합

민딛 — Wed, 15 Mar 2023 21:29:16 +0900

문제링크

https://www.acmicpc.net/problem/1789

풀이

합이 S라면 1부터 N까지 더하며 S가 넘지 않을때까지 반복한다.

input은 S(1 ≤ S ≤ 4,294,967,295)으로 40억이 넘어가기 때문에 long으로 사용해야 한다.

1부터 더해야 하기 때문에 idx를 1로 시작한다.

200을 예로 들었을 때, 아래의 코드는 sum = 210, idx = 21인 상태에서 if문에 걸리게 된다.

idx++이 된 부분에 대해서 한번 빼주고, sum이 초과되는 부분에서 한번 더 빼준다.

설명으로 하니 복잡한데 반복문 내에 idx와 sum을 찍어보면 아래와 같이 나온다.

//idx sum
1 1
2 3
3 6
...
19 190
20 210
나가!
19

후위연산자로 증가한 값을 하나 줄여주고, 반복문 내에서 sum이 초과한 이전의 숫자를 사용하기 위해 한번 더 빼준다.

따라서 idx를 -2 해주게 되는 것이다.

처음에 이것을 잡는데 시간이 오래 걸렸다.

그 외의 반례로는 input 1, output 1을 확인하기.

코드

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main{

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        long S = Long.parseLong(br.readLine());

        //1부터 계속 더하면서 S가 넘지 않을때까지 반복
        long sum = 0;
        long idx = 1;
        while(true){
        	//System.out.print(idx +" ");
            sum += idx++;
            //System.out.println(sum);
            if(sum > S){
                //System.out.println("나가!");
                idx-=2;
                break;
            }
        }
        System.out.println(idx);
    }
}

그리디는 항상 접근이 어렵고 감을 잡으면 풀이는 쉬워지는 것 같다.

더 많이 풀어봐야지

[Openvidu] 공식 문서 공부

민딛 — Mon, 20 Feb 2023 15:18:06 +0900

https://docs.openvidu.io/en/2.25.0/

OpenVidu Docs

From here you can search these documents. Enter your search terms below.

docs.openvidu.io

위의 공식 문서를 보고 정리한 내용

간단 정리

Openvidu deployment - Docker

실시간 오디오 및 비디오 스트리밍에 필요한 모든 인프라 제공

Application server - Backend

세션 초기화

세션에 대한 커넥션(연결) 생성

브라우저에게 커넥션 토큰 전달

Openvidu browser - Frontend

오픈비두 개체 가져오고 setState로 세션 속성 초기화

서버에게 토큰 요청

오픈비두에게 세션 연결 요청하고 비디오 게시

세션 나가기

기본 동작

서버에서 세션 초기화

브라우저도 세션 초기화

서버는 커넥션도 만들어줌

브라우저가 세션 참여하려고 서버한테 토큰 달라고 요청

서버는 오픈비두한테 토큰 달라고 말하고 받아옴

서버가 브라우저한테 토큰 전달

브라우저는 오픈비두로 세션 참가

브라우저는 비디오 게시

브라우저는 세션을 나감

구조

OpenVidu deployment : 내부 측면이 중요하지 않은 블랙박스. 가져다쓰세요~
server application : Rest API endpoints 호출 가능
client application : 웹 브라우저, 데스크톱 애플리케이션에서 실행. openvidu-browser.js SDK사용해서 OpenVidu deployment와 통신, 세션 연결, 미디어스트림 게시 및 구독, 클라이언트측에서 화상통화 관리 등

Workflow

애플리케이션 서버에서 세션 초기화
애플리케이션 서버에서 세션의 연결 생성. 참가자가 있을 만큼 연결 만들어야 함. 토큰은 세션에 대해 단일 접근
세션에 연결할 수 있게 클라이언트에게 토큰 전달
클라이언트는 토큰 사용하여 세션에 연결(openvidu-browser.js). 성공적으로 되면 참가자로 간주.
세션에 연결되면, 참가자는 스트림 게시 가능(openvidu-browser.js). 모든 참가자들은 subscribe 기회 있음

용어 정리

온프레미스 : 기업이 자체 시설에서 보유하고 직접 유지 관리하는 프라이빗 데이터 센터
endpoint : API는 두 어플리케이션이 상호작용 할 수 있게 하는 것이라면 Endpoint는 API가 서버에서 리소스에 접근할 수 있도록 가능하게 하는 URL
Session(세션) : 참가자가 연결하여 오디오/비디오 스트림을 보내고 받을 수 있는 가상 공간. 동일한 세션 연결된 참가자만 서로 보고 들을 수 있음
Connection(연결) : 각 세션의 참가자. 세션에 연결하여면 서버에서 초기화하고 해당 토큰을 클라이언트에 전달해야 함.
Token(토큰) : 참가자에게 세션에 대한 액세스 권한. 서버에서 연결을 생성해야 클라이언트에게 토큰을 전달 가능
Stream(스트림) : 세션으로 흐르는 미디어 스트림

Openvidu - Client

Ready-to-use component
- 어플리케이션에 바로 적용
- 몇줄의 코드로 화상 회의
Full control of the UI
- 클라이언트 SDK 사용하여 데스크톱 애플리케이션에서 처음부터 사용
- 원하는대로 UI 구축

Openvidu - Server

세션을 생성하고 연결하기 위해서는 클라이언트가 연결하기 전에 오픈비두배포와 연결을 주고받아야 한다.

자바와 Node SDK가 있음. 백엔드에서 REST API 사용해서도 가능함

서버에서 오픈비두배포에 도달하려면 오픈비두배포 URL OPENVIDU_URL과 오픈비두암호 OPENVIDU_SECRET가 필요함

1. 세션 초기화

세션 초기화. 동일 세션에 연결된 참가자는 스트림을 주고받을 수 있음

OpenVidu openvidu = new OpenVidu(OPENVIDU_URL, OPENVIDU_SECRET);
SessionProperties properties = new SessionProperties.Builder().build();
Session session = openVidu.createSession(properties);

2. 세션 생성

특정 세션에 대한 연결 생성. 각 참가자는 토큰 사용하여 하나의 연결 사용해서 연결됨

ConnectionProperties connectionProperties = new ConnectionProperties.Builder()
    .role(OpenViduRole.PUBLISHER)
    .data("Alice")
    .build();
Connection connection = session.createConnection(connectionProperties);
String token = connection.getToken(); // Send this string to the client side

자바 기본 코드

Java 11 / Maven

하지만! Gradle로 사용할 수 있다.

기본 제공 Rest endpoints

1. 세션 초기화

HTTP METHOD POST

URL	https://localhost:5000/api/sessions
REQUEST BODY	Same request body as the REST API operation https://docs.openvidu.io/en/stable/reference-docs/REST-API/#post-session
200 OK RETURN VALUE	A string with the Session identifier.For example: "ses_JM9v0nfD1l"

2. 세션 생성

HTTP METHOD POST

URL	https://localhost:5000/api/sessions/SESSION_ID/connections
REQUEST BODY	Same request body as the REST API operation https://docs.openvidu.io/en/stable/reference-docs/REST-API/#post-connection
200 OK RETURN VALUE	A string with the Connection's token.For example: "wss://localhost:4443?sessionId=ses_JM9v0nfD1l&token=tok_MIYGGzuDQb8Xf1Qd"

사용자 인증

사용자 인증 이미 있으면 서버에서 사용자 자격 증명 확인하고 이를 사용하여 세션 및 연결 개체를 초기화 할 수 있는 사용자를 제어할 수 있다.

근데! 서버에서 사용자 인증 없으면 아래 6가지 사용 가능

기본 인증
쿠키 기반 인증
토큰 기반 인증
OAuth 2.0
OpenID Connect
SAML

openvidu-browser.js

세션 초기화

Openvidu 개체를 가져오고 이를 사용하여 세션 개체를 초기화함

OV = new OpenVidu();
session = OV.initSession();
session.on("streamCreated", function (event) {
    session.subscribe(event.stream, "subscriber");
});

토큰 받기

세션에 참여할 준비가 됨. 접근하려면 토큰이 필요함. 서버에게 토큰 달라고 요청. 서버는 openvidu에게 토큰 달라고 요청. 서버가 토큰을 클라이언트에게 줌

var APPLICATION_SERVER_URL = "<http://localhost:5000/>";

function getToken(mySessionId) {
    return createSession(mySessionId).then(sessionId => createToken(sessionId));
}

function createSession(sessionId) {
    return new Promise((resolve, reject) => {
        $.ajax({
            type: "POST",
            url: APPLICATION_SERVER_URL + "api/sessions",
            data: JSON.stringify({ customSessionId: sessionId }),
            headers: { "Content-Type": "application/json" },
            success: response => resolve(response), // The sessionId
            error: (error) => reject(error)
        });
    });
}

function createToken(sessionId) {
    return new Promise((resolve, reject) => {
        $.ajax({
            type: 'POST',
            url: APPLICATION_SERVER_URL + 'api/sessions/' + sessionId + '/connections',
            data: JSON.stringify({}),
            headers: { "Content-Type": "application/json" },
            success: (response) => resolve(response), // The token
            error: (error) => reject(error)
        });
    });
}

getToken(mySessionId)에서 createSession을 실행하고 거기서 얻어온 sessionId를 가지고 createToken(sessionId) 실행. 생성된 토큰을 받아온다

토큰 사용하여 세션에 연결

getToken(mySessionId).then(token => {

    session.connect(token)
        .then(() => {
            document.getElementById("session-header").innerText = mySessionId;
            document.getElementById("join").style.display = "none";
            document.getElementById("session").style.display = "block";

            var publisher = OV.initPublisher("publisher");
            session.publish(publisher);
        })
        .catch(error => {
            console.log("There was an error connecting to the session:", error.code, error.message);
        });
});

session.connect : 오픈비두 서버에서 최근 받은 토큰을 넘겨주면 됨

연결이 성공되면 view를 활성 비디오 세션으로 설정. 그리고 웹캠 볼 수 있게 함.

publisher로 만든다. 초기화는 .initPublisher. 비디오란은 보이게 설정

session.publish(publisher)로 게시

세션 나가기

function leaveSession() {
    session.disconnect();
    document.getElementById("join").style.display = "block";
    document.getElementById("session").style.display = "none";
}

window.onbeforeunload = function () {
    if (session) session.disconnect();
};

사용자가 세션을 나가길 원할때 session.disconnect 사용하게 함. 나가면 join 버튼 활성화

window.onbeforeunload : event를 사용하여 페이지가 언로드되기 전에 메서드가 호출되는지 확인

React의 경우

openvidu-react - OpenVidu Docs

[Git] 자주 사용하는 Git 명령어

민딛 — Mon, 20 Feb 2023 15:13:00 +0900

브랜치 생성

git branch 브랜치명

브랜치 확인

git branch

브랜치 전환

git checkout 브랜치명

원격 저장소 연결 확인

git remote -v

원격 저장소에 branch 올리기

git push origin 브랜치명

브랜치 삭제

git branch -d 브랜치명

브랜치 삭제 에러

error: The branch 'feature/docs' is not fully merged. If you are sure you want to delete it, run 'git branch -D feature/docs'.

해당 에러는 브랜치가 merge 되기 전에 삭제될 수 없다는 것이니 원격에 push가 됐다면 아래 명령어로 삭제해준다.

git branch -D 브랜치명

특정 브랜치 clone

git clone -b 브랜치명 --single-branch 저장소URL

특정 브랜치 pull

git pull origin 브랜치명

모든 작업 취소

git reset --hard

특정 파일 작업 취소

git checkout -- 파일명.확장자

[Git] fork 한 repository 업데이트 하기

민딛 — Mon, 26 Dec 2022 20:21:24 +0900

포크한 저장소 로컬에 클론

$ git clone <주소>

로컬 저장소로 이동

$ cd <레포지토리명>

리모트 확인

$ git remote -v

원본 레포지토리 리모트 추가

$ git remote add upstream <원본레포지토리주소>

추가된 리모트 저장소 확인

$ git remote -v

리모트 저장소 fetch

$ git fetch upstream

merge

$ git merge upstream/main

나는 git bash를 사용하였고, 사진의 괄호에 있는 것에 따라 upstream/ 다음에 main이나 master로 써줘야 정상적으로 처리 된다.

이 부분에서 무엇을 입력하라고 창이 바뀌었는데 :wq를 누르고 나왔다.

포크 저장소로 push

$ git push

이 다음부턴 6번부터 사용하면 된다.

[백준 Java] 1916 최소비용 구하기

민딛 — Mon, 19 Dec 2022 16:52:03 +0900

https://www.acmicpc.net/problem/1916

접근 방법

다익스트라를 사용한다.

인접리스트를 사용하여, 겉의 리스트는 출발 도시, 안의 리스트는 연결되는 도시를 넣어준다.

리스트 안의 리스트를 사용할때에는 안의 리스트를 출발도시 수만큼 새로 생성해줘야 한다.

다익스트라 메서드에서 거리 테이블을 만들어준다. 초기는 무한값으로 설정해준다.

다익스트라에서는 메모리와 시간 절약을 위해 우선순위 큐를 사용했다. 가중치가 낮은 순서로 가져오기 때문에 낮은 가중치의 도시 선형탐색과 방문처리를 할 필요가 없어진다.

거리테이블에 있는 값과, 연결된 도시를 거쳐갈때를 비교해서 더 작은 값으로 갱신해준다. 갱신 후 연결노드로 처리하기 위해 큐에 넣어준다.

코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Main_1916_최소비용구하기 {

	static int N, M;
	static final int INF = Integer.MAX_VALUE;
	static ArrayList<ArrayList<Node>> list;

	static class Node implements Comparable<Node> {
		int idx, cost; // 연결도시, 가중치

		public Node(int idx, int cost) {
			this.idx = idx;
			this.cost = cost;
		}

		@Override
		public int compareTo(Node o) { // 가중치 오름차순 정렬
			return this.cost - o.cost;
		}

	}

	private static int dijkstra(int start, int end) {
		int[] dist = new int[N + 1]; // 0번째 버림

		// INF 초기화
		for (int i = 0; i < N + 1; i++) {
			dist[i] = INF;
		}

		// 최단거리 테이블 초기 설정 - 최소 거리 순으로 정렬 위해
		PriorityQueue<Node> pq = new PriorityQueue<>();
		pq.add(new Node(start, 0)); // 초기 거리 넣어줌

		// 시작 거리 0
		dist[start] = 0;

		// dijkstra
		while (!pq.isEmpty()) {
			Node cur = pq.poll();

			// 현재 가중치가 더 크다면 진행 안함
			if (dist[cur.idx] < cur.cost)
				continue;

			// 현재 노드와 연결된 노드 파악
			for (int i = 0; i < list.get(cur.idx).size(); i++) {
				Node next = list.get(cur.idx).get(i); // 연결된 노드를 가져옴

				if (dist[next.idx] > cur.cost + next.cost) { // 거쳐가는 것이 더 비용이 작다면
					dist[next.idx] = cur.cost + next.cost;
					pq.offer(new Node(next.idx, dist[next.idx])); // 갱신된 거리를 큐에 넣어준다.
				}
			}
		}

		return dist[end];
	}

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer tokens;

		N = Integer.parseInt(br.readLine()); // 도시의 개수
		M = Integer.parseInt(br.readLine()); // 버스의 개수

		list = new ArrayList<ArrayList<Node>>();

		for (int i = 0; i < N + 1; i++) { // 0번째 노드 버림
			list.add(new ArrayList<>());
		}

		for (int i = 0; i < M; i++) {
			tokens = new StringTokenizer(br.readLine());

			// 출발 도시, 도착 도시, 버스 비용
			int start = Integer.parseInt(tokens.nextToken());
			int end = Integer.parseInt(tokens.nextToken());
			int cost = Integer.parseInt(tokens.nextToken());

			list.get(start).add(new Node(end, cost)); // 연결 도시 저장
		}

		tokens = new StringTokenizer(br.readLine());
		int S = Integer.parseInt(tokens.nextToken()); // 출발 도시
		int E = Integer.parseInt(tokens.nextToken()); // 도착 도시

		System.out.println(dijkstra(S, E));

	}

}

처음에 행렬로 풀었었는데 틀린 답이 나왔다. 백준의 질문 게시판을 살펴보니 인접행렬을 사용했을 경우 중복값에 대한 처리가 어쩌구 써있어서 인접리스트를 사용했다.

[알고리즘 정리] 그래프 (Graph)와 Floyd warshall 알고리즘

민딛 — Mon, 19 Dec 2022 16:01:25 +0900

그래프란?

정점과 간선으로 이루어진 자료구조를 말한다. 무슨 소리지? 싶어 그림을 첨부했다.

대충 이렇게 생겼으면 그래프라고 할 수 있다.

정점(Vertex)은 노드(Node)라고도 하며 그림의 A, B, C ... 와 같은 동그라미를 말한다.

간선(Edge)은 링크(Link)라고도 하며 노드를 이은 선을 말한다. 화살표가 없으면 무뱡향 그래프, 화살표가 있으면 단방향/양방향 그래프가 된다.

가중치는 간선에 표시된 숫자이다. 있을수도 없을 수도 있다.

그래프의 특징

다수의 진입차수와 다수의 진출 차수를 가질 수 있고, 무방향성과 유방향성을 가질 수 있으며 순환과 비순환 형태를 가질 수 있다.

위에서 설명한 내용이다. 순환과 비순환은 추후에 설명하기로...

그래프 구현

인접행렬
인접리스트
간선리스트

세가지 방식으로 구현할 수 있다.

인접행렬

위에 첨부된 사진으로 예를 들었을 때 인접 행렬로 그래프의 정보를 나타낸다면 다음과 같이 표현할 수 있다.

	A	B	C	D	E
A	0	3	0	8	7
B	3	0	1	4	0
C	0	1	0	2	0
D	8	4	2	0	3
E	7	0	0	3	0

장점은 직관적이며 구현이 쉽다.

단점은 연결되지 않은 간선에 대해서도 저장하여 쓸모없는 메모리 발생.

인접리스트

연결된 노드만 저장한다.

A → B → D → E

B → A → C → D

C → B → D

D → A → B → C → E

E → A → D

정점의 개수만큼 인접리스트가 있고, 그 안에 연결된 노드 정보가 있다.

장점은 메모리 관리에 효율적

단점은 구현 어려움

하지만 알고리즘을 풀다보면 점점 인접리스트로 구현하게 된다.

그래프 알고리즘

DFS : 출발점과 도착점의 모든 경로를 탐색
정점의 최단거리 알고리즘
- 단일 출발점
  - BFS : 가중치가 없음
  - Dijkstra : 가중치 있음. 음의 가중치 없음
  - Bellman-ford : 가중치 있음. 음의 가중치 있음
- 모든 출발점
  - Floyd warshall

	DFS	BFS	Dijkstra	Bellman-ford	Floyd warshall
방식	연결 정점 선택 후 끝날때까지 파고 들어가며 탐색	연결된 주변 정점 퍼져나가듯 탐색	한 정점에서 다른 정점까지의 최소 가중치 탐색	(수정중)	모든 정점에서 각 정점까지의 최소 가중치 탐색
자료구조	Stack / recursive	Queue	heap	(수정중)	3중 for문
시간복잡도	인접행렬 O(V^2) 인접리스트 O(V+E)		O(V^2) 힙 사용 O(ElogV)	(수정중)	O(V^3)

...

Floyd warshall 알고리즘

모든 정점에서의 최단 경로(가중치)를 구하는 알고리즘

음의 가중치, 양의 가중치 모두 사용 가능하다.

동작 과정

1. 그래프의 최단 거리 테이블 갱신

2. n번째 노드를 거쳐 가는 경우에 대해 테이블 갱신

그래프의 최단 거리 테이블 갱신

i → j로 가는 방향에 가중치를 표시해줬고, 갈 수 없는 경우는 무한 값으로 설정했다. 자기 자신으로 가는 경우는 0이다.

n번째 노드를 거쳐 가는 경우

연결되어 갈 수 있는 경우에만 갱신해준다.

1번째 노드 A를 거쳐 가는 경우

A를 거쳐서 갈 수 있는 경우는 B → C의 경우만 존재한다. 갱신된 값을 비교하여 테이블을 갱신해준다

2번째 노드 B를 거쳐 가는 경우

D→B→A→C의 경우는

기존의 B→C 경로가 B→A→C 인 최단경로로 업데이트됐기 때문에 D→B→C 가 아닌 D→B→A→C가 된다.

3번째 노드 C를 거쳐 가는 경우

마찬가지로 BCD의 경우도 BACD로 갱신된다.

4번째 노드 D를 거쳐 가는 경우

CDB를 새로 연결해준다

CDB가 갱신되었기 때문에 CDBA의 새 경로를 업데이트해줄 수 있다.

AD는 위에서 연결이 새로 갱신되었기 때문에 ACDB로 갱신해줄 수 있다.

최종적으로 위와 같은 최단거리 그래프가 나오게 된다.

의사코드

let dist be V × V matrix of minimum distances initialized to INFINITY
for each vertex v
  dist[v][v] = 0
for each edge (u, v)
  dist[u][v] = weight(u, v)
 
for k from 0 to |V| – 1
  for i from 0 to |V| – 1
    for j from 0 to |V| – 1
      if (dist[i][k] + dist[k][j]) is less than dist[i][j] then
        dist[i][j] = dist[i][k] + dist[k][j]

초기값을 INF로 초기화해준다.

자기 자신에 대해서는 0으로, 간선이 존재하면 가중치로 갱신해준다.

거쳐가는 노드를 k로 두고 노드만큼 반복한다.

i는 시작하는 노드, j는 도착하는 노드이고 각각 노드의 수만큼 반복해준다..

만약 현재 i, j의 연결보다 k를 거쳐가는 경우가 더 작다면 갱신해준다.

구현은 셀프 ^-^

풀어보면 좋은 문제

백준 11404 플로이드 - 골드4

https://www.acmicpc.net/problem/11404

[SWEA Java] 1949. 등산로 조성

민딛 — Mon, 21 Nov 2022 20:45:56 +0900

기본 등산로 조성은 dfs로 4방향에서 갈 수 있다면 방문처리 해주고 가는 방식으로 짰는데

산을 깎는 경우를 잘 모르겠다.

그냥 N만큼 i,j for문 돌리고 그 안에서 K만큼 반복문 돌려서 다 깎아봤어도 시간 초과가 안 났을 것 같은데 풀다보니 이렇게 풀게 됐다.

정리

❗️현재 높이와 다음 높이를 비교했을 때, 작은 경우와 큰 경우를 따로 생각한다.

❗️큰 경우라면 이전에 깎았는지 확인하고 안깎깎 ? 깎 : 안깎처리를 해준다.

❗️다음 높이가 높을 때 깎는 높이는 현재 높이에서 1만 깎으면 된다. 물론 K만큼 깎았을 때 현재 높이보다 낮아야 한다. 이거 이해하는데 오래 걸렸다

❗️방문처리! 깎은 산! 복원이 중요했다. 갔다 왔으면 원래대로 돌려주자.

❗️제일 높은 봉우리만 시작이 됨.

코드

package SWEA;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Solution_1949_등산로조성 {

    static int N, K, res;
    static int[][] map;
    static boolean[][] v;
    static int[] dr = {-1, 1, 0, 0}, dc = {0, 0, -1, 1};

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tokens;
        StringBuilder sb = new StringBuilder();
        int T = Integer.parseInt(br.readLine());

        for (int tc = 1; tc <= T; tc++) {
            tokens = new StringTokenizer(br.readLine());
            N = Integer.parseInt(tokens.nextToken());
            K = Integer.parseInt(tokens.nextToken());

            map = new int[N][N];
            v = new boolean[N][N];
            int max = 0;

            for (int i = 0; i < N; i++) {
                tokens = new StringTokenizer(br.readLine());
                for (int j = 0; j < N; j++) {
                    map[i][j] = Integer.parseInt(tokens.nextToken());
                    if (max < map[i][j]) max = map[i][j];
                }
            } // end input

            res = 0;
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    if (map[i][j] == max) {
                        dfs(i, j, 1, true);
                    }
                }
            }
            sb.append("#").append(tc).append(" ").append(res).append("\n");
        } // end test case
        System.out.println(sb);
    }

    private static void dfs(int x, int y, int len, boolean flag) {
        v[x][y] = true;
        for (int d = 0; d < 4; d++) {
            int nx = x + dr[d];
            int ny = y + dc[d];

            // 범위 밖, 방문이면 다음 방향
            if (!isRange(nx, ny) || v[nx][ny])
                continue;

            //다음 높이가 현재 높이보다 작을때
            if (map[nx][ny] < map[x][y]) {
                dfs(nx, ny, len + 1, flag);
            } else {//다음 높이가 현재 높이보다 같거나 크고 깎을 수 있을 때
                if (flag && map[nx][ny] - K < map[x][y]) {
                    int temp = map[nx][ny];
                    v[nx][ny] = true;
                    map[nx][ny] = map[x][y]-1;
                    dfs(nx, ny, len + 1, false);
                    map[nx][ny] = temp;
                    v[nx][ny] = false;
                    flag = true;
                }
            }
        }
        v[x][y] = false;
        // 더이상 갈 수 없으면 거리 갱신
        res = Math.max(res, len);
    }

    private static boolean isRange(int x, int y) {
        if (x < 0 || y < 0 || x >= N || y >= N)
            return false;
        return true;
    }
}