📌  相关文章
📜  范围查询以计算位于给定范围内的元素：MO的算法

📅  最后修改于: 2021-06-26 18:33:32             🧑  作者: Mango

给定一个由N个元素和两个整数A到B组成的数组arr [] ，任务是回答Q个查询，每个查询具有两个整数L和R。对于每个查询，找到子数组arr [L…R]中的元素数量，其中位于A到B (含)范围内。

例子：

先决条件： MO的算法，SQRT分解

方法：想法是使用MO的算法对所有查询进行预处理，以便一个查询的结果可以在下一个查询中使用。下面是步骤说明：

  • 将查询分组为多个块，其中每个块包含(0到√N– 1)，(√N到2x√N– 1)的起始范围值，依此类推。以R的升序对块内的查询进行排序。
  • 以每个查询都使用上一个查询中计算出的结果的方式，一个接一个地处理所有查询。
  • 保持频率数组，该数组将对出现在[L，R]范围内的arr [i]的频率进行计数。

    下面是上述方法的实现：

    C++
    // C++ implementation to find the 
// values in the range A to B 
// in a subarray of L to R
  
#include 
  
using namespace std;
  
#define MAX 100001
#define SQRSIZE 400
  
// Variable to represent block size.
// This is made global so compare()
// of sort can use it.
int query_blk_sz;
  
// Structure to represent a
// query range
struct Query {
    int L;
    int R;
};
  
// Frequency array
// to keep count of elements
int frequency[MAX];
  
// Array which contains the frequency
// of a particular block
int blocks[SQRSIZE];
  
// Block size
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.
bool 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
int getblocknumber(int ind)
{
    return (ind) / blk_sz;
}
  
// Function to get the answer
// of range [0, k] which uses the
// sqrt decompostion technique
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
    // rigth 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;
}
  
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]++;
}
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]--;
}
void queryResults(int a[], int n,
                Query q[], int m, int A, int B)
{
  
    // Initialize the block size
    // for queries
    query_blk_sz = sqrt(m);
  
    // Sort all queries so that queries
    // of same blocks are arranged
    // together.
    sort(q, q + m, compare);
  
    // 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++;
        }
        printf("%d\n", getans(A, B));
    }
}
  
// Driver code
int main()
{
  
    int arr[] = { 2, 0, 3, 1, 4, 2, 5, 11 };
    int N = sizeof(arr) / sizeof(arr[0]);
  
    int A = 1, B = 5;
    blk_sz = sqrt(N);
    Query Q[] = { { 0, 2 }, { 0, 3 }, { 5, 7 } };
  
    int M = sizeof(Q) / sizeof(Q[0]);
  
    // Answer the queries
    queryResults(arr, N, Q, M, A, B);
    return 0;
}

    输出： 
    2
3
2

    如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。