Segment Tree for Range Assignment and Range Sum Queries

using System;

public class SegmentTree {
    const int MAX = 100000; // Max size of array
    int[] tree = new int[4 * MAX]; // Segment tree
    int[] lazy = new int[4 * MAX]; // Lazy array

    // Function to update the segment tree
    public void UpdateRange(int node, int start, int end,
                            int l, int r, int val)
    {
        // If lazy[node] is non-zero, then there are some
        // pending updates. So we need to make sure the node
        // is updated
        if (lazy[node] != 0) {
            // Updating the node
            tree[node] = (end - start + 1) * lazy[node];

            // Passing the update information to its
            // children
            if (start != end) {
                lazy[node * 2] = lazy[node];
                lazy[node * 2 + 1] = lazy[node];
            }

            // Resetting the lazy value for the current node
            lazy[node] = 0;
        }

        // Out of range
        if (start > end || start > r || end < l)
            return;

        // Current segment is fully in range
        if (start >= l && end <= r) {
            // Update the node
            tree[node] = (end - start + 1) * val;

            // Pass the update information to its children
            if (start != end) {
                lazy[node * 2] = val;
                lazy[node * 2 + 1] = val;
            }
            return;
        }

        // If not completely in range but overlaps, recur
        // for children,

        int mid = (start + end) / 2;
        UpdateRange(node * 2, start, mid, l, r, val);
        UpdateRange(node * 2 + 1, mid + 1, end, l, r, val);

        // Use the result of children calls to update this
        // node
        tree[node] = tree[node * 2] + tree[node * 2 + 1];
    }

    // Function to calculate the sum on a given range
    public int QueryRange(int node, int start, int end,
                          int l, int r)
    {
        // Out of range
        if (start > end || start > r || end < l)
            return 0;

        // If there are pending updates
        if (lazy[node] != 0) {
            // Updating the node
            tree[node] = (end - start + 1) * lazy[node];

            // Passing the update information to its
            // children
            if (start != end) {
                lazy[node * 2] = lazy[node];
                lazy[node * 2 + 1] = lazy[node];
            }

            // Resetting the lazy value for the current node
            lazy[node] = 0;
        }

        // At this point we are sure that pending lazy
        // updates are done for current node. So we can
        // return value
        if (start >= l && end <= r)
            return tree[node];

        // If not completely in range but overlaps, recur
        // for children,
        int mid = (start + end) / 2;
        int p1 = QueryRange(node * 2, start, mid, l, r);
        int p2
            = QueryRange(node * 2 + 1, mid + 1, end, l, r);

        // Use the result of children calls to update this
        // node
        return (p1 + p2);
    }

    public static void Main(string[] args)
    {
        SegmentTree segmentTree = new SegmentTree();

        // Hardcoded input
        int n = 5, q = 3;
        int[][] queries = new int[q][];
        queries[0] = new int[] { 1, 0, 3, 5 };
        queries[1] = new int[] { 2, 1, 4 };
        queries[2] = new int[] { 1, 2, 4, 10 };

        for (int i = 0; i < q; i++) {
            int type = queries[i][0];

            if (type == 1) {
                int l = queries[i][1], r = queries[i][2],
                    v = queries[i][3];
                segmentTree.UpdateRange(1, 0, n - 1, l,
                                        r - 1, v);
            }
            else {
                int l = queries[i][1], r = queries[i][2];
                Console.WriteLine(segmentTree.QueryRange(
                    1, 0, n - 1, l, r - 1));
            }
        }
    }
}