Queries for elements having values within the range A to B using MO's Algorithm

// Java implementation to find the
// values in the range A to B
// in a subarray of L to R

import java.util.Arrays;

public class GFG {

    static final int MAX = 100001;
    static final int SQRSIZE = 400;

    // Variable to represent block size.
    // This is made global so compare()
    // of sort can use it.
    static int query_blk_sz;

    // Structure to represent a query range
    static class Query {
        int L;
        int R;

        public Query(int l, int r)
        {
            L = l;
            R = r;
        }
    }

    // Frequency array
    // to keep count of elements
    static int[] frequency = new int[MAX];

    // Array which contains the frequency
    // of a particular block
    static int[] blocks = new int[SQRSIZE];

    // Block size
    static int blk_sz;

    // Function used to sort all queries
    // so that all queries of the same
    // block are arranged together and
    // within a block, queries are sorted
    // in increasing order of R values.
    static boolean compare(Query x, Query y)
    {
        if (x.L / query_blk_sz != y.L / query_blk_sz)
            return (x.L / query_blk_sz
                    < y.L / query_blk_sz);

        return x.R < y.R;
    }

    // Function used to get the block
    // number of current a[i] i.e ind
    static int getblocknumber(int ind)
    {
        return (ind) / blk_sz;
    }

    // Function to get the answer
    // of range [0, k] which uses the
    // sqrt decomposition technique
    static int getans(int A, int B)
    {
        int ans = 0;
        int left_blk, right_blk;
        left_blk = getblocknumber(A);
        right_blk = getblocknumber(B);

        // If left block is equal to right block
        // then we can traverse that block
        if (left_blk == right_blk) {
            for (int i = A; i <= B; i++)
                ans += frequency[i];
        }
        else {
            // Traversing first block in
            // range
            for (int i = A; i < (left_blk + 1) * blk_sz;
                 i++)
                ans += frequency[i];

            // Traversing completely overlapped
            // blocks in range
            for (int i = left_blk + 1; i < right_blk; i++)
                ans += blocks[i];

            // Traversing last block in range
            for (int i = right_blk * blk_sz; i <= B; i++)
                ans += frequency[i];
        }
        return ans;
    }

    static void add(int ind, int a[])
    {
        // Increment the frequency of a[ind]
        // in the frequency array
        frequency[a[ind]]++;

        // Get the block number of a[ind]
        // to update the result in blocks
        int block_num = getblocknumber(a[ind]);

        blocks[block_num]++;
    }

    static void remove(int ind, int a[])
    {
        // Decrement the frequency of
        // a[ind] in the frequency array
        frequency[a[ind]]--;

        // Get the block number of a[ind]
        // to update the result in blocks
        int block_num = getblocknumber(a[ind]);

        blocks[block_num]--;
    }

    static void queryResults(int a[], int n, Query q[],
                             int m, int A, int B)
    {

        // Initialize the block size
        // for queries
        query_blk_sz = (int)Math.sqrt(m);

        // Sort all queries so that queries
        // of same blocks are arranged
        // together.
        Arrays.parallelSort(q, (x, y) -> {
            if (x.L / query_blk_sz != y.L / query_blk_sz)
                return (x.L / query_blk_sz
                        - y.L / query_blk_sz);

            return x.R - y.R;
        });

        // Initialize current L,
        // current R and current result
        int currL = 0, currR = 0;

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

            // L and R values of the
            // current range

            int L = q[i].L, R = q[i].R;

            // Add Elements of current
            // range
            while (currR <= R) {
                add(currR, a);
                currR++;
            }
            while (currL > L) {
                add(currL - 1, a);
                currL--;
            }

            // Remove element of previous
            // range
            while (currR > R + 1)

            {
                remove(currR - 1, a);
                currR--;
            }
            while (currL < L) {
                remove(currL, a);
                currL++;
            }
            System.out.println(getans(A, B));
        }
    }

    // Driver code
    public static void main(String[] args)
    {

        int arr[] = { 3, 4, 6, 2, 7, 1 };
        int N = arr.length;

        int A = 1, B = 6;
        blk_sz = (int)Math.sqrt(N);
        Query Q[] = { new Query(0, 4) };

        int M = Q.length;

        // Answer the queries
        queryResults(arr, N, Q, M, A, B);
    }
}

// This code is contributed by Lovely Jain