코딩공부방

문제 설명

당신은 폰켓몬을 잡기 위한 오랜 여행 끝에, 홍 박사님의 연구실에 도착했습니다. 홍 박사님은 당신에게 자신의 연구실에 있는 총 N 마리의 폰켓몬 중에서 N/2마리를 가져가도 좋다고 했습니다.
홍 박사님 연구실의 폰켓몬은 종류에 따라 번호를 붙여 구분합니다. 따라서 같은 종류의 폰켓몬은 같은 번호를 가지고 있습니다. 예를 들어 연구실에 총 4마리의 폰켓몬이 있고, 각 폰켓몬의 종류 번호가 [3번, 1번, 2번, 3번]이라면 이는 3번 폰켓몬 두 마리, 1번 폰켓몬 한 마리, 2번 폰켓몬 한 마리가 있음을 나타냅니다. 이때, 4마리의 폰켓몬 중 2마리를 고르는 방법은 다음과 같이 6가지가 있습니다.

1. 첫 번째(3번), 두 번째(1번) 폰켓몬을 선택
2. 첫 번째(3번), 세 번째(2번) 폰켓몬을 선택
3. 첫 번째(3번), 네 번째(3번) 폰켓몬을 선택
4. 두 번째(1번), 세 번째(2번) 폰켓몬을 선택
5. 두 번째(1번), 네 번째(3번) 폰켓몬을 선택
6. 세 번째(2번), 네 번째(3번) 폰켓몬을 선택

이때, 첫 번째(3번) 폰켓몬과 네 번째(3번) 폰켓몬을 선택하는 방법은 한 종류(3번 폰켓몬 두 마리)의 폰켓몬만 가질 수 있지만, 다른 방법들은 모두 두 종류의 폰켓몬을 가질 수 있습니다. 따라서 위 예시에서 가질 수 있는 폰켓몬 종류 수의 최댓값은 2가 됩니다.
당신은 최대한 다양한 종류의 폰켓몬을 가지길 원하기 때문에, 최대한 많은 종류의 폰켓몬을 포함해서 N/2마리를 선택하려 합니다. N마리 폰켓몬의 종류 번호가 담긴 배열 nums가 매개변수로 주어질 때, N/2마리의 폰켓몬을 선택하는 방법 중, 가장 많은 종류의 폰켓몬을 선택하는 방법을 찾아, 그때의 폰켓몬 종류 번호의 개수를 return 하도록 solution 함수를 완성해주세요.

제한사항

• nums는 폰켓몬의 종류 번호가 담긴 1차원 배열입니다.
• nums의 길이(N)는 1 이상 10,000 이하의 자연수이며, 항상 짝수로 주어집니다.
• 폰켓몬의 종류 번호는 1 이상 200,000 이하의 자연수로 나타냅니다.
• 가장 많은 종류의 폰켓몬을 선택하는 방법이 여러 가지인 경우에도, 선택할 수 있는 폰켓몬 종류 개수의 최댓값 하나만 return 하면 됩니다.

입출력 예

numsresult

입출력 예 설명

입출력 예 #1
문제의 예시와 같습니다.

입출력 예 #2
6마리의 폰켓몬이 있으므로, 3마리의 폰켓몬을 골라야 합니다.
가장 많은 종류의 폰켓몬을 고르기 위해서는 3번 폰켓몬 한 마리, 2번 폰켓몬 한 마리, 4번 폰켓몬 한 마리를 고르면 되며, 따라서 3을 return 합니다.

입출력 예 #3
6마리의 폰켓몬이 있으므로, 3마리의 폰켓몬을 골라야 합니다.
가장 많은 종류의 폰켓몬을 고르기 위해서는 3번 폰켓몬 한 마리와 2번 폰켓몬 두 마리를 고르거나, 혹은 3번 폰켓몬 두 마리와 3번 폰켓몬 한 마리를 고르면 됩니다. 따라서 최대 고를 수 있는 폰켓몬 종류의 수는 2입니다.

1. 최대한 많은 수의 포켓몬을 골라야 하기 때문에, 중복을 제거해준다.
2. 가질 수 있는 최댓값은 N/2 마리 이므로, 배열의 길이 / 2 가 최대값이다.
3. 중복을 제거한 포켓몬 수 보다 최댓값이 크면 중복을 제거한 포켓몬 수가 최대값이 된다.

풀이 코드

  public int solution(int[] nums) {
        int answer = nums.length / 2;

        Set<Integer> set = new HashSet<>();

        for (int i = 0; i < nums.length; i++) {
            set.add(nums[i]);
        }
        if(answer > set.size())
            answer = set.size();
        return answer;
    }

문제 설명

0과 1로 이루어진 어떤 문자열 x에 대한 이진 변환을 다음과 같이 정의합니다.

1. x의 모든 0을 제거합니다.
2. x의 길이를 c라고 하면, x를 "c를 2진법으로 표현한 문자열"로 바꿉니다.

예를 들어, x = "0111010"이라면, x에 이진 변환을 가하면 x = "0111010" -> "1111" -> "100" 이 됩니다.

0과 1로 이루어진 문자열 s가 매개변수로 주어집니다. s가 "1"이 될 때까지 계속해서 s에 이진 변환을 가했을 때, 이진 변환의 횟수와 변환 과정에서 제거된 모든 0의 개수를 각각 배열에 담아 return 하도록 solution 함수를 완성해주세요.

제한사항

• s의 길이는 1 이상 150,000 이하입니다.
• s에는 '1'이 최소 하나 이상 포함되어 있습니다.

입출력 예

sresult

입출력 예 설명

입출력 예 #1

• "110010101001"이 "1"이 될 때까지 이진 변환을 가하는 과정은 다음과 같습니다.

회차이진 변환 이전제거할 0의 개수0 제거 후 길이이진 변환 결과

• 3번의 이진 변환을 하는 동안 8개의 0을 제거했으므로, [3,8]을 return 해야 합니다.

입출력 예 #2

• "01110"이 "1"이 될 때까지 이진 변환을 가하는 과정은 다음과 같습니다.

회차이진 변환 이전제거할 0의 개수0 제거 후 길이이진 변환 결과

• 3번의 이진 변환을 하는 동안 3개의 0을 제거했으므로, [3,3]을 return 해야 합니다.

입출력 예 #3

• "1111111"이 "1"이 될 때까지 이진 변환을 가하는 과정은 다음과 같습니다.

회차이진 변환 이전제거할 0의 개수0 제거 후 길이이진 변환 결과

• 4번의 이진 변환을 하는 동안 1개의 0을 제거했으므로, [4,1]을 return 해야 합니다.

나의 풀이

1. 문자열에서 0 제거하기

2. 이진 변환하기

3. 문자열의 길이가 1이 될때까지 반복하기

public int[] solution(String s) {
        int[] answer = new int[2];
        int zeroCount = 0;
        int binaryCount = 0;
        while (true) {

            if (s.length() == 1) { // 문자열의 길이가 1일 경우 break
                break;
            }

            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '0') {
                    zeroCount++; // 문자가 0일경우 count 증가
                }
            }

            s = s.replaceAll("0", ""); // 0을 모두 공백으로 변경

            int binaryStr = s.length();

            s = Integer.toBinaryString(binaryStr); // 문자열의 길이를 이진수로 변환
            binaryCount++;
        }
        
        answer[0] = binaryCount;
        answer[1] = zeroCount;

        return answer;
    }

문제 설명

한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.

각 종이 조각에 적힌 숫자가 적힌 문자열 numbers가 주어졌을 때, 종이 조각으로 만들 수 있는 소수가 몇 개인지 return 하도록 solution 함수를 완성해주세요.

제한사항

• numbers는 길이 1 이상 7 이하인 문자열입니다.
• numbers는 0~9까지 숫자만으로 이루어져 있습니다.
• "013"은 0, 1, 3 숫자가 적힌 종이 조각이 흩어져있다는 의미입니다.

입출력 예

numbersreturn

입출력 예 설명

예제 #1
[1, 7]으로는 소수 [7, 17, 71]를 만들 수 있습니다.

예제 #2
[0, 1, 1]으로는 소수 [11, 101]를 만들 수 있습니다.

• 11과 011은 같은 숫자로 취급합니다.

출처

나의 풀이

1. 만들 수 있는 모든 경우의 수 구하기 - DFS 이용

2. 중복 제거하기 및 0으로 시작하는 숫자는 지우기.

3. 소수 찾기

public class FindDecimal {
	// 모든 경우의 수를 담을 어레이리스트
    ArrayList<String> arrayList = new ArrayList<>();
    
    public int solution(String numbers) {
    
        int answer = 0;
        // dfs에서 방문확인
        boolean[] booleans = new boolean[numbers.length()];
        // 소수를 찾을 리스트
        ArrayList<String> answerList = new ArrayList<>();
        
        char[] chars = numbers.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            String s = "";
            dfs(i, booleans, s, chars);
        }
		
        // 0으로 시작하는 문자열은 삭제시키고 0부터 다시 시작
        for (int i = 0; i < arrayList.size(); i++) {
            if(arrayList.get(i).startsWith("0")) {
                arrayList.remove(i);
                i = -1;
            }
            else if (!answerList.contains(arrayList.get(i))) {
                answerList.add(arrayList.get(i));
            }
        }
        
        // 인덱스에 해당하는 숫자가 소수일 경우 정답 수 증가
        for (int i = 0; i < answerList.size(); i++) {
            int n = Integer.parseInt(answerList.get(i));

            for(int j = 2; j <= n; j++) {
                if(j == n) {
                    answer++;
                }
                if ( n%j == 0) {
                    break;
                }

            }
        }
        
        // System.out.println(answer);
        
        return answer;
    }
    
    // dfs 함수
    public void dfs(int i, boolean[] booleans, String s, char[] chars) {
        booleans[i] = true;
        s = s + chars[i];
        arrayList.add(s);
        for (int j = 0; j < booleans.length; j++) {
            if (!booleans[j]) {
                dfs(j, booleans, s, chars);
            }

        }
        booleans[i] = false;
    }

    public static void main(String[] args) {
        FindDecimal findDecimal = new FindDecimal();
        findDecimal.solution("17");
        // System.out.println(findDecimal.arrayList);

    }

}

알고리즘이 약하다는 생각에 대학생 취준 이후로 다시 알고리즘 공부를 시작하려고 한다. 더 좋은 방법이 있으면 댓글 달아주세요 ㅎㅅㅎ  dfs 알고리즘 짜는데 시간이 좀 걸려서 한시간 정도 걸렸다.... 공부하자!!

문제 설명

트럭 여러 대가 강을 가로지르는 일 차선 다리를 정해진 순으로 건너려 합니다. 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 알아내야 합니다. 트럭은 1초에 1만큼 움직이며, 다리 길이는 bridge_length이고 다리는 무게 weight까지 견딥니다.
※ 트럭이 다리에 완전히 오르지 않은 경우, 이 트럭의 무게는 고려하지 않습니다.

예를 들어, 길이가 2이고 10kg 무게를 견디는 다리가 있습니다. 무게가 [7, 4, 5, 6]kg인 트럭이 순서대로 최단 시간 안에 다리를 건너려면 다음과 같이 건너야 합니다.

경과 시간다리를 지난 트럭다리를 건너는 트럭대기 트럭

따라서, 모든 트럭이 다리를 지나려면 최소 8초가 걸립니다.

solution 함수의 매개변수로 다리 길이 bridge_length, 다리가 견딜 수 있는 무게 weight, 트럭별 무게 truck_weights가 주어집니다. 이때 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 return 하도록 solution 함수를 완성하세요.

제한 조건

• bridge_length는 1 이상 10,000 이하입니다.
• weight는 1 이상 10,000 이하입니다.
• truck_weights의 길이는 1 이상 10,000 이하입니다.
• 모든 트럭의 무게는 1 이상 weight 이하입니다.

입출력 예

bridge_lengthweighttruck_weightsreturn

출처

※ 공지 - 2020년 4월 06일 테스트케이스가 추가되었습니다.

나의 풀이

1. 한번의 반복문이 도는 것을 1초로 잡는다.

2. 더이상 남아있는 트럭이 없을 때 까지 반복한다.

3. 큐의 길이가 다리 길이보다 작을 경우 큐에 트럭을 올린다.

4. 큐에 들어가있는 트럭 무게의 합과 추가될 트럭 무게의 합이 다리의 무게한도 보다 작으면 큐에 트럭을 추가하고, 

   아닐 경우 큐에 0을 추가함 (앞에 추가되어 있는 값들을 한칸 씩 밀어내기 위해!)

5. 큐의 길이가 다리의 길이보다 같거나 커질 경우 큐에 있는 트럭을 삭제하고 위의 로직을 반복한다. 

6. 트럭이 모두 큐에 add 되면, 마지막 트럭이 큐에서 삭제 되는 수를 더해준다. (큐의 길이를 더해서 리턴)

    public int solution(int bridge_length, int weight, int[] truck_weights) {
        int answer = 0;

        Queue<Integer> bridgeQueue = new ArrayDeque<>();
        Queue<Integer> waitQueue = new ArrayDeque<>();

        for (int i: truck_weights) {
            waitQueue.add(i);
        }
        int sum = 0;
        while (!waitQueue.isEmpty()){
            answer++;
            if(bridgeQueue.size() < bridge_length){
                if(sum + waitQueue.peek() <= weight){
                    sum += waitQueue.peek();
                    bridgeQueue.add(waitQueue.poll());

                }else{
                    bridgeQueue.add(0);
                }
            }else{
                sum -= bridgeQueue.poll();
                if(sum + waitQueue.peek() < weight){
                    sum += waitQueue.peek();
                    bridgeQueue.add(waitQueue.poll());

                }else{
                    bridgeQueue.add(0);
                }
            }
        }
        bridgeQueue.size();
        return answer + bridge_length;
    }

문제 설명

게임개발자인 죠르디는 크레인 인형뽑기 기계를 모바일 게임으로 만들려고 합니다.
죠르디는 게임의 재미를 높이기 위해 화면 구성과 규칙을 다음과 같이 게임 로직에 반영하려고 합니다.

게임 화면은 1 x 1 크기의 칸들로 이루어진 N x N 크기의 정사각 격자이며 위쪽에는 크레인이 있고 오른쪽에는 바구니가 있습니다. (위 그림은 5 x 5 크기의 예시입니다). 각 격자 칸에는 다양한 인형이 들어 있으며 인형이 없는 칸은 빈칸입니다. 모든 인형은 1 x 1 크기의 격자 한 칸을 차지하며 격자의 가장 아래 칸부터 차곡차곡 쌓여 있습니다. 게임 사용자는 크레인을 좌우로 움직여서 멈춘 위치에서 가장 위에 있는 인형을 집어 올릴 수 있습니다. 집어 올린 인형은 바구니에 쌓이게 되는 데, 이때 바구니의 가장 아래 칸부터 인형이 순서대로 쌓이게 됩니다. 다음 그림은 [1번, 5번, 3번] 위치에서 순서대로 인형을 집어 올려 바구니에 담은 모습입니다.

만약 같은 모양의 인형 두 개가 바구니에 연속해서 쌓이게 되면 두 인형은 터뜨려지면서 바구니에서 사라지게 됩니다. 위 상태에서 이어서 [5번] 위치에서 인형을 집어 바구니에 쌓으면 같은 모양 인형 두 개가 없어집니다.

크레인 작동 시 인형이 집어지지 않는 경우는 없으나 만약 인형이 없는 곳에서 크레인을 작동시키는 경우에는 아무런 일도 일어나지 않습니다. 또한 바구니는 모든 인형이 들어갈 수 있을 만큼 충분히 크다고 가정합니다. (그림에서는 화면표시 제약으로 5칸만으로 표현하였음)

게임 화면의 격자의 상태가 담긴 2차원 배열 board와 인형을 집기 위해 크레인을 작동시킨 위치가 담긴 배열 moves가 매개변수로 주어질 때, 크레인을 모두 작동시킨 후 터트려져 사라진 인형의 개수를 return 하도록 solution 함수를 완성해주세요.

[제한사항]

• board 배열은 2차원 배열로 크기는 5 x 5 이상 30 x 30 이하입니다.
• board의 각 칸에는 0 이상 100 이하인 정수가 담겨있습니다.
  • 0은 빈 칸을 나타냅니다.
  • 1 ~ 100의 각 숫자는 각기 다른 인형의 모양을 의미하며 같은 숫자는 같은 모양의 인형을 나타냅니다.
• moves 배열의 크기는 1 이상 1,000 이하입니다.
• moves 배열 각 원소들의 값은 1 이상이며 board 배열의 가로 크기 이하인 자연수입니다.

입출력 예

boardmovesresult

입출력 예에 대한 설명

입출력 예 #1

인형의 처음 상태는 문제에 주어진 예시와 같습니다. 크레인이 [1, 5, 3, 5, 1, 2, 1, 4] 번 위치에서 차례대로 인형을 집어서 바구니에 옮겨 담은 후, 상태는 아래 그림과 같으며 바구니에 담는 과정에서 터트려져 사라진 인형은 4개 입니다.

public int solution(int[][] board, int[] moves) {
        int answer = 0;

        Stack<Integer> answerStack = new Stack<>();
        for(int i = 0; i < moves.length; i++)
        {
            for(int j = 0; j < board.length; j++)
            {
                if(board[board.length - 1][moves[i] - 1] == 0)
                    break;
                if(board[j][moves[i] - 1] != 0)
                {
                    answerStack.add(board[j][moves[i] - 1]);
                    board[j][moves[i] - 1] = 0;
                    if(answerStack.size() >= 2 && answerStack.peek() == answerStack.get(answerStack.size() - 2))
                    {
                        answerStack.pop();
                        answerStack.pop();
                        answer += 2;
                    }
                    break;
                }
            }
        }
        return answer;
    }

스택을 사용하면 간단하게 풀수있다.

문제 설명

위와 같은 삼각형의 꼭대기에서 바닥까지 이어지는 경로 중, 거쳐간 숫자의 합이 가장 큰 경우를 찾아보려고 합니다. 아래 칸으로 이동할 때는 대각선 방향으로 한 칸 오른쪽 또는 왼쪽으로만 이동 가능합니다. 예를 들어 3에서는 그 아래칸의 8 또는 1로만 이동이 가능합니다.

삼각형의 정보가 담긴 배열 triangle이 매개변수로 주어질 때, 거쳐간 숫자의 최댓값을 return 하도록 solution 함수를 완성하세요.

제한사항

• 삼각형의 높이는 1 이상 500 이하입니다.
• 삼각형을 이루고 있는 숫자는 0 이상 9,999 이하의 정수입니다.

입출력 예

triangleresult

public int solution(int[][] triangle) {
        int answer = 0;

        for(int i = 1; i < triangle.length; i++)
        {
            for (int j = 0; j < triangle[i].length; j++)
            {
                if(j == 0)
                {
                    triangle[i][j] += triangle[i - 1][j];
                }else if ( j == triangle[i].length - 1)
                {
                    triangle[i][j] += triangle[i - 1][j - 1];
                }
                else
                {
                    triangle[i][j] += Math.max(triangle[i - 1][j - 1],triangle[i - 1][j]);
                }
            }
        }
        int max = 0;
        for(int k = 0; k < triangle[triangle.length - 1].length; k++)
        {
            if (triangle[triangle.length - 1][k] > max)
                max = triangle[triangle.length - 1][k];
        }

        answer = max;

        return answer;
    }

위에서 부터 배열에 값을 더해가면서 가장 아래에 있는 값 중에 가장 큰 수가 답이 된다. 처음 풀어본 레벨 3 단계 문제이다!

문제 설명

매운 것을 좋아하는 Leo는 모든 음식의 스코빌 지수를 K 이상으로 만들고 싶습니다. 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 Leo는 스코빌 지수가 가장 낮은 두 개의 음식을 아래와 같이 특별한 방법으로 섞어 새로운 음식을 만듭니다.

섞은 음식의 스코빌 지수 = 가장 맵지 않은 음식의 스코빌 지수 + (두 번째로 맵지 않은 음식의 스코빌 지수 * 2)

Leo는 모든 음식의 스코빌 지수가 K 이상이 될 때까지 반복하여 섞습니다.
Leo가 가진 음식의 스코빌 지수를 담은 배열 scoville과 원하는 스코빌 지수 K가 주어질 때, 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 섞어야 하는 최소 횟수를 return 하도록 solution 함수를 작성해주세요.

제한 사항

• scoville의 길이는 2 이상 1,000,000 이하입니다.
• K는 0 이상 1,000,000,000 이하입니다.
• scoville의 원소는 각각 0 이상 1,000,000 이하입니다.
• 모든 음식의 스코빌 지수를 K 이상으로 만들 수 없는 경우에는 -1을 return 합니다.

입출력 예

scovilleKreturn

입출력 예 설명

1. 스코빌 지수가 1인 음식과 2인 음식을 섞으면 음식의 스코빌 지수가 아래와 같이 됩니다.
   새로운 음식의 스코빌 지수 = 1 + (2 * 2) = 5
   가진 음식의 스코빌 지수 = [5, 3, 9, 10, 12]

2. 스코빌 지수가 3인 음식과 5인 음식을 섞으면 음식의 스코빌 지수가 아래와 같이 됩니다.
   새로운 음식의 스코빌 지수 = 3 + (5 * 2) = 13
   가진 음식의 스코빌 지수 = [13, 9, 10, 12]

모든 음식의 스코빌 지수가 7 이상이 되었고 이때 섞은 횟수는 2회입니다.

public int solution(int[] scoville, int K) {
        int answer = 0;
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();

        for (int num:scoville)
        { priorityQueue.add(num); }

        while(!priorityQueue.isEmpty())
        {
            try
            {
                int a = priorityQueue.poll();
                int b = priorityQueue.poll();
                priorityQueue.add(a + (b * 2));
                answer++;
                if(priorityQueue.peek() > K)
                {
                    break;
                }
            }catch (Exception e)
            {
                return -1;
            }    
        }
        
        return answer;
    }

우선순위 큐를 이용하여 가장 작은 수 두가지를 꺼낸 후 첫째 수 + 둘째 수 * 2 연산 수행 후 다시 우선순위 큐에 값을 넣는다. 만약 우선순위 큐에서 가장 작은 수를 꺼냈을 때, K 보다 클 경우 answer를 리턴하고, Exception이 발생하는 경우는 우선순위 큐에 모든 값을 꺼내서 K보다 큰 수를 못 만들었을 경우이다. 이때 Exception에 대한 처리로 return -1 을 해주면 K보다 큰 수를 만들 수 없을 경우에 대해서 처리할 수 있다.

문제 설명

괄호가 바르게 짝지어졌다는 것은 '(' 문자로 열렸으면 반드시 짝지어서 ')' 문자로 닫혀야 한다는 뜻입니다. 예를 들어

• ()() 또는 (())() 는 올바른 괄호입니다.
• )()( 또는 (()( 는 올바르지 않은 괄호입니다.

'(' 또는 ')' 로만 이루어진 문자열 s가 주어졌을 때, 문자열 s가 올바른 괄호이면 true를 return 하고, 올바르지 않은 괄호이면 false를 return 하는 solution 함수를 완성해 주세요.

제한사항

• 문자열 s의 길이 : 100,000 이하의 자연수
• 문자열 s는 '(' 또는 ')' 로만 이루어져 있습니다.

입출력 예

sanswer

입출력 예 설명

입출력 예 #1,2,3,4
문제의 예시와 같습니다.

 boolean solution(String s) {
        boolean answer = false;
        char[] chars = s.toCharArray();

        Stack stack = new Stack();

        if(chars[0] == ')')
        {
            return answer;
        }

        for (char i : chars
        ) {
            if(i == '(')
            {
                stack.push(i);
            }
            else if (i == ')' && !stack.isEmpty())
            {
                stack.pop();
            }
        }
        if(stack.empty())
        {
            answer = true;
            return answer;
        }
        else
        {
            return answer;
        }
    }

처음에는 ArrayList를 이용하여 풀었으나, 효율성 테스트에서 떨어졌다. 그 이후 스택을 사용하는 방법으로 변경하고,

처음부터 닫는 괄호가 나올경우 무조건 올바른 괄호가 나올 수 없으므로 그에대한 처리 후에, 여는 괄호가 나올 경우 스택에 추가하고 닫는 괄호가 나올 경우 스택에 추가했던 여는 괄호를 삭제한다. 이 과정이 끝난 후에 스택에 값이 남아있을 경우, 올바른 괄호가 아니고, 스택이 비어있을 경우 올바른 괄호이다!

문제 설명

선행 스킬이란 어떤 스킬을 배우기 전에 먼저 배워야 하는 스킬을 뜻합니다.

예를 들어 선행 스킬 순서가 스파크 → 라이트닝 볼트 → 썬더일때, 썬더를 배우려면 먼저 라이트닝 볼트를 배워야 하고, 라이트닝 볼트를 배우려면 먼저 스파크를 배워야 합니다.

위 순서에 없는 다른 스킬(힐링 등)은 순서에 상관없이 배울 수 있습니다. 따라서 스파크 → 힐링 → 라이트닝 볼트 → 썬더와 같은 스킬트리는 가능하지만, 썬더 → 스파크나 라이트닝 볼트 → 스파크 → 힐링 → 썬더와 같은 스킬트리는 불가능합니다.

선행 스킬 순서 skill과 유저들이 만든 스킬트리1를 담은 배열 skill_trees가 매개변수로 주어질 때, 가능한 스킬트리 개수를 return 하는 solution 함수를 작성해주세요.

제한 조건

• 스킬은 알파벳 대문자로 표기하며, 모든 문자열은 알파벳 대문자로만 이루어져 있습니다.
• 스킬 순서와 스킬트리는 문자열로 표기합니다.
  • 예를 들어, C → B → D 라면 CBD로 표기합니다
• 선행 스킬 순서 skill의 길이는 1 이상 26 이하이며, 스킬은 중복해 주어지지 않습니다.
• skill_trees는 길이 1 이상 20 이하인 배열입니다.
• skill_trees의 원소는 스킬을 나타내는 문자열입니다.
  • skill_trees의 원소는 길이가 2 이상 26 이하인 문자열이며, 스킬이 중복해 주어지지 않습니다.

입출력 예

skillskill_treesreturn

입출력 예 설명

• BACDE: B 스킬을 배우기 전에 C 스킬을 먼저 배워야 합니다. 불가능한 스킬트립니다.
• CBADF: 가능한 스킬트리입니다.
• AECB: 가능한 스킬트리입니다.
• BDA: B 스킬을 배우기 전에 C 스킬을 먼저 배워야 합니다. 불가능한 스킬트리입니다.

1. 스킬 트리: 유저가 스킬을 배울 순서 ↩

public class SkillTree {

    public int solution(String skill, String[] skill_trees) {
        int answer = 0;
        ArrayList<String> array = new ArrayList<>();
        for (int i = 0; i < skill_trees.length; i++)
        {
            String str = "";
            for(int j = 0; j < skill_trees[i].length(); j++) {

                for (int k = 0; k < skill.length(); k++) {
                    if (skill.charAt(k) == skill_trees[i].charAt(j)) {
                        str += skill.charAt(k);
                    }
                }
            }
            array.add(str);
            System.out.println("결과는 " + str);
        }
        for(int i = 0; i < array.size(); i++)
        {
            int[] answers = new int[array.size()];
            answers[i] = 1;
            for (int j = 0; j < array.get(i).length(); j++)
            {
                if (array.get(i).charAt(j) != skill.charAt(j))
                {
                    System.out.println(skill_trees[i] + ":" + array.get(i).charAt(j) + "스킬을 배우기전에 "
                            + skill.charAt(j) + "스킬을 먼저 배워야 합니다.");
                    answers[i] = 0;
                    break;
                }
            }
            if (answers[i] == 1)
            {
                answer++;
            }
        }
        System.out.println("정답 수는" + answer);
        return answer;
    }

    public static void main(String[] args)
    {

        SkillTree s = new SkillTree();
        s.solution("CBD",new String[]{"BACDE","CBADF","AECB","BDA"});
    }


}