응파카 성장일지

[백준 2812] 크게 만들기

응파카 — Sun, 28 May 2023 19:04:40 +0900

2812번: 크게 만들기

N자리 숫자가 주어졌을 때, 여기서 숫자 K개를 지워서 얻을 수 있는 가장 큰 수를 구하는 프로그램을 작성하시오.

www.acmicpc.net

1. 문제 요약

- N과 K (1 ≤ K < N ≤ 500,000) 를 입력받는다
- N 자리 숫자 input 을 입력받으면 그 중 K 만큼의 숫자를 지운다
- 이 때 얻을 수 있는 가장 큰 수를 구하면 되는 문제이다

2. 아이디어 (문제 접근법)

[아이디어-1]
- input 을 String 으로 입력받은 후에 char[] sorted =  Arrays.sort 로 정렬한다
    이를 통해 입력받은 숫자들이 오름차순으로 나열된다
    이후 앞에서부터 (작은 숫자들부터) K 번째까지 문자들을 순회하며 해당 문자들을 삭제한다
    같은 문자의 경우 input 에서 더 앞에 있는 문자를 지운다

[아이디어-2]
- input 을 애초에 크기 N-K의 배열 arr 에 입력받아보자
- int count = K 로 할당하고
    int pointer = 0 으로 할당하여
    count = 0 이 될 때까지 앞자리수를 최대한 큰 숫자로 세팅할 수 있도록 다음과 같이 반복한다

    1. 현재 포인터가 가리키는 수가 없으면 (0이면) 입력받은 수를 넣는다
    2. 현재 포인터가 가리키는 수와 입력받은 수를 비교하여
        2-1. 포인터가 가리키는 수가 더 크고, count>0 이면 다음 수를 입력받는다
        2-2. count<=0 이면 입력받은 수를 다음 자리에 넣는다
        2-3. 입력받은 수가 더 크고, count>0 이면 그 숫자로 교체한다

    만들다보니 배열보단 자료구조를 활용하는 것이 더 구현이 쉬울 것 같다고 생각했다
    따라서 큐를 사용하기로 했다

[아이디어-3]

- '[아이디어-2]의 어려움 및 해결' 의 해결방법 적용, 아래를 (0 < i < N-1) 만큼 반복한다
    - greedy 가 비어있지 않다면 반복하여 greedy.pop() 과 현재 입력받은 수를 비교
        - 아래를 greedy 가 isEmpty 하지 않고 count >= 0 인 동안 반복한다
            - greedy.pop() 가 더 크다면 다시 greedy.pop()을 push() 하고, 반복을 해제
            - 입력받은 수가 더 크다면 greedy.pop()을 삭제 (이미 pop 되어있으니 그냥 패스)
                - count--
    - 입력받은 수를 push() 한다
    - 만약 count <= 0 이라면
        - 뒤에 있는 남은 모든 수를 greedy 에 붙인다
        - 이후 반복을 해제

- greedy 의 값을 StringBuffer sb 에 옳겨 담는다
- sb 를 앞에서부터 N-K 크기만큼 잘라서 출력한다

3. 어려움 및 해결

[아이디어-1] -> 예제입력 3번에서 틀린 값이 출력될 것이다
            10 4 /n 4177252841 를 입력 받았을 때
            775841이 나와야 하지만 , 477584가 나온다
            그렇다면 무조건 앞자리 수를 최대로 맞추는 것에 초점을 둬보자

[아이디어-2] -> 예제입력 3번에서 틀린 값이 출력 되었다
            10 4 /n 4177252841 를 입력 받았을 때
            775841이 나와야 하지만 , 772841이 나온다
            앞자리 수를 온전히 최대로 맞추는 것에 실패한 것인데,
            이는 뒤에서 지금 삭제하는 값보다 더 작은 숫자를 입력받을 수 있는 경우를 간과한 결과이다
            따라서 이미 입력받은 수와 현재 입력받는 수를 비교하는 대신 현재 입력받는 수와 비교하여
                -> 이미 입력받은 수를 삭제하는 방식으로 진행해 보려고 한다

public class BOJ_2812_크게_만들기 {

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

        int N = Integer.parseInt(stk.nextToken());
        int K = Integer.parseInt(stk.nextToken());
        char[] input = br.readLine().toCharArray();

        Stack<Character> greedy = new Stack<>();

        int count = K;

        for(int i=0; i<N; i++){
            if(!greedy.isEmpty()){
                while(!greedy.isEmpty() && count>0){
                    if(greedy.peek() < input[i]){
                        greedy.pop();
                        count--;
                    }else{
                        break;
                    }
                }
            }
            greedy.push(input[i]);

            if(count == 0) {
                for(int j=i+1; j<N; j++){
                    greedy.add(input[j]);
                }
                break;
            }
        }

        StringBuffer sb = new StringBuffer();

        int size = greedy.size();
        for(int i=0; i<size; i++){
            char pop = greedy.pop();
            sb.insert(0, pop);
        }
        sb.setLength(N-K);

        System.out.println(sb);
    }
}

[백준 15724] 주지수

응파카 — Sat, 27 May 2023 23:11:42 +0900

15724번: 주지수

네모 왕국의 왕인 진경대왕은 왕국의 영토를 편하게 통치하기 위해서 1X1의 단위 구역을 여러 개 묶어서 하나의 거대 행정구역인 주지수(州地數, 마을의 땅을 셈)를 만들 예정이다. 진경대왕은

www.acmicpc.net

1. 문제 요약

- 제한시간 2초
- N x M 사이즈의 단위구역 내에 각 값을 입력받고
- 이어서 시작행, 시작열, 끝행, 끝열을 입력받는다
해당 범위 내의 사람들의 수의 합을 구하는 문제이다

2. 아이디어 (문제 접근법)

[아이디어-1]
- int answer 를 만들어 범위 내의 합을 저장한다
- for 시작행-1 ~ 끝행-1
    for 시작열-1 ~ 끝열-1
        answer += 해당 위치 값
[아이디어-2]
- 시간을 줄이는 방법
    1. (0, 0) 에서 시작하는 범위의 합을 그때그때 기록해둔다
        -> 순회 시간을 줄이기 위함
        -> sumArr[x][y]를 새로 입력받기 위해서는
            입력받는 값 + sunArr[x][y-1] + sumArr[x-1][y] - sumArr[x-1][y-1]
    2. DP 과정이 인구 수를 궁금해하는 직사각형 범위가 주어질 때가 아니라
                단위 구역 내에 살고 있는 사람 수를 입력받을 때 적용된다

이후 board 가 필요 없다고 판단하여 삭제
                    메모리        시간
board 가 있을 때 -> 123328 KB  864 ms
board 가 없을 때 -> 120120 KB  952 ms

3. 어려움 및 해결

[아이디어-1] -> 시간초과 발생
            -> 영토의 크기는 (1 ≤ N, M ≤ 1,024) 으로 잘 체감이 안되었는데
            -> 다시 확인하니 직사각형 범위의 개수 K(1 ≤ K ≤ 100,000) 였다
            -> 시간을 줄일 수 있는 방법을 고안해봄 ([아이디어-2]로)
[아이디어-2] -> sumArr[0][0]을 입력받을 때 ArrayIndexOutOfBoundsException 발생 가능하므로
            sumArr 의 크기를 int[N+1][M+1] 로 입력받아 sum[1][1]부터 입력받는다

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

public class BOJ_15724_주지수 {
    static int[][] sumArr;

    static StringBuffer sb = new StringBuffer();

    static int N;
    static int M;

    public static int dp(int startRow, int startColumn, int endRow, int endColumn){
        return sumArr[endRow][endColumn] + sumArr[startRow-1][startColumn-1] - sumArr[endRow][startColumn-1] - sumArr[startRow-1][endColumn];
    }
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stk;

        stk = new StringTokenizer(br.readLine());
        N = Integer.parseInt(stk.nextToken());
        M = Integer.parseInt(stk.nextToken());
        sumArr = new int[N+1][M+1];

        for(int i=1; i<=N; i++){
            stk = new StringTokenizer(br.readLine());
            for(int j=1; j<=M; j++){
                sumArr[i][j] = Integer.parseInt(stk.nextToken()) + sumArr[i-1][j] + sumArr[i][j-1] - sumArr[i-1][j-1];
            }
        }

        int n = Integer.parseInt(br.readLine());
        for(int i=0; i<n; i++){
            stk = new StringTokenizer(br.readLine());
            sb.append(dp(Integer.parseInt(stk.nextToken()), Integer.parseInt(stk.nextToken()), Integer.parseInt(stk.nextToken()), Integer.parseInt(stk.nextToken())) + "\n");
        }
        if(sb.length() > 0) {
            sb.deleteCharAt(sb.length() - 1);
        }
        System.out.println(sb);
    }
}

[백준12865] 평범한 배낭

응파카 — Thu, 25 May 2023 02:30:47 +0900

12865번: 평범한 배낭

첫 줄에 물품의 수 N(1 ≤ N ≤ 100)과 준서가 버틸 수 있는 무게 K(1 ≤ K ≤ 100,000)가 주어진다. 두 번째 줄부터 N개의 줄에 거쳐 각 물건의 무게 W(1 ≤ W ≤ 100,000)와 해당 물건의 가치 V(0 ≤ V ≤ 1,000)

www.acmicpc.net

1. 문제 요약

- 물품의 수 N 만큼 각각 무게 W와 가치 V를 가진 물품을 입력받는다
- 준서가 견딜 수 있는 무게를 K라고 할 때 가능한 가장 높은 가치의 물건을 담는 경우의 가치를 출력

2. 아이디어 (문제 접근법)

[아이디어-1]
- T 인스턴스를 생성해 저장할 배열 tArr[N] 를 만든다
- 각 무게에서의 최고 가치를 저장할 배열 maxValue[K+1] 를 만들어둔다
- tList 순회, 그 안에서 maxValue 순회하며 다음과 같이 처리
    - 새로운 물건 tList[i]를 maxValue[j] 에 넣을 수 있는가?
        -> 있다
            - (지금의 최고 가치) vs (지금의 무게 - 새로운 물건의 무게) 때의 최고 가치 + 새로운 물건의 가치
        -> 없다
            - 직전의 값(현재까진 가장 큰 V 가짐) 그대로 저장

[아이디어-2]

- "(지금의 무게 - 새로운 물건의 무게) 때의 최고 가치 + 새로운 물건의 가치" 부분에서 (이전 값을 불러오는 과정에서) 이전값을 누적해서 저장하는 문제점 발견
    이전의 최고가치를 계속 누적하는 문제의 해결 방법을 찾던 도중
    https://st-lab.tistory.com/141 에서 maxValue 에 해당하는 dp 배열을 끝에서 처음으로 탐색하는 것을 발견
    순회 순서를 바꾸니 이전값이 누적되는 문제가 해결되었다..

3. 어려움 및 해결

[아이디어-1] -> 이미 담았던 값을 또 담는 문제 발생
-> 이를 해결하기 위해 담은 T를 체크하는 배열 생성하고 하다보니 코드가 너무 비효율적으로 길어져 원점으로 복귀

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

class T{
    int W, V;
    public T(int W, int V){
        this.W = W;
        this.V = V;
    }
}
public class BOJ_12865_평범한_배낭 {
    static T[] tArr;
    static int[] maxValue;
    static int N, K;

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

        stk = new StringTokenizer(br.readLine());
        N = Integer.parseInt(stk.nextToken());
        tArr = new T[N];
        K = Integer.parseInt(stk.nextToken());
        maxValue = new int[K+1];

        // tArr 에 T 저장
        for(int i=0; i<N; i++){
            stk = new StringTokenizer(br.readLine());
            tArr[i] = new T(Integer.parseInt(stk.nextToken()), Integer.parseInt(stk.nextToken()));
        }

        maxValue[0] = 0;
        for(int i=0; i<N; i++){
            T t = tArr[i];
            int w = t.W;
            int v = t.V;
            for (int j = K; j-w >= 0; j--) {
                maxValue[j] = Math.max(maxValue[j], maxValue[j-w] + v);
            }
        }

        System.out.println(maxValue[K]);
    }
}

[백준 5557] 1학년

응파카 — Wed, 24 May 2023 08:05:45 +0900

5557번: 1학년

상근이가 1학년 때, 덧셈, 뺄셈을 매우 좋아했다. 상근이는 숫자가 줄 지어있는 것을 보기만 하면, 마지막 두 숫자 사이에 '='을 넣고, 나머지 숫자 사이에는 '+' 또는 '-'를 넣어 등식을 만들며 놀

www.acmicpc.net

1. 문제 요약

- 제한시간 1초
- 0~9 범위의 숫자 3~100 개가 주어지고
오른쪽 끝의 숫자의 앞에 = 를 붙여 답으로,
그 외의 숫자들 사이에 '+' 나 '-' 를 붙여 올바른 등식을 만들어야 한다
- '+' 혹은 '-' 만 사용하므로 왼쪽에서 오른쪽 순으로만 확인하면 된다
- 중간에 값이 0~20 범위를 벗어나면 올바르지 않은 공식으로 취급받는다

2. 아이디어 (문제 접근법)

[아이디어-1]
- 태블릿 그림을 통해 풀었다
- arr[N] 에 입력받은 숫자들 기록
- result = arr[N-1] -> {...} = arr[N-1]
- int[][] dp = new int[N-1][21]
    - for(i = 1~N-2)
        for(j = 0~20)
            반복문 적용 시,
            i => arr[i] 를 사용하여
            j => 를 만들 수 있는지 순회하는 것
- (1) dp[0][arr[0]] = 1 로 적용해놓고 시작한다 (어차피 처음은 무조건 하나)
- (2) 이후 for(i = 1~N-2)
            for(j = 0~20)
    - if(dp[i-1][j] == 1) 이면 다음을 실행한다
    - 0 <= j-arr[i], j+arr[i] <= 20 인지 체크
    - 문제 없는 경우 dp[i][j-arr[i]] 와 dp[i][j+arr[i]] 에 += dp[i-1][j]
- (3) 이를 반복
- 이차원 배열 DP[i][j] 의 값은 arr[i] 를 사용했을 때 j 를 만들 수 있는 경우의 수를 의미하므로
    - DP[N-2][arr[N-1]] 를 출력하면 된다

3. 어려움 및 해결

- 딱 봐도 DFS 로 접근하면 시간초과가 날듯 하여 다른 방법을 생각해 보았다
(최대 99 개의 숫자들 사이에 '+' 혹은 '-' 를 붙여야 하므로 대충 계산해도 2^98)
[아이디어-1] -> 답이 int 의 범위를 벗어나는 일이 생겨서 Long 자료형으로 변경했다

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

public class BOJ_5557_1학년 {

    static int N;
    static int[] arr;
    static long[][] DP;
    static int result;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stk;

        N = Integer.parseInt(br.readLine());
        arr = new int[N];
        DP = new long[N-1][21];

        stk = new StringTokenizer(br.readLine());
        for(int i=0; i<N; i++){
            arr[i] = Integer.parseInt(stk.nextToken());
        }
        result = arr[N-1];

        DP[0][arr[0]] = 1;
        for(int i=1; i<=N-2; i++){
            for(int j=0; j<=20; j++){
                if(DP[i-1][j] != 0){
                    int plus = j+arr[i];
                    int minus = j-arr[i];
                    if(0<=plus && plus<=20){
                        DP[i][plus] += DP[i-1][j];
                    }
                    if(0<=minus && minus<=20){
                        DP[i][minus] += DP[i-1][j];
                    }
                }
            }
        }
        System.out.println(DP[N-2][arr[N-1]]);
    }
}

[백준 1695] 팰린드롬 만들기

응파카 — Tue, 23 May 2023 18:44:24 +0900

1695번: 팰린드롬 만들기

앞에서 뒤로 보나, 뒤에서 앞으로 보나 같은 수열을 팰린드롬 이라고 한다. 예를 들어 {1}, {1, 2, 1}, {1, 2, 2, 1}과 같은 수열은 팰린드롬 이지만, {1, 2, 3}, {1, 2, 3, 2} 등은 팰린드롬이 아니다. 한 수열

www.acmicpc.net

1. 문제 요약

- 제한시간 2초

- 수열을 입력받고, 최소 몇 개의 숫자를 입력받으면 팰린드롬이 되는지 알아내는 문제

2. 아이디어 (문제 접근법)

[아이디어-1]
- 참조 링크의 풀이를 태블릿 그림으로 이해하며 풀어보았다
- 입력받은 수열을 기록하기 위해 int[] arr = new int[N] 생성
- 다른 DP 문제들과 마찬가지로 연산 결과를 배열에 담기 위해 int[][] DPArr = new int[N][N] 를 생성
    - 이후 DPArr 의 값들을 -1로 초기화한다
- arr 의 왼쪽과 오른쪽 투 포인터 역할을 할 int left 와 int right 를 파라미터로 갖는
    DP(int left, int right) -> DP(0, N-1) 실행
    다음 포인터란 left+1 과 right-1을 의미한다 (가운데로 범위를 좁혀감)
    - if (left >= right) return 0;
        투 포인터가 교차하면
        - 0 반환
    - if (DPArr[left][right] != -1) return DPArr[left][right];
        이미 해당 위치까지의 최소값을 구했으면
        - 해당 값 반환
    - if (arr[left] == arr[right])
        각 포인터가 가리키는 값이 같으면
        - DPArr[left][right] = DP(left+1, right-1);
        - return DP(left+1, right-1);
            다음 포인터가 가리키는 값을 기록하고 반환 (추가한 게 없기 때문)
    - else
        각 포인터가 가리키는 값이 다르면
        - DPArr[left][right] = Math.min(DP(left+1 ,right)+1, DP(left ,right-1)+1);
        - return Math.min(DP(left+1 ,right)+1, DP(left ,right-1)+1);
            왼쪽이나 오른쪽 포인터 중 하나만 다음 위치로 이동
            이후 해당 위치의 DP 값중 더 작은 값 + 1 을 기록하고 반환 (숫자 하나를 추가하기 때문)

3. 어려움 및 해결

- 수열이 주어졌을 때 왼쪽, 오른쪽 끝 각각에 left, right 포인터를 만든다
- 이후 가운데로 하나씩 좁혀오며 포인터가 가리키는 값이 다른 경우
    - 왼쪽에 오른쪽 값 생성
    - 오른쪽에 왼쪽 값 생성
        의 두 가지 경우의 수 발생
- 이것만으로는 메모이제이션은 가능하지만 최소의 개수가 나오는 경우의 수를 구하지 못한다
- 아이디어가 나오지 않아 다른 사람의 풀이를 참조

[백준]1695번 팰린드롬 만들기 2️⃣

\[백준]1695번 팰린드롬 만들기이전에 풀었던 문제인데 당시에 풀지 못해서 다른 사람 풀이를 봤었다. 다시 풀어보았다. 내 머리속에 항상 먼저 드는 생각은 투포인터이다....;.1\. left, right라는 두

velog.io

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

public class BOJ_1695_팰린드롬_만들기 {

    static int N;
    static int[] arr;
    static int[][] DPArr;

    static int DP(int left, int right){
        if(left >= right) return 0;
        if(DPArr[left][right] != -1) return DPArr[left][right];

        if(arr[left]==arr[right]){
            int min = DP(left+1, right-1);
            DPArr[left][right] = min;
            return min;
        }else{
            int min = Math.min(DP(left+1 ,right)+1, DP(left ,right-1)+1);
            DPArr[left][right] = min;
            return min;
        }
    }

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

        N = Integer.parseInt(br.readLine());
        arr = new int[N];
        DPArr = new int[N][N];
        stk = new StringTokenizer(br.readLine());
        for(int i=0; i<N; i++) {
            arr[i] = Integer.parseInt(stk.nextToken());
            Arrays.fill(DPArr[i], -1);
        }

        System.out.println(DP(0, N-1));
    }
}

[백준 11727] 2xn 타일링 2

응파카 — Sun, 21 May 2023 15:48:22 +0900

11727번: 2×n 타일링 2

2×n 직사각형을 1×2, 2×1과 2×2 타일로 채우는 방법의 수를 구하는 프로그램을 작성하시오. 아래 그림은 2×17 직사각형을 채운 한가지 예이다.

www.acmicpc.net

1. 문제 요약

위 그림과 같이 주어진 2 x n 크기의 공간을 세 가지 종류의 타일로 채우는 방법에는 몇 가지가 있는지 알아내는 문제

2. 아이디어

- 처음 아이디어
    - 2Xn 직사각형을 1X2, 2X1, 2X2 타일로 채우는 방법의 수
        - 1X2나, 2X2나 둘 다 가로 2칸을 차지한다
        [1] - 가로의 길이 n을 길이 1과 2로 채울 수 있는 모든 경우를 구한다
        [2] - 길이 2로 채우는 경우의 수는 1X2타일 두개로 채우는 경우와
         2X2타일 하나로 채우는 경우 두 가지만 있다
            - 길이 2로 채운 부분의 수 T 에 대하여
             1X2와 2X2 두 가지 경우를 적용시키면 된다. (2^T)
-> 답은 맞지만, 시간초과 발생

- 그림을 그려보니 이해가 쉬웠다
    2Xn 타일 -> 2X(n+1) 로 변할 때
    이는 곧
    2Xn 타일 모든 경우에 2X1 타일 하나를 더한 경우 혹은
    2X(n-1) 타일 모든 경우에
     2X2 타일 혹은 1x2(2) 를 더한 경우이다

    따라서
    arr[n] = arr[n-1] + 2*arr[n-2] 이다

3. 어려움 및 해결방식

- 처음 재귀를 활용한 DFS 방식으로 해결하려 했을 때
시간복잡도를 고려하지 않았던 점이 아쉽다

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

public class BOJ_11727_2xn_타일링_2 {
    static int N;
    static int[] arr;

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

        arr[1] = 1;
        if(N>1) arr[2] = 3;

        for(int i=3; i<=N; i++){
            arr[i] = ( arr[i-1] + 2*arr[i-2] ) % 10007;
        }

        System.out.println(arr[N]);
    }
}

[백준 11055] 가장 큰 증가하는 부분수열

응파카 — Sat, 20 May 2023 10:51:41 +0900

11055번: 가장 큰 증가하는 부분 수열

수열 A가 주어졌을 때, 그 수열의 증가하는 부분 수열 중에서 합이 가장 큰 것을 구하는 프로그램을 작성하시오. 예를 들어, 수열 A = {1, 100, 2, 50, 60, 3, 5, 6, 7, 8} 인 경우에 합이 가장 큰 증가하는

www.acmicpc.net

1. 문제 요약

부분 수열을 활용한 문제
- 증가하는 부분수열이므로 추가되는 요소는 이전 요소보다 큰 값을 갖는다
- 부분 수열이므로 연속되어야 할 필요가 없다
- 생성 가능한 부분수열들 중 합이 가장 큰 경우의 합을 출력

2. 아이디어

- 생성하고자 하는 수열과 같은 크기의 배열을 만들어 각 index 에
해당 위치까지 가질 수 있는 가장 큰 수열의 합을 기록하는 방식으로 풀어보려 한다

3. 어려움 및 해결방식

- 입력값을 기록하는 배열 arr 과 부분수열의 합을 기록하는 배열 check 를 만든다
- check 를 순회한다
- 이전의 arr 값들 중 arr[i] 보다 작은 값을 갖는 index = j1, j2, ... 라고 할때
가장 큰 check[j] 의 값에 arr[i] 를 더한다

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

public class BOJ_11055_가장_큰_증가하는_부분_수열 {

    static int[] arr;
    static int[] check;
    static int N;

    static void DP(int i){
        int max = 0;
        for(int j = 0; j<i; j++){
            if(arr[j]<arr[i] && max<check[j]){
                max = check[j];
            }
        }
        check[i] = arr[i] + max;
    }

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

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

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

        check[0] = arr[0];
        
        for(int i=1; i<N; i++){
            DP(i);
        }

        int answer = Integer.MIN_VALUE;
        for(int x : check){
            answer = Math.max(x, answer);
        }
        System.out.println(answer);
    }
}

[백준 2839] 설탕 배달

응파카 — Thu, 18 May 2023 19:37:51 +0900

2839번: 설탕 배달

상근이는 요즘 설탕공장에서 설탕을 배달하고 있다. 상근이는 지금 사탕가게에 설탕을 정확하게 N킬로그램을 배달해야 한다. 설탕공장에서 만드는 설탕은 봉지에 담겨져 있다. 봉지는 3킬로그

www.acmicpc.net

1. 문제 요약

- 사용 가능한 봉지는 5kg, 3kg의 두 종류이다
- N kg 을 가능한 적은 수의 봉지에 나누어 담아야 한다
- 만약 나누어 떨어지지 않는다면 -1을 출력한다

2. 아이디어

- 처음 아이디어
    - N kg 을 가능한 적은 개수의 봉지에 담기 위해서는
    - N/5 개수의 5kg 봉지와
    - N%5 / 3 개수의 3kg 봉지에 담으면 된다
    - 만약 N 이 5보다 작다면 -1을 출력한다
    - 만약 N%5 가 3으로 나누어 떨어지지 않는다면 -1을 출력한다

-> 하지만 6과 11의 경우 위의 방법이 먹히지 많는다
6의 경우 3kg 봉지 두 개를 쓰면 되고 11의 경우 5kg 봉지 하나와 3kg 봉지 두 개를 쓴다
단순히 5로 나눠서 해결되는 문제가 아니므로 우선 N에 따른 최소 봉지의 수를 정리하면 다음과 같다

N    1  2  3  4 | 5  6  7  8  9 | 10 11 12 13 14 | 15 16 17 18 19 ...
N/5  0  0  0  0 | 1  1  1  1  1 |  2  2  2  2  2 |  3  3  3  3  3
5kg  0  0  0  0 | 1  0  0  1  0 |  2  1  0  2  1 |  3  2  1  3  2 ...
3kg  0  0  1  0 | 0  2  0  1  3 |  0  2  4  1  3 |  0  2  4  1  3 ...
봉지 -1 -1  1 -1 | 1  2 -1  2  3 |  2  3  4  3  4 |  3  4  5  4  5 ...

3 <= N <= 5000 이므로 3 아래는 고려하지 말자
그러면 다음과 같은 규칙이 나온다

N/5 -> N/5
N/5+1 -> N/5 + 1
N/5+2 -> N/5 + 2
N/5+3 -> N/5 + 1
N/5+4 -> N/5 + 2

예외 : 4, 7 -> -1

즉 이를 분류하면 다음과 같다
- 5의 배수인 경우
- 5의 배수+1 or 5의 배수+3
- 5의 배수+2 or 5의 배수+4
- 4, 7인 경우

각각에 해당하는 값을 출력해주면 된다
- 4, 7인 경우를 먼저 조건문으로 걸면 된다

3. 어려움 및 해결방식

- 처음에 모든 경우의 수를 구해야 하나 고민했지만
먼저 풀어보았던 BOJ_11727_2xn_타일링_2 문제에서의 경험을 통해 시간복잡도 문제가 발생함을 알 수 있었다
규칙을 찾고자 값을 나열하다보니 방법을 발견해버린 경우여서 근본적인 해결 방법은 아닌 것 같다

- 각 N을 5씩 나누어서 고려하면 당연하게 나오는 규칙이었다
5의 배수로 떨어지는 경우 : N/5 만큼의 봉지가 필요
N%5 = 3 인 경우 : N/5+1 만큼의 봉지가 필요 (3kg 봉지 하나만 추가하면 되기 때문)
N%5 = 1 인 경우 : 6, 11 ... 인데
                N=6이면 3kg 짜리 2개를 필요로 하고, 이후로 5씩 증가
N%5 = 4 인 경우 : 4, 9, 13 ... 인데 4는 제외하고
                N=9이면 3kg 짜리 3개를 필요로 하고, 이후로 5씩 증가
N%5 = 2 인 경우 : 7, 12, 17 ... 인데 7은 제외하고
                N=12이면 3kg 짜리 4개를 필요로 하고, 이후로 5씩 증가

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

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

        if(N==4 || N==7){
            System.out.println(-1);
        }else if(N%5 == 0){
            System.out.println(N/5);
        }else if(N%5 == 1 || N%5 == 3){
            System.out.println(N/5 + 1);
        }else if(N%5 == 2 || N%5 == 4){
            System.out.println(N/5 + 2);
        }
    }
}

[백준 1106] 호텔

응파카 — Wed, 17 May 2023 03:28:43 +0900

1106번: 호텔

첫째 줄에 C와 형택이가 홍보할 수 있는 도시의 개수 N이 주어진다. C는 1,000보다 작거나 같은 자연수이고, N은 20보다 작거나 같은 자연수이다. 둘째 줄부터 N개의 줄에는 각 도시에서 홍보할 때

www.acmicpc.net

1. 문제 요약

- C 이상의 고객을 늘려야 하고 N 개의 도시가 있을 때
- N 개의 도시들 각각에 대한 홍보 비용 cost 와
- 얻을 수 있는 고객의 수 customer 를 입력받는다
- 각각의 도시는 cost 의 정수배 만큼만 홍보 가능하다
- customer 은 최대 100이다

2. 아이디어

- 처음 아이디어
    - 비용당 얻을 수 있는 고객의 수 (얻는 고객의 수/비용) 가 가장 많은 도시를 고르고
    - 그 도시에 C 만큼의/C를 넘지 않는 만큼의 홍보를 한 후
    - 도시들 중 가장 적은 비용으로 C 이상이 되는 도시에 홍보하기

- 힌트 참고 후
    - 적어도 C명의 고객을 얻는 것이 목표이기에
        C명 얻는 비용 > C+n명 얻는 비용
        이런 상황이 발생 가능하다
        이런 경우 C+n 명을 얻는 것이 답에 가까우므로 다음과 같이 해결해야 한다

    - customer 는 최대 100이라는 조건 때문에 홍보를 통해 얻을 수 있는 최대 고객의 수는 C+100 이다
        int maxCustomer = C+100
        - 이를 위한 int[] costForIdx = new int[maxCustomer+1] 를 만든다
            -> 각 인덱스만큼의 고객을 얻기 위한 최소 비용
            - 최소값을 구하는 과정이므로 초기값을 MAX_VALUE 로 세팅 한다
            - costForIdx[0] = 0 (나중 정수배 투자 부분을 위해 세팅)

    - 이후 각 도시별 홍보비용 cost 와 이 때 얻을 수 있는 고객의 수 customer 를 입력받는다
        - customer 부터 maxCustomer 까지 순회하며 아래를 반복한다
        [각 index 의 최소비용] 과 [각 index-customer 의 비용 + cost] 를 비교해 더 작은값으로 업데이트 한다
            - 만약 index-customer 의 비용이 MAX_VALUE 그대로라면
                - 업데이트되지 않아 최소값을 구할수 없으므로 패스한다
            -> 정수배 홍보

    - 위 과정을 마친 후 costForIdx 의 index C 부터 maxCustomer 범위의 최소값을 구한다

3. 어려움 및 해결방식

- 최소 C 명을 늘린다는 의미를 처음에 제대로 이해하지 못했었다
- cost 를 통해 한 번에 늘릴 수 있는 고객의 최대 수가 100 이라는 조건을 활용할 방법을 떠올리지 못했다

각각에 대한 해결방식은 2.아이디어 - 힌트 참고 후 참조

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

public class BOJ_1106_호텔 {

    static int[] costForIdx; // index 명을 늘릴때의 cost
    static int maxCustomer;

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

        stk = new StringTokenizer(br.readLine());
        int C = Integer.parseInt(stk.nextToken()); // C명 이상의 고객
        int N = Integer.parseInt(stk.nextToken()); // 도시의 개수 N
        maxCustomer = C+100;

        costForIdx = new int[maxCustomer+1]; // 한 번에 얻을 수 있는 고객의 수 <= 100
        // 각 Index 만큼의 고객을 얻기 위해 필요한 최소 비용을 MAX_VALUE 로 세팅
        Arrays.fill(costForIdx, Integer.MAX_VALUE);

        // 나중 정수배만큼 홍보하는 부분을 위해 세팅해야 한다
        costForIdx[0] = 0;

        for(int i=0; i<N; i++){
            // 각 도시별로 비용별 얻을 수 있는 사람의 수를 입력받고
            stk = new StringTokenizer(br.readLine());
            int cost = Integer.parseInt(stk.nextToken());
            int customer = Integer.parseInt(stk.nextToken());

            // cost 로 얻을 수 있는 사람의 수 부터 최대 얻을 수 있는 사람의 수 까지 순회
            // 순회하며 현재 최소 비용과 (현재 - cost 로 얻을 수 있는 사람의 수)의 비용중
            	// 더 작은 값으로 업데이트 한다
                // 정수배만큼 추가로 홍보하는 부분
            // 만약 업데이트 되어있지 않다면 값을 구할 수 없으므로 패스한다
            for(int j=customer; j<=maxCustomer; j++){
                if(costForIdx[j-customer] == Integer.MAX_VALUE) continue;
                costForIdx[j] = Math.min(costForIdx[j], costForIdx[j-customer]+cost);
            }
        }

        int answer = Integer.MAX_VALUE;
        for(int i=C; i<=maxCustomer; i++){
            answer = Math.min(answer, costForIdx[i]);
        }
        System.out.println(answer);
    }
}

[백준 14600] 샤워실 바닥 깔기 (Small)

응파카 — Tue, 16 May 2023 01:29:53 +0900

14600번: 샤워실 바닥 깔기 (Small)

첫 번째 줄에는 바닥의 한 변의 길이를 표현하는 자연수 K(1 ≤ K ≤ 2) 가 주어진다. 이때 바닥의 크기는 2K 가 됨에 유의하라. 두 번째 줄에는 배수구의 위치를 나타내는 자연수 x, y (1 ≤ x, y ≤ 2K)

www.acmicpc.net

2^n X 2^n 크기의 정사각형은 1X1 한 칸을 제외하고 'ㄴ' 모양의 타일로 전부 채울 수 있다.

1. x, y축에 주의하여 하수구 위치 -1로 표시

static number = 1
아래 내용을 재귀로 해결
recursion(startX, startY, size)

2. 현재 범위의 한 변의 길이를 size라고 하자

    - 현재 범위를 4등분하여 (size=2^n 이라서 1만 아니라면 무조건 가능하다)
        check 메서드 안 파라미터는 다음과 같이
        그 아래는 check 결과 true면 취할 행동
            - startX, startY, size/2
                - (startX+size/2-1, startY+size/2-1) number++로
            - startX, startY+size/2, size/2
                - (startX+size/2-1, startY+size/2) number++로
            - startX+size/2, startY, size/2
                - (startX+size/2, startY+size/2-1) number++로
            - startX+size/2, startY+size/2, size/2
                - (startX+size/2, startY+size/2) number++로
    - 이어서 아래로 recursion 진행
    recursion(startX, startY, size/2)
    recursion(startX, startY+size/2, size/2)
    recursion(startX+size/2, startY, size/2)
    recursion(startX+size/2, startY+size/2, size/2)

3. check(시작X, 시작Y, 체크길이)

체크하는 범위가 전부 0인지 확인 (아무 이벤트 없는지)

2^n X 2^n 크기의 정사각형은 1X1 한 칸을 제외하고 ㄴ 모양의 타일로 전부 채울 수 있다.

1. x, y축에 주의하여 하수구 위치 -1로 표시
    static number = 1
아래 내용을 재귀로 해결
recursion(startX, startY, size)
2. 현재 범위의 한 변의 길이를 size라고 하자
    - 현재 범위를 4등분하여 (size=2^n 이라서 1만 아니라면 무조건 가능하다)
        check 메서드 안 파라미터는 다음과 같이
        그 아래는 check 결과 true면 취할 행동
            - startX, startY, size/2
                - (startX+size/2-1, startY+size/2-1) number++로
            - startX, startY+size/2, size/2
                - (startX+size/2-1, startY+size/2) number++로
            - startX+size/2, startY, size/2
                - (startX+size/2, startY+size/2-1) number++로
            - startX+size/2, startY+size/2, size/2
                - (startX+size/2, startY+size/2) number++로
    - 이어서 아래로 recursion 진행
    recursion(startX, startY, size/2)
    recursion(startX, startY+size/2, size/2)
    recursion(startX+size/2, startY, size/2)
    recursion(startX+size/2, startY+size/2, size/2)

3. check(시작X, 시작Y, 체크길이)
    체크하는 범위가 전부 0인지 확인 (아무 이벤트 없는지)

public class Main {
    static int[][] board;
    static int N;
    static int number = 1; //타일 번호

    static boolean check(int startX, int startY, int size){
        for(int i=startX; i<startX+size; i++){
            for(int j=startY; j<startY+size; j++){
                if(board[i][j]!=0) return false;
            }
        }
        return true;
    }

    static void recursion(int startX, int startY, int size){

        if(size==1){
            return;
        }

        int newSize = size/2;
        if(check(startX, startY, newSize)){
            board[startX+newSize-1][startY+newSize-1] = number;
        }
        if(check(startX, startY+newSize, newSize)){
            board[startX+newSize-1][startY+newSize] = number;
        }
        if(check(startX+newSize, startY, newSize)){
            board[startX+newSize][startY+newSize-1] = number;
        }
        if(check(startX+newSize, startY+newSize, newSize)){
            board[startX+newSize][startY+newSize] = number;
        }
        number++;

//        showBoard();
        System.out.println();

        recursion(startX, startY, newSize);
        recursion(startX, startY+newSize, newSize);
        recursion(startX+newSize, startY, newSize);
        recursion(startX+newSize, startY+newSize, newSize);

    }

    static void showBoard(){
        for(int i=0; i<N; i++){
            for(int j=0; j<N; j++){
                System.out.print(board[i][j] + " ");
            }
            System.out.println();
        }
    }
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stk;
        int n = Integer.parseInt(br.readLine());
        N = (int) pow(2, n);
        board = new int[N][N];

        stk = new StringTokenizer(br.readLine());
        int holeX = Integer.parseInt(stk.nextToken());
        int holeY = Integer.parseInt(stk.nextToken());
        board[N-holeY][holeX-1] = -1;

        recursion(0, 0, N);

        showBoard();
    }
}