Range Update Queries to XOR with 1 in a Binary Array.

// l1 = leftmost index of 1, l0 = leftmost index of 0.
// r1 = rightmost index of 1, r0 = rightmost index of 0.
// max1 = maximum distance between two 1’s.
// max0 = maximum distance between two 0’s.
// min1 = minimum distance between two 1’s.
// min0 = minimum distance between two 0’s.
public Node Merge(Node left, Node right)
{
    Node cur = new Node();

    if (left.l0 != null)
        cur.l0 = left.l0;
    else
        cur.l0 = right.l0;
  
    // We will do this for all values
    // i.e. cur.r0, cur.l1, cur.r1, cur.l0

    // To find the min and max difference between two 1's and 0's
    // we will take min/max value of left side, right side and 
    // difference between rightmost index of 1/0 in right node 
    // and leftmost index of 1/0 in left node respectively.
    cur.min0 = Math.Min(left.min0, right.min0);

    if (left.r0 != null && right.l0 != null)
        cur.min0 = Math.Min(cur.min0, (right.l0 - left.r0));

    // We will do this for all max/min values
    // i.e. cur.min0, cur.min1, cur.max1, cur.max0
    return cur;
}

// This code is contributed by akashish__

// C# code addition 

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

// Class for each node in the segment tree
class Node
{
    public int l1, r1, l0, r0;
    public int min0, max0, min1, max1;

    public Node()
    {
        l1 = r1 = l0 = r0 = -1;
        max1 = max0 = int.MinValue;
        min1 = min0 = int.MaxValue;
    }
}


class LazyPropagationSegmentTree
{
    public static  int MAX = 100001;
    public static  int[] lazy = new int[MAX];
    


    public static  Node[] seg = new Node[MAX];
    

    // A utility function for merging two nodes
    public static Node MergeUtil(Node l, Node r)
    {
        Node x = new Node();

        x.l0 = (l.l0 != -1) ? l.l0 : r.l0;
        x.r0 = (r.r0 != -1) ? r.r0 : l.r0;

        x.l1 = (l.l1 != -1) ? l.l1 : r.l1;
        x.r1 = (r.r1 != -1) ? r.r1 : l.r1;

        x.min0 = Math.Min(l.min0, r.min0);
        if (l.r0 != -1 && r.l0 != -1)
            x.min0 = Math.Min(x.min0, r.l0 - l.r0);

        x.min1 = Math.Min(l.min1, r.min1);
        if (l.r1 != -1 && r.l1 != -1)
            x.min1 = Math.Min(x.min1, r.l1 - l.r1);

        x.max0 = Math.Max(l.max0, r.max0);
        if (l.l0 != -1 && r.r0 != -1)
            x.max0 = Math.Max(x.max0, r.r0 - l.l0);

        x.max1 = Math.Max(l.max1, r.max1);
        if (l.l1 != -1 && r.r1 != -1)
            x.max1 = Math.Max(x.max1, r.r1 - l.l1);

        return x;
    }

    // A utility function for updating a node
    public static Node UpdateUtil(Node x)
    {
        int temp;
        temp = x.l0; x.l0 = x.l1; x.l1 = temp;
        temp = x.r0; x.r0 = x.r1; x.r1 = temp;
        temp = x.min0; x.min0 = x.min1; x.min1 = temp;
        temp = x.max0; x.max0 = x.max1; x.max1 = temp;

        return x;
    }

    // A recursive function that constructs
    // Segment Tree for given string
    public static void Build(int qs, int qe, int ind, int[] arr)
    {
        // If start is equal to end then
        // insert the array element
        // Console.WriteLine(ind);
        if (qs == qe) {
            if (arr[qs] == 1) {
                seg[ind].l1 = seg[ind].r1 = qs;
            }
            else {
                seg[ind].l0 = seg[ind].r0 = qs;
            }

            lazy[ind] = 0;
            return;
        }
        int mid = (qs + qe) >> 1;

        // Build the segment tree
        // for range qs to mid
        Build(qs, mid, ind << 1, arr);

        // Build the segment tree
        // for range mid+1 to qe
        Build(mid + 1, qe, ind << 1 | 1, arr);

        // merge the two child nodes
        // to obtain the parent node
        seg[ind] = MergeUtil(
            seg[ind << 1],
            seg[ind << 1 | 1]);
    }

    // Query in a range qs to qe
    public static Node Query(int qs, int qe,
               int ns, int ne, int ind)
    {
        if (lazy[ind] != 0) {
            seg[ind] = UpdateUtil(seg[ind]);
            if (ns != ne) {
                lazy[ind * 2] ^= lazy[ind];
                lazy[ind * 2 + 1] ^= lazy[ind];
            }
            lazy[ind] = 0;
        }

        Node x = new Node();

        // If the range lies in this segment
        if (qs <= ns && qe >= ne)
            return seg[ind];

        // If the range is out of the bounds
        // of this segment
        if (ne < qs || ns > qe || ns > ne)
            return x;

        // Else query for the right and left
        // child node of this subtree
        // and merge them
        int mid = (ns + ne) >> 1;

        Node l = Query(qs, qe, ns,
                       mid, ind << 1);
        Node r = Query(qs, qe,
                       mid + 1, ne,
                       ind << 1 | 1);

        x = MergeUtil(l, r);
        return x;
    }

    // range update using lazy propagation
    public static void RangeUpdate(int us, int ue,
                     int ns, int ne, int ind)
    {
        if (lazy[ind] != 0) {
            seg[ind] = UpdateUtil(seg[ind]);
            if (ns != ne) {
                lazy[ind * 2] ^= lazy[ind];
                lazy[ind * 2 + 1] ^= lazy[ind];
            }
            lazy[ind] = 0;
        }

        // If the range is out of the bounds
        // of this segment
        if (ns > ne || ns > ue || ne < us)
            return;

        // If the range lies in this segment
        if (ns >= us && ne <= ue) {
            seg[ind] = UpdateUtil(seg[ind]);
            if (ns != ne) {
                lazy[ind * 2] ^= 1;
                lazy[ind * 2 + 1] ^= 1;
            }
            return;
        }

        // Else query for the right and left
        // child node of this subtree
        // and merge them
        int mid = (ns + ne) >> 1;
        RangeUpdate(us, ue, ns, mid, ind << 1);
        RangeUpdate(us, ue, mid + 1, ne, ind << 1 | 1);

        Node l = seg[ind << 1], r = seg[ind << 1 | 1];
        seg[ind] = MergeUtil(l, r);
    }

    // Driver code
    static void Main()
    {
        
        // Initialising segment 
        for(int i = 0; i < 100001; i++){
            seg[i] = new Node();
        }
        
        int[] arr = { 1, 1, 0,
                      1, 0, 1,
                      0, 1, 0,
                      1, 0, 1,
                      1, 0 };
        int n = arr.Length;

        // Build the segment tree
        // Console.WriteLine("HI");
        Build(0, n - 1, 1, arr);
        // Console.WriteLine("HI2");

        // Query of Type 2 in the range 3 to 7
        Node ans = Query(3, 7, 0, n - 1, 1);
        Console.WriteLine(ans.min1);

        // Query of Type 3 in the range 2 to 5
        ans = Query(2, 5, 0, n - 1, 1);
        Console.WriteLine(ans.max1);

        // Query of Type 1 in the range 1 to 4
        RangeUpdate(1, 4, 0, n - 1, 1);

        // Query of Type 4 in the range 3 to 7
        ans = Query(3, 7, 0, n - 1, 1);
        Console.WriteLine(ans.min0);

        // Query of Type 5 in the range 4 to 9
        ans = Query(4, 9, 0, n - 1, 1);
        Console.WriteLine(ans.max0);
    }
    
}

// The code is contributed by Nidhi goel.