728x90

문제

 

 

접근 방식

배열에서 특정 부분만 확인 했을 때 팰린드롬인지 판별하는 문제다.

 

DP 문제이긴 하지만 이전 값을 사용해 테이블을 채워나가는 방식은 아니고

길이별로 팰린드롬인지 직접 확인해서 테이블에 저장해

s와 e를 입력 받을 때마다 매번 계산하지 않고 저장된 값을 읽는 방식이다.

1, 2, 1, 3, 1, 2, 1

 

위와 같은 배열의 경우에는 다음과 같은 테이블이 만들어진다.

  1 2 1 3 1 2 1
1 T F T F F F T
2   T F F F T F
1     T F T F F
3       T F F F
1         T F T
2           T F
1             T

 

숫자가 하나인 경우는 무조건 팰린드롬이니 참으로 설정해두고

2개 이상인 경우만 판단하면 되고, 시작점이 끝점보다 큰 경우는 없기 때문에

자기 자신의 인덱스 이전은 신경 쓸 필요가 없다.

1 ~ 2번이 팰린드롬인지, 1 ~ 3번이 팰린드롬인지, ..., 1 ~ 7번이 팰린드롬인지
2 ~ 3번이 팰린드롬인지, 2 ~ 4번이 팰린드롬인지, ..., 2 ~ 7번이 팰린드롬인지
...
...
5 ~ 6번이 팰린드롬인지, 5 ~ 7번이 팰린드롬인지
6 ~ 7번이 팰린드롬인지

 

이중 반복문을 돌면서 위와 같이 다 검증해주면서 테이블만 채워주면 된다.

 

 

풀이

public class Main {

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

		int n = Integer.parseInt(br.readLine());
		StringTokenizer st = new StringTokenizer(br.readLine());

		int[] seq = new int[n + 1];
		boolean[][] dp = new boolean[n + 1][n + 1];

		for (int i = 1; i <= n; i++) {
			seq[i] = Integer.parseInt(st.nextToken());
			dp[i][i] = true;
		}

		for (int i = 1; i <= n; i++) {
			for (int j = i + 1; j <= n; j++) {
				if (isPalindrome(seq, i, j)) dp[i][j] = true;
			}
		}

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

		for (int i = 0; i < m; i++) {
			st = new StringTokenizer(br.readLine());
			sb.append(dp[Integer.parseInt(st.nextToken())][Integer.parseInt(st.nextToken())] ? 1 : 0).append("\n");
		}

		System.out.println(sb);
	}

	private static boolean isPalindrome(int[] seq, int s, int e) {
		while (s < e) {
			if (seq[s++] != seq[e--]) return false;
		}

		return true;
	}
}

 

'Java > Algorithms' 카테고리의 다른 글

[백준] 11660번 : 구간 합 구하기 5  (1) 2024.03.22
[백준] 2011번 : 암호코드  (0) 2024.03.19
[백준] 1915번 : 가장 큰 정사각형  (1) 2024.03.17
[백준] 2294번 : 동전2  (0) 2024.03.16
[백준] 9084번 : 동전  (0) 2024.03.16
728x90

문제

 

 

접근 방식

1인 부분으로만 이루어진 정사각형 중 가장 큰 정사각형을 찾아야 한다.

1

11
11

111
111
111

 

위와 같이 1로만 이루어진 곳을 찾아야 하는데

1인 곳을 발견할 때마다 주변을 한 칸씩 넓혀가며 모두 1인지 확인하는 것은

시간초과가 날 것이 확실하기 때문에 그렇게 무식하게 풀 수는 없다.

00
01

 

위의 경우를 생각해보면 1 주변은 모두 0이기 때문에 정사각형이 될 수 없고

크기가 1인 정사각형 하나만 가능하다.

11
11 <

 

위의 경우라면 오른쪽 맨 아래의 1을 기준으로 주변 3개가 모두 1이니

크기가 4인 정사각형을 만들 수 있다.

01
11

 

하지만 위와 같이 하나라도 1이 아니라면 각각 크기가 1인 정사각형만 만들 수 있고

결국 자기 주변의 칸들이 모두 1이라면 길이가 1 더 긴 정사각형을 만들 수 있다는 것이다.

0111
0111
0111

 

위의 경우를 예시로 DP 테이블을 채우는 과정을 살펴보면 아래와 같다.

01

011

0111

0111
0

0111
01

0111
012

0111
0122

0111
0122
0

0111
0122
01

0111
0122
012

0111
0122
0122

 

첫 행과 열에 등장한 1은 위나 옆을 살펴볼 수 없으니 무조건 1이 될 것이고

이후에 등장한 1들은 주변 3칸을 살펴봐서 모두 1이라면

기존보다 길이가 1긴 정사각형을 만들 수 있으니 0 > 1 > 2 ... > n 순으로

길이를 늘려주기만 하면 된다.

 

풀이

public class Main {

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

		int n = Integer.parseInt(input[0]);
		int m = Integer.parseInt(input[1]);
		int max = 0;

		int[][] dp = new int[n][m];
		int[] dx = {-1, -1, 0};
		int[] dy = {-1, 0, -1};

		for (int i = 0; i < n; i++) {
			input = br.readLine().split("");
			for (int j = 0; j < m; j++) {
				if (Integer.parseInt(input[j]) != 1) continue;

				int min = Integer.MAX_VALUE;

				for (int dir = 0; dir < 3; dir++) {
					int x = i + dx[dir];
					int y = j + dy[dir];

					if (x < 0 || y < 0) {
						min = 0;
						break;
					}

					min = Math.min(min, dp[x][y]);
				}

				dp[i][j] = min + 1;
				max = Math.max(max, dp[i][j]);
			}
		}

		System.out.println(max * max);
	}
}

 

'Java > Algorithms' 카테고리의 다른 글

[백준] 2011번 : 암호코드  (0) 2024.03.19
[백준] 10942번 : 팰린드롬?  (0) 2024.03.18
[백준] 2294번 : 동전2  (0) 2024.03.16
[백준] 9084번 : 동전  (0) 2024.03.16
[백준] 9657번 : 돌 게임 3  (1) 2024.03.13
728x90

문제

 

 

접근 방식

이전 동전 문제처럼 k원을 만드는 모든 경우의 수를 구하는 것이 아니라

가장 적은 수의 동전을 사용해 k원을 만들 수 있는 경우를 구해야 한다.

 

5원, 1원, 12원 총 3개의 동전으로 15원을 만들어야 할 때

5원으로 15원을 만들 수 있는 경우를 먼저 생각해 보자

1원을 만드는 경우 : X
2원을 만드는 경우 : X
3원을 만드는 경우 : X
4원을 만드는 경우 : X
5원을 만드는 경우 : 1
6원을 만드는 경우 : X
7원을 만드는 경우 : X
8원을 만드는 경우 : X
9원을 만드는 경우 : X
10원을 만드는 경우 : 2
11원을 만드는 경우 : X
12원을 만드는 경우 : X
13원을 만드는 경우 : X
14원을 만드는 경우 : X
15원을 만드는 경우 : 3

 

위와 같이 5원 동전은 5원 이상의 값부터 사용할 수 있으니 자기 자신부터 1로 시작할 것이다.

 

N원을 만드는 경우는 (N-5)원에 5원 동전을 하나 더 사용한 것이니 DP[N-5] + 1이 되고

10원을 만드는 경우는 DP[5] + 1인 2, 15원을 만드는 경우는 DP[10] + 1인 3이 되는 것이다.

 

나머지 금액들은 5원만으로는 만들 수 없는 금액이니 DP[6-5]나 DP[7-5]처럼 0인 경우는 건너뛰면 된다.

 

이제 1원까지 사용한 경우를 계산해 보겠다.

1원을 만드는 경우 : 1
2원을 만드는 경우 : 2
3원을 만드는 경우 : 3
4원을 만드는 경우 : 4
5원을 만드는 경우 : 1 < 5
6원을 만드는 경우 : 2
7원을 만드는 경우 : 3
8원을 만드는 경우 : 4
9원을 만드는 경우 : 5
10원을 만드는 경우 : 2
11원을 만드는 경우 : 3
12원을 만드는 경우 : 4
13원을 만드는 경우 : 5
14원을 만드는 경우 : 6
15원을 만드는 경우 : 3

 

1 ~ 4원은 당연히 값만큼의 동전수가 사용될 것이고 DP[5]를 채우는 경우를 살펴보면

기존에 5원짜리 동전 하나만 사용하는 경우가 1원짜리 동전 5개를 사용하는 것보다 효율적이니

둘 중 더 작은 값으로 채워주면 된다.

 

12원 동전까지 사용하는 경우도 살펴보자

1원을 만드는 경우 : 1
2원을 만드는 경우 : 2
3원을 만드는 경우 : 3
4원을 만드는 경우 : 4
5원을 만드는 경우 : 1
6원을 만드는 경우 : 2
7원을 만드는 경우 : 3
8원을 만드는 경우 : 4
9원을 만드는 경우 : 5
10원을 만드는 경우 : 2
11원을 만드는 경우 : 3
12원을 만드는 경우 : 4 > 1
13원을 만드는 경우 : 2
14원을 만드는 경우 : 3
15원을 만드는 경우 : 3 < 4

 

12원 동전도 마찬가지로 12원부터 DP 테이블을 더 작은 값으로 갱신해 주면 된다.

 

사소한 걸 놓쳐서 여러 번 틀렸던 문제인데

DP 배열이 비어있는 경우에는 초기값인 0으로 설정되어 있기 때문에

항상 비교하면 0이 제일 작아 테이블이 정상적으로 채워지지 않는다.

 

배열을 생성하고 테이블을 채우기 전에 큰 값으로 초기화해주거나

테이블을 채우면서 0인 경우는 비교 없이 채우게 분기를 만들어 줘야 한다.

 

풀이

class Main {
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        
        int n = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());
        
        int[] dp = new int[100001];
        boolean[] isUsed = new boolean[100001];
        
        for (int i = 0; i < n; i++) {
            int coin = Integer.parseInt(br.readLine());
            
            if (isUsed[coin]) continue;
            isUsed[coin] = true;
            dp[coin] = 1;
            
            for (int j = coin + 1; j <= k; j++) {
                if (dp[j - coin] == 0) continue;
                if(dp[j] != 0) dp[j] = Math.min(dp[j], dp[j - coin] + 1);
                else dp[j] = dp[j - coin] + 1;
            }
        }
        
        System.out.println(dp[k] != 0 ? dp[k] : -1);
    }
}

 

'Java > Algorithms' 카테고리의 다른 글

[백준] 10942번 : 팰린드롬?  (0) 2024.03.18
[백준] 1915번 : 가장 큰 정사각형  (1) 2024.03.17
[백준] 9084번 : 동전  (0) 2024.03.16
[백준] 9657번 : 돌 게임 3  (1) 2024.03.13
[백준] 4883번 : 삼각 그래프  (4) 2024.03.11
728x90

문제

 

 

접근 방식

 

[백준] 2293번 : 동전 1

문제 접근 방식 1원, 2원, 5원 총 3가지의 동전으로 1원부터 10원을 만드는 경우를 적어보면 다음과 같다. 11 211 2 3111 12 41111 112 22 511111 1112 122 5 6111111 11112 1122 15 222 71111111 111112 11122 115 1222 25 811111111 1

da9dac.tistory.com

 

위의 문제와 입출력만 좀 다를 뿐 사실상 풀이가 같은 문제라 설명은 생략하겠다.

 

 

풀이

class Main {
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        StringBuilder sb = new StringBuilder();
        
        int t = Integer.parseInt(br.readLine());
        
        while (t-- > 0) {
            int n = Integer.parseInt(br.readLine());
            st = new StringTokenizer(br.readLine());
            int m = Integer.parseInt(br.readLine());
            int[] dp = new int[m + 1];
            
            dp[0] = 1;
            
            for (int i = 1; i <= n; i++) {
                int coin = Integer.parseInt(st.nextToken());
                
                for (int j = coin; j <= m; j++) {
                    dp[j] += dp[j - coin];
                }
            }
            
            sb.append(dp[m]).append("\n");
        }
        
        System.out.println(sb);
    }
}

 

'Java > Algorithms' 카테고리의 다른 글

[백준] 1915번 : 가장 큰 정사각형  (1) 2024.03.17
[백준] 2294번 : 동전2  (0) 2024.03.16
[백준] 9657번 : 돌 게임 3  (1) 2024.03.13
[백준] 4883번 : 삼각 그래프  (4) 2024.03.11
[백준] 2293번 : 동전 1  (0) 2024.03.09
728x90

문제

 

 

접근 방식

DP로 풀 필요도 없이 규칙만 찾으면 연산 한 줄로도 풀 수 있는 문제지만 그냥 DP로 풀어봤다.

 

우선 DP 테이블은 불리언 타입의 1차원 배열로 생성한 후에

상근이가 이기는 경우를 true, 창영이가 이기는 경우를 false로 채워주면 된다.

 

자기 순서에 1, 3, 4개 중 한 번씩 가져갈 수 있으니 이 경우에 상근이는 무조건 이길 수 있고

1, 3, 4번의 초기값은 true로 설정해준다.

 

9까지 직접 계산해 가며 표를 만들어보면 알 수 있는데

n번째 수를 가져가는 경우 중 상근이가 한 번이라도 가져가는 경우가 있다면

무조건 상근이가 이기는 경우이기 때문에

상근이가 처음에 1개를 가져가거나 3개를 가져가거나 4개를 가져간 후에

창근이가 지는 경우가 한 번이라도 있다면 상근이가 이기는 것이 된다.

dp[i] = (!dp[i - 1 || !dp[i - 3] || !dp[i - 4])

 

즉, 위와 같은 풀이가 나오게 된다.

 

이 문제는 n의 범위가 1,000 이하이기 때문에 dp 테이블이 설정이 가능하지만

같은 문제에 n의 범위만 int 형을 벗어난 돌 게임 6 문제 같은 경우에는

배열을 선언할 수 없기 때문에 다른 방법으로 풀어야 한다.

 

처음에 언급했던 것처럼 이 문제는 더 간단하게 풀 수 있는데

n을 7로 나눈 나머지가 0이거나 2인 경우에만 상근이가 지기 때문에

한 줄 만으로도 풀 수 있는 문제다.

 

풀이

class Main {
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        int n = Integer.parseInt(br.readLine());
        
        boolean[] dp = new boolean[1001];
        
        dp[1] = dp[3] = dp[4] = true;
        
        for (int i = 5; i <= n; i++) {
            dp[i] = (!dp[i - 1] || !dp[i - 3] || !dp[i - 4]);
        }
        
        System.out.println(dp[n] ? "SK" : "CY");
    }
}

 

'Java > Algorithms' 카테고리의 다른 글

[백준] 2294번 : 동전2  (0) 2024.03.16
[백준] 9084번 : 동전  (0) 2024.03.16
[백준] 4883번 : 삼각 그래프  (4) 2024.03.11
[백준] 2293번 : 동전 1  (0) 2024.03.09
[백준] 11052번 : 카드 구매하기  (0) 2024.03.08
728x90

문제

 

 

접근 방식

풀고 나서도 이게 그래프인지 DP 풀이인지 모르겠는 문제였다.

 

 

우선 그래프의 한 정점을 기준으로 위와 같이 이동할 수 있으며

2차원 배열을 처음부터 끝까지 돌면서 위와 같이 이동만 해주며 DP 테이블을 채워주면 된다.

 

따로 방문여부를 기록하지 않고 DP 테이블의 값이 0인지 아닌지로

확인하려 했는데 정점의 값이 음수인 경우도 있어서 합이 0일 때가 있을 수 있기 때문에

따로 방문 여부를 기록할 불리언 배열을 사용했다.

 

각 정점(i, j)에서 갈 수 있는 정점들을 방문하며

처음 방문한 정점(x, y)이면 방문 여부를 참으로 바꾸고,

(x, y)의 DP 테이블에 (i, j) 테이블의 값 + 현재 정점의 값을 기록하고

이미 방문한 정점이라면 이미 기록된 값과 새로운 값 중 더 작은 값을 기록한다.

 

목적지까지 테이블을 다 채운 후에 목적지의 값을 출력해주면 된다.

 

풀이

public class Main {

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

		int[] dx = {0, 1, 1, 1};
		int[] dy = {1, -1, 0, 1};
		int tc = 1;

		while (true) {
			int n = Integer.parseInt(br.readLine());

			if (n == 0) break;

			int[][] arr = new int[n][3];
			int[][] dp = new int[n][3];
			boolean[][] isVisited = new boolean[n][3];

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

				for (int j = 0; j < 3; j++) {
					arr[i][j] = Integer.parseInt(st.nextToken());
				}
			}

			dp[0][1] = arr[0][1];
			isVisited[0][1] = true;

			for (int i = 0; i < n; i++) {
				for (int j = 0; j < 3; j++) {
					if (i == 0 && j == 0) continue;
					if (i == n - 1 && j == 1) {
						sb.append(tc++).append(". ").append(dp[i][j]).append("\n");
						break;
					}

					for (int dir = 0; dir < 4; dir++) {
						int x = i + dx[dir];
						int y = j + dy[dir];

						if (y < 0 || x >= n || y >= 3) continue;

						if (isVisited[x][y]) {
							dp[x][y] = Math.min(dp[x][y], dp[i][j] + arr[x][y]);
						} else {
							isVisited[x][y] = true;
							dp[x][y] = dp[i][j] + arr[x][y];
						}
					}
				}
			}
		}

		System.out.println(sb);
	}
}

 

'Java > Algorithms' 카테고리의 다른 글

[백준] 9084번 : 동전  (0) 2024.03.16
[백준] 9657번 : 돌 게임 3  (1) 2024.03.13
[백준] 2293번 : 동전 1  (0) 2024.03.09
[백준] 11052번 : 카드 구매하기  (0) 2024.03.08
[백준] 2156번 : 포도주 시식  (0) 2024.03.08
728x90

문제

 

 

접근 방식

1원, 2원, 5원 총 3가지의 동전으로 1원부터 10원을 만드는 경우를 적어보면 다음과 같다.

1	1
2	11 2
3	111 12
4	1111 112 22
5	11111 1112 122 5
6	111111 11112 1122 15 222
7	1111111 111112 11122 115 1222 25
8	11111111 1111112 111122 1115 11222 125 2222
9	111111111 11111112 1111122 11115 111222 1125 12222 225
10	1111111111 111111112 11111122 111115 1111222 11125 112222 1225 22222 55

 

다시 1원만 사용한 경우, 1원과 2원을 사용한 경우, 세 가지 동전을 모두 사용한 경우로

경우의 수가 몇 개인지 정리해보면 다음과 같다. (0번 인덱스는 1이다.)

  1 2 3 4 5 6 7 8 9 10
1 1 1 1 1 1 1 1 1 1 1
1,2 1 2 2 3 3 4 4 5 5 6
1,2,5 1 2 2 3 4 5 6 7 8 10

 

1원 동전으로는 값만큼 동전을 사용하면 모든 값을 만들 수 있기 때문에 모두 한 가지일 것이니 넘어가고

2원까지 추가로 사용해 n원을 만드는 경우를 먼저 생각해보겠다.

 

2원을 사용해서 2원 미만의 값은 당연히 만들 수 없으니

미만의 값들은 이전의 값을 그대로 사용하고 넘어가면 되고

2원 이상부터는 2원 동전을 사용할 수 있으니 값이 달라질 것이다.

 

위의 표에서 1원과 2원을 사용해 2원을 만드는 경우를 살펴보면

(1원으로 2를 만드는 경우인 1) + (2원으로 2 - 2원을 만드는 경우인 1) = 2가 되고

10원을 만드는 경우를 살펴보면

(1원으로 10원을 만드는 경우인 1 + 2원으로 (10 - 2)원을 만드는 경우인 5 = 6이 된다

 

이제 5원 동전까지 사용하는 경우도 마찬가지로

5원 이상부터 테이블의 값을 변경해주면 되고

10원을 만드는 경우를 살펴보면

(1원과 2원으로 10원을 만드는 경우인 6) + (5원으로 10 - 5원을 만드는 경우인 4) = 10이 된다.

 

점화식으로 정리하면 다음과 같다. (i는 목표가치, j는 현재 동전의 가치)

dp[i] = dp[i] + dp[i-j]

 

이때 dp[0] = 1로 초기화 해주어야

동전의 가치가 K인 경우를 처리할 수 있고

동전의 가치 이상의 dp 테이블을 수정할 때 처음에 dp[0]을 호출할 일이 있기 때문에

이를 0인 초기값으로 냅둬두면 테이블의 값이 변하지 않는다.

 

 

풀이

public class Main {

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

		int n = Integer.parseInt(st.nextToken());
		int k = Integer.parseInt(st.nextToken());

		int[] dp = new int[k + 1];

		dp[0] = 0;

		for (int i = 0; i < n; i++) {
			int coin = Integer.parseInt(br.readLine());

			for (int j = coin; j <= k; j++) {
				dp[j] += dp[j - coin];
			}
		}

		System.out.println(dp[k]);
	}
}

 

'Java > Algorithms' 카테고리의 다른 글

[백준] 9657번 : 돌 게임 3  (1) 2024.03.13
[백준] 4883번 : 삼각 그래프  (4) 2024.03.11
[백준] 11052번 : 카드 구매하기  (0) 2024.03.08
[백준] 2156번 : 포도주 시식  (0) 2024.03.08
[백준] 1904번 : 01타일  (0) 2024.03.07
728x90

문제

 

 

접근 방식

카드를 n개 살 때, 가장 돈을 많이 쓰는 경우를 구해야 한다.

 

i번째 카드팩에는 카드가 i개 들어있다 했으니

만약 카드를 4개 사야한다 가정하면

1번팩 + 1번팩 + 1번팩 + 1번팩
1번팩 + 1번팩 + 2번팩
1번팩 + 3번팩
2번팩 + 2번팩
4번팩

 

위와 같은 경우의 수가 만들어진다.

 

4개가 아닌 3개로 줄여보면 다음과 같을 것이고

1번팩 + 1번팩 + 1번팩
1번팩 + 2번팩
3번팩

 

2개로 줄이면 다음과 같다.

1번팩 + 1번팩
2번팩

 

1개면 당연히 1번팩 하나만 살 수 있다.

 

결국 n개를 고를 때 i번 팩을 골랐다면 n-i개를 고를 수 있고

(i번 팩값 + n-i개를 고를 수 있는 경우 가장 큰 값) 이 된다.

 

이를 dp[i]를 채울 때마다 1번 팩을 고른 경우부터 i번 팩을 고른 경우까지 비교하면서

가장 큰 값을 채워주면 되고 하나를 고르고 두 개를 고르나 두 개를 고르고 하나를 고르나 같기 때문에

i번까지 비교할 필요도 없이 i/2번까지만 비교해줘도 괜찮다.

 

이를 점화식으로 표현하면 다음과 같다.

j = 1; j  <= i/2; j++
dp[i] = (max(dp[i], dp[j] + dp[i-j]))

 

확실히 DP 문제를 많이 풀다 보니 경우의 수를 적다보면 규칙이 보이게 되는거 같다

PS는 그냥 많이 풀어보는게 답...

 

풀이

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];

        StringTokenizer st = new StringTokenizer(br.readLine());

        for (int i = 1; i <= n; i++) {
            dp[i] = Integer.parseInt(st.nextToken());
            for (int j = 1; j <= i; j++) {
            	dp[i] = Math.max(dp[i], dp[j] + dp[i - j]);
            }
        }

        System.out.println(dp[n]);
    }
}

 

'Java > Algorithms' 카테고리의 다른 글

[백준] 4883번 : 삼각 그래프  (4) 2024.03.11
[백준] 2293번 : 동전 1  (0) 2024.03.09
[백준] 2156번 : 포도주 시식  (0) 2024.03.08
[백준] 1904번 : 01타일  (0) 2024.03.07
[프로그래머스] 더 맵게  (0) 2024.03.05

+ Recent posts