LeetCode Largest Rectangle in Histogram

class SegmentTree {
    private:
        int *mem;
        int *idx;
        int capacity;
        int storage_size;

    private:
        void init_level_update() {
            int k = capacity - 1;
            while (--k >= 0) {
                int L = (k<<1) + 1;
                int R = L + 1;
                if (mem[L] < mem[R]) {
                    mem[k] = mem[L];
                    idx[k] = idx[L];
                } else {
                    mem[k] = mem[R];
                    idx[k] = idx[R];
                }
            }
        }

        pair<int, int> query(int a, int b, int idx, int L, int R) {
            if (b <= L || a >= R) return make_pair(INT_MAX, -1);
            if (a <= L && R <= b) return make_pair(mem[idx], this->idx[idx]);

            pair<int, int> ml = query(a, b, (idx<<1) + 1, L, (L+R)/2);
            pair<int, int> mr = query(a, b, (idx<<1) + 2, (L+R)/2, R);
            if (ml.second == -1) return mr;
            if (mr.second == -1) return ml;
            return ml.first < mr.first ? ml : mr;
        }

        void init_mem(int _capacity) {
            if (_capacity <= 0) {
                capacity = 0;
                return;
            }
            int n = 1;
            while (n < _capacity) n<<=1;
            capacity = n;
            storage_size = capacity * 2 - 1;
            mem = new int[storage_size];
            idx = new int[storage_size];
            
            int k = 0;
            while (k < storage_size) mem[k++] = INT_MAX;
            k = capacity - 1;
            int i = 0;
            while (k < storage_size) idx[k++] = i++;
        }
    public:
        SegmentTree(int _capacity) {
            init_mem(_capacity);
        }
        SegmentTree(vector<int>::iterator begin, vector<int>::iterator end) {
            capacity = end - begin;
            init_mem(capacity);

            int k = capacity - 1;
            vector<int>::iterator iter = begin;
            while (iter != end) mem[k++] = *iter++;

            init_level_update();
        }

        ~SegmentTree() {
            delete[] mem;
            delete[] idx;
        }

        // update value in original data index
        void update(int index, int val) {
            if (index >= capacity || idx < 0) return;
            int k = index + capacity - 1; // internal storage index
            mem[k] = val;
            while (k > 0) {
                k = (k - 1) >> 1;
                int L = (k << 1) + 1;
                int R = L + 1;
                if (mem[L] < mem[R]) {
                    mem[k] = mem[L];
                    idx[k] = idx[L];
                } else {
                    mem[k] = mem[R];
                    idx[k] = idx[R];
                }
            }
        }

        // retrive the min value in index range [a, b)
        pair<int, int> query(int a, int b) {
            return query(a, b, 0, 0, capacity);
        }

        void print_mem(const char* msg) {
            cout<<msg<<endl;
            for (int i=0; i<(capacity*2-1); i++) {
                cout<<mem[i]<<" ";
            }
            
            for (int i=0; i<capacity * 2 - 1; i++) {
                cout<<idx[i]<<",";
            }
            cout<<endl;
        }
};

class Solution {
private:
    SegmentTree* seg_tree;
public:
    // this brute-force method will case TLE
    int bf_largestRectangleArea(vector<int> &height) {
        vector<bool> visited(height.size(), false);
        int len = height.size();
        int max_area = 0;
        for (int i=0; i<len; i++) {
            int ch = height[i];
            int range = 1;
            if (visited[i]) continue;
            for (int j = i - 1; j >= 0; j--) {
                if (height[j] < ch) break;
                if (height[j] == ch) visited[j] = true;
                range++;
            }
            for (int j = i + 1; j < len; j++) {
                if (height[j] < ch) break;
                if (height[j] == ch) visited[j] = true;
                range++;
            }
            if (range * ch > max_area) max_area = range * ch;
        }
        return max_area;
    }
    
    int largestRectangleArea(vector<int> &height) {
        seg_tree = new SegmentTree(height.begin(), height.end());
        int maxarea = dfs(0, height.size());
        delete seg_tree;
        return maxarea;
    }
    
    int dfs(int L, int R) {
        int ret = 0;
        if (L >= R) return ret;
        pair<int, int> res = seg_tree->query(L, R);
        ret = (R - L) * res.first;
        int ml = dfs(L, res.second);
        int mr = dfs(res.second + 1, R);
        return max(ret, max(ml, mr));
    }
};

人艰不拆，趁机学习了一下线段树，180+ms，数据多的情况下（如大量连续递增序列）有可能造成栈溢出

找到一个巧妙的O(n)解法

class Solution {
public:
    int largestRectangleArea(vector<int> &height) {
        int len = height.size();
        if (len == 0) return 0;
        int maxarea = height[0], area;
        vector<int> stack;
        int pos = 0, idx;
        while (pos<len) {
            if (stack.empty() || height[stack.back()] <= height[pos]) {
                stack.push_back(pos++);
            } else {
                idx = stack.back();
                stack.pop_back();
                area = height[idx] * (stack.empty() ? pos : pos - stack.back() - 1);
                if (area > maxarea) maxarea = area;
            }
        }
        
        while (!stack.empty()) {
            idx = stack.back();
            stack.pop_back();
            area = height[idx] * (stack.empty() ? pos : pos - stack.back() - 1);
            if (maxarea < area) maxarea = area;
        }
        
        return maxarea;
    }
};

100+ms

 

后来看了zhuli哥的解法，感觉更自然一点，就是先求出两个数组L,R，他们存储了从位置i开始向左/右不小于height[i]的且中间不被隔断的最远的一条bar的索引值，求的过程中可以复用以前的结果，这样就比暴力的找两个端点高效很多，时间也是这几种方法里最快的。下面给出代码：

class Solution {
public:
    int largestRectangleArea(vector<int> &height) {
        int len = height.size();
        if (len == 0) return 0;
        int maxarea = 0;
        vector<int> L, R;
        L.resize(len), R.resize(len);
        for (int i=0; i<len; i++) {
            L[i] = i;
            while (L[i]-1 >= 0 && height[L[i]-1] >= height[i]) {
                L[i] = L[L[i] - 1];
            }
        }
        int area;
        for (int i=len-1; i>=0; i--) {
            R[i] = i;
            while (R[i]+1 <= len-1 && height[R[i]+1] >= height[i]) {
                R[i] = R[R[i] + 1];
            }
            area = (R[i] - L[i] + 1) * height[i];
            if (area > maxarea) maxarea = area;
        }
        return maxarea;
    }
};

60ms+

感觉关键还是怎么样去分解问题，把其中的效率瓶颈解决掉，另外简单最美

 

这回用下那个是用stack的版本的解法，似乎要好理解一些，同时也适用于很多类似的问题

class Solution {
public:
    int largestRectangleArea(vector<int>& height) {
        height.push_back(0);
        int len = height.size();
        stack<int> pos;
        int maxarea = 0;
        for (int i=0; i<len; i++) {
            while (!pos.empty() && height[i] < height[pos.top()]) {
                int last = pos.top();
                pos.pop();
                
                int w = i - (pos.empty() ? -1 : pos.top()) - 1;
                int h = height[last];
                
                maxarea = max(w * h, maxarea);
            }
            pos.push(i);
        }
        return maxarea;
    }
};

 

参考：

　　http://www.geeksforgeeks.org/largest-rectangular-area-in-a-histogram-set-1/

　　http://www.geeksforgeeks.org/largest-rectangle-under-histogram/

　　http://www.cnblogs.com/zhuli19901106/p/3568217.html

　　http://www.julyedu.com/course/index/category/algorithm.html