📌  相关文章
📜  数组范围查询以查找具有更新的最大斐波那契数

📅  最后修改于: 2021-05-17 17:32:32             🧑  作者: Mango

给定N个整数的数组arr [] ,任务是执行以下两个查询:

  • maximum(start,end) :从头到尾打印子数组中元素的最大斐波那契数
  • update(i,x) :将x添加到数组索引i引用的数组元素中,即:arr [i] = x

注意:以下示例由基于0的索引组成。

例子:

简单方法:

一个简单的解决方案是从l到r循环运行,并计算给定范围内所有元素的最大斐波那契数。要更新值,只需做arr [i] = x。第一次操作花费O(N)时间,第二次操作花费O(1)时间。

高效的方法:
在这里,我们需要在O(Log N )时间内执行操作,因此我们可以使用细分树 O(Log N)时间内执行这两项操作。
段树的表示形式:
1.叶节点是输入数组的元素。
2.每个内部节点代表其所有子节点的最大斐波那契数;如果范围内不存在斐波那契数,则为-1。
树的数组表示形式用于表示段树。对于索引i处的每个节点,左子节点在索引2 * i + 1处右子节点在索引2 * i + 2处父节点在索引(i-1)/ 2处
从给定数组构造细分树:
我们从一个段arr [0开始。 。 。 [n-1],并且每次我们将当前段分成两半(如果尚未变成长度为1的段),然后在这两个半段上调用相同的过程,则对于每个这样的段,我们都会存储最大值细分树节点中的斐波那契数字值或-1。除最后一个级别外,已构建的段树的所有级别都将被完全填充。而且,该树将是完整的二叉树,因为我们总是在每个级别将分段分为两半。由于构造的树始终是具有n个叶子的完整二叉树,因此将有n-1个内部节点。因此,总节点数将为2 * n – 1 。段树的高度将为log 2 N。由于树是使用数组表示的,并且必须维护父索引和子索引之间的关系,因此分配给段树的内存大小将为2 *(2 ceil(log2n) )– 1
为了检查斐波那契数,我们可以使用动态编程来构建一个哈希表,其中包含所有小于或等于最大值arr可以说为MAX的斐波那契数,它将用于测试O(1)时间中的数字。
然后,我们在段树上进行范围查询,以找出给定范围的max_set_bits并输出相应的值。

下面是上述方法的实现:

CPP
// CPP code for range maximum query and updates
#include 
using namespace std;
 
set fibonacci;
 
// A utility function to get the
// middle index of given range.
int getMid(int s, int e)
{
    return s + (e - s) / 2;
}
 
// Function to create hash table
// to check Fibonacci numbers
void createHash(int maxElement)
{
    int prev = 0, curr = 1;
    fibonacci.insert(prev);
    fibonacci.insert(curr);
 
    while (curr <= maxElement) {
        int temp = curr + prev;
        fibonacci.insert(temp);
        prev = curr;
        curr = temp;
    }
}
 
/*  A recursive function to get the sum of
    values in given range of the array.
    The following are parameters for this
    function.
 
    st       -> Pointer to segment tree
    node     -> Index of current node in
                the segment tree .
    ss & se  -> Starting and ending indexes
                of the segment represented
                by current node, i.e., st[node]
    l & r    -> Starting and ending indexes
                of range query */
int MaxUtil(int* st, int ss, int se, int l,
            int r, int node)
{
    // If segment of this node is completely
    // part of given range, then return
    // the max of segment
    if (l <= ss && r >= se)
        return st[node];
 
    // If segment of this node does not
    // belong to given range
    if (se < l || ss > r)
        return -1;
 
    // If segment of this node is partially
    // the part of given range
    int mid = getMid(ss, se);
 
    return max(MaxUtil(st, ss, mid, l, r,
                       2 * node + 1),
               MaxUtil(st, mid + 1, se, l,
                       r, 2 * node + 2));
}
 
/* A recursive function to update the nodes which
   have the given index in their range. The following
   are parameters st, ss and se are same as defined
   above index -> index of the element to be updated.*/
void updateValue(int arr[], int* st, int ss, int se,
                 int index, int value, int node)
{
    if (index < ss || index > se) {
        cout << "Invalid Input" << endl;
        return;
    }
 
    if (ss == se) {
        // update value in array and in segment tree
        arr[index] = value;
 
        if (fibonacci.find(value) != fibonacci.end())
            st[node] = value;
        else
            st[node] = -1;
    }
    else {
        int mid = getMid(ss, se);
 
        if (index >= ss && index <= mid)
            updateValue(arr, st, ss, mid, index,
                        value, 2 * node + 1);
        else
            updateValue(arr, st, mid + 1, se,
                        index, value, 2 * node + 2);
 
        st[node] = max(st[2 * node + 1],
                       st[2 * node + 2]);
    }
    return;
}
 
// Return max of elements in range from
// index l (query start) to r (query end).
int getMax(int* st, int n, int l, int r)
{
    // Check for erroneous input values
    if (l < 0 || r > n - 1 || l > r) {
        printf("Invalid Input");
        return -1;
    }
 
    return MaxUtil(st, 0, n - 1, l, r, 0);
}
 
// A recursive function that constructs Segment
// Tree for array[ss..se]. si is index of
// current node in segment tree st
int constructSTUtil(int arr[], int ss, int se,
                    int* st, int si)
{
    // If there is one element in array, store
    // it in current node of segment tree and return
    if (ss == se) {
        if (fibonacci.find(arr[ss])
            != fibonacci.end())
            st[si] = arr[ss];
        else
            st[si] = -1;
        return st[si];
    }
 
    // If there are more than one elements, then
    // recur for left and right subtrees and
    // store the max of values in this node
    int mid = getMid(ss, se);
 
    st[si]
        = max(constructSTUtil(
                  arr, ss, mid, st,
                  si * 2 + 1),
              constructSTUtil(
                  arr, mid + 1, se,
                  st, si * 2 + 2));
 
    return st[si];
}
 
/* Function to construct segment tree
   from given array.
   This function allocates memory
   for segment tree.*/
int* constructST(int arr[], int n)
{
    // Height of segment tree
    int x = (int)(ceil(log2(n)));
 
    // Maximum size of segment tree
    int max_size = 2 * (int)pow(2, x) - 1;
 
    // Allocate memory
    int* st = new int[max_size];
 
    // Fill the allocated memory st
    constructSTUtil(arr, 0, n - 1, st, 0);
 
    // Return the constructed segment tree
    return st;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 3, 5, 7, 9, 11 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // find the largest node value
    // in the array
    int maxEle = *max_element(arr, arr + n);
 
    // creating a set containing
    // all fibonacci numbers
    // upto the maximum data value
    // in the array
    createHash(maxEle);
 
    // Build segment tree from given array
    int* st = constructST(arr, n);
 
    // Print max of values in array
    // from index 1 to 3
    cout << "Maximum fibonacci number"
         << " in given range = "
         << getMax(st, n, 1, 3) << endl;
 
    // Update: set arr[1] = 8 and update
    // corresponding segment tree nodes.
    updateValue(arr, st, 0, n - 1, 3, 8, 0);
 
    // Find max after the value is updated
    cout << "Updated Maximum Fibonacci"
         << " number in given range = "
         << getMax(st, n, 1, 3) << endl;
 
    return 0;
}


Java
// Java code for range maximum query and updates
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
 
class GFG {
 
  static Set fibonacci = new HashSet<>();
 
  // A utility function to get the
  // middle index of given range.
  static int getMid(int s, int e) {
    return s + (e - s) / 2;
  }
 
  // Function to create hash table
  // to check Fibonacci numbers
  static void createHash(int maxElement) {
    int prev = 0, curr = 1;
    fibonacci.add(prev);
    fibonacci.add(curr);
 
    while (curr <= maxElement) {
      int temp = curr + prev;
      fibonacci.add(temp);
      prev = curr;
      curr = temp;
    }
  }
 
  /*
     * A recursive function to get the sum of
     * values in given range of the array.
     * The following are parameters for this function.
     *
     * st       -> Pointer to segment tree
     * node     -> Index of current node
     *             in the segment tree .
     * ss & se  -> Starting and ending indexes
     *             of the segment represented
     *             by current node, i.e., st[node]
     * l & r    -> Starting and ending indexes
     *             of range query
     */
  static int MaxUtil(int[] st, int ss, int se,
                     int l, int r, int node)
  {
 
    // If segment of this node is completely
    // part of given range, then return
    // the max of segment
    if (l <= ss && r >= se)
      return st[node];
 
    // If segment of this node does not
    // belong to given range
    if (se < l || ss > r)
      return -1;
 
    // If segment of this node is partially
    // the part of given range
    int mid = getMid(ss, se);
 
    return Math.max(MaxUtil(st, ss, mid, l, r, 2 * node + 1),
                    MaxUtil(st, mid + 1, se, l, r, 2 * node + 2));
  }
 
  /*
     * A recursive function to update the nodes which
     * have the given index in their range. The following
     * are parameters st, ss and se are same as defined
     * above index -> index of the element to be updated.
     */
  static void updateValue(int arr[], int[] st, int ss, int se,
                          int index, int value, int node) {
    if (index < ss || index > se) {
      System.out.println("Invalid Input");
      return;
    }
 
    if (ss == se) {
      // update value in array and in segment tree
      arr[index] = value;
 
      if (fibonacci.contains(value))
        st[node] = value;
      else
        st[node] = -1;
    } else {
      int mid = getMid(ss, se);
 
      if (index >= ss && index <= mid)
        updateValue(arr, st, ss, mid, index,
                    value, 2 * node + 1);
      else
        updateValue(arr, st, mid + 1, se,
                    index, value, 2 * node + 2);
 
      st[node] = Math.max(st[2 * node + 1], st[2 * node + 2]);
    }
    return;
  }
 
  // Return max of elements in range from
  // index l (query start) to r (query end).
  static int getMax(int[] st, int n, int l, int r)
  {
 
    // Check for erroneous input values
    if (l < 0 || r > n - 1 || l > r)
    {
      System.out.printf("Invalid Input\n");
      return -1;
    }
 
    return MaxUtil(st, 0, n - 1, l, r, 0);
  }
 
  // A recursive function that constructs Segment
  // Tree for array[ss..se]. si is index of
  // current node in segment tree st
  static int constructSTUtil(int arr[], int ss, int se,
                             int[] st, int si)
  {
 
    // If there is one element in array, store
    // it in current node of segment tree and return
    if (ss == se) {
      if (fibonacci.contains(arr[ss]))
        st[si] = arr[ss];
      else
        st[si] = -1;
      return st[si];
    }
 
    // If there are more than one elements, then
    // recur for left and right subtrees and
    // store the max of values in this node
    int mid = getMid(ss, se);
 
    st[si] = Math.max(constructSTUtil(arr, ss, mid, st, si * 2 + 1),
                      constructSTUtil(arr, mid + 1, se, st, si * 2 + 2));
 
    return st[si];
  }
 
  /*
     * Function to construct segment tree
     * from given array. This function allocates
     * memory for segment tree.
     */
  static int[] constructST(int arr[], int n)
  {
 
    // Height of segment tree
    int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
 
    // Maximum size of segment tree
    int max_size = 2 * (int) Math.pow(2, x) - 1;
 
    // Allocate memory
    int[] st = new int[max_size];
 
    // Fill the allocated memory st
    constructSTUtil(arr, 0, n - 1, st, 0);
 
    // Return the constructed segment tree
    return st;
  }
 
  // Driver code
  public static void main(String[] args)
  {
 
    int arr[] = { 1, 3, 5, 7, 9, 11 };
    int n = arr.length;
 
    // find the largest node value
    // in the array
    int maxEle = Arrays.stream(arr).max().getAsInt();
 
    // creating a set containing
    // all fibonacci numbers
    // upto the maximum data value
    // in the array
    createHash(maxEle);
 
    // Build segment tree from given array
    int[] st = constructST(arr, n);
 
    // Print max of values in array
    // from index 1 to 3
    System.out.println("Maximum fibonacci number in given range = " +
                       getMax(st, n, 1, 3));
 
    // Update: set arr[1] = 8 and update
    // corresponding segment tree nodes.
    updateValue(arr, st, 0, n - 1, 3, 8, 0);
 
    // Find max after the value is updated
    System.out.println("Updated Maximum fibonacci number in given range = " +
                       getMax(st, n, 1, 3));
  }
}
 
// This code is contributed by sanjeev2552


输出:
给定范围内的最大斐波那契数= 5
在给定范围内更新最大斐波那契数= 8