leetcode 352 & leetcode 239 & leetcode 295 & leetcode 53 & leetcode 209

最新推荐文章于 2024-09-12 11:28:45 发布

weixin_30263073

最新推荐文章于 2024-09-12 11:28:45 发布

阅读量87

点赞数

原文链接：http://www.cnblogs.com/hwd9654/p/10917735.html

版权

lc352 Data Stream as Disjoint Intervals

可以用treemap解

key保存interval的start，value保存interval的end。分别找出当前val的lowerKey（treemap中>val的最小key值，没有就返回null）和higherKey(<val的最大key没有就返回null) 有以下几种情况： 1）当前插入的key与前后两个interval重叠合并三者，将前一个的interval.end改成后一个的end，并且将后一个从treemap中删除 2）当前插入的key与前面的interval重叠合并，前一个interval的end改成Math.max(end, val) 注意这里的判断条件不能写成 treemap.(treemap.lowerKey(val)) == val – 1; 而是应该写成>=，前者会出现异常，举例来说[4, 9] 现在val=7，按前者的判断条件，可能就直接放到case4里了，变成[4, 9]和[7, 7]共存 3）当前插入的key与后面的interval重叠 put(val, 后一个的end) remove(后一个的key) 4）当前插入的key不和任何已存在interval重叠，直接插入，按题意value设为key值

class SummaryRanges {
    TreeMap<Integer, Integer> tree;
    /** Initialize your data structure here. */
    public SummaryRanges() {
        tree = new TreeMap<>();
    }
    
    public void addNum(int val) {
        if(tree.containsKey(val))
            return;
        Integer l = tree.lowerKey(val);
        Integer h = tree.higherKey(val);
        Integer lv = l == null ? null : tree.get(l);
        Integer hv = h == null ? null : tree.get(h);
        
        if(l != null && h != null && lv == val - 1 && h == val + 1){
            //lv = hv;
            tree.put(l, hv);
            tree.remove(h);
        }else if(l != null && lv >= val - 1){
            //lv = val;
            tree.put(l, Math.max(lv, val));
        }else if(h != null && h == val + 1){
            tree.put(val, hv);
            tree.remove(h);
        }else{
            tree.putIfAbsent(val, val);
        }
        
    }
    
    public int[][] getIntervals() {
        Iterator it = tree.keySet().iterator();
        int i = 0;
        int[][] res = new int[tree.size()][2];
        while(it.hasNext()){
            Integer key = (Integer)it.next();
            res[i][0] = key;
            res[i][1] = tree.get(key);
            i++;
        }
        return res;
    }
    /*public int[][] getIntervals() {
        return tree.entrySet()
                .stream()
                .map(e -> new int[]{e.getKey(), e.getValue()})
                .toArray(int[][]::new);
    }*/
}

/**
 * Your SummaryRanges object will be instantiated and called as such:
 * SummaryRanges obj = new SummaryRanges();
 * obj.addNum(val);
 * int[][] param_2 = obj.getIntervals();
 */

239 Sliding Window Maximum

1）双向队列，时间复杂度o(n)

　　a）维护一个最大长为k（可能实际长度小于k，见b）的双向队列，保证当前队列有序，头元素为最大，这样每次只需要取dq.peek()即可。怎么保证队列有序其头元素最大呢？每次i迭代后，把队列中没有用的元素剔除。就是把<nums[i]的元素全部剔除，然后把nums[i]的索引i放入队列。怎么剔除？这里就用到了双向队列，从队尾开始删pollLast() 注意，队列中存放的是index而非值本身，目的是为了下一步b中确定队头元素的位置是否还在window内

　　b）保证队头的元素都来自i-k+1~i，因为这是一个sliding window。 if(dp.peek() < i-k+1) dp.poll() //直接删除队首元素

 1 class Solution {
 2     public int[] maxSlidingWindow(int[] nums, int k) {
 3         if(nums == null ||nums.length == 0)
 4             return nums;
 5         int len = nums.length;
 6         int size = len - k + 1;
 7         
 8         int[] res = new int[size];
 9         Deque<Integer> dq = new ArrayDeque<>();
10         
11         
12         for(int i=0, j=0; i<len; i++){
13             while(!dq.isEmpty() && dq.peek() < i - k + 1)
14                 dq.poll();
15             
16             while(!dq.isEmpty() && nums[dq.peekLast()] <= nums[i])
17                 dq.pollLast();
18             dq.offer(i);
19             if(i >= k-1)
20                 res[j++] = nums[dq.peek()];
21         }
22         
23         return res;
24         
25     }
26 }

2）最大堆，时间复杂度o(nlogk)

维护一个大小为k的最大堆，可以把priorityqueue翻转一下即可 PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.reverseOrder()) 每次i迭代，去掉nums[i-k]，插入nums[i]，然后取堆root元素即可。

295 Find Median from Data Stream

用一个最大堆和一个最小堆，最大堆里放历史数据流中前k小的数，最小堆中放剩下的数，数据流总size为偶数，则两个堆大小相等，若为奇数，则最大堆比最小堆多一个数。这样我们median要么是最大堆root值，要么是两个堆root的平均值。

 1 class MedianFinder {
 2         PriorityQueue<Integer> min = new PriorityQueue<>();
 3         PriorityQueue<Integer> max = new PriorityQueue<>(Comparator.reverseOrder());
 4     /** initialize your data structure here. */
 5     public MedianFinder() {
 6         
 7     }
 8     
 9     public void addNum(int num) {
10         max.offer(num);
11         min.offer(max.poll());
12         if(max.size() < min.size())
13             max.offer(min.poll());
14     }
15     
16     public double findMedian() {
17         if(max.size() == min.size())
18             //return (max.poll() + min.poll()) / 2;
19             //poll() will remove the first element of priorityqueue, but peek() will just retrieve the value and will not remove the element
20             return (max.peek() +min.peek()) / 2.0;
21         else
22             return max.peek();
23     }
24 }
25 
26 /**
27  * Your MedianFinder object will be instantiated and called as such:
28  * MedianFinder obj = new MedianFinder();
29  * obj.addNum(num);
30  * double param_2 = obj.findMedian();
31  */

53 Maximum Subarray

用dp解

dp[i]定义为包含当前i的最大子序列

递归式：dp[i] = max(dp[i-1], dp[i-1] + nums[i]);

注意还要用一个max变量保存dp[i]中（i=0~n-1）最大的那个dp[i]

返回值为max

 1 class Solution {
 2     public int maxSubArray(int[] nums) {
 3         if(nums == null ||nums.length == 0)
 4             return 0;
 5         int len = nums.length;
 6         int[] dp = new int[len];
 7         dp[0] = nums[0];
 8         int max = dp[0];
 9         
10         for(int i=1; i<len; i++){
11             dp[i] = Math.max(dp[i-1] + nums[i], nums[i]);
12             max = Math.max(max, dp[i]);
13         }
14         //max = Math.max(max, dp[0]);
15         return max;
16     }
17 }

209 Minimum Size Subarray Sum

双指针，

一个指针用来求和，即j-i的所有元素只和，sum += nums[i++]

一个指针用来减去0-j的元素, sum -= nums[j++] 每当j~i之和>=s，记录j~i的长度，用一个min记录所有ij组合的长度最小值,r然后减去当前j所指元素，j++，直到j~i之和<s

 1 class Solution {
 2     public int minSubArrayLen(int s, int[] nums) {
 3         if(nums == null || nums.length == 0)
 4             return 0;
 5         int i=0, j=0, min = Integer.MAX_VALUE;
 6         int sum = 0;
 7         
 8         while(i < nums.length){
 9             sum += nums[i++];
10             
11             while(sum >= s){
12                 min = Math.min(min, i-j);
13                 sum -= nums[j++];
14             }
15         }
16         
17         return min == Integer.MAX_VALUE ? 0 : min;
18     }
19     
20     
21 }