[백준] 알파벳 (java) Dfs

2020-03-10

알파벳 (백준> Dfs_Bfs)

문제 링크

문제설명

세로 R칸, 가로 C칸으로 된 표 모양의 보드가 있다. 보드의 각 칸에는 대문자 알파벳이 하나씩 적혀 있고, 좌측 상단 칸 (1행 1열) 에는 말이 놓여 있다.

말은 상하좌우로 인접한 네 칸 중의 한 칸으로 이동할 수 있는데, 새로 이동한 칸에 적혀 있는 알파벳은 지금까지 지나온 모든 칸에 적혀 있는 알파벳과는 달라야 한다. 즉, 같은 알파벳이 적힌 칸을 두 번 지날 수 없다.

좌측 상단에서 시작해서, 말이 최대한 몇 칸을 지날 수 있는지를 구하는 프로그램을 작성하시오. 말이 지나는 칸은 좌측 상단의 칸도 포함된다.

입력

첫째 줄에 R과 C가 빈칸을 사이에 두고 주어진다. (1<=R,C<=20) 둘째 줄부터 R개의 줄에 걸쳐서 보드에 적혀 있는 C개의 대문자 알파벳들이 빈칸 없이 주어진다.

출력

첫째 줄에 말이 지날 수 있는 최대의 칸 수를 출력한다.

예제 입력 1 복사

2 4
CAAB
ADCB

예제 출력 1 복사

3


풀이

import java.util.*;

public class Main {

	static int arr[][];
	static boolean alpa[] = new boolean[26];	 //A=0, B=1, C=2 ...
	static int answer= 1;
	static int count = 1;
	
    public static int[] dy = {-1, 1, 0, 0}; // 상하 좌우;
    public static int[] dx = {0, 0, -1, 1};
	
    
    public static int step = 1;
    public static int max_step = 1;
    
    public static void dfs(int x, int y) {
        int alpha = arr[x][y];
        alpa[alpha] = true;
        
        for(int i=0; i < 4; i++) {
            int xx = dy[i] + x;
            int yy = dx[i] + y;
            
            if(xx >= 0 && yy >= 0 && xx < arr.length && yy < arr[0].length && !alpa[arr[xx][yy]]) {
	            max_step = Math.max(max_step, ++step);    
	            dfs(xx, yy);
	        }
            
        }//for
        
        // 여기서 초기화 하지 않으면 다른 경로에서 접근 할 수 없다.
        step --;
        alpa[alpha] = false;
    }
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int r = sc.nextInt();
		int c = sc.nextInt();
		
		sc.nextLine();
		
		arr = new int[r][c];
		
		for(int i=0; i<r; i++) {
			String s = sc.nextLine();
			for(int j=0; j<c; j++) {
				arr[i][j] = s.charAt(j)-65;
			}
		}
		
		dfs(0,0);
		
		System.out.println(max_step);
	}
}

후기 (1h)

난 분명히 넣는 것도 제대로 넣고, 다 했는데 왜…? 같은코드 인 것 같은데 왜때문에 안된다구요….? 밑에 코드랑 차이점 아는 분 설명해주세오….

+왜 난 점점 dfs를 풀면 풀 수록 멍청이가 되어가는 것 같지…? 정신차려잇


package Dfs_Bfs;

import java.util.*;

public class beak_알파벳 {

	static int arr[][];
	static boolean alpa[] = new boolean[26];	 //A=0, B=1, C=2 ...
	static int answer= 1;
	static int count = 1;
	
	static void dfs(int i, int j) {
		int c = arr[i][j];
		alpa[c] = true; //방문했으니까 1로바꿔줌
		
		int dx[] = {0, 0, 1, -1};
		int dy[] = {1,-1, 0, 0};
		
		for(int k=0;i<4;i++) {
			int x = i + dx[k];
			int y = j + dy[k];
			
			if(x>=0 && x<arr.length && y>=0&& y<arr[0].length && !alpa[arr[x][y]]) {
				answer = Math.max(answer, ++count);
				dfs(x,y);
			}
		}
		
		//갔다 나왔으면 cnt--해주고, visited도 false로 만들어 줘야 다음으로 갈 수 있다.
		count--;
		alpa[c] = false;
		
	}
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int r = sc.nextInt();
		int c = sc.nextInt();
		
		sc.nextLine();
		
		arr = new int[r][c];
		
		for(int i=0; i<r; i++) {
			String s = sc.nextLine();
			for(int j=0; j<c; j++) {
				arr[i][j] = s.charAt(j)-65;
			}
		}
		
		dfs(0,0);
		
		System.out.println(answer);
	}
}

Read More

[백준] 카드 구매하기 (java) Dynamic_programming

2020-03-10

카드 구매하기 (백준> Dynamic_programming)

문제 링크

문제설명

요즘 민규네 동네에서는 스타트링크에서 만든 PS카드를 모으는 것이 유행이다.

PS카드는 PS(Problem Solving)분야에서 유명한 사람들의 아이디와 얼굴이 적혀있는 카드이다. 각각의 카드에는 등급을 나타내는 색이 칠해져 있고, 다음과 같이 8가지가 있다.

  • 전설카드
  • 레드카드
  • 오렌지카드
  • 퍼플카드
  • 블루카드
  • 청록카드
  • 그린카드
  • 그레이카드

카드는 카드팩의 형태로만 구매할 수 있고, 카드팩의 종류는 카드 1개가 포함된 카드팩, 카드 2개가 포함된 카드팩, … 카드 N개가 포함된 카드팩과 같이 총 N가지가 존재한다.

민규는 카드의 개수가 적은 팩이더라도 가격이 비싸면 높은 등급의 카드가 많이 들어있을 것이라는 미신을 믿고 있다. 따라서, 민규는 돈을 최대한 많이 지불해서 카드 N개 구매하려고 한다. 카드가 i개 포함된 카드팩의 가격은 Pi원이다.

예를 들어, 카드팩이 총 4가지 종류가 있고, P1 = 1, P2 = 5, P3 = 6, P4 = 7인 경우에 민규가 카드 4개를 갖기 위해 지불해야 하는 금액의 최댓값은 10원이다. 2개 들어있는 카드팩을 2번 사면 된다.

P1 = 5, P2 = 2, P3 = 8, P4 = 10인 경우에는 카드가 1개 들어있는 카드팩을 4번 사면 20원이고, 이 경우가 민규가 지불해야 하는 금액의 최댓값이다.

마지막으로, P1 = 3, P2 = 5, P3 = 15, P4 = 16인 경우에는 3개 들어있는 카드팩과 1개 들어있는 카드팩을 구매해 18원을 지불하는 것이 최댓값이다.

카드 팩의 가격이 주어졌을 때, N개의 카드를 구매하기 위해 민규가 지불해야 하는 금액의 최댓값을 구하는 프로그램을 작성하시오. N개보다 많은 개수의 카드를 산 다음, 나머지 카드를 버려서 N개를 만드는 것은 불가능하다. 즉, 구매한 카드팩에 포함되어 있는 카드 개수의 합은 N과 같아야 한다.

입력

첫째 줄에 민규가 구매하려고 하는 카드의 개수 N이 주어진다. (1 ≤ N ≤ 1,000)

둘째 줄에는 Pi가 P1부터 PN까지 순서대로 주어진다. (1 ≤ Pi ≤ 10,000)

출력

첫째 줄에 민규가 카드 N개를 갖기 위해 지불해야 하는 금액의 최댓값을 출력한다.

예제 입력 1 복사

4
1 5 6 7

예제 출력 1 복사

10

풀이

package Dynamic_programming;

import java.util.*;

public class beak_카드구매하기 {
	
	//40min
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int n = sc.nextInt();
		
		int arr[] = new int[n];
		for(int i=0; i<n; i++)
			arr[i] = sc.nextInt();
		
		int dp[] = new int[n];
		
		dp[0] = arr[0];
		dp[1] = Math.max(dp[0]*2, arr[1]);
		
		for(int i=2; i<n; i++) {
			
			int k=i-1;
			for(int j=0; j< (i+1/2); j++, k--) {
				int p = dp[i];
				if(j == i) 
					dp[i] = Math.max(dp[j]*2, p);
				else
					dp[i] = Math.max(dp[j] + dp[k], p);
			}
			
			dp[i] = Math.max(dp[i], arr[i]);
		}
		
		System.out.println(dp[n-1]);
		
	}
}

후기 (40min)

정답 안보고 풀었다…! 사실 반쯤은 안될거라고도 생각한 다음 푼 문제라서, 방법만 확실히 까먹지않으면 될듯!

넣을 수 있는 제일 큰 값들을 dp에 넣고, 14 23 이런식으로 더해서 비교해보는 부분이 키포인트!

Read More

복습 5

2020-03-09

복습 5

3.6부터 앞으로

  1. 좋은 단어 (Stack) -> 문제.. 헷갈리지말자

  2. 퇴사 (DP)

    1. n일까지도 일할 수 있다 + (n+1)과 n일을 비교하므로 배열은 p[n+2], t[n+2], dp[n+2]로 진행
    2. 또 dp[day]가 day일이후로 가질 수 있는 최대값이면서, 1일차값이 p[1]과 dp[day+1]로 진행된다면
    	끝에서부터 dp[막날 이후로 가질수있는 값], dp[막날 전날 가질 수 있는값].. 으로 진행해야한다.
    3. 따라서 for(i=n; i>0; i--) 1일부터 시작하게 했으니까 i>0 이어야한다
    4. day는 현재 내 날짜 i + 상담기간 t[i] 이며, 
    	day가 <=n 날짜 안에 끝난다면
    	dp[i] = max(p[i]+dp[day], dp[i+1]); 중 큰 값을 넣고
    	day가 >n 이라면
    	dp[i] = dp[i+1]; 뒤에서부터 오니까 다음날이 가질 수 있는 최대값이 오늘 가질 수 있는 최대값!!
       	
    5. 따라서 dp[1]에 가질 수 있는 최대의 값이 담겨있다
    
  3. 가장 긴 펠린드롬 (String)

    스터디원이 푼 것 처럼, 모든 나올 수 있는 숫자의 조합으로 나눠서 계산했다. 코드도 짧아지고 답은 정답인데 효율성에서 0점 맞음…(?)

    import java.util.*;
       
    public class Review {
    	boolean palen(String s) {
    		int j=s.length()-1; //끝부터 시작
       		
    		for(int i=0; i<s.length()/2; i++,j--) {//i는 0부터 j는 끝부터 다가오다 만난다
    			if(s.charAt(i) != s.charAt(j))
    				return false; //아닐때만 잡아내면 되니까
    		}
       		
    		return true; // 안걸리고 나왔으면 true
    	}
       	
        public int solution(String s) {
        	int answer = 0;
        	for(int i=1; i<=s.length(); i++) {
        		for(int j=0; j<s.length(); j++) {
        			if(j+i <=s.length()) {
        				String a = s.substring(j, j+i);
        				System.out.println(a);
        				if(palen(a) == true)
        					answer = Math.max(answer, a.length());
        			}
        		}//in for - 0부터 돌려보는 갯수까지 쪼개봄 (0~5)
        	}//out for - 돌려보는 갯수 (1~5)
           	
        	return answer;
        }
    }
    
  4. 문자열 압축 (String)

    오우… 위의 문제랑 비슷해서 비슷하게 풀었는데 다른점은

    1) 위에 문제는 j+i 끊어지는 부분에서 멈춘다는 것

    2) 이 문제는 j+i 끊어지는 부분에서 멈춘 후에, 그 뒷부분도 찾아내야 한다는 점이었다

    import java.util.*;
       
    //28min
    public class Review {
       	
    	//작은 문자열의 사이즈로
    	static int solution(String s) {
    		int answer=2500;
       		
    		for(int i=1; i<=s.length(); i++) {
    			//일단 하나 넣고 시작하기
    			String answer_s = "";
    			String temp = s.substring(0, i);
    			int num = 1;
    			int idx = 0; boolean chk = false;
       			
    			for(int j=i; j<s.length(); j = j+i) {
    				if(j+i<=s.length()) {
    					if(temp.equals(s.substring(j, j+i))) { // 음... 문자열끼리 비교할때는 == 안쓰는거 잊지말자...
    						num++;
    					}
    					else {
    						if(num == 1)
    							answer_s += temp;
    						else
    							answer_s += num+temp;
    						num = 1;
    					}
    					temp = s.substring(j, j+i); // if 든 else 든 무조건 temp에는 다음 값 넣어줌
    				}//배열 size안에 들어온다는 조건
    				else {
    					chk = true;
    					idx = j;
    				}
    			}//in for
       			
    			//비교는 이미 했고, 못들어간거 넣어주기
    			if(num == 1)
    				answer_s += temp;
    			else
    				answer_s += num + temp;
       			
    			if(chk == true)// 끝까지 도달못했으면
    				answer_s += s.substring(idx, s.length());
       			
    			System.out.println(answer_s);
       			
    			answer = Math.min(answer, answer_s.length());
    		}//out for
       		
       		
    		return answer;
    	}
           
        public static void main(String[] args) {
       
    		System.out.println(solution("abcabcabcabcdededededede"));
           	
    	}
    }
    
  5. 경로찾기 (BFS)

    Pos 클래스 필요없고, j행만 가지고 들어가기때문에 큐는 Integer로 설정해준다! 기억해놓기!

    또한, 큐가 무한루프를 돌지 않기위해서 어떤 조건일때 add 해주는지도 잘 생각해야한다!

    import java.util.*;
       
    public class Review {
       	
    	//30min
        public static void main(String[] args) {
           	
        	Scanner sc = new Scanner(System.in);
           	
        	int n = sc.nextInt();
           	
        	int arr[][] = new int[n][n];
           	
        	for(int i=0; i<n; i++) {
        		for(int j=0;j<n; j++)
        			arr[i][j] = sc.nextInt();
        	}
           	
        	Queue<Integer> qu = new LinkedList<>();
           	
        	for(int i=0; i<n; i++) {// 인접행렬이니까 0-n행까지만 가보면 된다
        		for(int j=0; j<n; j++) {//i행 쫙 돌기
        			if(arr[i][j] == 1) 
        				qu.add(j);
        		}
           			
    			while(!qu.isEmpty()) {//j행에 방문할 수 있는데까지 다 방문하면서 1로만들어주고 나온다.
    				int nextj = qu.poll();
       				
    				arr[i][nextj] = 1; //i행의 j는 갈수있으니까 1로 만들어줌
       				
    				for(int k=0; k<n; k++) {
    					if(arr[nextj][k] == 1 && arr[i][k] !=1) {
    						//arr[i][k]!=1이라는 뜻은 전행의 1이 있는곳은 전부 안가겠다는 뜻! qu에 안넣겠다는 뜻!
    						qu.add(k);
    					}
    				}
    			}//while
                   
                //그렇게 while 돌고나오면 다음 i행으로 진행한다!
        	}//out for
           	
           	
        	for(int i=0;i<n;i++) {
        		for(int j=0; j<n; j++)
        			System.out.print(arr[i][j] + " ");
        		System.out.println();
        	}
    	}
    }
    
  6. RGB거리 (DP)

  7. Z (Recursion)

    면이 아닌 점이라고 생각하면 쉽게 풀 수 있다.

    또한, 기저조건에서 return 을 해주는것과 멈출 수 없다면 그냥 거기서 출력해주는 것도 좋은 방법!

    import java.util.*;
       
    public class Review {
    	//10min
    	static int answer = 0;
       	
    	static void go(int m, int i, int j, int x, int y) {
    		if(m == 1) {//기저조건
    			if(i==x && j==y)
    				System.out.println(answer);
       			
    			answer++;
    			return;
    		}
       
    		int h = m/2;
       		
    		go(h, i, j, x, y);
    		go(h, i, j+h, x, y);
    		go(h, i+h, j, x, y);
    		go(h, i+h, j+h, x, y);
       
    	}
       	
        public static void main(String[] args) {
        	Scanner sc = new Scanner(System.in);
           	
        	int n = sc.nextInt();
        	//점이라고 생각
        	int m = (int)Math.pow(2, n); // 한면만 가지고 들어가면 나머지는 half 옮기면서 알 수 있다
       
        	int x = sc.nextInt();
        	int y = sc.nextInt();
           	
        	go(m, 0, 0, x, y);
           	
    	}
    }
    
  8. 잃어버린 괄호 (Greedy)

    첫 시작은 무조건 +로 시작하니까, - 시작 전까지오는 s[0]은 전부 더해주면 된다

    또, 뒤의 -로 쪼개져있는 배열들은 뒤에 +가 있으면 전부 괄호로 묶어서 더해준다는 개념이니까

    -가나오는 배열마다 안에있는 애들을 전부 더해서 -처리해주면 된다.

    import java.util.*;
       
    public class Review {
       	
        public static void main(String[] args) {
        	Scanner sc = new Scanner(System.in);
           	
        	String a = sc.nextLine();
           	
        	String a_split[] = a.split("-"); //-로 나누기
           	
        	String first_split[] = a_split[0].split("\\+"); //첫 -의 앞부분 +들은 전부 더해준다
           	
        	int f = 0;
        	for(int i=0; i<first_split.length; i++)
        		f += Integer.parseInt(first_split[i]);
           	
        	//나머지 -로 쪼개진 부분들은 전부 더해준다
        	int l =0;
        	for(int i=1; i<a_split.length; i++) {
        		//+가 있는 부분은 제거하고 숫자만 더해준다
        		String s[] = a_split[i].split("\\+");
           		
        		for(int j=0;j<s.length; j++)
        			l += Integer.parseInt(s[j]);
        	}
           	
        	System.out.println(f-l);
           	
    	}
    }
    
  9. 0 만들기 (Greedy)

    실패!!!!!!!!!!! 비슷하게 따라가다가 결국 조건에서 헤맸다… 으ㅏ아

    import java.util.*;
       
    public class Review {
       	
    	static int target = 0;
       	
    	static void rec(int sum, int sign, int num, int increase, String a) {
    		if(target == increase) {//기저조건
       			
    			sum = sum + sign*num;
    			if(sum == 0)
    				System.out.println(a);
    			return;
    		}
       		
    		rec(sum,  sign, num*10 + (increase+1), increase+1, a+ " " + String.valueOf(increase+1));
    		rec(sum + (sign*num),  1, increase+1,	  increase+1, a + "+" + String.valueOf(increase+1));
    		rec(sum + (sign*num), -1, increase+1, increase+1, a + "-" + String.valueOf(increase+1));
       		
    	}
       	
        public static void main(String[] args) {
        	Scanner sc = new Scanner(System.in);
           	
        	int n = sc.nextInt();
           	
        	for(int i=0; i<n; i++) {
        		target = sc.nextInt();
        		String a = "1";
        		//sum, 부등호 , 초기값, 하나씩 증가해서 n 도달하는 값, 1넣고 출발 
           		
        		rec(0,1, 1, 1, a);
        		System.out.println();
        	}
    	}
           
    }
    
Read More

[백준] 좋은 단어 (java) Stack

2020-03-06

좋은 단어 (백준> Stack_Queue)

문제 링크

문제설명

이번 계절학기에 심리학 개론을 수강 중인 평석이는 오늘 자정까지 보고서를 제출해야 한다. 보고서 작성이 너무 지루했던 평석이는 노트북에 엎드려서 꾸벅꾸벅 졸다가 제출 마감 1시간 전에 깨고 말았다. 안타깝게도 자는 동안 키보드가 잘못 눌려서 보고서의 모든 글자가 A와 B로 바뀌어 버렸다! 그래서 평석이는 보고서 작성을 때려치우고 보고서에서 ‘좋은 단어’나 세보기로 마음 먹었다.

평석이는 단어 위로 아치형 곡선을 그어 같은 글자끼리(A는 A끼리, B는 B끼리) 쌍을 짓기로 하였다. 만약 선끼리 교차하지 않으면서 각 글자를 정확히 한 개의 다른 위치에 있는 같은 글자와 짝 지을수 있다면, 그 단어는 ‘좋은 단어’이다. 평석이가 ‘좋은 단어’ 개수를 세는 것을 도와주자.

입력

첫째 줄에 단어의 수 N이 주어진다. (1 ≤ N ≤ 100)

다음 N개 줄에는 A와 B로만 이루어진 단어가 한 줄에 하나씩 주어진다. 단어의 길이는 2와 100,000사이이며, 모든 단어 길이의 합은 1,000,000을 넘지 않는다.

출력

첫째 줄에 좋은 단어의 수를 출력한다.

예제 입력 1 복사

3
ABAB
AABB
ABBA

예제 출력 1 복사

2


풀이

package Stack_Queue;

import java.util.*;

public class beak_좋은단어 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int answer = 0;
		
		int n = sc.nextInt();
		
		sc.nextLine();
		
		for(int k=0; k<n; k++) {
			String s = sc.nextLine();
			
			Stack<Character> stk = new Stack<>();
			stk.add(s.charAt(0));
			
			for(int i=1;i<s.length(); i++) {
				char c = s.charAt(i);
				
				if(!stk.isEmpty() && c ==stk.peek()) //비어있으면서의 조건을 항상 앞에 붙여줘야한다!
					stk.pop();
				else
					stk.push(c);
			}
			
			if(stk.isEmpty())
				answer++;
			
		}//for
		
		System.out.println(answer);
	}
}

후기 (30min)

처음에 문제를 이해못해서 한 이십분을 헤매다가.. 전에 풀었던 문제랑 비슷하다는걸 이해하고 십분도 안돼서 풀었다.. 이래서 복습이 중요하다고 하는거구나ㅎ.ㅎ

Read More

[백준] 퇴사 (java) Dynamic_programming

2020-03-06

퇴사 (백준> Dynamic_programming)

문제 링크

문제설명

상담원으로 일하고 있는 백준이는 퇴사를 하려고 한다.

오늘부터 N+1일째 되는 날 퇴사를 하기 위해서, 남은 N일 동안 최대한 많은 상담을 하려고 한다.

백준이는 비서에게 최대한 많은 상담을 잡으라고 부탁을 했고, 비서는 하루에 하나씩 서로 다른 사람의 상담을 잡아놓았다.

각각의 상담은 상담을 완료하는데 걸리는 기간 Ti와 상담을 했을 때 받을 수 있는 금액 Pi로 이루어져 있다.

N = 7인 경우에 다음과 같은 상담 일정표를 보자.

  1일 2일 3일 4일 5일 6일 7일
Ti 3 5 1 1 2 4 2
Pi 10 20 10 20 15 40 200

1일에 잡혀있는 상담은 총 3일이 걸리며, 상담했을 때 받을 수 있는 금액은 10이다. 5일에 잡혀있는 상담은 총 2일이 걸리며, 받을 수 있는 금액은 15이다.

상담을 하는데 필요한 기간은 1일보다 클 수 있기 때문에, 모든 상담을 할 수는 없다. 예를 들어서 1일에 상담을 하게 되면, 2일, 3일에 있는 상담은 할 수 없게 된다. 2일에 있는 상담을 하게 되면, 3, 4, 5, 6일에 잡혀있는 상담은 할 수 없다.

또한, N+1일째에는 회사에 없기 때문에, 6, 7일에 있는 상담을 할 수 없다.

퇴사 전에 할 수 있는 상담의 최대 이익은 1일, 4일, 5일에 있는 상담을 하는 것이며, 이때의 이익은 10+20+15=45이다.

상담을 적절히 했을 때, 백준이가 얻을 수 있는 최대 수익을 구하는 프로그램을 작성하시오.

입력

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

둘째 줄부터 N개의 줄에 Ti와 Pi가 공백으로 구분되어서 주어지며, 1일부터 N일까지 순서대로 주어진다. (1 ≤ Ti ≤ 5, 1 ≤ Pi ≤ 1,000)

출력

첫째 줄에 백준이가 얻을 수 있는 최대 이익을 출력한다.

예제 입력 1 복사

7
3 10
5 20
1 10
1 20
2 15
4 40
2 200

예제 출력 1 복사

45

풀이

package Dynamic_programming;

import java.util.*;

public class beak_퇴사 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int n = sc.nextInt();
		
		int t[] = new int[n+2];
		int p[] = new int[n+2];
		
		for(int i=1; i<=n;i++) {
			t[i] = sc.nextInt();
			p[i] = sc.nextInt();
		}
	
		int dp[] = new int[n+2];
		for(int i=n; i>0; i--) {//끝에서부터
			int day = i +t[i]; //일 끝나는 시간
			
			if(day <=n) //시간안에 끝나면
				dp[i] = Math.max(p[i] + dp[day], dp[i+1]);
			else // 시간안에 못끝나는 일이면
				dp[i] = dp[i+1]; //다음날부터 가질수있는 최대값을 넣는다
		}
		
		System.out.println(dp[1]);
		
	}
}

후기 (–)

오랜만에 해답을 봐도 이해가 안되는 dp 문제를 봤다.. 끝에서부터 넣는거까지는 알겠는데, n+1일의 dp값은 왜…
조금 더 생각해봐야하는 문제였다…!

Read More