POJ 3368 Frequent values - (线段树)

题目链接：http://poj.org/problem?id=3368
题目大意：不减数列，求出区间内频率最大数的频率。
思路：把相同的数合并，保留频率，放到线段树里面，求max；
对于给出的区间，先把两头去掉，再对中间部分用线段树查询max。
(有点边界还是略复杂的，比如给出的区间属于同一个区间，或者相邻区间)

#include <stdio.h>  
#include <vector>   
#include <algorithm>
using namespace std;

//POJ 3368 Frequent values

class SegmentTree {

    struct SegmentTreeNode
    {
        int start, end;
        int  _max;
        SegmentTreeNode(int start, int end, int max) {
            this->start = start;
            this->end = end;
            this->_max = max;
        }
    };

public:

    SegmentTree(vector<int>& Vec)
        :_size(1),
        _Identity_Element_for_MAX(0x80000000)
    {

        find_size(Vec.size());
        ST.resize(2 * _size - 1);
        build(0, 0, _size - 1, Vec);

    }


    int queryMAX(int start, int end) const
    {
        return doQueryMAX(0, start, end);
    }


protected:

    int _size;

    vector<SegmentTreeNode*> ST;

    const int _Identity_Element_for_MAX;

private:

    //find_size
    void find_size(int size)
    {
        while (_size < size)
        {
            _size <<= 1;
        }
    }


    //SegmentTree Initialization
    void build(int index, int start, int end, const vector<int>& Vec)
    {

        //leaf node
        if (start == end)
        {
            ST[index] = new SegmentTreeNode(start, end,
                (start < Vec.size()) ? Vec[start] : _Identity_Element_for_MAX);
            return;
        }

        //internal node (non-leaf)
        int mid = (start + end) / 2;


        //construct this node with initial val(_Identity_Element)
        ST[index] = new SegmentTreeNode(start, end, _Identity_Element_for_MAX);


        //construct left and right subTree (recursion)
        build((index << 1) + 1, start, mid, Vec);
        build((index << 1) + 2, mid + 1, end, Vec);


        //set value
        ST[index]->_max = max(ST[(index << 1) + 1]->_max,
            ST[(index << 1) + 2]->_max);

    }


    //index: cur_node
    int doQueryMAX(int index, int start, int end) const
    {

        //no segment union
        if (start > ST[index]->end || end < ST[index]->start)
            return _Identity_Element_for_MAX;


        //querying segment includes root segment
        if (start <= ST[index]->start && ST[index]->end <= end)
            return ST[index]->_max;


        //partially coincide
        return max(doQueryMAX((index << 1) + 1, start, end),
            doQueryMAX((index << 1) + 2, start, end));

    }

};
int main() {
    int n, q;
    while (~scanf("%d%d", &n, &q))
    {
        if (n == 0)continue;
        vector<int> num(n);
        for (int i = 0; i < n; ++i)
            scanf("%d", &num[i]);
        vector<int> frequence(n);   //记录每个区间的长度
        vector<int> interval(n); interval[0] = 0;   //区间，记录每个不同区间的start
        int counter = 0, prev = 0;
        for (int i = 1; i < n; ++i)
        {
            if (num[i] != num[i - 1])
            {
                frequence[counter++] = i - prev;
                interval[counter] = i;
                prev = i;
            }
        }
        frequence[counter++] = n - prev;
        frequence.resize(counter);
        interval.resize(counter);
        SegmentTree ST(frequence);
        for (int i = 0; i < q; ++i)
        {
            int start, end;
            scanf("%d%d", &start, &end);
            if (start == end)
            {
                printf("%d\n", 1);
                continue;
            }
            start--; end--;
            if (counter == 1)
            {
                printf("%d\n", end - start + 1);
                continue;
            }
            if (start >= interval[counter - 1])
            {
                printf("%d\n", end - start + 1);
                continue;
            }
            //分开两边，中间用线段树查询max，再和两边取max
            //分离左边
            int low = 0, high = counter - 1;
            while (high - low > 1)
            {
                if (interval[(low + high) / 2] > start)
                    high = (low + high) / 2;
                else low = (low + high) / 2;
            }
            int _start = high, left = interval[high] - start;//_start表示右边区间是第几个
            //分离右边
            int _end, right;//_end表示左边区间是第几个
            if (end >= interval[counter - 1])
            {
                _end = counter - 2, right = end - interval[counter - 1] + 1;
            }
            else {
                low = 0, high = counter - 1;
                while (high - low > 1)
                {
                    if (interval[(low + high) / 2] > end)
                        high = (low + high) / 2;
                    else low = (low + high) / 2;
                }
                _end = low - 1, right = end - interval[low] + 1;
            }
            //属于同一区间
            if (_start - _end > 1)
            {
                printf("%d\n", end - start + 1);
                continue;
            }
            int frequent;
            if (_start - _end == 1) frequent = 0;
            else frequent = ST.queryMAX(_start, _end);
            frequent = max(frequent, left);
            frequent = max(frequent, right);
            printf("%d\n", frequent);
        }
        getchar();
    }

    system("pause");
    return 0;
}