코딩 공부소

[백준 2096번] 내려가기

제이 니퍼 — Tue, 28 Nov 2023 09:59:23 +0900

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

2096번: 내려가기

첫째 줄에 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 N개의 줄에는 숫자가 세 개씩 주어진다. 숫자는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 중의 하나가 된다.

www.acmicpc.net

이 문제는 dp를 이용한 문제입니다.

풀이법

이 문제는 전단계의 값들과 자신의 값을 더한 것중 최댓값과 최솟값을 찾으며 비교하는 문제입니다. 푸는 방법은 다음과 같습니다.

1.1번쨰 자리에서 시작할 경우 전단계의 1번째자리와 2번째자리의 값중 최댓값과 최솟값을 찾는다
2.2번째 자리에서 시작할 경우 전단계의 1번째 자리와 2번째 자리, 그리고 3번째 자리중 최댓값 최솟값을 찾는다.
3. 3번째 자리에서 시작할 경우 전 단계의 2번째 자리와 3번째 자리중 최댓값 최솟값을 찾는다.

이를통해 전체 더한 값을 구한뒤 최솟값또는 최댓값을 더하면 된다.

코드

import java.util.*;

public class Main {
	public static void main(String arg[]) {
		Scanner sc=new Scanner(System.in);
		int n= sc.nextInt();
		int [][]plates=new int[n][3];
		int max=0;
		int min=999999999;
		int [][]dp=new int[n][3];
		for(int i =0;i<n;i++) {
			for(int j = 0; j<3;j++) {
				plates[i][j]=sc.nextInt();
			}
		}
		
		for(int i=0;i<3;i++)
			dp[0][i]=plates[0][i];
		
		for(int i=1;i<n;i++) {
			dp[i][0]=Math.max(dp[i-1][0], dp[i-1][1])+plates[i][0];
			dp[i][1]=Math.max(dp[i-1][0],Math.max(dp[i-1][1], dp[i-1][2]))+plates[i][1];
			dp[i][2]=Math.max(dp[i-1][1], dp[i-1][2])+plates[i][2];
		}
		max=Math.max(dp[n-1][0],Math.max(dp[n-1][1],dp[n-1][2]));
		for(int i=1;i<n;i++) {
			dp[i][0]=Math.min(dp[i-1][0], dp[i-1][1])+plates[i][0];
			dp[i][1]=Math.min(dp[i-1][0],Math.min(dp[i-1][1], dp[i-1][2]))+plates[i][1];
			dp[i][2]=Math.min(dp[i-1][1], dp[i-1][2])+plates[i][2];
		}
		min=Math.min(dp[n-1][0],Math.min(dp[n-1][1],dp[n-1][2]));
		
		System.out.println(max+" "+min);
	}

	
}

[백준 2512번] 예산

제이 니퍼 — Tue, 28 Nov 2023 09:40:13 +0900

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

2512번: 예산

첫째 줄에는 지방의 수를 의미하는 정수 N이 주어진다. N은 3 이상 10,000 이하이다. 다음 줄에는 각 지방의 예산요청을 표현하는 N개의 정수가 빈칸을 사이에 두고 주어진다. 이 값들은 모두 1 이상

www.acmicpc.net

이 문제는 이진 탐색을 이용한 문제입니다

풀이법

이진 탐색을 이용하는 방법은 다음과 같습니다

1. 무조건 가능한 수 중에 최소값 start 변수로 지정
2. 가능 여부를 떠나 , 현재 최대값을 end 변수로 지정
3.중간 값mid 를 찾은 다음 그 중간값에 따라 값을 바꿨을 때, 조건에 맞는 지 확인
4.조건에 맞는다면 이 중간값을 start 변수에 대입, 아니면 end 변수에 대입합니다
5.mid 가 start 또는 end와 같아지면 탐색을 종료 하고 해당 mid 값을 찾습니다.

이 방법을 반복해 배정된 예싼들 중 최댓값을 찾을 수 있습니다

코드

import java.util.*;
public class Main {
	public static void main(String arg[]) {
		Scanner sc= new Scanner(System.in);
		int n=sc.nextInt();
		int []locals=new int[n];
		int first_sum=0;
		for(int i =0;i<n;i++) {
			locals[i]=sc.nextInt();
			first_sum+=locals[i];
		}
		int max_budget=sc.nextInt();
		Arrays.sort(locals);
		if(first_sum<=max_budget)
			System.out.println(locals[n-1]);
		else
			System.out.println(sol(0,locals[n-1],max_budget,locals));
	}
	public static int sol(int start,int end, int max_budget,int[]locals) {
		int mid=(start+end)/2;
		int sum=0;
		if(mid==end || mid==start) {
			return mid;
		}else {
			for(int i=0;i<locals.length;i++) {
				if(locals[i]>mid) {
					sum+=mid;
				}else {
				sum+=locals[i];
				}
			}
			if(sum>max_budget)
				end=mid;
			else if (sum<max_budget)
				start=mid;
			else
				return mid;
			return sol(start,end,max_budget,locals);
		}
	}

}

[백준 1012번] 유기농 배추

제이 니퍼 — Tue, 21 Nov 2023 10:24:14 +0900

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

1012번: 유기농 배추

차세대 영농인 한나는 강원도 고랭지에서 유기농 배추를 재배하기로 하였다. 농약을 쓰지 않고 배추를 재배하려면 배추를 해충으로부터 보호하는 것이 중요하기 때문에, 한나는 해충 방지에

www.acmicpc.net

이 문제는 그래프 탐색을 이용해서 푸는 문제입니다.

해결법

m*n 크기의 밭에 있는 배추들이 인접해있으면 인접해있는 배추들의 수와 관계없이 하나의 지렁이만 있으면 되는 내용입니다. 한마디로, 인접해있는 노드들의 집합 개수만 세면 되는 문제죠. 그러기 떄문에 해결법은

1. 이중 for문을 통해 값이 1인 밭을 찾는다.
2. 찾았다면, y방향으로 -1, 1, x방향으로 -1 1를 각각 이동하면서 값이 1인 밭을 찾는다.
3.단 방문할때마다. 그 값을 0으로 바꿔준다.
4.다 방문하였다면 count를 1해주고 다시 이중 for문을 이용 끝까지 탐색한다.

코드

import java.util.*;
import java.io.*;
public class Main {
	static int count=0;
	//방향설정
	static int[] strX= {0,0,-1,1};
	static int[] strY= {-1,1,0,0};
	public static void main(String arg[]) {
		Scanner sc=new Scanner(System.in);
		int T=sc.nextInt();
		
		for(int i=0;i<T;i++) {
			int x=0;
			int y=0;
			int m=sc.nextInt();
			int n=sc.nextInt();
			int k=sc.nextInt();
			int [][]field=new int[m][n];
			
			for(int j=0;j<k;j++) {
				x=sc.nextInt();
				y=sc.nextInt();
				field[x][y]=1;
			}
			sol(field,m,n);
			System.out.println(count);
			count=0;
		}
		
	}
	public static void counting_cabbage(int[][]field,int x,int y,int m,int n) {
		for(int i=0;i<4;i++) {
			if((x+strX[i]>=0&&x+strX[i]<m)&&((y+strY[i]>=0&&y+strY[i]<n))) {
				if(field[x+strX[i]][y+strY[i]]==1) {
					field[x+strX[i]][y+strY[i]]=0;
					counting_cabbage(field,x+strX[i],y+strY[i],m,n);
				}
			}
		}
		return;
	}
	public static void sol(int [][]field,int m,int n) {
		for(int i=0;i<m;i++) {
			for(int j=0;j<n;j++) {
				if(field[i][j]==1) {
					count++;
					counting_cabbage(field,i,j,m,n);
				}
			}
		}
	}
}

[백준 2606번] 바이러스

제이 니퍼 — Tue, 21 Nov 2023 10:18:24 +0900

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

2606번: 바이러스

첫째 줄에는 컴퓨터의 수가 주어진다. 컴퓨터의 수는 100 이하인 양의 정수이고 각 컴퓨터에는 1번 부터 차례대로 번호가 매겨진다. 둘째 줄에는 네트워크 상에서 직접 연결되어 있는 컴퓨터 쌍

www.acmicpc.net

그래프를 이용해서 푸는 문제입니다.

풀이법

문제를 보면 1번 컴퓨터와 연결되있는 컴퓨터들은 모두 바이러스에 걸리므로, 1번 컴퓨터와 연결되있는 2 5 그리고 그 두 컴퓨터와 이어져있는 3 6까지 총 4개의 컴퓨터들은 바이러스에 걸리고, 4 7 컴퓨터만 무사한것으로 볼 수 있습니다. 따라서 해결법은

1. 입력 간선을 모두 정점 노트의 다음 노드에 저장한다.( 예 1-2를 정점이 1인 노드의 다음 노드 값엔 2를 저장)
2. DFS 또는 BFS를 이용하며 그래프를 탐색하는데. 한번 방문한 노드는 방문하지 않는다.
3.방문하면서 해당 컴퓨터를 카운트해주면, 마지막에는 바이러스에 걸린 컴퓨터를 알게 된다.

코드

import java.util.*;
import java.io.*;
public class Main {
	static int count=0;
	public static void main(String arg[]) {
		//입력단계
		Scanner sc= new Scanner(System.in);
		int n=sc.nextInt();
		int k=sc.nextInt();
		int firstNode=0;
		int nextNode=0;
		ArrayList<Integer>[] arr= new ArrayList[101];
		for(int i=0; i<=100;i++)
			arr[i]=new ArrayList<Integer>();
		boolean []visted=new boolean[n+1];
		Arrays.fill(visted, false);
		//입력받은 간선들을 각 노드의 정점 배열에 저장
		for(int i=0;i<k;i++) {
			firstNode=sc.nextInt();
			nextNode=sc.nextInt();
			arr[firstNode].add(nextNode);
			arr[nextNode].add(firstNode);
		}
		//만약 정점이 하나가 아닐경우 계산
		if(n!=1)
			DFS(arr,1,visted);
		
		System.out.println(count);
		
	}
	public static void DFS(ArrayList<Integer>[] arr,int n,boolean []visted){
		visted[n]=true;
		if(n!=1)//시작 지점이 아닐시 계산
			count++;
		for (int i :arr[n]) {//이미 방문했는지 확인 
			if(visted[i]==false) {
				DFS(arr,i,visted);
			}
			
		}
		
	
		
	}

	

}

[백준 15651번] N과 M (3)

제이 니퍼 — Tue, 14 Nov 2023 09:53:57 +0900

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

15651번: N과 M (3)

한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다. 중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다. 수열은 사전 순으로 증가하는 순서로 출력해

www.acmicpc.net

이 문제는 백트래킹을 이용하는 문제로 실버 3문제입니다

해결책

문제는 간단합니다. 만약 n이 3이고 m이 2가 됬다면 2자리 수열로 모든 가능한 수를 만드는것입니다 .그러면 수열은

(1,1),(1,2)......(3,3)까지 나오게 되는거죠. 이를 이용하면 다음과 같습니다

1. 해당 노드의 자리에 노드를 놓으면, 다음엔 자리수를 줄여서 재귀함수를 호출한다.

예를 들어 n이 3이고 m이 2라고 했을떄, 맨 처음 자리에 수를 놨다면 그 다음에는 m-1를 해, 그 다음 자리수에 값을 집어 넣을 수 있도록 하는 것입니다.

2. 만약 끝까지 갔다면 그 노드를 당장 출력하지 않고 문자열 변수에 저장한다.

보통 재귀함수의 종료조건까지 갔으면, 해당 수열을 출력하는 것이 맞다고 생각하실 수 있습니다. 하지만, 그렇게 된다면, 만약 m 과 n이 7 7이라면 경우의 수는 7^7이므로 굉장히 수가 길어집니다. 그 순간마다 출력을 요청하니, 시간이 오래걸리고, 시간초과가 날 것입니다. 그러므로 그 값을 출력이 아니라, 한 문자열 변수에 저장하며, 계속 단계를 진행하는것이 더 효율적입니다.

코드

import java.util.*;

public class Main {
	static StringBuilder sb = new StringBuilder();
	public static void main(String [] arg) {
		
		Scanner sc = new Scanner(System.in);
		ArrayList<Integer> list=new ArrayList<Integer>();
		int n=sc.nextInt();
		int m=sc.nextInt();
	    
		sol(n,m,list);
		System.out.println(sb);
	}
	public static void sol(int n, int m,ArrayList arr) {
		if(m==0) {
			int size=arr.size();
			
			for(int i=0;i<size;i++) {
				sb.append(arr.get(i)+" ");
				
			}
			sb.append("\n");
			return;
		}
		for(int i=1;i<=n; i++){
			arr.add(i);
			
			sol(n,m-1,arr);
			arr.remove(arr.size()-1);
			
			
		}
	}
}

[백준 9663번] N-Queen

제이 니퍼 — Tue, 14 Nov 2023 09:37:48 +0900

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

9663번: N-Queen

N-Queen 문제는 크기가 N × N인 체스판 위에 퀸 N개를 서로 공격할 수 없게 놓는 문제이다. N이 주어졌을 때, 퀸을 놓는 방법의 수를 구하는 프로그램을 작성하시오.

www.acmicpc.net

이 문제는 백트래킹 알고리즘의 대표적인 문제 중 하나로, 골드 4 문제입니다.

해결책

이 문제를 해결하기 위해 백트래킹의 개념을 알아야합니다. 백트래킹은 기존 끝까지 탐사하는 DFS와 달리 만약 탐색하고 있는 값이, 옳지 않다 생각하면, 바로 전 노드 단계로 돌아가버려 그 다음 단계를 수행합니다. 그럼으로써 효율적이게 탐색을 할 수 있는것입니다.

위 그림을 보시면, 백트래킹에 대해 잘 나타내고 있습니다. 일단 해당 자리에 퀸을 놓는다 했을때, 겹치면 바로 전 단계로 돌아간다는 것이죠, 그럼 이 퀸을 놓을 떄 겹치지 않는 조건은 무엇일 까요?

1.놓는 자리에 겹치는 열이 없어야 한다.

퀸은 겹치지않게, 매 n의 퀸을 놓을떄, n번째 행에 놓는다고 가정하면, 겹치는 열이 없어야 합니다. 퀸은 직선과, 대각선으로 이동할 수 있으니까요, 그러므로 n번째, 퀸의 자리가 (x,n)일때, 저 x랑 같은 값을 가지는 값이 없어야한다는 것입니다

2. 놓는 자리의 대각선에도 겹치지 말아야한다.

만약 놓는자리의 퀸의 자리가 (2,2)라고 가정합시다 이때 (1,1)에 퀸이 놓여있으면, 겹치므로 놓을 수 가 없습니다. 만약 해당 퀸의 자리가 (2,3)이라고 합시다, 이때 (1,2)에 퀸이 놓여 있으면, 겹칩니다. 그럼 이 차이는 어떻게 알 수 있을까요?

바로 n번째 자리의 퀸의 행- (n-1)번째 퀸의 행 = |n번째 자리의 퀸의 열 - (n-1)번째 자리의 퀸의 열| 이면, 대각선에도 겹치는 것입니다. 대각선이 항상 (x,y)의 차이가 일정하게 가기 때문이죠. 때문에 그걸 고려하며 코드를 작성해 줘야 합니다.

코드

import java.io.*;
import java.util.*;
public class Main {
	static int [] chess;
	static int count=0;
	public static void sol(int n,int s) {
		if(n==s) {
			count++;
			return;
		}else {
			for(int i=0; i<s;i++) {
				chess[n]=i;
				if(promise(n)) {//증명한 뒤 놓을 수 있으면 다음 단계로 넘어간다
					sol(n+1,s);
				}
			}
		}
	}
	public static boolean promise(int n) {
		for(int i=0;i<n;i++) {
			if(chess[n]==chess[i]||n-i==Math.abs(chess[n]-chess[i]))
				return false;
			
		}
		return true;
	}
	public static void main(String args[]) {
		Scanner sc=new Scanner(System.in);
		int n = sc.nextInt();
		chess=new int[n+1];
		sol(0,n);
		System.out.println(count);
		
		
	}

}

[백준 11053번] 가장 긴 증가하는 부분수열

제이 니퍼 — Mon, 9 Oct 2023 21:45:16 +0900

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

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

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

www.acmicpc.net

이 문제는 실버 3으로 동적 계획을 사용하는 문제입니다.

풀이

이 문제는 LIS라는 유명한 문제입니다. 왜 동적 배열을 이용하는지, 살펴 봅시다

i	1	2	3	4	5	6
A	10	20	10	30	20	50
DP

이런 표가 있다고 해봅시다 보기 쉽게 i=0일때 경우를 추가해봤습니다. LIS 문제를 푸는 키워드는 다음과 같습니다

해당 값이 어떤 증가 부분수열의 마지막보다 큰지를 본다!

i	1	2	3	4	5	6
A	10	20	10	30	20	50
DP	1

i가 1일때 입니다. A[1]은 A[0]보다 큽니다 따라서 부분 증가수열에 포함이 됩니다. 따라서 해당 부분수열의 수는 1입니다.

i	1	2	3	4	5	6
A	10	20	10	30	20	50
DP	1	2

i가 2일때입니다. 마찬가지로 부분수열 dp[1]의 마지막 수인 10보다 a[2]가 크기 때문에 부분증가 수열을 만들수 있습니다. 따라서 dp[2]=dp[1]+1 =2입니다.

i	1	2	3	4	5	6
A	10	20	10	30	20	50
DP	1	2	1

i=3일때입니다. a[3]은 dp[2]의 마지막 수인 a[2]보다 작기 때문에 dp[2]의 뒤에는 이을 수 없습니다 하지만 dp[0]보다는 크기 때문에 dp[3]은

dp[0]+1=1입니다

i	1	2	3	4	5	6
A	10	20	10	30	20	50
DP	1	2	1	3

i=4일때 A[4]는 dp[3]의 마지막 수인 A[3]보다 크므로 dp[3]+1이다 생각할수 있습니다 하지만 저희는 가장 긴 증가 부분 수열을 찾는 것이므로 dp[2]의 뒤에다 이을 수 있습니다. 그러므로 dp[4] = dp[2]+1 = 3 입니다.

i	1	2	3	4	5	6
A	10	20	10	30	20	50
DP	1	2	1	3	2

i=5일때입니다. A[5]는 dp[4]의 마지막 수인 A[4]보다는 작습니다. 그렇기에 가장 길면서 a[5]보다 작은 dp[3]의 뒤에 붙어 2라는 값을 갖습니다.

i	1	2	3	4	5	6
A	10	20	10	30	20	50
DP	1	2	1	3	2	4

마지막 i=6일때입니다. 마찬가지로 a[6]보다 마지막 수 가 작으면서 가장 많이 증가해있는 수열은 dp[4]의 수열입니다. 따라서 dp[4]+1=4입니다. 따라서 가장 긴 수열은 4입니다.

코드

import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;
public class longSequence {
	public static void main(String arg[]) throws IOException {
		BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw= new BufferedWriter(new OutputStreamWriter(System.out));
		int n=Integer.parseInt(br.readLine());
		int []a=new int[n+1];
		int []dp=new int[n+1];
		StringTokenizer st= new StringTokenizer(br.readLine());
		for(int i=1; i<=n;i++) {
			a[i]=Integer.parseInt(st.nextToken());
		}
		dp[0]=0;
		a[0]=0;
		for(int i=1;i<=n;i++) {
			for(int j=i-1; j>=0;j--) {
				if(a[i]>a[j]) { //전값보다 커야한다 해당 값이
					if(dp[i]<dp[j]+1) //만약 해당값이 더 크면 바꾼다.
						dp[i]=dp[j]+1;
					
				}
			}
		}
		Arrays.sort(dp);
		System.out.print(dp[n]);
	}
}

[백준 9095번] 1, 2, 3 더하기(Java)

제이 니퍼 — Mon, 9 Oct 2023 21:08:20 +0900

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

9095번: 1, 2, 3 더하기

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

www.acmicpc.net

실버 3이며, 동적할당을 이용해서 푸는 문제입니다

풀이

만약 n이 주어진다면 저 n을 1,2,3의 합으로 나타내는 경우를 모두 구해 주면 됩니다. 처음 생각해보면 꽤 시간이 많이 걸릴것 같지만 푸는 방법만 알면 어렵지 않습니다

동적 계획은 이전에 저장 되어있는 값을 이용해 누적해서 계산해주는 방법입니다. 때문에, 만약 n이 1..3.까지 라고 했을때, dp[1] =1, dp[2]=2, dp[3]= 4입니다. dp[0]은 0으로 둡시다. 0원을 만드는 경우의 수는 없으니까요

그러면 만약 n=4일때, 그러니까 dp[4]일때를 구한다 해봅시다. 그럼 식은 다음과 같습니다

1원을 마지막으로 사용했을때: 4 - 1 = 3, 그러니까 dp[3]인 경우의 수 입니다.

2원을 마지막으로 사용 했을 때, 4 - 2 = 2, dp[2] 인 경우의 수입니다.

3원을 마지막으로 사용 했을 때, 4 - 3 = 1.dp[1]인 경우의 수 입니다.

따라서 dp[4]= dp[1] +dp[2]+dp[3]=1+2+4=7입니다. 이를 이용하면 점화식을 하나 구할 수 있습니다.

dp[n]=dp[n-1]+dp[n-2]+dp[n-3] (n>=3)

코드

import java.io.*;
public class Main {
	public static void main(String arg[]) throws NumberFormatException, IOException {
		BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw= new BufferedWriter(new OutputStreamWriter(System.out));
		
		int t=Integer.parseInt(br.readLine());
		int [] dp=new int[1000];
		int []n=new int[t];
		for(int i=0; i<t;i++) {
			n[i]=Integer.parseInt(br.readLine());
		}
		dp[0]=1;
		dp[1]=2;
		dp[2]=4;
		for(int i=0;i<t;i++) {
			for(int j=3; j<n[i];j++) {
				dp[j]=dp[j-1]+dp[j-2]+dp[j-3];
			}
			bw.write(String.valueOf(dp[n[i]-1])+"\n");
			
		}
		bw.flush();
		bw.close();
	}
}

[백준 11057번] 오르막 수(Java)

제이 니퍼 — Sat, 23 Sep 2023 22:54:21 +0900

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

11057번: 오르막 수

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

www.acmicpc.net

실버 1 문제인 오르막 수 입니다.

풀이

1인 경우는 0, 1,2,3,4,5,6,7,8,9로 총 10가지입니다. 이것도 표로 구현해보겠습니다

i)길이가 1인 경우

0	1	2	3	4	5	6	7	8	9
1	1	1	1	1	1	1	1	1	1

ii)길이가 2인 경우

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

iii)길이가 3인 경우

0	1	2	3	4	5	6	7	8	9
55	45	36	28	21	15	10	6	3	1

이 표를 합치면

0	1	2	3	4	5	6	7	8	9
1	1	1	1	1	1	1	1	1	1
10	9	8	7	6	5	4	3	2	1
55	45	36	28	21	15	10	6	3	1

이를 보면 규칙이 보일것이다. 예를 들면, 맨앞에 숫자가 2이고 길이는 3자리인 오르막수의 수는 45-9=36이다.

따라서 맨 앞에 붙을 숫자를 i, 오르막수의 길이를 n으로 하면 점화식은

dp[i][n]=dp[i][n-1]-dp[i-1][n-1] (i, n >0)
dp[i][0]= Sum(dp[i-1])

코드

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

public class ascent {
    
    
    

    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 n=Integer.parseInt(br.readLine());
        int [][]dp=new int[1010][1000];
        //초기 오르막 수의 개수 저장은 모두 1개씩 있다.
        for(int i=0;i<10;i++) {
        	dp[0][i]=1;
        	
        }
      
        
        
        for(int i=1;i<n;i++) {
        	//전단계의 오르막수를 전부 더한 값을 0번째 인덱스에 삽입
            //크기가 커지는 것을 막기 위해 10007의 나머지를 대입한다.
        	dp[i][0]=GetSum(dp[i-1])%10007;
	        for(int j=1; j<10;j++) {
	        	dp[i][j]=(dp[i][j-1]-dp[i-1][j-1]);
	        	//만약 범위가 초과되 음수가 나오면
	        	if (dp[i][j] < 0) {
	                dp[i][j] += 10007; // 음수를 방지하기 위해 10007을 더해줌
	            }
	        }
	        
	        
        }
        System.out.print(GetSum(dp[n-1])%10007);
    }
    //해당 길이의 오르막수를 전부 저장한다
    public static int  GetSum(int[]arr) {
    	int count=0;
    	for(int i=0;i<10;i++) {
    		count+=arr[i];
    	}
    	return count;
    }

   
}

[백준 2293번] 동전 1

제이 니퍼 — Sat, 23 Sep 2023 22:22:31 +0900

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

2293번: 동전 1

첫째 줄에 n, k가 주어진다. (1 ≤ n ≤ 100, 1 ≤ k ≤ 10,000) 다음 n개의 줄에는 각각의 동전의 가치가 주어진다. 동전의 가치는 100,000보다 작거나 같은 자연수이다.

www.acmicpc.net

풀이

DP(동적계획) 은 점화식이 중요하다. 그렇기 때문에 해당 문제의 규칙을 찾아서 점화식을 세우고 그걸 기반으로 코드를 짜야한다. 예를 들어보자

예시

최대 3종류 사용가능하며 10을 만들어야한다. 그렇다면 먼저 1원을 사용해서 만들수 있는 가치를 살펴보자

i) 1원으로 조합 가능한 경우

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

ii) 1,2원으로 조합 가능한 경우

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

iii) 1,2,5원으로 조합 가능한 경우

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

마지막으로 이 세가지 경우를 합쳐보겠다

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

이걸보면 점화식을 알 수있다. 만약 n종류로 k번째 가치를 만드는 경우는

dp[k]=dp[k](이전 값)+dp[k-coin[n]] 이다. 만약 3가지 종류를 만드는 경우에서, 10번째 값을 원한다면,

dp[10]=6+dp[10-5]=6+4=10 인것이다.

코드

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));
        StringTokenizer st = new StringTokenizer(br.readLine());
        
        int n=Integer.parseInt(st.nextToken());
        int k=Integer.parseInt(st.nextToken());
        int [] coin= new int[n];
        int [] dp=new int[k+1]; //0인경우도 포함
        for(int i =0;i<n; i++) {
        	coin[i]=Integer.parseInt(br.readLine());
        }
        for(int i=0; i<=k;i++) {
        	if(i%coin[0]==0)
        		dp[i]++;
        }
        for(int i=1;i<n;i++) {
        	for(int j=1; j<=k;j++) {
        		if(coin[i]<=j) {
        			//점화식 
        			dp[j]=dp[j]+dp[j-coin[i]];
        			
        		}
        		
        	}
        }
        System.out.print(dp[k]);
    }

   
}