www.acmicpc.net/problem/11055

 

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

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

www.acmicpc.net

문제

수열 A가 주어졌을 때, 그 수열의 증가 부분 수열 중에서 합이 가장 큰 것을 구하는 프로그램을 작성하시오.

예를 들어, 수열 A = {1, 100, 2, 50, 60, 3, 5, 6, 7, 8} 인 경우에 합이 가장 큰 증가 부분 수열은 A = {1, 100, 2, 50, 60, 3, 5, 6, 7, 8} 이고, 합은 113이다.

입력

첫째 줄에 수열 A의 크기 N (1 ≤ N ≤ 1,000)이 주어진다.

둘째 줄에는 수열 A를 이루고 있는 Ai가 주어진다. (1 ≤ Ai ≤ 1,000)

출력

첫째 줄에 수열 A의 합이 가장 큰 증가 부분 수열의 합을 출력한다.

예제 입력 1

10

1 100 2 50 60 3 5 6 7 8

예제 출력 1

113

 

 

 

 

 

풀이 .

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.OptionalInt;
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());
        StringTokenizer st = new StringTokenizer(br.readLine());
        int[] arr = new int[n];
        int[] dp = new int[n];
        for(int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }

        dp[0] = arr[0];
        for(int i = 1; i < n; i++) {
            dp[i] = arr[i];
            for(int j = 0; j < i; j++) {
                if(arr[i] > arr[j] && dp[j] + arr[i] > dp[i]) {
                    dp[i] = dp[j] + arr[i];
                }
            }
        }

        OptionalInt ans = Arrays.stream(dp).max();
        System.out.println(ans.getAsInt());
    }
}

 

codeung.tistory.com/118?category=449370 와 비슷한 문제이다

 

dp[n] = "arr[n]으로 끝나는 부분수열 중 가장 큰 합"

arr[n]으로 끝난다는 것은 arr[n]이 마지막 원소라는 것. 즉, [0]~[n-1] 까지만 검사하면 된다.

 

증가하는 부분수열이란 조건을 지키기 위해 [0]~[n-1] 중 arr[n]보다 작은 놈들에 대해서만 검사하면 된다.

dp[0]~dp[n-1] 에서 arr[n]을 더했을 때 현재의 dp[n] 값보다 커지는 놈이 있다면 dp[n] 값을 갱신해준다.

www.acmicpc.net/problem/11053

 

11053번: 가장 긴 증가하는 부분 수열

수열 A가 주어졌을 때, 가장 긴 증가하는 부분 수열을 구하는 프로그램을 작성하시오. 예를 들어, 수열 A = {10, 20, 10, 30, 20, 50} 인 경우에 가장 긴 증가하는 부분 수열은 A = {10, 20, 10, 30, 20, 50} 이

www.acmicpc.net

문제

수열 A가 주어졌을 때, 가장 긴 증가하는 부분 수열을 구하는 프로그램을 작성하시오.

예를 들어, 수열 A = {10, 20, 10, 30, 20, 50} 인 경우에 가장 긴 증가하는 부분 수열은 A = {10, 20, 10, 30, 20, 50} 이고, 길이는 4이다.

입력

첫째 줄에 수열 A의 크기 N (1 ≤ N ≤ 1,000)이 주어진다.

둘째 줄에는 수열 A를 이루고 있는 Ai가 주어진다. (1 ≤ Ai ≤ 1,000)

출력

첫째 줄에 수열 A의 가장 긴 증가하는 부분 수열의 길이를 출력한다.

예제 입력 1

6 10 20 10 30 20 50

예제 출력 1

4

 

 

 

 

 

풀이 .

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.OptionalInt;
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());
        StringTokenizer st = new StringTokenizer(br.readLine());
        int[] arr = new int[n];
        int[] dp = new int[n];
        for(int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }

        dp[0] = 1;
        for(int i = 1; i < n; i++) {
            dp[i] = 1;
            for(int j = 0; j < i; j++) {
                if(arr[i] > arr[j] && dp[j] + 1 > dp[i]) {
                    dp[i] = dp[j] + 1;
                }
            }
        }

        OptionalInt ans = Arrays.stream(dp).max();
        System.out.println(ans.getAsInt());
    }
}

 

잘 알려진 LIS(Longest Increasing Subsequence) 문제이다.

 

dp[n] = "n번째 수로 끝나는 부분수열 중 가장 긴 것의 길이"

n번째 수로 끝나는 부분수열에서는 n번째 수가 마지막 수이기 때문에 dp[n]을 구하기 위해선 dp[n-1] 까지만 살펴보면 된다.

 

증가하는 부분수열을 유지하려면 arr[n]로 끝나는 부분수열에서 arr[n] 앞에 올 수 있는 숫자는 반드시 arr[n]보다 작아야 한다.

즉, [0]~[n-1] 중에서 arr[n] 보다 작은 숫자만 검사하면 된다.

 

arr[n]보다 작은 인덱스를 대상으로 dp[0]~dp[n-1]을 검사한다. arr[n]을 추가해서 arr[n]으로 끝나는 부분수열을 완성했을 때 최장길이가 되기 위해선 dp[n 이전의 인덱스] + 1 은 dp[n] 의 현재값보다 더 커야 한다. 

 

위 검사를 arr[0]~arr[n-1] 중 arr[n] 보다 작은 놈들에게만 수행하여 dp[n] 값을 갱신하면 된다.

www.acmicpc.net/problem/2156

 

2156번: 포도주 시식

효주는 포도주 시식회에 갔다. 그 곳에 갔더니, 테이블 위에 다양한 포도주가 들어있는 포도주 잔이 일렬로 놓여 있었다. 효주는 포도주 시식을 하려고 하는데, 여기에는 다음과 같은 두 가지 규

www.acmicpc.net

문제

효주는 포도주 시식회에 갔다. 그 곳에 갔더니, 테이블 위에 다양한 포도주가 들어있는 포도주 잔이 일렬로 놓여 있었다. 효주는 포도주 시식을 하려고 하는데, 여기에는 다음과 같은 두 가지 규칙이 있다.

  1. 포도주 잔을 선택하면 그 잔에 들어있는 포도주는 모두 마셔야 하고, 마신 후에는 원래 위치에 다시 놓아야 한다.
  2. 연속으로 놓여 있는 3잔을 모두 마실 수는 없다.

효주는 될 수 있는 대로 많은 양의 포도주를 맛보기 위해서 어떤 포도주 잔을 선택해야 할지 고민하고 있다. 1부터 n까지의 번호가 붙어 있는 n개의 포도주 잔이 순서대로 테이블 위에 놓여 있고, 각 포도주 잔에 들어있는 포도주의 양이 주어졌을 때, 효주를 도와 가장 많은 양의 포도주를 마실 수 있도록 하는 프로그램을 작성하시오. 

예를 들어 6개의 포도주 잔이 있고, 각각의 잔에 순서대로 6, 10, 13, 9, 8, 1 만큼의 포도주가 들어 있을 때, 첫 번째, 두 번째, 네 번째, 다섯 번째 포도주 잔을 선택하면 총 포도주 양이 33으로 최대로 마실 수 있다.

입력

첫째 줄에 포도주 잔의 개수 n이 주어진다. (1≤n≤10,000) 둘째 줄부터 n+1번째 줄까지 포도주 잔에 들어있는 포도주의 양이 순서대로 주어진다. 포도주의 양은 1,000 이하의 음이 아닌 정수이다.

출력

첫째 줄에 최대로 마실 수 있는 포도주의 양을 출력한다.

예제 입력 1

6

6

10

13

9

8

1

예제 출력 1

33

 

 

 

 

 

풀이 .

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 n = Integer.parseInt(br.readLine());
        int[] arr = new int[n+1];
        int[][] dp = new int[n+1][3];
        for(int i = 1; i <= n; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }
        dp[1][0] = 0;
        dp[1][1] = arr[1];
        dp[1][2] = arr[1];

        for(int i = 2; i <= n; i++) {
            dp[i][0] = Math.max(dp[i-1][0], Math.max(dp[i-1][1], dp[i-1][2]));
            dp[i][1] = dp[i-1][0] + arr[i];
            dp[i][2] = dp[i-1][1] + arr[i];
        }

        int ans = Math.max(dp[n][0], Math.max(dp[n][1], dp[n][2]));
        System.out.println(ans);
    }
}

 

n번째 잔에서 할 수 있는 선택지는 3개 이다.

1. n번째 잔을 0번 연속 선택 (선택하지 않음) -> n-1번째에서 어떤 선택을 했든지 상관 없음

2. n번째 잔을 1번 연속 선택 -> n-1번째에서 0번 연속 선택을 했어야 함

3. n번째 잔을 2번 연속 선택 -> n-1번째에서 1번 연속 선택을 했어야 함

 

dp[i][j] = i 번째 잔을 j 번 연속 선택할 때 마실 수 있는 최대 포도주의 양

 

 

www.acmicpc.net/problem/9465

 

9465번: 스티커

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스의 첫째 줄에는 n (1 ≤ n ≤ 100,000)이 주어진다. 다음 두 줄에는 n개의 정수가 주어지며, 각 정수는 그 위치에 해당하는 스티커의

www.acmicpc.net

문제

상근이의 여동생 상냥이는 문방구에서 스티커 2n개를 구매했다. 스티커는 그림 (a)와 같이 2행 n열로 배치되어 있다. 상냥이는 스티커를 이용해 책상을 꾸미려고 한다.

상냥이가 구매한 스티커의 품질은 매우 좋지 않다. 스티커 한 장을 떼면, 그 스티커와 변을 공유하는 스티커는 모두 찢어져서 사용할 수 없게 된다. 즉, 뗀 스티커의 왼쪽, 오른쪽, 위, 아래에 있는 스티커는 사용할 수 없게 된다.

모든 스티커를 붙일 수 없게된 상냥이는 각 스티커에 점수를 매기고, 점수의 합이 최대가 되게 스티커를 떼어내려고 한다. 먼저, 그림 (b)와 같이 각 스티커에 점수를 매겼다. 상냥이가 뗄 수 있는 스티커의 점수의 최댓값을 구하는 프로그램을 작성하시오. 즉, 2n개의 스티커 중에서 점수의 합이 최대가 되면서 서로 변을 공유 하지 않는 스티커 집합을 구해야 한다.

위의 그림의 경우에 점수가 50, 50, 100, 60인 스티커를 고르면, 점수는 260이 되고 이 것이 최대 점수이다. 가장 높은 점수를 가지는 두 스티커 (100과 70)은 변을 공유하기 때문에, 동시에 뗄 수 없다.

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스의 첫째 줄에는 n (1 ≤ n ≤ 100,000)이 주어진다. 다음 두 줄에는 n개의 정수가 주어지며, 각 정수는 그 위치에 해당하는 스티커의 점수이다. 연속하는 두 정수 사이에는 빈 칸이 하나 있다. 점수는 0보다 크거나 같고, 100보다 작거나 같은 정수이다. 

출력

각 테스트 케이스 마다, 2n개의 스티커 중에서 두 변을 공유하지 않는 스티커 점수의 최댓값을 출력한다.

예제 입력 1

2

5

50 10 100 20 40

30 50 70 10 60

7

10 30 10 50 100 20 40

20 40 30 50 60 20 80

예제 출력 1

260

290

 

 

 

 

풀이 .

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 T = Integer.parseInt(br.readLine());

        while(T-- > 0) {
            int n = Integer.parseInt(br.readLine());
            int[][] arr = new int[3][n+1];
            StringTokenizer st1 = new StringTokenizer(br.readLine());
            StringTokenizer st2 = new StringTokenizer(br.readLine());

            // 0행은 무시. dp랑 행 라인 맞추려면 0행 있는 게 편함
            for(int i = 1; i <= n; i++) {
                arr[1][i] = Integer.parseInt(st1.nextToken());
                arr[2][i] = Integer.parseInt(st2.nextToken());
            }

            // n개의 열에서 선택안하기, 1행선택하기, 2행선택하기
            int[][] dp = new int[3][n+1];
            dp[0][1] = 0;
            dp[1][1] = arr[1][1];
            dp[2][1] = arr[2][1];

            // 2~n 열
            for(int i = 2; i <= n; i++) {
                dp[0][i] = Math.max(dp[0][i-1], Math.max(dp[1][i-1], dp[2][i-1]));
                dp[1][i] = Math.max(dp[0][i-1], dp[2][i-1]) + arr[1][i];
                dp[2][i] = Math.max(dp[0][i-1], dp[1][i-1]) + arr[2][i];
            }
            int ans = Math.max(dp[0][n], Math.max(dp[1][n], dp[2][n]));
            System.out.println(ans);
        }
    }
}

 

하나의 열에서 고를 수 있는 선택지는 3개다.

1. 아무것도 고르지 않기

2. 1행의 스티커 고르기

3. 2행의 스티커 고르기

 

 

1. 아무것도 고르지 않으려면?

-> 이전 열에서 어떤 선택을 하더라도 모두 가능

 

2. 1행을 고르려면?

-> 이전 열에서 아무것도 안 골랐거나 2행을 골랐어야 가능

 

3. 2행을 고르려면?

-> 이전 열에서 아무것도 안 골랐거나 1행을 골랐어야 가능

 

 

계산의 편의상 0행 0열은 빈 칸으로 두고 1, 2행  1~n열이 존재할 때,

dp[i][j] = "j 번째 열에서 i 행을 선택하는 경우 점수의 최대값" 이다. (i = 0 일 경우 아무 행도 선택하지 않는 것으로 한다)

 

즉,

dp[n][0] = (이전 열에서 아무것도 안 고르기, 1행 고르기, 2행 고르기 중 최대값)

dp[n][1] = (이전 열에서 아무것도 안 고르기, 2행 고르기 중 최대값) + n열 1행의 값

dp[n][2] = (이전 열에서 아무것도 안 고르기, 1행 고르기 중 최대값) + n열 2행의 값

 

 

dp, ans 모두 int 사용 가능한 이유?

한 칸의 최대 점수는 100, 가장 많이 고를 수 있는 칸은 n칸 (지그재그로 한 열당 하나씩 무조건 고르는 경우)

즉, 획득 가능한 점수의 상한은 100n = 100 * 100,000 = 천만

-> int 범위 내에 속한다.

www.acmicpc.net/problem/2193

 

2193번: 이친수

0과 1로만 이루어진 수를 이진수라 한다. 이러한 이진수 중 특별한 성질을 갖는 것들이 있는데, 이들을 이친수(pinary number)라 한다. 이친수는 다음의 성질을 만족한다. 이친수는 0으로 시작하지 않

www.acmicpc.net

문제

0과 1로만 이루어진 수를 이진수라 한다. 이러한 이진수 중 특별한 성질을 갖는 것들이 있는데, 이들을 이친수(pinary number)라 한다. 이친수는 다음의 성질을 만족한다.

  1. 이친수는 0으로 시작하지 않는다.
  2. 이친수에서는 1이 두 번 연속으로 나타나지 않는다. 즉, 11을 부분 문자열로 갖지 않는다.

예를 들면 1, 10, 100, 101, 1000, 1001 등이 이친수가 된다. 하지만 0010101이나 101101은 각각 1, 2번 규칙에 위배되므로 이친수가 아니다.

N(1 ≤ N ≤ 90)이 주어졌을 때, N자리 이친수의 개수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N이 주어진다.

출력

첫째 줄에 N자리 이친수의 개수를 출력한다.

예제 입력 1

3

예제 출력 1

2

 

 

 

 

풀이 .

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 n = Integer.parseInt(br.readLine());
        long[][] dp = new long[n + 1][2];
        dp[1][0] = 0;
        dp[1][1] = 1;

        for(int i = 2; i <= n; i++) {
            dp[i][0] = dp[i - 1][0] + dp[i - 1][1];
            dp[i][1] = dp[i - 1][0];
        }

        long ans = dp[n][0] + dp[n][1];
        System.out.println(ans);
    }
}

 

dp[i][j] = i 자리 이친수가 j 로 끝나는 경우의 수

 

1. i 번째 자리에 0이 올 수 있는 경우 : i-1번째가 0일때, 1일때 모두 가능

2. i 번째 자리에 1이 올 수 있는 경우 : i-1번째가 0일 경우만 가능

 

즉, dp[n][0] = dp[n-1][0] + dp[n-1][1], dp[n][1] = dp[n-1][0]

 

dp, ans에 long을 사용한 이유?

-> % 연산을 취하라는 별도의 조건 없이 무작정 더해나가기만 하면서 dp[n]을 구한다. 이런 경우는 덧셈을 거듭하면서 숫자가 얼마나 커질지 모르기 때문에 굳이 시간 아깝게 계산하지 말고 그냥 처음부터 long을 사용하자.

 

www.acmicpc.net/problem/11057

 

11057번: 오르막 수

오르막 수는 수의 자리가 오름차순을 이루는 수를 말한다. 이때, 인접한 수가 같아도 오름차순으로 친다. 예를 들어, 2234와 3678, 11119는 오르막 수이지만, 2232, 3676, 91111은 오르막 수가 아니다. 수

www.acmicpc.net

문제

오르막 수는 수의 자리가 오름차순을 이루는 수를 말한다. 이때, 인접한 수가 같아도 오름차순으로 친다.

예를 들어, 2234와 3678, 11119는 오르막 수이지만, 2232, 3676, 91111은 오르막 수가 아니다.

수의 길이 N이 주어졌을 때, 오르막 수의 개수를 구하는 프로그램을 작성하시오. 수는 0으로 시작할 수 있다.

입력

첫째 줄에 N (1 ≤ N ≤ 1,000)이 주어진다.

출력

첫째 줄에 길이가 N인 오르막 수의 개수를 10,007로 나눈 나머지를 출력한다.

예제 입력 1

1

예제 출력 1

10

예제 입력 2

2

예제 출력 2

55

예제 입력 3

3

예제 출력 3

220

 

 

 

 

풀이 .

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 n = Integer.parseInt(br.readLine());
        int[][] dp = new int[n + 1][10];
        for(int i = 0; i <= 9; i++) {
            dp[1][i] = 1;
        }

        for(int i = 2; i <= n; i++) {
            for(int j = 0; j <= 9; j++) {
                for(int k = 0; k <= j; k++) {
                    dp[i][j] += dp[i - 1][k];
                }
                dp[i][j] %= 10007;
            }
        }

        int ans = 0;
        for(int num : dp[n]) {
            ans += num;
        }
        ans %= 10007;
        System.out.println(ans);
    }
}

 

dp[i][j] = 길이가 i인 오르막수가 j로 끝나는 경우.

i번째 자리에 j가 오려면 i-1번째 자리는 0~j 만 올 수 있다.

 

n * 10 * 10 = 100,000번의 연산으로 처리 가능

 

dp, ans 모두 int로 처리 가능

(dp[n][0]~dp[n][9]의 총합은 10007 * 10 이하이므로)

 

 

www.acmicpc.net/problem/10844

 

10844번: 쉬운 계단 수

첫째 줄에 정답을 1,000,000,000으로 나눈 나머지를 출력한다.

www.acmicpc.net

문제

45656이란 수를 보자.

이 수는 인접한 모든 자리수의 차이가 1이 난다. 이런 수를 계단 수라고 한다.

세준이는 수의 길이가 N인 계단 수가 몇 개 있는지 궁금해졌다.

N이 주어질 때, 길이가 N인 계단 수가 총 몇 개 있는지 구하는 프로그램을 작성하시오. (0으로 시작하는 수는 없다.)

입력

첫째 줄에 N이 주어진다. N은 1보다 크거나 같고, 100보다 작거나 같은 자연수이다.

출력

첫째 줄에 정답을 1,000,000,000으로 나눈 나머지를 출력한다.

예제 입력 1

1

예제 출력 1

9

예제 입력 2

2

예제 출력 2

17

 

 

 

 

풀이 .

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 n = Integer.parseInt(br.readLine());
        long[][] dp = new long[n + 1][10];
        for(int i = 1; i <= 9; i++) {
            dp[1][i] = 1;
        }

        for(int i = 2; i <= n; i++) {
            for(int j = 0; j <= 9; j++) {
                if(j == 0) dp[i][j] = (dp[i - 1][j + 1]) % 1000000000;
                else if(j == 9) dp[i][j] = (dp[i - 1][j - 1]) % 1000000000;
                else dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j + 1]) % 1000000000;
            }
        }

        long ans = 0;
        for(long num : dp[n]) {
            ans += num;
        }
        ans %= 1000000000;
        System.out.println(ans);
    }
}

 

dp[i][j] = 길이가 i 이고 j로 끝나는 계단수의 개수

 

% 10억한 것을 dp에 넣으면 dp는 int로 처리가 가능하다.

 

그런데 그 dp[n][0] ~ dp[n][9] 를 모두 더하면 int 범위가 넘어가기 때문에 ans는 long을 사용하고 다시 한 번 '%= 10억'을 해줘야 한다.

www.acmicpc.net/problem/9095

 

9095번: 1, 2, 3 더하기

각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 출력한다.

www.acmicpc.net

문제

정수 4를 1, 2, 3의 합으로 나타내는 방법은 총 7가지가 있다. 합을 나타낼 때는 수를 1개 이상 사용해야 한다.

  • 1+1+1+1
  • 1+1+2
  • 1+2+1
  • 2+1+1
  • 2+2
  • 1+3
  • 3+1

정수 n이 주어졌을 때, n을 1, 2, 3의 합으로 나타내는 방법의 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스는 한 줄로 이루어져 있고, 정수 n이 주어진다. n은 양수이며 11보다 작다.

출력

각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 출력한다.

예제 입력 1

3

4

7

10

예제 출력 1

7

44

274

 

 

 

 

풀이 1. (DP)

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 T = Integer.parseInt(br.readLine());
        int[] dp = new int[11];
        dp[0] = 1;
        dp[1] = 1;
        dp[2] = 2;

        for(int i = 3; i <= 10; i++) {
            dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
        }

        for(int i = 0; i < T; i++) {
            int n = Integer.parseInt(br.readLine());
            System.out.println(dp[n]);
        }
    }
}

 

+1, +2, +3을 사용해 n을 만드는 경우는 총 3가지가 있다.

1. n-1  +1

2. n-2  +2

3. n-3  +3

 

 

 

 

 

풀이 2. (Brute Force)

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

public class Main {
    static BufferedReader br = null;
    static int ans;

    public static void dfs(int sum, int target) {
        if(sum >= target) {
            if(sum == target) {
                ans += 1;
            }
            return;
        }

        for(int i = 1; i <= 3; i++) {
            dfs(sum + i, target);
        }
    }

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

        while(T-- > 0) {
            int n = Integer.parseInt(br.readLine());
            ans = 0;
            dfs(0, n);
            System.out.println(ans);
        }
    }
}

 

DFS로도 풀 수 있다.

+ Recent posts