11235 - Frequent values

#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 5;
struct Node
{
    int leftMost, rightMost, frLeftMost, frRightMost, ans;
    Node() {}
    Node(int a, int b, int c, int d, int e)
    {
        leftMost = a;
        rightMost = b;
        frLeftMost = c;
        frRightMost = d;
        ans = e;
    }
};
void print(struct Node n)
{
    cout << n.leftMost << " " << n.frLeftMost << " " << n.rightMost << " " << n.frRightMost << " " << n.ans << endl;
}
struct Node tree[mx * 3];
struct Node merge(struct Node leftNode, struct Node rightNode)
{
    if (leftNode.ans == 0)
        return rightNode;
    if (rightNode.ans == 0)
        return leftNode;
    struct Node cur;
    cur.leftMost = leftNode.leftMost;
    cur.rightMost = rightNode.rightMost;
    if (leftNode.leftMost == rightNode.rightMost)
    {
        int tmp = leftNode.frLeftMost + rightNode.frRightMost;
        cur.frLeftMost = tmp;
        cur.frRightMost = tmp;
        cur.ans = tmp;
    }
    else if (leftNode.leftMost == rightNode.leftMost)
    {
        cur.frLeftMost = leftNode.frLeftMost + rightNode.frLeftMost;
        cur.frRightMost = rightNode.frRightMost;
        cur.ans = max(cur.frLeftMost, rightNode.ans);
    }
    else if (leftNode.rightMost == rightNode.rightMost)
    {
        cur.frLeftMost = leftNode.frLeftMost;
        cur.frRightMost = leftNode.frRightMost + rightNode.frLeftMost;
        cur.ans = max(cur.frRightMost, leftNode.ans);
    }
    else if (leftNode.rightMost == rightNode.leftMost)
    {
        cur.frLeftMost = leftNode.frLeftMost;
        cur.frRightMost = rightNode.frRightMost;
        cur.ans = max({leftNode.ans, rightNode.ans, leftNode.frRightMost + rightNode.frLeftMost});
    }
    else
    {
        cur.frLeftMost = leftNode.frLeftMost;
        cur.frRightMost = rightNode.frRightMost;
        cur.ans = max(leftNode.ans, rightNode.ans);
    }
    return cur;
}
void build(int node, int segL, int segR, int a[])
{
    if (segL == segR)
    {
        tree[node].leftMost = a[segL];
        tree[node].rightMost = a[segL];
        tree[node].frLeftMost = 1;
        tree[node].frRightMost = 1;
        tree[node].ans = 1;
        return;
    }
    int mid = segL + ((segR - segL) / 2);
    int leftMostNode = node * 2;
    int rightMostNode = leftMostNode + 1;
    build(leftMostNode, segL, mid, a);
    build(rightMostNode, mid + 1, segR, a);
    tree[node] = merge(tree[leftMostNode], tree[rightMostNode]);
}
struct Node query(int node, int segL, int segR, int i, int j)
{
    if (segL > j || segR < i)
        return Node(0, 0, 0, 0, 0);
    if (segL >= i && segR <= j)
    {
        return tree[node];
    }
    int mid = segL + ((segR - segL) / 2);
    int leftMostNode = node * 2;
    int rightMostNode = leftMostNode + 1;
    struct Node a = query(leftMostNode, segL, mid, i, j);
    struct Node b = query(rightMostNode, mid + 1, segR, i, j);
    return merge(a, b);
}
int main()
{
    int n, q;
    while (cin >> n)
    {
        if (n == 0)
            break;
        cin >> q;
        int a[n];
        for (int i = 0; i < n; i++)
            cin >> a[i];
        build(1, 0, n - 1, a);
        while (q--)
        {
            int l, r;
            cin >> l >> r;
            --l;
            --r;
            cout << query(1, 0, n - 1, l, r).ans << endl;
        }
    }
    return 0;
}