Count of Ks in the Array for a given range of indices after array updates for Q queries

// Java program for the above approach
import java.util.*;

class GFG{

// Function to perform all the queries
static void performQueries(int n, int q, int k,
                    int[] arr,
                    int[][] query)
{
    for (int i = 1; i <= q; i++) {

        // Stores the count of 0s
        int count = 0;

        // Count the number of 0s for
        // query of type 1
        if (query[i - 1][0] == 1) {
            for (int j = query[i - 1][1];
                 j <= query[i - 1][2]; j++) {

                if (arr[j] == k)
                    count++;
            }
            System.out.print(count +"\n");
        }

        // Update the array element for
        // query of type 2
        else {
            arr[query[i - 1][1]]
                = query[i - 1][2];
        }
    }
}

// Driver Code
public static void main(String[] args)
{
    int[] arr = { 9, 5, 7, 6, 9,
                        0, 0, 0, 0, 5,
                        6, 7, 3, 9, 0,
                        7, 0, 9, 0 };
    int Q = 5;

    int[][] query
        = { { 1, 5, 14 },
            { 2, 6, 1 },
            { 1, 0, 8 },
            { 2, 13, 0 },
            { 1, 6, 18 } };
    int N = arr.length;

    int K = 0;

    performQueries(N, Q, K, arr, query);

}
}

// This code is contributed by Princi Singh 

// Java program for the above approach
import java.util.*;
public class Main
{
    static int[] a;
    static int[] seg_tree;
    static int[][] query;
     
    // Function to build the segment tree
    static void build_tree(int v, int tl, int tr)
    {
        // Base case
        if (tl != tr) {
  
            // Since the count of zero is
            // required set leaf node as 1
            if (a[tl] == 0)
                seg_tree[v] = 1;
  
            // If the value in array is not
            // zero, store 0 in the leaf node
            else
                seg_tree[v] = 0;
        }
        else {
  
            // Find the mid
            int tm = (tl + tr) / 2;
  
            // Recursive call for left subtree
            build_tree(v * 2, tl, tm);
  
            // Recursive call for right subtree
            build_tree(v * 2 + 1,
                       tm + 1, tr);
  
            // Parent nodes contains the
            // count of zero in range tl to tr
            seg_tree[v] = seg_tree[v * 2]
                          + seg_tree[v * 2 + 1];
        }
    }
  
    // Function to find the count of 0s
    // in range l to r
    static int frequency_zero(int v, int tl, int tr, int l, int r)
    {
        // Base Case
        if (l > r)
            return 0;
  
        // Case when no two segment
        // are combining
        if (l == tl && r == tr) {
            return seg_tree[v];
        }
  
        // Finding the mid
        int tm = (tl + tr) / 2;
  
        // When it is required to combine
        // left subtree and right subtree
        // to get the range l to r
        return frequency_zero(v * 2, tl, tm, l, Math.min(r, tm))
               + frequency_zero(v * 2 + 1, tm + 1, tr, Math.max(l, tm + 1), r);
    }
  
    // Function that updates the segment
    // tree nodes
    static void update(int v, int tl, int tr, int pos, int new_val)
    {
        // Base Case
        if (tl == tr) {
  
            // If array element is 0
            if (new_val == 0)
                seg_tree[v] = 1;
  
            // If array element is not 0
            else
                seg_tree[v] = 0;
        }
  
        // Otherwise
        else {
  
            // Find the mid
            int tm = (tl + tr) / 2;
            if (pos <= tm)
                update(v * 2, tl, tm,
                       pos, new_val);
            else
                update(v * 2 + 1, tm + 1,
                       tr, pos, new_val);
  
            // Update the tree or count
            // which is stored in
            // parent node
            seg_tree[v] = seg_tree[v * 2]
                          + seg_tree[v * 2 + 1];
        }
    }
  
    // Function to solve all the queries
    static void solve(int n, int q)
    {
        int[] qu = {5,3,6};
        seg_tree = new int[4 * n + 1];
        Arrays.fill(seg_tree, 0);
        build_tree(1, 0, n - 1);
        for(int i = 0; i < qu.length; i++)
        {
            System.out.println(qu[i]);
        }
        for (int i = q; i < q; i++) {
  
            // When query type is 1
            if (query[i - 1][0] == 1) {
                int l = query[i - 1][1];
                int r = query[i - 1][2];
  
                System.out.println(frequency_zero(1, 0, n - 1, l, r));
            }
  
            // When query type is 2
            else {
                a[query[i - 1][1]] = query[i - 1][2];
                int pos = query[i - 1][1];
                int new_val = query[i - 1][2];
  
                update(1, 0, n - 1, pos, new_val);
            }
        }
    }
    
    public static void main(String[] args) {
        a = new int[]{ 9, 5, 7, 6, 9,
                        0, 0, 0, 0, 5,
                        6, 7, 3, 9, 0,
                        7, 0, 9, 0 };
        int Q = 5;
      
        query
            = new int[][]{ { 1, 5, 14 },
                { 2, 6, 1 },
                { 1, 0, 8 },
                { 2, 13, 0 },
                { 1, 6, 18 } };
        int N = a.length;
  
        solve(N, Q);
    }
}

// This code is contributed by suresh07