Check if given Array can be divided into subsequences of K increasing consecutive integers

import java.util.*;

class GFG {
    // Function to check if the array can
    // be divided into subsequences of K
    // consecutive integers in increasing order
    public static boolean isPossible(List<Integer> nums, int K) {
        int N = nums.size();

        // If N is not divisible by K or
        // K>N, no possible set of required
        // subsequences exist
        if (N % K != 0 || K > N) {
            return false;
        }

        // Stores the indices of each
        // element in a set
        Map<Integer, TreeSet<Integer>> idx = new HashMap<>();

        // Stores the index of each number
        for (int i = 0; i < nums.size(); i++) {
            idx.computeIfAbsent(nums.get(i), k -> new TreeSet<>()).add(i);
        }

        // Stores if the integer at current
        // index is already included in
        // a subsequence
        boolean[] visited = new boolean[N];

        // Stores the count of total
        // visited elements
        int total_visited = 0;

        for (int i = 0; i < nums.size(); i++) {

            // If current integer is already
            // in a subsequence
            if (visited[i]) {
                continue;
            }

            // Stores the value of last element
// of the current subsequence
int num = nums.get(i);
                  // Stores the index of last element
        // of the current subsequence
        int last_index = i;

        // Mark Visited
        visited[i] = true;

        // Increment the visited count
        total_visited++;

        // Find the next K-1 elements of the
        // subsequence starting from index i
        for (int j = num + 1; j < num + K; j++) {

            // No valid index found
            if (!idx.containsKey(j) || idx.get(j).size() == 0) {
                return false;
            }

            // Find index of j such that it
            // is greater than last_index
            int next_index = idx.get(j).tailSet(last_index + 1).first();

            // if no such index found,
            // return false
            if (next_index <= last_index) {
                return false;
            }

            // Update last_index
            last_index = next_index;

            // Mark current index as visited
            visited[last_index] = true;

            // Increment total_visited by 1
            total_visited++;

            // Remove the index from set because
            // it has been already used
            idx.get(j).remove(last_index);
        }
    }

    // Return the result
    return total_visited == N;
}

// Driver Code
public static void main(String[] args) {
    List<Integer> arr = Arrays.asList(4, 3, 1, 2);
    int K = 2;
    System.out.println(isPossible(arr, K) ? "Yes" : "No");
}
}