I used to think that way too. I used to be in a rush to do LeetCode since I had interviews coming up and was very busy with school. I decided to try and prepare better since I am graduating in May 2021. I started doing at least 5 Leetcode problems a day since June. I try to do 10 on weekends. I know these numbers sound high, but I really don't want to fuck up again so I'm doing everything I can to get better.

Since I have much more time to prepare and don't feel rushed, I try to take my time solving the problems and looking at solutions. What I found is that the biggest skill you develop with Leetcode is problem solving. I see a lot of people on Reddit say that LeetCode only tests your data structures and algorithms knowledge, which is 100% false. In fact, knowing DS&A is the easy part of LeetCode. Once you know how they are implemented and their runtimes, you know DS&A. The difficulty of LeetCode is applying data structures to problems and solving them. Having a good explanation for solutions is very important, but understanding solutions is not what matters. What actually matters is practicing problem solving. I used to give up quite quickly on problems and then just try to understand solutions, which is a terrible approach. While I did remember a lot of solutions, I couldn't solve new problems for shit.

Once I really started practicing trying to solve problems I became a lot better at Leetcode. Understanding solutions is only one part of the equation, you first need to solve problems.

*Edit: I just wanted to add on to what I said about LeetCode not testing your DS&A knowledge whatsoever. Before starting LeetCode and even knowing it existed, I had already done the DS&A course and was a TA for that course. I knew all the runtime complexities, knew how to implement all of them and knew advanced algorithms (probabilistic, meta-heuristics and approximative algorithms). It's fair to say that I knew very well all the theory for DS&A. However, I struggled on LeetCode easy problems when I first started and was really bad at solving them. Even if I knew DS&A very well, it didn't help me at all to outperform my colleagues who knew basic theory but had practiced LeetCode for a while. The real difficulty of LeetCode is not understanding that a HashSet performs searches in O(1). The difficulty is understanding when this data structure could be useful and what repeated computations could be stored in a Set for a given problem.

The reason I am writing this is because everytime someone on Reddit says that he is struggling with LeetCode, many people just comment to learn more about DS&A. I'm frankly tired of seeing that shitty advice. People who struggle at LeetCode don't struggle because they don't know what a stack is, they struggle because they didn't develop the problem solving skills and haven't seen problems solved usings stacks. There are plenty of hard problems that are solved by using like 3 stacks in a smart way. That doesn't require extensive DS&A skills to figure out, it requires great problem solving skills.

After studying Fenwick Tree and Segment tree, then getting hint from @wLui155, I solved it by Fenwick tree and HashMap. It took 1 year to solve it. wow... I realise that the basic Data structure like stack, queue, linkedList isn't enough to pass the real code assessment!

    public int books(int[] orders, int n) {
        // shelf is Fenwick Tree that starts from node 1.
        int[] shelf = new int[n + 1];
        // [bookType, index in tree]
        HashMap<Integer, Integer> map = new HashMap<>();
        int i = 1;
        for (int book : orders) {
            if (!map.containsKey(book)) {
                shelf[i] = 2;
                map.put(book, i);
                i++;
            }
            // Just for efficiency.
            if (i == n + 1) break;
        }
        // The book on top of the shelf needs no effort.
        shelf[map.get(orders[0])] = 0;
        build(shelf);

        int sum = 0;
        for (int book : orders) {
            int index = map.get(book);
            sum += query(shelf, index);
            // Removing a book has a effect on only behind for that book index.
            update(shelf, index + 1, -1);
        }
        return sum;
    }

    private void build(int[] shelf) {
        for (int i = 1; i < shelf.length; i++) {
            int j = i + lsb(i);
            if (j < shelf.length) shelf[j] += shelf[i];
        }
    }

    private void update(int[] shelf, int idx, int delta) {
        while (idx < shelf.length) {
            shelf[idx] += delta;
            idx += lsb(idx);
        }
    }

    private int query(int[] shelf, int idx) {
        int sum = 0;
        while (idx > 0) {
            sum += shelf[idx];
            idx -= lsb(idx);
        }
        return sum;
    }

    private int lsb(int i) {
        return i & -i;
    }
    ```