JAVA풀이 => 15점밖에 안나옴 샘플케이스가 다 맞았어도 실제 채점해보면 런타임에러나고 오류나는 경우가 많다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package programmers;
 
import java.util.*;
import java.io.*;
 
    public class pretest7{
 
    public static void main(String[] args){
 
        /*
        String str1[]={"ba","na","n","a"};
        String t1[]={"banana"};
        solution(str1,t1);
        String str2[]={"app","ap","p","l","e","ple","pp"};
        String t2[]={"apple"};       
        solution(str2,t2);
        String str3[]={"ba","an","nan","ban","n"};
        String t3[]={"banana"};  
        solution(str3,t3);
        }
        */
           // System.out.println(solution(new String[] { "ab", "na", "n", "a", "bn" }, "nabnabn"));
           // System.out.println(solution(new String[] { "ba", "an", "nan", "ban","n" }, "banana"));
            System.out.println(solution(new String[] { "ba""na""n""a" }, "banana"));
            System.out.println(solution(new String[] { "app""ap""p""l""e""ple""pp" }, "apple"));
            System.out.println(solution(new String[] { "ba","an","nan","ban","n"},"banana"));
        }
      private static int solution(String[] strs,String t){
 
        String[] dp = new String[t.length()];
        int[] dpMin = new int[t.length()];
        //Arrays.fill은 전체 배열을 채우는 방식이다.
        Arrays.fill(dp,"");
        Arrays.fill(dpMin,999999);
        dpMin[0= 0;
        int pivot =0;
 
        for(int index=0;index < t.length(); index++){
            
         //   String word = strs[index];
 
            //이전 dp를 쓰기 위한 pivot
            pivot = (index ==0)? 0 : index-1;
 
            int depth = dpMin[pivot];
            String tempDp = dp[pivot];
 
            //(text - 이전 dp)에서 남은 것 중 찾기
            for(String word : strs){
                if(t.substring(tempDp.length(), index+1).startsWith(word)==true){
                    dp[index] = tempDp + word;
                    dpMin[index] = depth + 1;
            //        System.out.println("dp: " + dp[index]);
                    break;
                }
            }
            System.out.println("index: " + index + " pivot: "+ pivot);
            //더 나은 것 없나 찾기
            while(pivot-1 >=0){
                for(String word : strs){
                    depth = dpMin[pivot-1];
                    tempDp = dp[pivot-1];
 
                    if(t.substring(tempDp.length(), index + 1).startsWith(word) == false)
                    continue;
                    depth++;
                    //dpMin[index]보다 크거나 같으면 의미 없으니 멈춤
                    if(depth>=dpMin[index])
                    continue;
                
                    //만약 tempDp를 제외한 나머지가 word랑 같으면, tempDp
                    if(t.substring(tempDp.length(),index+1).equals(word)==true){
                        tempDp = tempDp + word;
                        break;
                    }
                    //아니라면 그 다음것도 찾아봄
                    for(int count=0;count < strs.length;count++){
                        String innerWord = strs[count];
                        if(t.substring(tempDp.length(),index+1).startsWith(innerWord) == false)
                        continue;
                        //depth값이 최소값보다 크거나 같으면 의미 없으니 멈춤
                        if(depth+1 >= dpMin[index])
                        break;
                        depth++;
                        tempDp = tempDp+word;
                        //만약에 tempDp와 text(0~index+1)이 같으면 찾았으니 멈춤
                        if(t.substring(0,index+1).equals(tempDp)==true){
                            break;
                        }
                    }
                }
                //만약 지금 찾은 depth가 최솟값보다 낮으면 적용시키고 멈춤
                System.out.println("index: " + index+ " pivot: "+ pivot+" depth: "+depth+" tempDp: "+tempDp);
                if(depth<dpMin[index]&&tempDp.equals(t.substring(0,index+1))){
                    dpMin[index] = depth;
                    dp[index] = tempDp;
                    break;
                }
                //아니라면 pivot을 감소하고 돌림 
                pivot--;
            }
        }
       System.out.printf("======dp======");
       for(String p : dp){
           System.out.println(p);
       }
       //다 찾아봤는데 dp끝 값이 text와 같지 않으면 -1
       return(dp[t.length()-1].equals(t))? dpMin[t.length()-1]: -1;
        }
      
    }
 
cs


C++풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <string>
#include <vector>
#include <set>
#include <algorithm>
 
using namespace std;
 
int pretest7(vector<string> strs, string t)
{
    //vector에 있는 단어 조각들을 빠르게 탐색
    set<string> str_set(strs.begin(), strs.end());
 
    //무한대를 나타내는INF 변수 
    const int INF = 987654321;
 
    //dp배열 선언
    int dp[20002];
 
    //문자열의 길이를 나타내는 len
    int len = t.length();
 
    for(int i=0;i<len; i++)
    //dp배열 무한대로 초기화
        dp[i] = INF;
    //dp의 문자열의 마지막 
    //문자열의 길이가 len이므로 문자열의 마지막 index는 len-1이 됩니다.
        dp[len] = 0;
 
    //문자열을 뒷쪽 방향부터 순서대로 순회한다.
        for(int i=len-1;i>=0;i--){
                //i가 현재 가르키는 index부터 한개에서 5개를 이어붙힌 문자열을 이어붙히기 위해 변수 하나 선언
            string tmp ="";
 
            //길이가 1~5인 문자열을 저장하기 위한 for문 이때 i+j가 가리키는 위치와 문자열 전체 위치가 문자열 길이보다 크면 안됨
            for(int j=0; i+j<len && j<5;j++){
                tmp += t[i+j]; //for문돌떄마다 이어붙힌 문자열 더할 수 있다.
                //현재 만들어진 문자열이 주어진 단어 조각에 있는지 확인하기 위함
                //포함되어 있다면 i+j+1번 위치부터 주어진 단어조각을 이용해서 만들수 있는지 확인해야합니다. 무한대가 아니라면
                if(str_set.find(tmp) != str_set.end() && dp[i + j + 1!= INF)
                   //dp[i]값 갱신 
                    dp[i] = min(dp[i], dp[i+j+1]+1);
            }
        }
    //dp[0]가 무한대면 주어진 단어들로 만들수 없어서 -1 출력 아니라면 dp[0] 자체 출력 가능
    if(dp[0= INF)
        return -1;
    return dp[0];
}
 
 
cs


C++풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include<vector>
using namespace std;
 
int dp1[100001]; //첫번째 스티커를 뜯은 경우
int dp2[100001]; //첫번째 스티커를 뜯지 않은 경우
 
int pretest6(vector<int> sticker)
{
    int n = sticker.size();
//스티커가 한장이라면
    if(n == 1)
        return sticker[0];
 
//스티커가 적어도 2장 이상인경우
 
    //첫 번째 스티커를 뜯은 경우
    //첫번째 인덱스와 두번째 인덱스를 초기화 시켜준다.
    dp1[0= sticker[0];
    dp1[1= dp1[0];
 
//원형이어야 하기 때문에 양옆이 포함되지 않음을 기반으로 출발하는 for문 그래서 i=2부터 시작하고 <n이지만 원래는 여기는 n-1도 안되기때문
    //첫번째 스티커 반드시 뜯은 경우 n-1번째 스티커를 뜯으면 안되기 때문에 n-2까지 for문 돈다.(dp가 0부터 시작해서 n-1이 마지막 숫자임)
    for(int i=2;i<n-1;i++){
        dp1[i] = max(dp1[i-1],dp1[i-2+ sticker[i]);
        //dp1[n-2]에 답이 들어있게 됩니다.첫번쨰 스티커부터 마지막스티커까지 적절히 잘뜯었을때 들어있는 최대 정수
    
    
    //첫번째 스티커를 뜯지 않은 경우
    dp2[0= 0;
    dp2[1= dp2[0];
    for(int i=2;i<n;i++){
        dp2[i] = max(dp2[i-1],dp2[i-2+ sticker[i]);
        //dp2[n-1]에 답이 들어있게 됩니다.
    }
    }
   // int answer = 36;
    return max(dp1[n-2],dp2[n-1]);
}
cs

JAVA 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package programmers;
 
public class pretest6{
 
public static void main(String[] args){
 
    int[] sticker = {14,6,5,11,3,9,2,10}; //36
    System.out.println(solution(sticker));
}
public static int solution(int[] sticker){
    
    int answer =0;
 
    int len = sticker.length;
    if(len==1return sticker[0];
 
    int[] dp1 = new int[100001];
    int[] dp2 = new int[100001];
 
    //1번 스티커 뜯을 경우
    dp1[0= sticker[0];
    dp1[1= dp1[0];
 
    for(int i=2;i<len-1;i++){
        dp1[i] = Math.max(dp1[i-1],dp1[i-2+ sticker[i]);
    }
 
    //1번 스티커 안뜯을 경우
    dp2[0= 0;
    dp2[1= sticker[1];
 
    for(int i=2;i<len;i++){
        dp2[i] = Math.max(dp2[i-1],dp2[i-2+ sticker[i]);
    }
 
    return Math.max(dp1[len-2],dp2[len-1]);
    }
}
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//3자리로 이루어진 자연수 3개를 입력받아 그 수들의 곱을 구한 후 그 결과값의 각 자리 숫자들중 0을 제외한 모든 수들의 곱을 구하여 출력하는 프로그램을 재귀함수로 작성하시오.
//입력예제의 세 수의 곱은 1365300이다. 그러므로 1 * 3 * 6 * 5 * 3 = 270
//1의 자리수 * 1의 자리를 제외한 남은 자리수의 곱 (단  1의 자리수가 0이면 1로 바꾸어서 곱한다.)
import java.util.Scanner;
 
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        int N = a*b*c;
        System.out.println(recur(N,1));
    }
    public static int recur(int N,int sum){
        //몇자리 수인가?
        int i =0;
        while(N/Math.pow(10,i)>10)
        {
            i++;
        }
        //i+1자리 수이다.
        if(N<10){
            if(N!=0){
                return sum*N;
            }else{
                return sum*1;
            }
        }else{
            int x = N/(int)(Math.pow(10,i));//첫번째 수
            int y = N%(int)(Math.pow(10,i));//첫번째 수 잘라내고 남은 수
            return recur(y,sum*x);
        }
    }
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//100만 이하의 자연수 N을 입력받아 짝수이면 2로  홀수이면 3으로 나누는 작업을 반복하다가 그 값이 1이 되면 그때까지 나누었던 작업의 횟수를 출력하는 프로그램을 재귀함수로 작성하시오.
//100 → 50 → 25 → 8 → 4 → 2 → 1
//횟수(level)도 함께 전달하고 n이 1이면 level을 출력하면 된다. 
//함수(n/2 또는 n/3  level+1)
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
 
        int n = sc.nextInt();
        System.out.println(recur(n,0));
    }
    public static int recur(int n,int level){
        if(n==1){
            return level;
        }else if(n%2 ==0){
            return recur(n/2,level+1);
        }else{
            return recur(n/3,level+1);
        }
    }
 
}
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//첫 번째는 1, 두 번째는 2, 세 번째부터는 앞의 두 수의 곱을 100으로 나눈 나머지로 이루어진 수열이 있다. 
//100 이하의 자연수 N을 입력받아 재귀함수를 이용하여 N번째 값을 출력하는 프로그램을 작성하시오.
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        System.out.println(recur(N));
    }
    public static int recur(int N){
        if(N == 1){
            return 1;
        }else if(N==2){
            return 2;
        }else{
            return (recur(N-2)*recur(N-1))%100;
        }
    }
}
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//자연수 N과 M을 입력받아서 주사위를 N번 던져서 나온 눈의 합이 M이 나올 수 있는 모든 경우를 출력하는 프로그램을 작성하시오. 
//단, N은 10 이하의 정수이다.
public class Main{
    static int N;
    static int M;
    static int [] arr;
 
    public static void main(String[] args){
        Scanner sc  = new Scanner(System.in);
        N = sc.nextInt();
        M = sc.nextInt();
 
        arr = new int[N];
 
        dice(0,0);
    }
    public static void dice(int level,int sum){
        if(level < arr.length){
            for(int i=1;i<=6;i++){
                arr[level] = i;
                dice(level+1,sum+i);
            }
        }else{
            if(sum == M){
                for(int j=0;j<arr.length;j++){
                    System.out.print(arr[j]+" ");
                }
                System.out.println("");
            }
        }
    }
}
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//자연수 N을 입력받아 N이 홀수인 경우에는 1부터 N까지의 홀수를  짝수인 경우는 2부터 N까지의 짝수를 모두 출력하는 프로그램을 재귀함수로 작성하시오.
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
       // method(n);
        //System.out.println(n);
        System.out.println(method(n));
    }
    public static int method(int n){
        if(n==1 || n==2){
            return n;
        }
        else{
            System.out.print(method(n-2)+" ");
            //this method must  return a result of type int Java 때문에 반드시 return n해준다
           return n;
        }
    }
}
 
cs



헷갈림 이거 안되는 이유같이 보기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//100 이하의 자연수 N을 입력받아 재귀함수를 이용하여 1부터 N까지의 합을 구하는 프로그램을 작성하시오.
 
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        recur(a);
        System.out.println(a);
      //System.out.println(recur(input));
    }
    public static int recur(int a){
 
        if(a==1){
            return a;
        }
        else 
        {
            //System.out.print(n+" ");
 
            //return 꼭 쓰는 이유
            //recur(int a) 이부분에서 에러가 나는데 this method must return a result of type int java
 
            //여기서 그냥 return a가 아니기떄문에 형성평가 2번의 짝수 홀수 출력하는 재귀함수와는 다르게 나온다. 위에     //recur(input); // System.out.println(input); 안되는 이유
            a = recur(a-1)+a;
            return a;
            //System.out.println(recur(a-1) + a);
      
        }
    }
}
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//자연수 N을 입력받아 1부터 N까지 출력을 하되 n-1번째 값은 n번째 값을 2로 나눈 몫이 되도록 하는 프로그램을 작성하시오.
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        method(n);
        System.out.println(n);
    }
    public static int method(int n){
        if(n==1){
            return 1;
        }else{
            System.out.print(method(n/2)+" ");
            return n;
        }
    }
}
cs


+ Recent posts