Heap — 20181120

363. Trapping Rain Water

 public class Solution {
     /**
      * @param heights: a list of integers
      * @return: a integer
      */
     public int trapRainWater(int[] heights) {
         // write your code here
         if (heights == null || heights.length == 0) {
             return 0;
         }

         int start = 0;
         int end = heights.length - 1;
         int maxLeft = Integer.MIN_VALUE;
         int maxRight = Integer.MIN_VALUE;
         int sum = 0;
         while (start < end) {
             maxLeft = heights[start] > maxLeft ? heights[start] : maxLeft;
             maxRight = heights[end] > maxRight ? heights[end] : maxRight;
             if (maxLeft < maxRight) {
                 sum += maxLeft - heights[start];
                 start++;
             } else {
                 sum += maxRight - heights[end];
                 end--;
             }
         }
         return sum;
     }
 }

364. Trapping Rain Water II

 class Point {
     int x;
     int y;
     int height;

     public Point(int x, int y, int height) {
         this.x = x;
         this.y = y;
         this.height = height;
     }
 }

 public class Solution {
     /**
      * @param heights: a matrix of integers
      * @return: an integer
      */

     int[] dx = {0, 1, 0, -1};
     int[] dy = {1, 0, -1, 0};

     public int trapRainWater(int[][] heights) {
         // write your code here
         if (heights == null || heights.length == 0 || heights[0].length == 0) {
             return 0;
         }
         int r = heights.length;
         int c = heights[0].length;
         boolean[][] visited = new boolean[r][c];

         Comparator<Point> minComparator = new Comparator<Point>() {
             @Override
             public int compare(Point o1, Point o2) {
                 return o1.height - o2.height;
             }
         };

         PriorityQueue<Point> minHeap = new PriorityQueue<>(minComparator);

         for (int i = 0; i < r; i++) {
             minHeap.add(new Point(i, 0, heights[i][0]));
             visited[i][0] = true;
             minHeap.add(new Point(i, c - 1, heights[i][c - 1]));
             visited[i][c - 1] = true;
         }

         for (int j = 0; j < c; j++) {
             minHeap.add(new Point(0, j, heights[0][j]));
             visited[0][j] = true;
             minHeap.add(new Point(r - 1, j, heights[r - 1][j]));
             visited[r - 1][j] = true;
         }

         int sum = 0;
         while (!minHeap.isEmpty()) {
             Point point = minHeap.poll();

             for (int i = 0; i < 4; i++) {
                 int nx = point.x + dx[i];
                 int ny = point.y + dy[i];
                 if (!isValid(nx, ny, heights, visited)) {
                     continue;
                 }

                 visited[nx][ny] = true;
                 minHeap.add(new Point(nx, ny, Math.max(heights[nx][ny], point.height)));
                 sum += Math.max(heights[nx][ny], point.height) - heights[nx][ny];
             }
         }
         return sum;

     }

     public boolean isValid(int x, int y, int[][] heights, boolean[][] visited) {
         if (x < 0 || x > heights.length - 1 || y < 0 || y > heights[0].length - 1) {
             return false;
         }
         if (visited[x][y]) {
             return false;
         }
         return true;
     }
 }

360. Sliding Window Median 具体思路见  81. Find Median from Data Stream

 public class Solution {
     /**
      * @param nums: A list of integers
      * @param k: An integer
      * @return: The median of the element inside the window at each moving
      */
     private PriorityQueue<Integer> minHeap;
     private PriorityQueue<Integer> maxHeap;
     private int maxSize = 0;
     private int minSize = 0;

     public List<Integer> medianSlidingWindow(int[] nums, int k) {
         // write your code here
         if (nums == null || nums.length < k || k <= 0) {
             return new ArrayList<>();
         }

         minHeap = new PriorityQueue<>();
         maxHeap = new PriorityQueue<>(new Comparator<Integer>() {
             @Override
             public int compare(Integer o1, Integer o2) {
                 return o2.compareTo(o1);
             }
         });
         List<Integer> res = new ArrayList<>();

         for (int i = 0; i < k; i++) {
             addNumber(nums[i]);
         }
         res.add(getMedian());
         for (int j = k; j < nums.length; j++) {
             slideByWindow(nums[j], nums[j - k]);
             res.add(getMedian());
         }
         return res;
     }

     public void addNumber(int num) {
         maxHeap.add(num);
         maxSize++;
         if (maxSize - minSize <= 1) {
             if (minHeap.isEmpty()) {
                 return;
             }

             if (maxHeap.peek() > minHeap.peek()) {
                 int maxTemp = maxHeap.poll();
                 int minTemp = minHeap.poll();
                 minHeap.add(maxTemp);
                 maxHeap.add(minTemp);
             }
             return;
         }

         minHeap.add(maxHeap.poll());
         minSize++;
         maxSize--;
     }

     public int getMedian() {
         return maxHeap.peek();
     }

     public void slideByWindow(int toAdd, int toRemove) {
         if (toRemove <= getMedian()) {
             maxHeap.remove(toRemove);
             maxSize--;
         } else {
             minHeap.remove(toRemove);
             minSize--;
         }
         addNumber(toAdd);
     }
 }