밤이 블로그

BOJ#1003 피보나치 함수

밤이2209 — Mon, 28 May 2018 01:11:20 +0900

* 문제

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

* 풀이

https://github.com/stack07142/BOJ/blob/master/BOJ%231003_FibonacciCount/src/Main.kt

var dp = Array(41) {
    Node()
}

fun main(args: Array<String>) {
    var T = readLine()!!.toInt()

    while (T-- > 0) {
        val N = readLine()!!.toInt()
        fibonacci(N)
        println("${dp[N].count0} ${dp[N].count1}")
    }
}

fun fibonacci(n: Int): Node {
    if (dp[n].num != -1) {
        return dp[n]
    }
    when (n) {
        0 -> {
            dp[n].num = 0
            dp[n].count0++
        }
        1 -> {
            dp[n].num = 1
            dp[n].count1++
        }
        else -> {
            dp[n] = fibonacci(n - 1) + fibonacci(n - 2)
        }
    }

    return dp[n]
}

class Node(var num: Int = -1, var count0: Int = 0, var count1: Int = 0) {
    operator fun plus(value: Node): Node {
        return Node(num + value.num, count0 + value.count0, count1 + value.count1)
    }
}

BOJ#5670 휴대폰 자판

밤이2209 — Sun, 26 Nov 2017 15:20:31 +0900

BOJ#5670 휴대폰 자판

* 문제

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

* 풀이

카카오 블라인드 채용 - 3차 코딩테스트 5번 문제와 유사합니다.

Trie를 사용하여 풀어보았습니다.

1. 모든 문자열을 Trie에 저장한 후

2. child의 개수가 2 이상인 경우, terminal 노드인데 child가 존재하는 경우를 카운트하였습니다.

부족한 점이 있으면 댓글로 알려주세요. 감사합니다.

* 나의 코드

https://github.com/stack07142/BOJ/blob/a3f55a12084c8b798e96dd86eedbdc8661595777/BOJ%235670/src/Main.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    static final int SIZE = 26;
    static int cnt = 0;

    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String line;
        while ((line = br.readLine()) != null) {

            Trie trie = new Trie();

            int N = Integer.parseInt(line);

            String[] str = new String[N];

            for (int i = 0; i < N; i++) {

                str[i] = br.readLine();
                trie.insert(str[i]);
            }

            for (int i = 0; i < SIZE; i++) {

                if (trie.root.children[i] != null) {

                    trie.check(trie.root.children[i], 1);
                }
            }

            System.out.printf("%.2f", (double) cnt / N);
            System.out.println();

            cnt = 0;
        }


    }
}

class Trie {

    TrieNode root;

    Trie() {

        root = new TrieNode();
    }

    private int toNumber(char c) {

        return c - 'a';
    }

    void insert(String key) {

        int length = key.length();
        TrieNode currentNode = root;

        for (int i = 0; i < length; i++) {

            int next = toNumber(key.charAt(i));

            if (currentNode.children[next] == null) {

                currentNode.children[next] = new TrieNode();
                currentNode.nChild++;
            }


            currentNode = currentNode.children[next];
        }

        currentNode.isTerminal = true;
    }

    void check(TrieNode node, int ret) {

        if (node.isTerminal) {

            Main.cnt += ret;
        }

        if (node.nChild >= 2) {

            ret++;
        }

        if (node.isTerminal && node.nChild == 1) {

            ret++;
        }

        for (int i = 0; i < Main.SIZE; i++) {

            if (node.children[i] != null) {

                check(node.children[i], ret);
            }
        }

    }
}

class TrieNode {

    TrieNode[] children = new TrieNode[Main.SIZE];
    boolean isTerminal;

    int nChild = 0;

    TrieNode() {

        isTerminal = false;

        for (int i = 0; i < Main.SIZE; i++) {

            children[i] = null;
        }
    }
}

BOJ#5052 전화번호 목록

밤이2209 — Sat, 25 Nov 2017 16:32:22 +0900

BOJ#5052 전화번호 목록

* 문제

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

* 풀이

저는 이 문제를 Trie를 이용해서 풀어보았습니다.

Trie를 처음 공부하고 풀어보는 것이라서 부족한점이 있을 것 같습니다. 댓글로 알려주시면 감사하겠습니다.

1. 일단 전화번호 목록을 배열에 저장한 후 정렬을 진행합니다.

2. Trie 자료구조에 Insert합니다.

3. 이 과정에서 terminal 노드인데 children이 추가되는 경우 '일관성 있지 않은' 목록으로 판단합니다.

* 나의 코드

https://github.com/stack07142/BOJ/blob/master/BOJ%235052/src/Main.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {

    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        while (T-- > 0) {

            int n = Integer.parseInt(br.readLine());
            String[] num = new String[n];

            Trie trie = new Trie();
            boolean ret = true;

            for (int i = 0; i < n; i++) {

                num[i] = br.readLine();
            }

            Arrays.sort(num);

            for (int i = 0; i < n; i++) {

                if (!trie.insert(num[i])) {

                    ret = false;
                    break;
                }
            }

            System.out.println(ret ? "YES" : "NO");
        } // ~ test case loop
    }
}

class Trie {

    private TrieNode root;

    Trie() {

        root = new TrieNode();
    }

    private int toNumber(char c) {

        return c - '0';
    }

    boolean insert(String key) {

        TrieNode currentNode = root;
        int length = key.length();

        for (int i = 0; i < length; i++) {

            char c = key.charAt(i);
            int next = toNumber(c);

            if (currentNode.children[next] == null) {

                currentNode.children[next] = new TrieNode();
            }

            currentNode = currentNode.children[next];

            if (currentNode.isTerminal && i + 1 < length) {

                return false;
            }
        }

        currentNode.isTerminal = true;

        return true;
    }
}

class TrieNode {

    TrieNode[] children = new TrieNode[10];
    boolean isTerminal;

    TrieNode() {

        isTerminal = false;

        for (int i = 0; i < 10; i++) {

            children[i] = null;
        }
    }
}

BOJ#11049 행렬 곱셈 순서

밤이2209 — Fri, 27 Oct 2017 15:04:24 +0900

BOJ#11049 행렬 곱셈 순서

* 문제

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

* 풀이

비슷한 문제 : 파일 합치기 https://www.acmicpc.net/problem/11066

행렬은 결합법칙이 성립합니다. (AB)C = A(BC)

그러나 순서에 따라 곱셈 횟수는 달라집니다.

문제 풀이 방식은 파일 합치기 문제와 동일합니다.

dp[start][end] = min(dp[start][end], dp[start][k] + dp[k+1][j] + (d_start * d_k+1 * d_end+1)), i <= k < end

위 예제에서

d_0 = 5

d_1 = 3

d_2 = 2

d_3 = 6

* 나의 코드

https://github.com/stack07142/BOJ/blob/e764b2d7fe041a5d170673f99cc6d4d2ba338157/BOJ%2311049/src/Main.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {

    static int N;
    static int[] D = new int[501];
    static int[][] dp = new int[501][501];

    static final int MAX_VALUE = Integer.MAX_VALUE;

    public static void main(String[] args) throws IOException {

        // Input
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        N = Integer.parseInt(br.readLine());

        for (int i = 0; i < N; i++) {

            StringTokenizer st = new StringTokenizer(br.readLine());

            D[i] = Integer.parseInt(st.nextToken());
            D[i + 1] = Integer.parseInt(st.nextToken());

            Arrays.fill(dp[i], MAX_VALUE);
        }

        // Solve

        System.out.println(solve(0, N - 1));

    }

    static int solve(int start, int end) {

        if (start == end) return 0;

        if (dp[start][end] != MAX_VALUE) return dp[start][end];

        for (int i = start; i < end; i++) {

            dp[start][end] = Math.min(dp[start][end], solve(start, i) + solve(i + 1, end) + D[start] * D[i + 1] * D[end + 1]);
        }

        return dp[start][end];
    }
}

BOJ#1509 팰린드롬 분할

밤이2209 — Fri, 27 Oct 2017 01:06:56 +0900

BOJ#1509 팰린드롬 분할

* 문제

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

* 풀이

- Manacher 알고리즘을 통해 임의의 범위의 문자열이 팰린드롬인지 구한다.

- dp[i] : 0 ~ i 범위의 문자열을 팰린드롬 분할할 때 최소 분할 수

j ~ i 범위 문자열이 팰린드롬일 때, dp[i] = min(dp[i], dp[j-1] + 1)

(여기서 j는 0 부터 i 까지)

dp[0] = 1이고 -> dp[1] -> dp[2] -> ... -> dp[N-1]을 차례대로 구한다

* 나의 코드

https://github.com/stack07142/BOJ/blob/d4b527b666ba54f7f53c1128f5a1523cb261d2b9/BOJ%231509/src/Main.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {

        // Input
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String input = br.readLine();

        int N = input.length() * 2 - 1;

        char[] S = new char[N];

        int idx = 0;
        for (int i = 0; i < N; i += 2) {

            S[i] = input.charAt(idx++);
        }

        int[] A = new int[N];

        // Solve

        int[] dp = new int[N];

        dp[0] = 1;

        manacher(S, A, N);

        for (int i = 2; i < N; i += 2) {

            dp[i] = N;
            for (int j = 0; j <= i; j += 2) {

                int center = (i + j) / 2;
                int radius = (i - j) / 2;

                if (A[center] >= radius) {

                    dp[i] = Math.min(dp[i], j - 1 >= 0 ? dp[j - 2] + 1 : 1);
                }
            }
        }

        System.out.println(dp[N - 1]);
    }

    static void manacher(char[] S, int[] A, int N) {

        int R = -1;
        int p = -1;

        for (int i = 0; i < N; i++) {

            // A[i]의 초기값 설정
            if (R < i) A[i] = 0;
            else A[i] = Math.min(R - i, A[2 * p - i]);

            // i를 기준으로 양 옆으로 범위를 넓혀가면서 검사
            while ((i - A[i] - 1 >= 0) && (i + A[i] + 1 < N)
                    && (S[i - A[i] - 1] == S[i + A[i] + 1])) {

                A[i]++;
            }

            // R과 p를 갱신
            if (i + A[i] > R) {

                R = i + A[i];
                p = i;
            }
        }
    }
}

BOJ#13706 제곱근

밤이2209 — Thu, 26 Oct 2017 19:26:29 +0900

BOJ#13706 제곱근

* 문제

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

* 풀이

이분 탐색, BigInteger 사용

* 나의 코드

https://github.com/stack07142/BOJ/blob/bcbfa3899c5c3acae75e515c8642eddcb3a9067e/BOJ%2313706/src/Main.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class Main {

    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String num = br.readLine();

        sqrt(num);
    }

    static void sqrt(String num) {

        BigInteger one = BigInteger.ONE;
        BigInteger two = new BigInteger("2");

        BigInteger target = new BigInteger(num);

        BigInteger left = BigInteger.ONE;
        BigInteger right = new BigInteger(num);

        BigInteger mid, x;

        while (left.compareTo(right) <= 0) {

            mid = (left.add(right)).divide(two);
            x = mid.multiply(mid);

            int ret = x.compareTo(target);
            if (ret == 0) {

                System.out.println(mid.toString());
                break;
            } else if (ret == -1) {

                left = mid.add(one);
            } else if (ret == 1) {

                right = mid.subtract(one);
            }
        }
    }
}

BOJ#3019 테트리스

밤이2209 — Wed, 18 Oct 2017 17:15:14 +0900

BOJ#3019 테트리스

* 문제

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

* 풀이

- 게임 규칙 : 블럭이 떨어졌을 때, 블럭과 바닥 사이에 채워져있지 않은 칸이 생기면 안된다.

- 풀이 방법 : 바닥 높이가 주어지고 블럭의 높이도 알 수 있으므로, 두 정보를 이용하면 빈 칸이 생기는지 알 수 있다.

평평한 바닥에 블럭을 놓았을 때 다음과 같이 블럭의 높이를 표현할 수 있습니다.

ㅗ -> "000"

ㅓ -> "10"

ㅏ -> "01"

ㅜ -> "101"

두 가지 경우를 그려보았습니다.

블럭 : "10"

블럭이 높이 1인 바닥에 놓여졌으므로 "10" -> "21"

블럭과 바닥 사이에 빈 칸이 있는가? = 각 col에 대해 블럭과 바닥 높이의 차이가 일정한지 검사

2 - 1 != 1 - 1

∴ FALSE

블럭 : "10"

블럭이 높이 1인 바닥에 놓여졌으므로 "10" -> "21"

블럭과 바닥 사이에 빈 칸이 있는가? = 각 col에 대해 블럭과 바닥 높이의 차이가 일정한지 검사

2 - 2 == 1 - 1

∴ TRUE

* 나의 코드

https://github.com/stack07142/BOJ/blob/e04833b62ad3a75946b454f5fc10c95cbdde2a85/BOJ%233019/src/Main.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    static int C, P;
    static int[] height = new int[101];

    public static void main(String[] args) throws IOException {

        // Input
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        C = Integer.parseInt(st.nextToken());
        P = Integer.parseInt(st.nextToken());

        st = new StringTokenizer(br.readLine());

        for (int i = 0; i < C; i++) {

            height[i] = Integer.parseInt(st.nextToken());
        }

        // Solve

        int ret = 0;
        switch (P) {

            case 1:
                ret = check("0") + check("0000");
                break;

            case 2:
                ret = check("00");
                break;

            case 3:
                ret = check("001") + check("10");
                break;

            case 4:
                ret = check("100") + check("01");
                break;

            case 5:
                ret = check("000") + check("01") + check("101") + check("10");
                break;

            case 6:
                ret = check("000") + check("00") + check("011") + check("20");
                break;

            case 7:
                ret = check("000") + check("00") + check("110") + check("02");
                break;
        }

        System.out.println(ret);
    }

    static int check(String S) {

        char[] tetrisHeight = S.toCharArray();
        int n = tetrisHeight.length;

        int ret = 0;
        for (int col = 0; col <= C - n; col++) {

            // col 위치에 따라 테트리스 높이에 basisColHeight가 일정하게 추가되어야 하는데,
            // 테트리스 높이와 각 칸과의 차이가 일정한지만 검사하면 되므로 생략한다
            /*

            for (int i = 0; i < n; i++) {

                tetrisHeight[i] += basisColHeight;
            }
            */

            boolean ok = true;
            int diff = tetrisHeight[0] - height[col];

            // 테트리스와 각 칸 사이에 공백이 있는지 확인( = 테트리스와 각 칸의 diff가 일정한지 확인)
            for (int j = 0; j < n; j++) {

                if (tetrisHeight[j] - height[col + j] != diff) ok = false;
            }

            if (ok) ret++;
        }

        return ret;
    }
}

BOJ#4920 테트리스 게임

밤이2209 — Tue, 17 Oct 2017 16:33:56 +0900

BOJ#4920 테트리스 게임

* 문제

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

이전에 풀어봤던 14500번 테트로미노(삼성 기출)와 비슷한 문제입니다.

* 풀이

14500번의 경우 (ㅓ, ㅏ, ㅗ, ㅜ)를 제외하고 다른 모양은 전부 dfs로 탐색이 가능했지만,

4920번의 경우 위 경우 이외에도 dfs로 탐색이 불가능한 경우가 있습니다. (예 : ㄱ 등등)

따라서 dfs 탐색을 사용하지 않고 패턴을 미리 정해놓은 후 매칭시키는 방법으로 시뮬레이션 하였습니다.

* 나의 코드

https://github.com/stack07142/BOJ/blob/f0d9bf85e203ff075cbf53506fb38d625f5115a3/BOJ%234920/src/Main.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    static final int[] dRow = { 0, -1, 0, 1 };
    static final int[] dCol = { -1, 0, 1, 0 };

    static final int[][] patternRow = {
            { 1, 1, 1 }, { 0, 0, 0 },
            { 0, 1, 0 }, { 1, 0, 1 },
            { 0, 0, 1 }, { 1, 1, 0 }, { 0, 0, -1 }, { -1, -1, 0 },
            { 0, 1, 0}
    };
    static final int[][] patternCol = {
            { 0, 0, 0 }, { 1, 1, 1 },
            { 1, 0, 1 }, { 0, -1, 0 },
            { 1, 1, 0 }, { 0, 0, -1 }, {-1, -1, 0 }, { 0, 0, 1 },
            { 1, 0, -1}
    };

    static int N;
    static int[][] map = new int[101][101];
    static int maxSum = Integer.MIN_VALUE;

    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int idx = 0;
        while (true) {

            idx++;
            maxSum = Integer.MIN_VALUE;

            // Input
            N = Integer.parseInt(br.readLine().trim());

            if (N == 0) break;

            for (int i = 0; i < N; i++) {

                String inputLine = br.readLine().trim();
                String[] line = inputLine.split("\\p{Blank}+");
                for (int j = 0; j < N; j++) {

                    map[i][j] = Integer.parseInt(line[j]);
                }
            }

            // Solve
            for (int row = 0; row < N; row++) {
                for (int col = 0; col < N; col++) {

                    // Pattern1
                    solve1(row, col);

                    // Pattern2 (+)
                    solve2(row, col);
                }
            }

            System.out.println(idx + ". " + maxSum);
        } // ~ test case loop
    } // ~ main

    static void solve1(int row, int col) {

        for (int i = 0; i < 9; i++) {

            int sum = map[row][col];
            boolean isMatchPattern = true;

            int nextRow = row;
            int nextCol = col;

            for (int j = 0; j < 3; j++) {

                nextRow += patternRow[i][j];
                nextCol += patternCol[i][j];

                if (nextRow < 0 || nextCol < 0 || nextRow >= N || nextCol >= N) {

                    isMatchPattern = false;
                    break;
                }

                sum += map[nextRow][nextCol];
            }

            if (isMatchPattern) {

                maxSum = maxSum < sum ? sum : maxSum;
            }
        }
    }

    static void solve2(int row, int col) {

        int nInvalidity = 0;
        int minValue = Integer.MAX_VALUE;
        int crossSum = map[row][col];

        for (int i = 0; i < 4; i++) {

            int nextRow = row + dRow[i];
            int nextCol = col + dCol[i];

            if (nextRow < 0 || nextCol < 0 || nextRow >= N || nextCol >= N) {

                nInvalidity++;
                continue;
            }

            crossSum += map[nextRow][nextCol];
            minValue = minValue > map[nextRow][nextCol] ? map[nextRow][nextCol] : minValue;
        }

        switch (nInvalidity) {

            case 0:

                crossSum -= minValue;
            case 1:
                maxSum = maxSum < crossSum ? crossSum : maxSum;
                break;

            case 2:
            case 3:
                break;
        }

    }
}

BOJ#1300 K번째 수

밤이2209 — Tue, 17 Oct 2017 14:15:44 +0900

BOJ#1300 K번째 수

* 문제

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

* 풀이

- N이 10^5일 때, N*N은 10,000,000,000 이므로 시뮬레이션하여 답을 구하는 것은 시간 내에 불가능합니다.

- 문제를 해결하기 위한 아이디어는 다음과 같습니다.

1. 어떤 수 x가 있을 때, x-1 이하의 수의 개수가 K개 미만이고 x 이하의 수의 개수가 K개 이상인 경우

우리가 찾는 K번째 수는 x 이다.

2. 즉, x는 x 이하의 수의 개수가 K개 이상이면서 가장 작은 수이다.

3. 위 조건을 만족하는 x를 이분 탐색을 통해 찾는다.

그러면 x까지 수의 개수는 어떻게 찾을 수 있을까요?

- N이 4일 때

1 2 3 4

2 4 6 8

3 6 8 12

4 8 12 16

i번째 행은 i의 배수임을 알 수 있습니다.

즉, 각 행에서 x이하의 수의 개수는 min(x/i, N)

추가적으로 고려해야할 점

- N이 최대 10^5 이므로 N*N에서 int 범위를 넘어가게 됩니다.

- K가 10^9 이하이므로 이분 탐색에서 right 범위를 좁힐 수 있습니다.

* 나의 코드

https://github.com/stack07142/BOJ/blob/3d1262e7a2aa6b2a715ad8f4a9be56cc9bb50c14/BOJ%231300/src/Main.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {

        // Input
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int N = Integer.parseInt(br.readLine());
        int K = Integer.parseInt(br.readLine());

        // Solve
        // x를 이분 탐색을 통해 찾는다
        // x : x까지의 수가 k개 이상인 가장 작은 수

        int left = 1;
        int right = (int) Math.min((long) N * N, (long) 1000000000);
        int mid;
        int ans = 0;

        while (left <= right) {

            mid = (left + right) / 2;

            int cnt = getCnt(mid, N);

            if (cnt >= K) {

                ans = mid;
                right = mid - 1;
            } else {

                left = mid + 1;
            }
        }

        System.out.println(ans);
    }

    static int getCnt(int x, int N) {

        int cnt = 0;

        for (int i = 1; i <= N; i++) {

            cnt += Math.min(x / i, N);
        }

        return cnt;
    }
}

BOJ#3653 영화 수집

밤이2209 — Wed, 11 Oct 2017 02:39:36 +0900

BOJ#3653 영화 수집

* 문제

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

* 풀이

저는 팬윅 트리를 완전히 마스터하지 못해서

이 문제를 세그먼트 트리를 이용해서 풀었습니다.

따라서 코드가 상당히 길고 최적화된 솔루션이 아닙니다.

다음에 기회가 되면 팬윅 트리를 이용해서 다시 풀어보도록 하겠습니다.

3 3
3 1 1

답 : 2 1 0

위 예제를 보면

일단 최초에는 아래와 같이 영화가 쌓여 있을 것입니다.

[1번 영화, 2번 영화, 3번 영화]

문제를 쉽게 풀기 위해서 위 배열을 다음과 같이 변형해봅시다.

사이즈를 n에서 n+m으로 늘렸습니다.

[0, 0, 0, 1, 2, 3]

1) 3번 영화를 꺼낼 때, 앞에 영화 2개가 쌓여있다

[0, 0, 0, 1, 2, 3] -> [0, 0, 3, 1, 2, 0]

2) 1번 영화를 꺼낼 때, 앞에 영화 1개가 쌓여있다

[0, 0, 3, 1, 2, 0] -> [0, 1, 3, 0, 2, 0]

3) 다시 1번 영화를 꺼낼 때, 앞에 영화 0개가 쌓여있다

[0, 1, 3, 0, 2, 0] -> [1, 0, 3, 0, 2, 0]

답 : 2 1 0

우리가 원하는 것은 i번 영화를 꺼낼 때 위에 쌓여있는 영화의 개수이고

위에서 볼 수 있듯이 쉽게 답을 구할 수 있습니다.

즉, query 구간 내에 영화가 몇개 있는지 빠르게 알아내는 것이 핵심이고 이를 위해 세그먼트 트리를 사용하였습니다.

* 나의 코드

https://github.com/stack07142/BOJ/blob/ca353312888b2d1aa920ca8e13093ed9e5b83c1d/BOJ%233653/src/Main.java

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

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

        while (T-- > 0) {

            // Input
            StringTokenizer st = new StringTokenizer(br.readLine());

            int n = Integer.parseInt(st.nextToken()); // 가지고 있는 영화 수
            int m = Integer.parseInt(st.nextToken()); // 보려고 하는 영화 수

            int[] movieStack = new int[n + m];
            int[] moviePosInStack = new int[n + 1];

            for (int i = 1; i <= n; i++) {

                moviePosInStack[i] = m + i - 1;
                movieStack[m + i - 1] = 1;
            }

            SegmentTree segmentTree = new SegmentTree(movieStack, n + m);

            st = new StringTokenizer(br.readLine());

            // m개의 Query
            for (int i = 0; i < m; i++) {

                int selectedMovie = Integer.parseInt(st.nextToken());

                // Query
                bw.write(segmentTree.query(0, moviePosInStack[selectedMovie] - 1, 1, 0, n + m - 1) + " ");

                // Update
                segmentTree.update(moviePosInStack[selectedMovie], 0, 1, 0, n + m - 1);
                moviePosInStack[selectedMovie] = (m - 1) - i;
                segmentTree.update(moviePosInStack[selectedMovie], 1, 1, 0, n + m - 1);
            }

            bw.write("\n");

        } // ~test case loop

        bw.flush();

        bw.close();
        br.close();
    } // ~main
}

// 세그먼트 트리 : 구간 내 영화 개수
class SegmentTree {

    int[] segmentArr;

    SegmentTree(int[] arr, int N) {

        int x = (int) Math.ceil(Math.log(N) / Math.log(2));

        int size = (int) Math.pow(2, x) * 2;

        segmentArr = new int[size];

        init(arr, 0, N - 1, 1);
    }

    int init(int[] arr, int left, int right, int node) {

        if (left == right) {

            if (arr[left] != 0) {
                return segmentArr[node] = 1;
            } else return segmentArr[node] = 0;
        }

        int mid = (left + right) / 2;

        return segmentArr[node] = init(arr, left, mid, node * 2) + init(arr, mid + 1, right, node * 2 + 1);
    }

    int query(int left, int right, int node, int nodeLeft, int nodeRight) {

        // 두 구간이 겹치지 않는 경우
        if (left > nodeRight || right < nodeLeft) return 0;

        // 노드 구간이 완전히 속하는 경우
        if (left <= nodeLeft && right >= nodeRight) return segmentArr[node];

        // 그 외의 경우
        int nodeMid = (nodeLeft + nodeRight) / 2;

        return segmentArr[node] = query(left, right, node * 2, nodeLeft, nodeMid) + query(left, right, node * 2 + 1, nodeMid + 1, nodeRight);
    }

    int update(int index, int newValue, int node, int nodeLeft, int nodeRight) {

        // 노드 구간에 포함되지 않는 경우
        if (index < nodeLeft || index > nodeRight) return segmentArr[node];

        // 노드 구간에 포함되는 경우
        // Leaf 노드인 경우
        if (nodeLeft == nodeRight) return segmentArr[node] = newValue;

        // Leaf 노드가 아닌 경우
        int nodeMid = (nodeLeft + nodeRight) / 2;

        return segmentArr[node] = update(index, newValue, node * 2, nodeLeft, nodeMid) + update(index, newValue, node * 2 + 1, nodeMid + 1, nodeRight);
    }
}