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