九章算法基础班

随时补充  ----

Remove Substrings

Given a string s and a set of n substrings. You are supposed to remove every instance of those n substrings from s so that s is of the minimum length and output this minimum length.

Have you met this question in a real interview? Yes
Example
Given s = ccdaabcdbb, substrs = ["ab", "cd"]
Return 2

Explanation: 
ccdaabcdbb -> ccdacdbb -> cabb -> cb (length = 2)

思路：很容易想到贪心，能尽量削减原串就削减原串，但是贪心是错误的，反例："abcabd", ["ab","abcd"]

　　　用DFS，对于dict中的每一个子串，在原串中找到匹配的该串的索引，并截取原字符串，更新结果，将截取后的字符串加入到队列中(增加一个set来避免相同的串重复加入到队列)以便下一次循环，然后从该索引后面的一个位置开始再找与该子串匹配的索引，重复上述过程。

public class Solution {
    /**
     * @param s a string
     * @param dict a set of n substrings
     * @return the minimum length
     */
    public int minLength(String s, Set<String> dict) {
        // Write your code here
        if (s == null) {
            return 0;
        }
        if (s.length() == 0 || dict == null || dict.size() == 0) {
            return s.length();
        }
        int result = s.length();
        Queue<String> queue = new LinkedList<>();
        Set<String> set = new HashSet<>();
        queue.offer(s);
        set.add(s);
        while (!queue.isEmpty()) {
            String str = queue.poll();
            for (String subStr : dict) {
                int index = str.indexOf(subStr);
                while (index != -1) {
                    String newStr = str.substring(0, index)
                        + str.substring(index + subStr.length(), str.length());
                    if (!set.contains(newStr)) {
                        set.add(newStr);
                        queue.offer(newStr);
                        result = Math.min(result, newStr.length());
                    }
                    index = str.indexOf(subStr, index + 1);
                }
            }
        }
        return result;
    }
}

Permutation Index

Given a permutation which contains no repeated number, find its index in all the permutations of these numbers, which are ordered in lexicographical order. The index begins at 1.

Have you met this question in a real interview? Yes
Example
Given [1,2,4], return 1.

思路：

对于某一个给定的位数A[i],需要判断在它后面有几个小于它的数，记下这个数字和A[i]所在的位置。

比如对于一个四位数，5316  ， 第一位后面有2小于它的数，如果这两个数排在第一位，那么（1和3）各有3！的排列组合数小于（5316）.

同理，对于第二位，其后有1个小于它的数，如果它放在第二位，那么有2！种排列。

因此判断一个给定数位于排列组合的第几位，则可以按照以下公式进行

count1*(A.length-1)!+count2*(A.length-2)!+......+countn*(0)!

public class Solution {
    /**
     * @param A an integer array
     * @return a long integer
     */
    public long permutationIndex(int[] A) {
        // Write your code here
        if (A == null || A.length == 0) {
            return 0;
        }
        long result = 1;
        long factor = 1;
        for (int i = A.length - 1; i >= 0; i--) {
            int count = 0;
            for (int j = i + 1; j < A.length; j++) {
                if (A[j] < A[i]) {
                    count++;
                }
            }
            result += count * factor;
            factor *= A.length - i;
        }
        return result;
    }
}

Permutation Index II

Given a permutation which may contain repeated numbers, find its index in all the permutations of these numbers, which are ordered in lexicographical order. The index begins at 1.

Have you met this question in a real interview? Yes
Example
Given the permutation [1, 4, 2, 2], return 3.

思路：

这道题和Permutation IndexI思想一样，计算每一位上数字是该位上第几个排列，再将每一位结果加和即可。只是这道题有重复元素，有无重复元素最大的区别在于原来的1!, 2!, 3!...等需要除以重复元素个数的阶乘。按照数字从低位到高位进行计算。每遇到一个重复的数字就更新重复元素个数的阶乘的值。

1. 从后往前遍历数组，用一个hashmap来记录重复元素个数。若新来的数不是重复元素，则加入hashmap，否则将重复元素个数＋1，同时更新重复元素个数的阶乘。

2. 比较当前位和其后面位的数，计算当前位是第几大的数count

3. 当前位的index为：2的结果count * 其后面位数的阶乘/重复数个数的阶乘。将当前位计入阶乘，重复1-3计算前一位。

4. 注意：1.题目说index从1开始算。2.要用long来保存result，factor和repeatFactor，用int有可能超过范围

public class Solution {
    /**
     * @param A an integer array
     * @return a long integer
     */
    public long permutationIndexII(int[] A) {
        // Write your code here
        if (A == null || A.length == 0) {
            return 0;
        }
        long result = 1;
        long factor = 1;
        long repeatFactor = 1;
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = A.length - 1; i >= 0; i--) {
            if (!map.containsKey(A[i])) {
                map.put(A[i], 1);
            } else {
                map.put(A[i], map.get(A[i]) + 1);
                repeatFactor *= map.get(A[i]);
            }
            int count = 0;
            for (int j = i + 1; j < A.length; j++) {
                if (A[j] < A[i]) {
                    count++;
                }
            }
            result += count * factor / repeatFactor;
            factor *= A.length - i;
        }
        return result;
    }
}

Maximum Subarray

Given an array of integers, find a contiguous subarray which has the largest sum.

 Notice

The subarray should contain at least one number.

Have you met this question in a real interview? Yes
Example
Given the array [−2,2,−3,4,−1,2,1,−5,3], the contiguous subarray [4,−1,2,1] has the largest sum = 6.

思路：sum记录到当前索引的子数组的和，minSum记录该索引之前的子数组（从索引0开始）的和的最小值。sum - minSum表示以当前索引结尾的最大子数组的和，遍历一遍后取sum - minSum的最大值即可。

public class Solution {
    /**
     * @param nums: A list of integers
     * @return: A integer indicate the sum of max subarray
     */
    public int maxSubArray(int[] nums) {
        // write your code
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int minSum = 0;
        int sum = 0;
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
            max = Math.max(max, sum - minSum);
            minSum = Math.min(minSum, sum);
        }
        return max;
    }
}

Maximum Subarray II

Given an array of integers, find two non-overlapping subarrays which have the largest sum.
The number in each subarray should be contiguous.
Return the largest sum.

 Notice

The subarray should contain at least one number

Have you met this question in a real interview? Yes
Example
For given [1, 3, -1, 2, -1, 2], the two subarrays are [1, 3] and [2, -1, 2] or [1, 3, -1, 2] and [2], they both have the largest sum 7.

思路：求两个不重叠的子数组的和最大。因为两个subarray 一定不重叠，所以必定存在一条分割线，分开这两个 subarrays。枚举分割线的位置，left[] 和 right[] 里分别存的是，某个位置往左的 maximum subarray 和往右的 maximum subarray。

public class Solution {
    /**
     * @param nums: A list of integers
     * @return: An integer denotes the sum of max two non-overlapping subarrays
     */
    public int maxTwoSubArrays(ArrayList<Integer> nums) {
        // write your code
        if (nums == null || nums.size() < 2) {
            return 0;
        }
        int sum = 0;
        int minSum = 0;
        int max = Integer.MIN_VALUE;
        int[] left = new int[nums.size()];
        for (int i = 0; i < nums.size(); i++) {
            sum += nums.get(i);
            max = Math.max(max, sum - minSum);
            minSum = Math.min(minSum, sum);
            left[i] = max;
        }
        sum = 0;
        minSum = 0;
        max = Integer.MIN_VALUE;
        int[] right = new int[nums.size()];
        for (int i = nums.size() - 1; i >= 0; i--) {
            sum += nums.get(i);
            max = Math.max(max, sum - minSum);
            minSum = Math.min(minSum, sum);
            right[i] = max;
        }
        max = Integer.MIN_VALUE;
        for (int i = 0; i < nums.size() - 1; i++) {
            max = Math.max(max, left[i] + right[i + 1]);
        }
        return max;
    }
}

Maximum Subarray Difference

Given an array with integers.

Find two non-overlapping subarrays A and B, which |SUM(A) - SUM(B)| is the largest.

Return the largest difference.

 Notice

The subarray should contain at least one number

Have you met this question in a real interview? Yes
Example
For [1, 2, -3, 1], return 6.

思路：求两个不重叠的子数组的差的绝对值最大。与Maximum Subarray II的区别在于，需要求出left_max、left_min、right_max、right_min这四个数组，分别表示某个位置往左的最大子数组、某个位置往左的最小子数组、某个位置往右的最大子数组、某个位置往右的最小子数组。然后枚举分割线的位置，对于某一位置的分割线，结果是左边最大值与右边最小值的差的绝对值或者左边最小值与右边最大值的差的绝对值。

public class Solution {
    /**
     * @param nums: A list of integers
     * @return: An integer indicate the value of maximum difference between two
     *          Subarrays
     */
    public int maxDiffSubArrays(int[] nums) {
        // write your code here
        if (nums == null || nums.length <= 1) {
            return 0;
        }
        int n = nums.length;
        int[] left_max = new int[n];
        int[] left_min = new int[n];
        int[] right_max = new int[n];
        int[] right_min = new int[n];
        int max = Integer.MIN_VALUE;
        int sum = 0;
        int minSum = 0;
        for (int i = 0; i < n; i++) {
            sum += nums[i];
            max = Math.max(max, sum - minSum);
            minSum = Math.min(minSum, sum);
            left_max[i] = max;
        }
        max = Integer.MIN_VALUE;
        sum = 0;
        minSum = 0;
        for (int i = n - 1; i >= 0; i--) {
            sum += nums[i];
            max = Math.max(max, sum - minSum);
            minSum = Math.min(minSum, sum);
            right_max[i] = max;
        }
        max = Integer.MIN_VALUE;
        sum = 0;
        minSum = 0;
        for (int i = 0; i < n; i++) {
            sum += -nums[i];
            max = Math.max(max, sum - minSum);
            minSum = Math.min(minSum, sum);
            left_min[i] = -max;
        }
        max = Integer.MIN_VALUE;
        sum = 0;
        minSum = 0;
        for (int i = n - 1; i >= 0; i--) {
            sum += -nums[i];
            max = Math.max(max, sum - minSum);
            minSum = Math.min(minSum, sum);
            right_min[i] = -max;
        }
        int result = 0;
        for (int i = 0; i < n - 1; i++) {
            result = Math.max(result, Math.abs(left_max[i] - right_min[i + 1]));
            result = Math.max(result, Math.abs(left_min[i] - right_max[i + 1]));
        }
        return result;
    }
}

Maximum Subarray III

Given an array of integers and a number k, find k non-overlapping subarrays which have the largest sum.

The number in each subarray should be contiguous.

Return the largest sum.

 Notice

The subarray should contain at least one number

Have you met this question in a real interview? Yes
Example
Given [-1,4,-2,3,-2,3], k=2, return 8

思路：

local[i][k]表示前i个元素取k个子数组并且必须包含第i个元素的最大和。

global[i][k]表示前i个元素取k个子数组不一定包含第i个元素的最大和。

local[i][k]的状态函数：

max(global[i-1][k-1], local[i-1][k]) + nums[i-1]

有两种情况，第一种是第i个元素自己组成一个子数组，则要在前i－1个元素中找k－1个子数组，第二种情况是第i个元素属于前一个元素的子数组，因此要在i－1个元素中找k个子数组（并且必须包含第i－1个元素，这样第i个元素才能合并到最后一个子数组中），取两种情况里面大的那个。

global[i][k]的状态函数：

max(global[i-1][k]，local[i][k])

有两种情况，第一种是不包含第i个元素，所以要在前i－1个元素中找k个子数组，第二种情况为包含第i个元素，在i个元素中找k个子数组且必须包含第i个元素，取两种情况里面大的那个。

注意这一题中DP的方向是先从上往下，再从左往右，而不是通常的先从左往右，再从上往下。这样做是因为localMax[j - 1][j]和globalMax[j - 1][j]置为Integer.MIN_VALUE的次数取决于列循环次数，而不是取决于行循环次数，否则二维数组下标会越界。

public class Solution {
    /**
     * @param nums: A list of integers
     * @param k: An integer denote to find k non-overlapping subarrays
     * @return: An integer denote the sum of max k non-overlapping subarrays
     */
    public int maxSubArray(int[] nums, int k) {
        // write your code here
        if (nums == null | nums.length == 0 || k <= 0 || k > nums.length) {
            return 0;
        }
        int n = nums.length;
        int[][] localMax = new int[n + 1][k + 1];
        int[][] globalMax = new int[n + 1][k + 1];
        for (int j = 1; j <= k; j++) {
            //前j－1个元素不可能找到不重叠的j个子数组，因此初始化为最小值
            //以防后面被取到
            localMax[j - 1][j] = Integer.MIN_VALUE;
            globalMax[j - 1][j] = Integer.MIN_VALUE;
            for (int i = j; i <= n; i++) {
                localMax[i][j] = Math.max(globalMax[i - 1][j - 1],
                    localMax[i - 1][j]) + nums[i - 1];
                globalMax[i][j] = Math.max(globalMax[i - 1][j], localMax[i][j]);
            }
        }
        return globalMax[n][k];
    }
}

Maximum Subarray IV

Given an integer arrays, find a contiguous subarray which has the largest sum and length should be greater or equal to given length k.
Return the largest sum, return 0 if there are fewer than k elements in the array.

 Notice

Ensure that the result is an integer type.

Have you met this question in a real interview? Yes
Example
Given the array [-2,2,-3,4,-1,2,1,-5,3] and k = 5, the contiguous subarray [2,-3,4,-1,2,1] has the largest sum = 5.

思路：同Maximum Subarray，区别在于更新min_pre的时机，不是每次循环都更新，而是i >= 的时候更新，这样才能保证子数组长度大于等于k。

public class Solution {
    /**
     * @param nums an array of integers
     * @param k an integer
     * @return the largest sum
     */
    public int maxSubarray4(int[] nums, int k) {
        // Write your code here
        if (nums == null || nums.length == 0 || k > nums.length) {
            return 0;
        }
        int n = nums.length;
        int[] sum = new int[n + 1];
        int min_pre = 0;
        int result = Integer.MIN_VALUE;
        for (int i = 1; i <= n; i++) {
            sum[i] = sum[i - 1] + nums[i - 1];
            if (i >= k && sum[i] - min_pre > result) {
                result = sum[i] - min_pre;
            }
            if (i >= k) {
                min_pre = Math.min(min_pre, sum[i - k + 1]);
            }
        }
        return result;
    }
}

Maximum Subarray V

Given an integer arrays, find a contiguous subarray which has the largest sum and length should be between k1 and k2 (include k1 and k2).
Return the largest sum, return 0 if there are fewer than k1 elements in the array.

 Notice

Ensure that the result is an integer type.

Have you met this question in a real interview? Yes
Example
Given the array [-2,2,-3,4,-1,2,1,-5,3] and k1 = 2, k2 = 4, the contiguous subarray [4,-1,2,1] has the largest sum = 6.

思路：使用双端队列Deque，存放i，表示前i个数，第i个数到前index数之间的子数组有可能成为最大和子数组。每次循环，做三个操作：在列首踢掉长度大于k2的子数组的索引，在列尾踢掉子数组的和小于当前长度为k1的子数组的和，此时列首到当前索引的子数组为以当前元素为子数组的最后一个元素的长度在k1 ～ k2之间的最大和子数组，如果这个和比结果大就更新结果。

public class Solution {
    /**
     * @param nums an array of integers
     * @param k1 an integer
     * @param k2 an integer
     * @return the largest sum
     */
    public int maxSubarray5(int[] nums, int k1, int k2) {
        // Write your code here
        if (nums == null || nums.length == 0 || k1 > k2 || k2 <= 0) {
            return 0;
        }
        Deque<Integer> deque = new LinkedList<>();
        int n = nums.length;
        int[] sum = new int[n + 1];
        int result = Integer.MIN_VALUE;
        for (int i = 1; i <= n; i++) {
            sum[i] = sum[i - 1] + nums[i - 1];
            if (!deque.isEmpty() && deque.peekFirst() < i - k2) {
                deque.pollFirst();
            }
            if (i >= k1) {
                while (!deque.isEmpty() && sum[i] - sum[deque.peekLast()] < sum[i] - sum[i - k1]) {
                    deque.pollLast();
                }
                deque.offerLast(i - k1);
            }
            if (!deque.isEmpty() && sum[i] - sum[deque.peekFirst()] > result) {
                result = sum[i] - sum[deque.peekFirst()];
            }
        }
        return result;
    }
}

LRU Cache

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

思路：HashMap + DoubleLinkedList　　HashMap存储key -> Node，Node节点里的元素：1. key（可不要） 2. value 3. prev和next指针

这一道题的set操作如果set(key, value)的key已经存在的话，不算做最近使用的。

class Node {
    int key;
    int value;
    Node prev;
    Node next;
    public Node(int key, int value) {
        this.key = key;
        this.value = value;
        prev = null;
        next = null;
    }
}

public class Solution {
    Node head;
    Node tail;
    Map<Integer, Node> map;
    int capacity;
    // @param capacity, an integer
    public Solution(int capacity) {
        // write your code here
        head = new Node(-1, -1);
        tail = new Node(-1, -1);
        head.next = tail;
        tail.prev = head;
        map = new HashMap<Integer, Node>();
        this.capacity = capacity;
    }

    // @return an integer
    public int get(int key) {
        // write your code here
        if (!map.containsKey(key)) {
            return -1;
        }
        Node node = map.get(key);
        node.prev.next = node.next;
        node.next.prev = node.prev;
        move_to_tail(node);
        return node.value;
    }

    // @param key, an integer
    // @param value, an integer
    // @return nothing
    public void set(int key, int value) {
        // write your code here
        if (get(key) != -1) {
            map.get(key).value = value;
            return;
        }
        if (map.size() == capacity) {
            map.remove(head.next.key);
            head.next = head.next.next;
            head.next.prev = head;
        }
        Node newNode = new Node(key, value);
        map.put(key, newNode);
        move_to_tail(newNode);
    }
    public void move_to_tail(Node node) {
        tail.prev.next = node;
        node.prev = tail.prev;
        node.next = tail;
        tail.prev = node;
    }
}

LFU Cache

LFU (Least Frequently Used) is a famous cache eviction algorithm.

For a cache with capacity k, if the cache is full and need to evict a key in it, the key with the lease frequently used will be kicked out.

Implement set and get method for LFU cache.

Have you met this question in a real interview? Yes
Example
Given capacity=3

set(2,2)
set(1,1)
get(2)
>> 2
get(1)
>> 1
get(2)
>> 2
set(3,3)
set(4,4)
get(3)
>> -1
get(2)
>> 2
get(1)
>> 1
get(4)
>> 4

思路：双HashMap + DoubleLinkedList。一个valueHash存储：key -> value；另一个nodeHash存储：key -> Node。

Node节点里的元素：1. 频率freq

　　　　　　　　　  2. LinkedHashSet<Integer> keys存储freq相同的key集合，可以保证先使用的Node放前面，最近使用的Node放后面

　　　　　　　　　  3. prev和next指针

事先构造好虚拟的head和tail Node节点。

注意要随时维护好valueHash、nodeHash和DoubleLinkedList中的元素关系。

class Node {
    int freq;
    LinkedHashSet<Integer> keys;
    Node prev;
    Node next;
    public Node(int freq) {
        this.freq = freq;
        keys = new LinkedHashSet<Integer>();
        prev = null;
        next = null;
    }
}
public class LFUCache {
    int capacity;
    Node head;
    Node tail;
    Map<Integer, Integer> valueHash;
    Map<Integer, Node> nodeHash;
    // @param capacity, an integer
    public LFUCache(int capacity) {
        // Write your code here
        this.capacity = capacity;
        head = new Node(0);
        tail = new Node(0);
        head.next = tail;
        tail.prev = head;
        valueHash = new HashMap<Integer, Integer>();
        nodeHash = new HashMap<Integer, Node>();
    }

    // @param key, an integer
    // @param value, an integer
    // @return nothing
    public void set(int key, int value) {
        // Write your code here
        if (valueHash.containsKey(key)) {
            valueHash.put(key, value);
            increaseFrequency(key);
            return;
        }
        if (valueHash.size() == capacity) {
            removeOld();
        }
        addToHead(key, value);
    }

    public int get(int key) {
        // Write your code here
        if (!valueHash.containsKey(key)) {
            return -1;
        }
        increaseFrequency(key);
        return valueHash.get(key);
    }
    public void increaseFrequency(int key) {
        Node node = nodeHash.get(key);
        node.keys.remove(key);
        if (node.freq + 1 != node.next.freq) {
            Node newNode = new Node(node.freq + 1);
            newNode.keys.add(key);
            newNode.prev = node;
            newNode.next = node.next;
            node.next = newNode;
            newNode.next.prev = newNode;
        } else {
            node.next.keys.add(key);
        }
        nodeHash.put(key, node.next);
        if (node.keys.size() == 0) {
            remove(node);
        }
    }
    public void remove(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }
    public void removeOld() {
        if (head.next == tail) {
            return;
        }
        int index = 0;
        for (int key : head.next.keys) {
            index = key;
            break;
        }
        head.next.keys.remove(index);
        if (head.next.keys.size() == 0) {
            remove(head.next);
        }
        valueHash.remove(index);
        nodeHash.remove(index);
    }
    public void addToHead(int key, int value) {
        if (head.next.freq != 1) {
            Node newNode = new Node(1);
            newNode.keys.add(key);
            newNode.prev = head;
            newNode.next = head.next;
            head.next = newNode;
            newNode.next.prev = newNode;
            valueHash.put(key, value);
            nodeHash.put(key, newNode);
        } else {
            head.next.keys.add(key);
            valueHash.put(key, value);
            nodeHash.put(key, head.next);
        }
    }
}