soo 문제집 완전탐색 easy 문제 남은 32문제중 22문제를 풀었고, 그중 힌트를 참고한 문제 및 정리하기 위한 11개의 문제를 재풀이해서 학습 및 체득하려는 목적으로 작성했습니다.

문제번호	제목	난이도
18868번	멀티버스 I	브론즈 1
1059번	좋은 구간	실버 4
1251번	단어 나누기	실버 5
2422번	한윤정이 이탈리아에 가서 아이스크림을 사먹는데	실버 4
2453번	기상청 인턴 신현수	브론즈1
2503번	숫자 야구	실버 3
2635번	수 이어가기	실버 5
5568번	카드 놓기	실버 4
1065번	한수	실버 4
1120번	문자열	실버 4
2607번	비슷한 단어	실버 2

18868번 멀티버스 I

해결코드:

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


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 m = Integer.parseInt(st.nextToken());
        int n = Integer.parseInt(st.nextToken());
        int[][] arr = new int[m][n];
        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < n; j++) {
                arr[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        int ans = 0;
        for (int i = 0; i < m; i++) {
            for (int j = i+1; j < m; j++) {
                boolean isOk = false;
                for (int k = 0; k < n; k++) {
                    for (int l = k+1; l < n; l++) {
                        if(arr[i][k] < arr[i][l] && arr[j][k] < arr[j][l]){
                            isOk = true;
                        } else if (arr[i][k] == arr[i][l] && arr[j][k] == arr[j][l]) {
                            isOk = true;
                        }else if(arr[i][k] > arr[i][l] && arr[j][k] > arr[j][l]){
                            isOk = true;
                        }else{
                            isOk = false;
                            break;
                        }
                    }
                    if(!isOk){
                        break;
                    }
                }
                if(isOk){
                    ans++;
                }
            }
        }
        bw.write(ans+"");

        br.close();
        bw.close();
    }

}

고민의 시간과 해결방법

1. 입력값이 작으므로 브루트포스로 풀면 쉽게 풀리는 문제이다.
2. m^2 * n^2의 복잡도로 문제를 해결하였다. 이렇게 해도 시간제한에 걸리지 않는다.
3. 만약 해당하는 조건을 만족하지 않으면 isOk를 false로 하고 break해주고 만족하면 isOk를 true로 한다. 각 순회가 완료될때마다 ans를 증가시킨다
4. ans를 출력하면 정답이 된다.

문제링크:

18868번 - 멀티버스 I

1059번 좋은 구간

해결코드:

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


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

        int l = Integer.parseInt(br.readLine());
        int[] arr = new int[l];
        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i = 0; i < l; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }
        int n = Integer.parseInt(br.readLine());

        Arrays.sort(arr);
        int start = 0;
        int end = 1001;
        int count = 0;
        for (int i = 0; i < l; i++) {
            if(arr[i] < n){
                if(arr[i] > start){
                    start = arr[i];
                }
            }else if(arr[i] > n){
                if(arr[i] < end){
                    end = arr[i];
                }
            }else{
                start = -1;
                end = -1;
                n = -1;
                break;
            }
        }

        for (int i = start+1; i <= n; i++) {
            for (int j = n; j <= end - 1; j++) {
                if(i != j){
                    count++;
                }
            }
        }

        bw.write(count+"");
        br.close();
        bw.close();
    }

}

고민의 시간과 해결방법

1. 주어진 집합이 있을 때, 구간을 구하고자 한다면 정렬을 하는 것이 가장 좋다.
2. 특정 수열처럼 주어진 대로만 해야하는 경우가 아니라서 오름차순 정렬을 해도 되기 때문에 입력된 배열을 오름차순 정렬해준다
3. 이제 좋은 구간을 찾기 위해 n과 비교를해준다. 그리고 시작지점과 끝지점을 찾기 위해 start와 end변수를 선언한다
4. 3가지 경우를 확인할 수 있다. n이 해당 배열의 값보다 작은경우, 큰경우, 같은 경우
5. 작은 경우에는 start의 범위를 축소할 수 있다. 만약 arr[i]가 n보다 작다면 start에 해당 arr[i]를 넣어주는데, 이때 범위를 좁히기 위해 arr[i]가 start보다 큰 경우에만 값을 start에 넣어준다
6. 큰 경우에는 end의 범위를 축소할 수 있다. 만약 arr[i]가 n보다 크다면 end에 해당 값을 넣어주는데, 이때 범위를 좁히기 위해 arr[i]가 end보다 작은 경우에만 해당 값을 end에 넣어준다
7. 만약 같은 경우에는 조건을 만족하지 않기 때문에 start, end, n모두 -1로 초기화하고 break해서 순회를 탈출한다
8. 이후 주어진 start와 end로 순회를 한다. start와 end는 각각 집합에 있는 수 이므로, start+1과 end-1로 순회의 시작과 종료를 진행한다.
9. 이중 포문으로 start부터 n까지 돌때, n부터 end-1까지 i와 j가 같아지는 경우를 제외하고서는 count를 증가시켜준다
10. 완성한 count가 정답이 된다.

문제링크:

1059번 - 좋은 구간

1251번 단어 나누기

해결코드:

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


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));
        String input = br.readLine();
        List<String> list = new ArrayList<>();
        for (int i = 1; i < input.length(); i++) {
            for (int j = i+1; j < input.length(); j++) {
                StringBuilder a = new StringBuilder(input.substring(0, i));
                StringBuilder b = new StringBuilder(input.substring(i, j));
                StringBuilder c = new StringBuilder(input.substring(j));
                StringBuilder tmp = new StringBuilder(a.reverse()).append(b.reverse()).append(c.reverse());
                list.add(tmp.toString());
            }
        }
        Collections.sort(list);

        bw.write(list.get(0));

        br.close();
        bw.close();
    }

}

고민의 시간과 해결방법

1. 처음 풀었던 문제는 이전 문제를 생각해서 3중 포문으로 풀었었다
2. 하지만 구간을 나누는 더 좋은 방법이 있다는 것을 알게 되었고 해당 방법을 익히고자 다시 풀게되었다
3. 이 문제는 구간을 3개로 나누면 되는 문제다. 구간을 3개로 나누기 위한 기준이 되는 포인트는 2개가 있으면 된다
4. 이것을 이중 포문을 이용해서 풀면된다. 바깥 포문은 1부터 시작하고 안쪽 포문은 i+1부터 시작한다
5. 구간은 다음과 같이 나누어서 StringBuilder에 넣는다. 0~i, i~j, j~끝
6. 그다음 tmp를 하나 만들어서 각각의 구간을 reverse한 값을 넣어준 뒤, 정렬을 위해 list에 넣어준다
7. 만들어진 모든 리스트 중 사전 순으로 가장 앞서는 것을 원하므로, 오름차순 정렬을 한 뒤 리스트의 제일 맨앞 값을 출력하면 정답이 된다

학습정리

1. 좋은 구간 문제도 그렇고 이 단어 나누기도 구간을 잘 나눠서 해결하는 문제였다. 완전탐색과 자료구조를 활용하는 문제가 실제 코딩테스트에 많이 나오니, 해당 문제들을 재풀이하면서 체득하도록 하자!
2. 주어진 문제를 잘 읽고 어떻게 구간을 나눌지를 생각하며, 정렬을 해야할 경우 리스트를 활용하는 것을 생각하자.
3. 문자열에서 뒤집기는 StringBuilder의 reverse를 생각하자!. 단 원본에서 reverse를 하면 복사되는 것이 아니라 원본의 값에 영향을 주므로 이점을 꼭 참고하자!

문제링크:

1251번 - 단어 나누기

2422번 한윤정이 이탈리아에 가서 아이스크림을 사먹는데

해결코드:

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


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 m = Integer.parseInt(st.nextToken());
        int[][] arr = new int[n+1][n+1];
        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            int first = Integer.parseInt(st.nextToken());
            int second = Integer.parseInt(st.nextToken());

            arr[first][second] = -1;
            arr[second][first] = -1;
        }

        int count = 0;
        for (int i = 1; i < n+1; i++) {
            for (int j = i+1; j < n+1; j++) {
                for (int k = j+1; k < n+1; k++) {
                    if(arr[i][j] == 0 && arr[j][k] ==0 && arr[i][k] == 0){
                        count++;
                    }
                }
            }
        }
        bw.write(count+"");

        br.close();
        bw.close();
    }

}

고민의 시간과 해결방법

1. 입력 수가 작아서 완탐으로 손쉽게 해결할 수 있다.
2. 주어진 입력값을 보고 양방향 트리처럼 배열을 선언해서 -1로 초기화하면 되겠다고 생각하였다.
3. 따라서 주어진 입력값을 배열의 인덱스로 하며, -1로 초기화한다. 이때 입력값이 오름차순으로 주어진다는 보장이 없으므로 거꾸로도 -1로 초기화해준다
4. 3중 포문으로 순회를 돌때, i/j, j/k, i/k가 0일때만 count를 증가시켜준다
5. 완성한 count를 출력하면 정답이 된다.

문제링크:

2422번 - 한윤정이 이탈리아에 가서 아이스크림을 사먹는데

2453번 기상청 인턴 신현수

해결코드:

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


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[] arr = new int[n];
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
            if(i!= 0){
                arr[i] += arr[i-1];
            }
        }
        int ans = arr[k-1];
        for (int i = k; i < n; i++) {
            ans = Math.max(ans, arr[i] - arr[i-k]);
        }

        bw.write(ans+"");

        br.close();
        bw.close();
    }

}

고민의 시간과 해결방법

1. 문제에서부터 누작합을 이야기하고 있다
2. 따라서 입력할 때, 그 배열의 값을 누적합으로 받아준다
3. 이어서 누적합 배열에서 특정 범위 중, 가장 큰 값을 찾고 싶으니 ans에 arr[k-1]를 넣어주고 k부터 n까지 순회를 돌면서 ans와 arr[i] - arr[i-k]중에 가장 큰 값을 넣어준다
4. 완성된 ans를 출력하면 정답이 된다.

문제링크:

2435번 - 기상청 인턴 신현수

2503번 숫자 야구

해결코드:

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


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));
        int n = Integer.parseInt(br.readLine());
        boolean[] arr = new boolean[1000];
        for (int i = 123; i < 988; i++) {
            String s = String.valueOf(i);
            if(s.charAt(0) == '0' || s.charAt(1) == '0' || s.charAt(2) == '0'){
                continue;
            }
            if(s.charAt(0) == s.charAt(1) || s.charAt(1) == s.charAt(2) || s.charAt(0) == s.charAt(2)){
                continue;
            }
            arr[i] = true;
        }

        for (int i = 0; i < n; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int num = Integer.parseInt(st.nextToken());
            int strike = Integer.parseInt(st.nextToken());
            int ball = Integer.parseInt(st.nextToken());
            for (int j = 123; j < 988; j++) {
                if(arr[j]){
                    int strikeCount = 0;
                    int ballCount = 0;
                    for (int k = 0; k < 3; k++) {
                        String s1 = String.valueOf(num);
                        for (int l = 0; l < 3; l++) {
                            String s2 = String.valueOf(j);
                            if(s1.charAt(k) == s2.charAt(l) && k == l){
                                strikeCount++;
                            }
                            if(s1.charAt(k) == s2.charAt(l) && k!=l){
                                ballCount++;
                            }
                        }
                    }

                    if(strike == strikeCount && ball == ballCount){
                        arr[j] = true;
                    }else{
                        arr[j] = false;
                    }
                }
            }

        }

        int ans = 0;
        for (int i = 123; i < 988; i++) {
            if(arr[i]){
                ans++;
            }
        }
        bw.write(ans+"");


        br.close();
        bw.close();
    }

}

고민의 시간과 해결방법

1. 유명한 숫자 야구 문제를 풀어볼 수 있는 좋은 시간이었다.
2. 먼저 숫자 야구의 수로 될 수 있는 경우는 123 ~ 987까지이다. 대략 1000이하의 수로만 가능하니 배열은 1000으로 설정하였다
3. 이제 123~987중에서 가능성이 아예 없는 숫자는 건너뛰고 가능성이 있는 경우는 true로 설정하자
4. 각 자리수가 0이거나, 각 자리수의 중복이 있는 경우 가능성이 아에 없다. 따라서 그경우는 continue하고 해당 조건을 모두 통과한 경우 true로 선언하자
5. 이제 n만큼 입력을 받아서 각 숫자, 스트라이크 수, 볼 수를 변수에 저장한다.
6. 이제 123~987까지의 범위에서 해당하는 숫자를 탐색하기 위해 순회를 한다.
7. 각 숫자를 문자로 바꿔서 자릿수를 비교해준다. 이때 3*3의 이중 포문을 추가로 돌아서 비교한다
8. 스트라이크와 볼을 세어줄 임시변수의 값을 비교하면서 증가시켜준다. 만약 자릿수랑 문자가 모두 같으면 스트라이크, 자릿수가 다르고 문자가 같다면 볼을 증가시킨다
9. 이후 입력받은 스트라이크 볼과 세어준 스트라이크 볼이 같으면 해당 배열의 숫자는 true, 아니면 false로 지정한다
10. 순회 종료후, 다시 123~987까지의 범위를 순회해서 true인 경우 ans를 증가시킨다
11. 완성한 ans를 출력하면 정답이 된다.

문제링크:

2503번 - 숫자 야구

2635번 수 이어가기

해결코드:

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


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));
        int input = Integer.parseInt(br.readLine());
        List<Integer> list = new ArrayList<>();
        int count = 0;
        for (int i = 1; i < input; i++) {
            List<Integer> tmp = new ArrayList<>();
            int first = input;
            int second = i;
            tmp.add(first);
            tmp.add(second);

            while(true){
                int third = first - second;
                if(third >= 0){
                    tmp.add(third);
                }else{
                    break;
                }

                first = second;
                second = third;
            }

            if(count < tmp.size()){
                count = tmp.size();
                list = tmp;
            }
        }

        bw.write(list.size()+"\n");
        for (int i = 0; i < list.size(); i++) {
            bw.write(list.get(i) + " ");
        }


        br.close();
        bw.close();
    }

}

고민의 시간과 해결방법

1. 정답을 담을 리스트와, 순회를 하면서 담아둘 리스트를 비교하는 문제이다
2. 1부터 input까지 모든 수를 비교하면서 정답이 될 리스트를 찬든다
3. 첫번째와 두번째값은 미리 저장해둔다
4. 이후 third는 first - second값으로 저장한다
5. 만약 third가 0보다 크면 계속 이어나간다. 그리고 third를 임시 리스트에 저장한다
6. third가 0보다 작으면 while문을 종료한다
7. 6번이 아닌 경우 first는 second로, second는 third로 값을 갱신한다
8. 이후 count가 tmp.size()보다 작으면 count를 tmp.size()로 갱신하고 정답리스트도 해당 리스트로 변경한다
9. 이후 정답 리스트의 크기와 그 원소값들을 출력하면 정답이 된다.

문제링크:

2635번 - 수 이어가기

5568번 카드 놓기

해결코드:

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


public class Main {


    static boolean[] visited;
    static Set<String> set = new HashSet<>();
    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 k = Integer.parseInt(br.readLine());
        visited = new boolean[100];
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }

        backtracking(arr, 0, k, "");
        bw.write(set.size()+"");

        br.close();
        bw.close();
    }

    private static void backtracking(int[] arr, int depth, int k, String s) {
        if(depth == k){
            set.add(s);
            return;
        }

        for (int i = 0; i < arr.length; i++) {
            if(!visited[i]){
               visited[i] = true;
               backtracking(arr, depth+1, k, s + String.valueOf(arr[i]));
               visited[i] = false;
            }
        }
    }

}

고민의 시간과 해결방법

1. 입력값이 작으면서, 조합의 모든 경우의 수를 구하는 문제이다. 해당 유형의 문제는 가장 먼저백트래킹을 떠올려보면 된다
2. 해당 문제는 모든 경우의 수를 다 구한다음, 중복되는 경우는 제거해주면된다. 이를 위해 Set을 사용하였다
3. 문자열은 백트래킹의 파라미터에 누적해서 완성해나가는 방법으로 구현하였다.
4. visited 배열을 만들어서 만약 이미 사용한 숫자라면 해당 숫자를 중복해서 사용하지 않도록 하였다
5. base condition에 도달했을 때, set에 해당 문자를 넣어준다.
6. 완성한 set의 크기를 출력하면 정답이 된다.

문제링크:

5568번 - 카드 놓기

1065번 한수

해결코드:

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


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));
        int n = Integer.parseInt(br.readLine());
        int count = 0;
        if(n < 100){
            count = n;
        }else{
            count = 99;
            for (int i = 100; i <= n; i++) {
                int first = i/100;
                int second = (i/10) % 10;
                int third = i%10;

                if(first - second == second - third){
                    count++;
                }
            }
        }


        bw.write(count+"");

        br.close();
        bw.close();
    }

}

고민의 시간과 해결방법

1. 입력값이 1000미만이고, 100미만인 경우 모두 한수라른 수학적인 사고로 푸는 문제였다
2. 100미만이면 count에 해당 수를 넣어주고 출력한다
3. 만약 100이상이면 100미만의 수는 다 한수이므로 count에 99를 넣어준다
4. 이후 100부터 n까지 순회를 하는데 각 자리수를 변수에 가져와서 fisrt - second와 second -third가 같으면 count를 증가시킨다
5. 완성한 count를 출력하면 정답이 된다

추가 고민

만약 n이 4자리나 5자리 이상이 된다면?
1. 그럴때는 해당 수의 첫자리와 둘째자리를 미리 구한 다음에 다시 둘째자리부터 해당 숫자의 길이만큼 포문을 돌아 각 자리수의 차이를 비교할 것 같다
2. 만약 미리 구해둔 차이와 같지 않은 경우 break해주고 count를 증가시키지 않는다.
3. 만약 순회를 모두 통과한다면 count를 증가시키며 이때 boolean isOk를 이용할 것 같다.

문제링크:

1065번 - 한수

1120번 문자열

해결코드:

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



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());
        String a = st.nextToken();
        String b = st.nextToken();
        int count = a.length();
        for (int i = 0; i < b.length() - a.length() + 1; i++) {
            int tmp = 0;
            for (int j = 0; j < a.length(); j++) {
                if(a.charAt(j) != b.charAt(j+i)){
                    tmp++;
                }
            }
            count = Math.min(tmp, count);
        }
        bw.write(count+"");

        br.close();
        bw.close();
    }

}

고민의 시간과 해결방법

1. 앞이랑 뒤에 문자를 추가할 수 있으니까, 현재 A와 B만을 가지고 그 차이가 가장 작은 경우만 구하면 된다
2. 그러기 위해서 B의 어느 위치에서 A를 놓고 비교했을 때 차이가 작을까를 생각해주면 된다
3. 따라서 이중포문으로 찾아준다. 만약 다른 경우 임시변수 tmp 값을 증가시키고, count와 비교해서 작은 값을 count에 넣어준다
4. count는 A의 길이로 미리 초기화해준다. 최악의 경우가 A와 길이가 같은 경우이기 때문이다
5. 완성한 count를 출력한다.

문제링크:

1120번 - 문자열

2607번 비슷한 단어

해결코드:

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


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

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

        String input = br.readLine();
        int[] alpha = new int[26];
        for (int i = 0; i < input.length(); i++) {
            alpha[input.charAt(i) - 'A']++;
        }

        int count = 0;
        for (int i = 0; i < n-1; i++) {
            String s = br.readLine();
            int[] tmp = alpha.clone();
            int same = 0;
            for (int j = 0; j < s.length(); j++) {
                if(tmp[s.charAt(j) - 'A'] > 0){
                    same++;
                    tmp[s.charAt(j)- 'A']--;
                }
            }
            if(s.length() == input.length()-1){
                if(same == s.length()){
                    count++;
                }
            }else if (s.length() == input.length()){
                if(same == input.length() || same== input.length()-1){
                    count++;
                }
            }else if (s.length() == input.length()+1){
                if(same == input.length()){
                    count++;
                }
            }
        }

        bw.write(count+"");
        br.close();
        bw.close();
    }

}

고민의 시간과 해결방법

1. Map을 쓸까 고민하다가 활용하기 애매해서 알파벳 배열을 이용하여 해결하였다
2. 먼저 기준이 되는 문자열의 문자 알파벳을 확인해서 그 위치의 값을 증가시킨다
3. 이제 입력값들을 비교해야하는데, 알파벳 배열은 기준이 되어야 하므로, clone해서 임시 배열에 저장한다
4. 이제 입력값의 문자를 비교한다. 만약 해당 문자 알파벳의 임시배열의 값이 0보다 크면 해당 배열의 값을 감소시키고 같은 문자의 수를 확인하는 same의 값을 증가시킨다
5. 순회 종료 후 3가지 경우로 나눠서 구분한다
6. 먼저 입력 문자가 기준문자열보다 1이 작은 경우 same과 입력문자열이 같아야 비슷한 단어이다. 이때 입력 문자에 하나의 문자를 더하면 되기 때문이다
7. 만약 같은 경우 same이 기준문자열과 같거나 기준 문자열보다 작은 경우 모두 비슷한 단어이다
   이때 그냥 그대로 거나 아니면 하나를 빼면 되기 때문이다
8. 만약 입력 문자가 하나 더 많은 경우 same이 기준 문자열과 같으면 된다. 입력 문자의 문자를 하나 빼면 되기 때문이다
9. 각 조건에 맞을 때마다 count를 증가시키고 이렇게 완성한 count를 출력하면 정답이 된다.

문제링크:

2607번 - 비슷한 단어