LeetCode解题报告—— Minimum Window Substring && Largest Rectangle in Histogram

1. Minimum Window Substring

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).

Example:

Input: S = "ADOBECODEBANC", T = "ABC"
Output: "BANC"

Note:

• If there is no such window in S that covers all characters in T, return the empty string "".
• If there is such window, you are guaranteed that there will always be only one unique minimum window in S.

思路

利用HashMap存储T中的每个字符，及其出现频率，先在S中找包含T的的第一个Window Substring，找到了后因为可能不是最小的所以还是要从左往右遍历找，只不过这是有点技巧的找。判断这个window substring的最左字符，如果不是在T中的直接删除，继续判断它的下一个位置，如果是在T中的话也删除它，不过这删除后下一步我们要转到window substring的最右边去寻找我们删除掉的字符，如果找到则构成新的window，再重复相同步骤，过程中记录windows的最小长度，如果找不到则表明后面没有能包含T的window substring了，也就是找到了所有包含T的Window Substring的情形。

1. create a hashmap for each character in t and count their frequency in t as the value of hashmap.
2. Find the first window in S that contains T.
3. Checking from the leftmost index of the window and to see if it belongs to t. The reason we do so is that we want to shrink the size of the window.
   3-1) If the character at leftmost index does not belong to t, we can directly remove this leftmost value and update our window(its minLeft and minLen value)
   3-2) If the character indeed exists in t, we still remove it, but in the next step, we will increase the right pointer and expect the removed character. If find so, repeat step 3.

代码

class Solution {
    public String minWindow(String s, String t) {
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();;
        for(char c : t.toCharArray()){
            if(map.containsKey(c)){
                map.put(c, map.get(c)+1);
            }else{
                map.put(c, 1);
            }
        }
        int counter=t.length(), begin=0, end=0, head=0, d=Integer.MAX_VALUE;
        while(end<s.length()){　// 先找左边第一个包含T的substring
            char c_left=s.charAt(end);
            if(map.containsKey(c_left)){
                map.put(c_left, map.get(c_left)-1);
                if(map.get(c_left)>=0) counter--;
            }
            end++;
            while(counter==0){ // 如果找到，则从substring的左边考虑
                if(end-begin<d){
                    head=begin;
                    d=end-begin;
                }
                char c_right=s.charAt(begin);
                if(map.containsKey(c_right)){
                    map.put(c_right, map.get(c_right)+1);
                    if(map.get(c_right)>0)  counter++;
                }
                begin++;
            }
        }
        return d==Integer.MAX_VALUE? "":s.substring(head, head+d);

    }
} 

2. Largest Rectangle in Histogram

Given n non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

The largest rectangle is shown in the shaded area, which has area = 10 unit.

Example:

Input: [2,1,5,6,2,3]
Output: 10

思路

解法和trap water那题有点类似，不过得转换下思维。还是利用栈，想到这点了，但是我一直在纠结后输入的bar后前面bar的组成的rectangle有什么关系或规律，当然这也是看了这题后最直观的想法了。这个切入点不是很好解题，这个时候应该换下思路才行，感觉犯了和trap water那题一样的思维错误，最直观的想法往往只适合循环遍历，即brute force。利用栈来解这题的话还是得换个切入点的。

和trap water那题一样，不去考虑不同bar之间的组合情形，而是从单个bar的入手，求包含每个bar为最低高度的 rectangle 来考虑。

For every bar ‘x’, we calculate the area with ‘x’ as the smallest bar in the rectangle. If we calculate such area for every bar ‘x’ and find the maximum of all areas, our task is done

至于怎么计算这个rectangle，其实就和trap water那题计算每个bar所能trap的water 是差不多的。

代码

class Solution {
    public int largestRectangleArea(int[] heights) {
        Stack<Integer> st=new Stack();
        int left=0;
        int maxArea=0;
        for(int i=0;i<=heights.length;i++){
            int h= (i==heights.length? 0:heights[i]);
            if(st.isEmpty() || h>=heights[st.peek()]){
                st.push(i);
            }else{
                int hi=heights[st.pop()];
                left=(st.isEmpty()? -1:st.peek());
                maxArea=Math.max(maxArea, (i-left-1)*hi);
                i--;
            }
        }
        return maxArea;
    }
}