题目要求比较类似的题目

接水问题

Container With Most Water

Given n non-negative integers a1, a2, ..., an, where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.

两个指针问题。需要计算的是两条线之间的最大面积。使用两个指针，先结算小的那边，因为这边此时的高度成为了下界，不移动这边的话，其他任何情况都会有此下界而且长度变短。

public int maxArea(int[] height) {
        if (height == null || height.length < 2) {
            return 0;
        }
        int left = 0;
        int right = height.length - 1;
        int res = 0;
        while (left < right) {
            if (height[left] < height[right]) {
                res = Math.max(res, height[left] * (right - left));
                left++;
            } else {
                res = Math.max(res, height[right] * (right - left));
                right--;
            }
        }
        return res;
    }

Trapping Rain Water

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.

一共可以接多少水。首先找到一个最大作为保障。然后分别计算左边和右边。分槽位计算每个槽位可以放多少水

public int trap(int[] height) {
        if(height==null||height.length<3)
            return 0;
        int max=0,maxIndex=0;
        for(int i=0;i<height.length;i++){
            if(height[i]>max)
            {
                max=height[i];
                maxIndex=i;
            }
        }
        int area=0;
        int left=0;
        for(int i=0;i<maxIndex;i++){
            if(height[i]<height[left]){
                area+=height[left]-height[i];
            }
            else
                left=i;
        }
        int right=height.length-1;
       for(int i=height.length-1;i>maxIndex;i--){
           if(height[i]<height[right])
               area+=height[right]-height[i];
           else
               right=i;
       }
        return area;
    }

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.

方法一：

升序栈。如果新来的数大于栈顶元素，直接压入。否则，弹出栈顶元素。而且要一直弹到栈为空或者栈顶元素小于新来的数。这是为什么呢？因为如果你新来的数小的话，那么这个数就是栈顶元素的右边界，弹出栈顶元素之后的栈顶元素（如果有的话）就是弹出的那个数的左边第一个比它小的数。

public int largestRectangleArea(int[] heights) {
        if (heights == null || heights.length == 0) {
            return 0;
        }
        Stack<Integer> stack = new Stack<Integer>();
        int res = 0;
        for (int i = 0; i <= heights.length; i++) {
            int cur = i == heights.length ? -1 : heights[i];
            while (!stack.isEmpty() && heights[stack.peek()] > cur) {
                int height = heights[stack.pop()];
                res = Math.max(res, (i - (stack.isEmpty() ? -1 : stack.peek()) - 1) * height);
            }
            stack.push(i);
        }
        return res;
    }

方法二：

DP。分别求出每个位置往左边可以扩张的最大位置和往右边可以扩张的最大位置。

public int largestRectangleArea(int[] heights) {
        if (heights == null || heights.length == 0) {
            return 0;
        }
        int n = heights.length;
        int[] left = new int[n]; // left[i]表示当前高度扩张的最左边
        int[] right = new int[n]; // right[i]表示当前高度扩展的最右边
        right[n - 1] = n - 1;
        for (int i = n - 2; i >= 0; i--) {
            int j = i + 1;
            while (j < n && heights[j] >= heights[i]) {
                j = right[j] + 1;
            }
            right[i] = j - 1; 
        }
        int res = 0;
        for (int i = 0; i < n; i++) {
            int j = i - 1;
            while (j >= 0 && heights[j] >= heights[i]) {
                j = left[j] - 1;
            }
            left[i] = j + 1; 
            res = Math.max(res, heights[i] * (right[i] - left[i] + 1)); // 一边扩张，一边结算
        }
        return res;
    }

删除重复元素问题

Remove Element

删除所有等于val的元素。

public int removeElement(int[] nums, int val) {
        if(nums.length<1)
            return nums.length;
        int pos=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]!=val){
                nums[pos++]=nums[i];
            }
        }
        return pos;
    }

Remove Linked List Elements

删除链表中值等于val的节点。

注意最后tail的next需要指向null

public ListNode removeElements(ListNode head, int val) {
        if (head == null) {
            return head;
        }
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        while (head != null) {
            if (head.val == val) {
                head = head.next;
            } else {
                tail.next = head;
                tail = head;
                head = head.next;
            }
        }
        tail.next = null; // Attention
        return dummy.next;
    }

Remove Duplicates from Sorted Array

删除重复元素，只保留一个。

public int removeDuplicates(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int left = 0;
        int i = 0;
        while (i < nums.length) {
            if (nums[i] == nums[left]) {
                i++;
            } else {
                nums[++left] = nums[i++];
            }
        }
        return left + 1;
    }

Remove Duplicates from Sorted Array II --not bug free

删除重复元素，最多保留两个。

pos记录一个新数位置，后边的如果等于nums[pos]就把times++,如果times == 2, 加一个进来，再多的话则不在处理。新来的数不等于nums[pos]的话，pos后边移动一位并放数。

 public int removeDuplicates(int[] nums) {
        if (nums == null) {
            return 0;
        }
        if (nums.length < 3) {
            return nums.length;
        }
        int n = nums.length;
        int pos = 0;
        int times = 1;
        for (int i = 1; i < n; i++) {
            if (nums[i] == nums[pos]) {
                times++;
                if (times == 2) {
                    nums[++pos] = nums[i];
                }
            } else {
                nums[++pos] = nums[i];
                times = 1;
            }
        }
        return pos + 1;
    }

Remove Duplicates from Sorted List

删除排序链表重复元素，保留一个。

public ListNode deleteDuplicates(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode cur = head;
        while (cur.next != null) {
            if (cur.val == cur.next.val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        return head;
    }

Remove Duplicates from Sorted List II--not bug free

删除排序链表重复元素，所有都删除。

public ListNode deleteDuplicates(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode tail = dummy;
        while (head != null) {
            while (head.next != null && head.val == head.next.val) {
                head = head.next;
            }
            if (tail.next == head) {
                tail = tail.next;
                head = head.next;
            } else {
                head = head.next;
                tail.next = head;
            }
        }
        return dummy.next;
    }

两种缓存方法

LRU Cache****--not bug free

get的时候忘记检测是否包含在map中了。

近期最少使用页面置换算法

方法一：HashMap + DoublyLinkedList

使用hashMap来记录一个页面是否出现过。如果只有get和set功能，那么这一个map就够用了，但是现在的问题是还需要在到达cache size的时候弹出最老的那一个，那么这怎么办呢？一种想法是直接记录一个LinkedList就行了嘛，每次删除list头部的那个,对应的删除map中的键值对。但是还有一个问题是假如缓存中已经存在了的页面又来了呢？这时候就需要从原始链表中把这个页面删除，但是问题来了，删除结点的前后两个结点是需要连接起来的，所以考虑到这一点，需要使用一个双向链表。

 private int capacity;
    private int size;
    HashMap<Integer, Node> hashMap;
    Node dummyEnd;
    Node dummyHead;
    
    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.size = 0;
        hashMap = new HashMap<Integer, Node>();
        // 新来节点加到dummyHead之后，最老节点是dummyEnd前一个节点
        dummyHead = new Node(0, 0);
        dummyEnd = new Node(0, 0);
        dummyHead.next = dummyEnd;
        dummyEnd.prev = dummyHead;
    }
    
    public int get(int key) {
        if (hashMap.containsKey(key)) {
            set(key, hashMap.get(key).val);
            return hashMap.get(key).val;
        } else {
            return -1;
        }
    }
    
    public void set(int key, int value) {
        if (hashMap.containsKey(key)) {
            Node cur = hashMap.get(key);
            cur.prev.next = cur.next;
            cur.next.prev = cur.prev;
        } else if (size == capacity) {
            Node end = dummyEnd.prev;
            end.prev.next = dummyEnd;
            dummyEnd.prev = end.prev;
            hashMap.remove(end.key);
        } else {
            size++;
        }
        Node newNode = new Node(key, value);
        hashMap.put(key, newNode);
        newNode.next = dummyHead.next;
        dummyHead.next.prev = newNode;
        dummyHead.next = newNode;
        newNode.prev = dummyHead;
    }
    class Node {
        int key;
        int val;
        Node next;
        Node prev;
        public Node(int key, int val) {
            this.key = key;
            this.val = val;
        }
    }

方法二：Java库中的LinkedHashMap可以其实就是基于hashMap和双向链表实现的，可以完美实现上述功能。

private int capacity;
    private LinkedHashMap<Integer, Integer> linkedHashMap;
    public LRUCache(int capacity) {
        this.capacity = capacity;
         // true表示对于map中已经存在了的key,要不要更新为最开始
        linkedHashMap = new LinkedHashMap<Integer, Integer>(capacity, (float)0.75, true) { 
            protected boolean removeEldestEntry(Map.Entry eldest) { // 重写这个方法，超过缓存大小的时候，就会删除最老的页面
                return size() > capacity;
            }
        };
    }
    
    public int get(int key) {
        Integer value = linkedHashMap.get(key);
        return value == null ? -1 : value;
    }
    
    public void set(int key, int value) {
        if (capacity == 0) {
            return;
        }
        linkedHashMap.put(key, value);
    }

LFU Cache****

最近最不常使用页面置换算法。

方法一：PriorityQueue   get O(capacity) set O(capacity)

long stamp;
    int capacity;
    int num;
    PriorityQueue<Pair> minHeap;
    HashMap<Integer, Pair> hashMap;

    // @param capacity, an integer
    public LFUCache(int capacity) {
        // Write your code here
        this.capacity = capacity;
        num = 0;
        minHeap = new PriorityQueue<Pair>();
        hashMap = new HashMap<Integer, Pair>();
        stamp = 0;
    }

    // @param key, an integer
    // @param value, an integer
    // @return nothing
    public void set(int key, int value) {
        if (capacity == 0) {
            return;
        }
        // Write your code here
        if (hashMap.containsKey(key)) {
            Pair old = hashMap.get(key);
            minHeap.remove(old);
            
            Pair newNode = new Pair(key, value, old.times + 1, stamp++);
            
            hashMap.put(key, newNode);
            minHeap.offer(newNode);
        } else if (num == capacity) {
            Pair old = minHeap.poll();
            hashMap.remove(old.key);
            
            Pair newNode = new Pair(key, value, 1, stamp++);
            
            hashMap.put(key, newNode);
            minHeap.offer(newNode);
        } else {
            num++;
            Pair pair = new Pair(key, value, 1, stamp++);
            hashMap.put(key, pair);
            minHeap.offer(pair);
        }
    }

    public int get(int key) {
        if (capacity == 0) {
            return -1;
        }
        // Write your code here
        if (hashMap.containsKey(key)) {
            Pair old = hashMap.get(key);
            minHeap.remove(old);
            
            Pair newNode = new Pair(key, old.value, old.times + 1, stamp++);
            
            hashMap.put(key, newNode);
            minHeap.offer(newNode);
            return hashMap.get(key).value;
        } else {
            return -1;
        }
    }
    
    class Pair implements Comparable<Pair> {
        long stamp;
        int key;
        int value;
        int times;
        public Pair(int key, int value, int times, long stamp) {
            this.key = key;
            this.value = value;
            this.times = times;
            this.stamp = stamp;
        }
        
        public int compareTo(Pair that) {
            if (this.times == that.times) {
                return (int)(this.stamp - that.stamp);
            } else {
                return this.times - that.times;    
            }
        }
    }

方法二：HashMap + TreeMap   get O(log (capacity)) set O(log(capacity))

private int capacity;
    private int stamp;
    private HashMap<Integer, Tuple> hashMap;
    private TreeMap<Tuple, Integer> treeMap;
    public LFUCache(int capacity) {
        this.capacity = capacity;
        stamp = 0;
        hashMap = new HashMap<Integer, Tuple>(); 
        treeMap = new TreeMap<Tuple, Integer>(new Comparator<Tuple>() {
            public int compare(Tuple t1, Tuple t2) {
                if (t1.times == t2.times) {
                    return t1.stamp - t2.stamp;
                }
                return t1.times - t2.times;
            }
        });
    }
    
    public int get(int key) {
        if (capacity == 0) {
            return -1;
        }
        if (!hashMap.containsKey(key)) {
            return -1;
        }
        Tuple old = hashMap.get(key);
        treeMap.remove(old);
        Tuple newTuple = new Tuple(old.value, stamp++, old.times + 1);
        treeMap.put(newTuple, key);
        hashMap.put(key, newTuple);
        return old.value;
    }
    
    public void set(int key, int value) {
        if (capacity == 0) {
            return;
        }
        if (hashMap.containsKey(key)) {
            Tuple old = hashMap.get(key);
            Tuple newTuple = new Tuple(value, stamp++, old.times + 1);
            treeMap.remove(old);
            hashMap.put(key, newTuple);
            treeMap.put(newTuple, key);
        } else {
            if (treeMap.size() == capacity) {
                int endKey = treeMap.pollFirstEntry().getValue();
                hashMap.remove(endKey);
            }
            Tuple newTuple = new Tuple(value, stamp++, 1);
            hashMap.put(key, newTuple);
            treeMap.put(newTuple, key);
        }
    }
    class Tuple {
        int value;
        int times;
        int stamp;
        public Tuple (int value, int stamp, int times) {
            this.value = value;
            this.stamp = stamp;
            this.times = times;
        }
    }

方法三：HashMap + HashMap + DoublyLinkedList **** --not bug free

使用一个map来记录出现过的节点，一个map来记录出现过key次的最后一个节点。

 private int capacity;
    private int count;
    private HashMap<Integer, Tuple> map1; // whether appeared
    private HashMap<Integer, Tuple> finalNodes; // value : the final node of key times
    private Tuple dummyHead;
    private Tuple dummyEnd;

    public LFUCache(int capacity) {
        this.capacity = capacity;
        count = 0;
        map1 = new HashMap<Integer, Tuple>();
        finalNodes = new HashMap<>();
        dummyHead = new Tuple(0, 0, 0);
        dummyEnd = new Tuple(0, 0, 0);
        dummyHead.next = dummyEnd;
        dummyEnd.prev = dummyHead;
    }

    public int get(int key) {
        if (capacity == 0 || !map1.containsKey(key)) {
            return -1;
        }
        Tuple old = map1.get(key);
        set(key, old.value);
        return old.value;
    }

    public void set(int key, int value) {
        if (capacity == 0) {
            return;
        }
        if (map1.containsKey(key)) { // this key has appeared
            Tuple cur = map1.get(key);
            if (finalNodes.get(cur.times) == cur && finalNodes.get(cur.times + 1) == null) { // the position should not change
                finalNodes.put(cur.times, cur.prev.times == cur.times ? cur.prev : null);
                cur.times++;
                cur.value = value;
                finalNodes.put(cur.times, cur);
                return;
            }
            removeNode(cur); // remove node cur
            if (finalNodes.get(cur.times) == cur) {
                finalNodes.put(cur.times, cur.prev.times == cur.times ? cur.prev : null);
            }
            cur.times++;
            cur.value = value;
            Tuple finalNode = finalNodes.get(cur.times) == null ? finalNodes.get(cur.times - 1) : finalNodes.get(cur.times);
            insertNode(finalNode, cur); 
            finalNodes.put(cur.times, cur); // cur is the final node whitch appeared cur.times
        } else if (count == capacity) { // reach limt of the cache
            Tuple head = dummyHead.next;
            removeNode(head); //remove the first which appeared least times and is the least Used
            map1.remove(head.key);
            if (finalNodes.get(head.times) == head) {
                finalNodes.remove(head.times);
            }
            Tuple cur = new Tuple(key, value, 1);
            if (finalNodes.get(1) == null) {
                insertNode(dummyHead, cur);
            } else {
                Tuple finalNode = finalNodes.get(1);
                insertNode(finalNode, cur);
            }
            finalNodes.put(1, cur);
            map1.put(key, cur);
        } else {
            count++;
            Tuple cur = new Tuple(key, value, 1);
            if (finalNodes.get(1) == null){
               insertNode(dummyHead, cur);
            } else {
                Tuple finalNode = finalNodes.get(1);
                insertNode(finalNode, cur);
            }
            finalNodes.put(1, cur);
            map1.put(key, cur);
        }
    }

    public void insertNode(Tuple t1, Tuple t2) {
        t2.next = t1.next;
        t1.next.prev = t2;
        t1.next = t2;
        t2.prev = t1;
    }

    public void removeNode(Tuple node) {
        node.next.prev = node.prev;
        node.prev.next = node.next;
    }
    class Tuple {
        int key;
        int value;
        int times;
        Tuple prev;
        Tuple next;
        public Tuple(int key, int value, int times) {
            this.key = key;
            this.value = value;
            this.times = times;
        }
    }