Array range queries to count the number of Fibonacci numbers with updates

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

// C# program to find number of fibonacci numbers
// in a subarray and performing updates
class HelloWorld {

  public static int MAX = 1000;

  // Function to create hash table
  // to check Fibonacci numbers
  public static void createHash(HashSet<int> hash, int maxElement)
  {
    int prev = 0;
    int curr = 1;
    hash.Add(prev);
    hash.Add(curr);

    while (curr <= maxElement) {
      int temp = curr + prev;
      hash.Add(temp);
      prev = curr;
      curr = temp;
    }
  }

  // A utility function to get the middle
  // index from corner indexes.
  public static int getMid(int s, int e)
  {
    return s + ((e - s) / 2);
  }

  // Recursive function to get the number
  // of Fibonacci numbers in a given range
  /* where
        st    --> Pointer to segment tree
        index --> Index of current node in the
                  segment tree. Initially 0 is passed
                  as root is always at index 0
        ss & se  --> Starting and ending indexes of 
                  the segment represented by current
                  node, i.e., st[index]
        qs & qe  --> Starting and ending indexes
                  of query range   
        */
  public static int queryFibonacciUtil(List<int> st, int ss, 
                                       int se, int qs, int qe, int index)
  {
    // If segment of this node is a part
    // of given range, then return
    // the number of Fibonacci numbers
    // in the segment
    if (qs <= ss && qe >= se)
      return st[index];

    // If segment of this node
    // is outside the given range
    if (se < qs || ss > qe)
      return 0;

    // If a part of this segment
    // overlaps with the given range
    int mid = getMid(ss, se);
    return queryFibonacciUtil(st, ss, mid, qs, qe, 2 * index + 1) + 
      queryFibonacciUtil(st, mid + 1, se, qs, qe, 2 * index + 2);
  }

  // Recursive function to update
  // the nodes which have the given
  // index in their range.
  /* where
        st, si, ss and se are same as getSumUtil()
        i --> index of the element to be updated. 
              This index is in input array.
       diff --> Value to be added to all nodes
              which have i in range 
    */
  public static void updateValueUtil(List<int> st, int ss, 
                                     int se, int i, 
                                     int diff, int si)
  {
    // Base Case:
    // If the input index lies outside
    // the range of this segment
    if (i < ss || i > se)
      return;

    // If the input index is in range
    // of this node, then update the value
    // of the node and its children
    st[si] = st[si] + diff;
    if (se != ss) {

      int mid = getMid(ss, se);
      updateValueUtil(st, ss, mid, i, diff, 2 * si + 1);
      updateValueUtil(st, mid + 1, se, i, diff, 2 * si + 2);
    }
  }

  // Function to update a value in the
  // input array and segment tree.
  // It uses updateValueUtil() to update
  // the value in segment tree
  public static void updateValue(int[] arr, List<int> st, 
                                 int n, int i, int new_val,
                                 HashSet<int> hash)
  {
    // Check for erroneous input index
    if (i < 0 || i > n - 1) {
      Console.WriteLine("Invalid Input");
      return;
    }

    int diff = 0;
    int oldValue = 0;

    oldValue = arr[i];

    // Update the value in array
    arr[i] = new_val;

    // Case 1: Old and new values
    // both are Fibonacci numbers
    if (hash.Contains(oldValue) == true && hash.Contains(new_val) == true)
      return;

    // Case 2: Old and new values
    // both not Fibonacci numbers
    if (hash.Contains(oldValue) == false && hash.Contains(new_val) == false)
      return;

    // Case 3: Old value was Fibonacci,
    // new value is non Fibonacci
    if (hash.Contains(oldValue) == true && hash.Contains(new_val) == false){
      diff = -1;
    }


    // Case 4: Old value was non Fibonacci,
    // new_val is Fibonacci
    if (hash.Contains(oldValue) == false && hash.Contains(new_val) == true){
      diff = 1;
    }

    // Update the values of nodes in segment tree
    updateValueUtil(st, 0, n -1, i, diff, 0);
  }



  // Return number of Fibonacci numbers
  // in range from index qs (query start)
  // to qe (query end).
  // It mainly uses queryFibonacciUtil()
  public static void queryFibonacci(List<int> st, int n, int qs, int qe)
  {
    int FibonacciInRange = queryFibonacciUtil(st, 0, n - 1, qs, qe, 0);

    Console.WriteLine("Number of Fibonacci numbers in subarray from " + qs + " to " + qe + " = " + FibonacciInRange);
  }


  // Recursive function that constructs
  // Segment Tree for array[ss..se].
  // si is index of current node
  // in segment tree st
  public static int constructSTUtil(int[] arr, int ss, int se, 
                                    List<int> st, int si, 
                                    HashSet<int> hash)
  {
    // If there is one element in array,
    // check if it is Fibonacci number
    // then store 1 in the segment tree
    // else store 0 and return
    if (ss == se) {

      // if arr[ss] is fibonacci number
      if (hash.Contains(arr[ss]) == true)
        st[si] = 1;
      else
        st[si] = 0;

      return st[si];
    }

    // If there are more than one elements,
    // then recur for left and right subtrees
    // and store the sum of the
    // two values in this node
    int mid = getMid(ss, se);
    st[si] = constructSTUtil(arr, ss, mid, st, si * 2 + 1, hash) + 
      constructSTUtil(arr, mid + 1, se, st, si * 2 + 2, hash);
    return st[si];
  }

  // Function to construct a segment tree from given array.
  // This function allocates memory for segment tree and
  // calls constructSTUtil() to fill the allocated memory
  public static List<int> constructST(int[] arr, int n, HashSet<int> hash)
  {
    // Allocate memory for segment tree

    // Height of segment tree
    int x = Convert.ToInt32((Math.Ceiling(Math.Log(n)*2.303)));

    // Maximum size of segment tree
    int max_size = 2 * Convert.ToInt32(Math.Pow(2, x)) - 1;

    List<int> st = new List<int>();
    for(int i = 0; i < max_size; i++){
      st.Add(0);
    }

    // Fill the allocated memory st
    constructSTUtil(arr, 0, n - 1, st, 0, hash);

    // Return the constructed segment tree
    return st;
  }

  static void Main() {

    int[] arr = { 1, 2, 3, 4, 8, 9 };
    int n = arr.Length;

    // find the largest node value in the array
    int maxEle = 0;
    for(int j = 0; j < n; j++){
      maxEle = Math.Max(maxEle, arr[j]);
    }

    // Creating a set containing all Fibonacci numbers
    // upto the maximum data value in the array
    HashSet<int> hash = new HashSet<int>();

    createHash(hash, maxEle);

    // Build segment tree from given array
    List<int> st = constructST(arr, n, hash);

    // Query 1: Query(start = 0, end = 4)
    int start = 0;
    int end = 4;
    queryFibonacci(st, n, start, end);

    // Query 2: Update(i = 3, x = 5),
    // i.e Update a[i] to x
    int i = 3;
    int x = 5;
    updateValue(arr, st, n, i, x, hash);

    // uncomment to see array after update
    // for(int i = 0; i < n; i++)
    // cout << arr[i] << " ";

    // Query 3: Query(start = 0, end = 4)
    start = 0;
    end = 4;
    queryFibonacci(st, n, start, end);
  }
}

// The code is contributed by Nidhi goel.