Merge pull request apachecn#53 from yudaer/master

Create 906._Super_Palindromes.md

Author: 0xkookoo

docs/Leetcode_Solutions/Java/887._Super_Egg_Drop.md

@@ -0,0 +1,66 @@
+### 887. Super Egg Drop
+
+
+
+题目:
+https://leetcode.com/problems/super-egg-drop
+
+难度:
+Hard
+
+题意：
+
+1. 已知蛋从F楼丢下会坏
+2. 现在给你K个蛋，在N层楼中，请问最坏情况最少要试验几次才能知道F的精确值
+3. 如果蛋丢下来不会坏，那么可以捡起来继续丢
+
+思路：
+
+- 又是一个脑筋急转弯的题目，我们来看看K=1的情况。由于只有一个蛋，坏了就没了，所以只能一层一层往下丢。一层丢下，蛋坏了，说明F=1，反之，继续去二层丢，所以K=1时，最坏情况要试验N次
+- 当K>=2时，由于蛋有多余，可以大胆的去中间丢，这样就可以少丢几次
+- 因此，令`cache[K][N]`表示K个蛋在N层试验最少要试验的次数，假设第一次要在i层丢蛋，那么分成了两个子问题，如果蛋没碎了，那么最少次数等于`cache[k][N-i]+1`，如果蛋碎了，那么最少次数等于`cache[k-1][i-1]+1`
+- 那么这个题就变成了`cache[k][N] = min[1<=i<=N]{max{cache[k][N-i], cache[k - 1][i - 1] + 1} + 1}`，时间复杂度是o(kNN)
+- 但是看数据范围，k<=100，N<=10000，o(kNN)肯定是过不了的
+- 注意到，`cache[k][N]`是非严格递增输了，且递增值不会超过1，即`0<=cache[k][i+1]-cache[k][i]<=1`
+- 计算过程中令`cache[k][N]`最优解的i，跟`cache[k][N+1]`最优解的j，关系是`0<=j-i<=1`
+- 因此在处理的过程，固定k，递推N，保存上一个最优解i，继续推出下一个最优解
+
+代码：
+
+```java
+class Solution {
+    private static int[][] cache;
+
+    private static void init() {
+        if (cache == null) {
+            cache = new int[101][10001];
+
+            for (int i = 1;i <= 10000;i++) {
+                cache[1][i] = i;
+            }
+
+            for (int i = 2;i <= 100;i++) {
+                cache[i][1] = 0;
+                cache[i][1] = 1;
+                cache[i][2] = 2;
+
+                int idx = 1;
+                for (int j = 3;j <= 10000;j++) {
+
+                    while (cache[i - 1][idx + 1] <= cache[i][j - idx - 2]) {
+                        idx++;
+                    }
+
+                    cache[i][j] = Math.max(cache[i - 1][idx], cache[i][j - idx - 1]) + 1;
+                }
+            }
+        }
+    }
+
+    public int superEggDrop(int K, int N) {
+        init();
+        return cache[K][N];
+    }
+}
+```
+

docs/Leetcode_Solutions/Java/895._Maximum_Frequency_Stack.md

@@ -0,0 +1,96 @@
+### 895. Maximum Frequency Stack
+
+
+
+题目:
+https://leetcode.com/problems/maximum-frequency-stack/
+
+难度:
+Hard
+
+题意：
+
+1. 一个特殊的类栈数据结构，具有两种操作
+2. push x：表示将x入栈
+3. pop：表示将栈中最多的数弹出，相同数量的数弹出最近入栈的一个数
+
+思路：
+
+- 这个题的数据结构中，x是key，既需要根据x来操作，又需要根据x的数量和入栈时间来出栈，典型的双向查找表
+
+- 维护一个x到x的入栈时间的映射关系，入栈时间我们定义为第几次push操作，即x->[t1,t2,t3]
+
+- 维护一个**有序**的x的入栈时间到x的对应表，比较函数定义为：栈中元素个数，和栈顶时间
+
+代码：
+
+```java
+class FreqStack {
+
+    int _count;
+    private class Item implements Comparable<Item> {
+        LinkedList<Integer> time;
+
+        public Item(LinkedList<Integer> time) {
+            this.time = time;
+        }
+
+        public LinkedList<Integer> getTime() {
+            return time;
+        }
+
+        @Override
+        public int compareTo(Item o) {
+            if (time.size() == o.time.size()) {
+                return Integer.compare(o.time.getLast(), time.getLast());
+            } else {
+                return Integer.compare(o.time.size(), time.size());
+            }
+        }
+    }
+
+    TreeMap<Item, Integer> freqToId;
+    Map<Integer, Item>  idToFreq;
+
+    public FreqStack() {
+        _count = 0;
+        freqToId = new TreeMap<Item, Integer>();
+        idToFreq = new HashMap<Integer, Item>();
+    }
+
+    public void push(int x) {
+        if (!idToFreq.containsKey(x)) {
+            LinkedList<Integer> time = new LinkedList<Integer>();
+            time.addLast(_count++);
+            Item item = new Item(time);
+            freqToId.put(item, x);
+            idToFreq.put(x, item);
+        } else {
+            Item origin = idToFreq.get(x);
+            freqToId.remove(origin);
+            LinkedList<Integer> time = origin.time;
+            time.addLast(_count++);
+            Item item = new Item(time);
+            idToFreq.put(x, item);
+            freqToId.put(item, x);
+        }
+    }
+
+    public int pop() {
+        Map.Entry<Item, Integer> first = freqToId.firstEntry();
+        freqToId.remove(first.getKey());
+        idToFreq.remove(first.getValue());
+
+        LinkedList<Integer> time = first.getKey().time;
+        time.removeLast();
+        if (time.size() != 0) {
+            Item item = new Item(time);
+            idToFreq.put(first.getValue(), item);
+            freqToId.put(item, first.getValue());
+        }
+
+        return first.getValue();
+    }
+}
+```
+

docs/Leetcode_Solutions/Java/899._Orderly_Queue.md

@@ -0,0 +1,54 @@
+### 899. Orderly Queue
+
+
+
+题目:
+https://leetcode.com/problems/orderly-queue/
+
+难度:
+Hard
+
+题意：
+
+1. 给定一个字符串S和一个数K
+2. 每一轮可以选择字符串的前K个数的其中一个，把它移到放在最后面
+3. 无限次数后，问生成的最小字符串是什么
+
+思路：
+
+- 不要考虑暴力了，由于是无限次数，连暴力搜索都无从下手，除非出动启发式搜索
+- 这是个脑筋急转弯的题目，分为两种情况
+- 当K=1时，由于每次只能取第一个放在最后面，这种情况是暴力搜索，时间复杂度是o(nk)，k是字符串的长度
+- 当K>=2时，我们拿K=2出来考虑，证明当K=2时，可以生成任一字符串。
+  - 固定第一个数，不断的把第二个数放在最后面，这种做法可以使第一个数插入到队列的任一位置
+  - 假设队列A1-Ak有序，我们要把第A(k+1)插入到Ak的后面，只需要把A(k+1)固定在第一个数，重复第一个做法即可
+  - 根据数据归纳法，当K=2时，可以生成任一字符串
+- 因此当K>=2时，只需要排序字符串里面的字符即可
+
+拓展：
+
+- 这道题有o(nlogn)的解法，当k=1时，可以用o(nlogn)的排序算法，找到最小的字符串。有兴趣的同学可以百度一下“后缀数组”，一百行代码左右，这里就不展示了
+
+代码：
+
+```java
+class Solution {
+    public String orderlyQueue(String S, int K) {
+        if (K == 1) {
+            String min = S;
+            for (int i = 0;i < S.length();i++) {
+                S = S.substring(1, S.length()) + S.charAt(0);
+                if (min.compareTo(S) > 0) {
+                    min = S;
+                }
+            }
+            return min;
+        } else {
+            char[] c = S.toCharArray();
+            Arrays.sort(c);
+            return new String(c);
+        }
+    }
+}
+```
+

docs/Leetcode_Solutions/Java/902._Numbers_At_Most_N_Given_Digit_Set.md

@@ -0,0 +1,78 @@
+### 902. Numbers At Most N Given Digit Set
+
+
+
+题目:
+https://leetcode.com/problems/numbers-at-most-n-given-digit-set/
+
+难度:
+Hard
+
+题意：
+
+1. 给定一个1-9的集合S，和一个上限k
+2. 求这个集合中能构成多少个数，并且不大于k
+
+思路：
+
+- 分情况计算
+  - 当构成的数的位数小于k的位数，那么能构成的数数量为|S|^位数
+  - 当构成的数的位数等于k的位数，遍历集合S的数a，判断a
+    - 如果小于k的最高位，那么能够成的数数量为|S|^(k的位数-1)
+    - 如果等于k的最高位，继续判断下一位
+    - 如果不存在等于k的最高位的数，不判断下一位，直接跳出循环
+
+代码：
+
+```java
+class Solution {
+    private int[] split(int a) {
+        int[] ret = new int[10];
+        int idx = 0;
+        while (a != 0) {
+            ret[idx++] = a % 10;
+            a /= 10;
+        }
+        return Arrays.copyOf(ret, idx);
+    }
+
+    public int atMostNGivenDigitSet(String[] D, int N) {
+        int[] d = new int[D.length];
+        for (int i = 0;i < D.length;i++) {
+            d[i] = Integer.parseInt(D[i]);
+        }
+
+        int[] length = new int[10];
+        length[0] = 1;
+        for (int i = 1;i < 10;i++) {
+            length[i] = length[i - 1] * D.length;
+        }
+
+        int[] a = split(N);
+        int ret = 0;
+        for (int i = 1;i < a.length;i++) {
+            ret += length[i];
+        }
+        int i;
+        for (i = a.length - 1;i >= 0;i--) {
+            boolean find = false;
+            for (int j = 0;j < d.length;j++) {
+                if (a[i] == d[j]) {
+                    find = true;
+                }
+                if (d[j] < a[i]) {
+                    ret += length[i];
+                }
+            }
+            if (!find) {
+                break;
+            }
+        }
+        if (i < 0) {
+            ret++;
+        }
+        return ret;
+    }
+}
+```
+

docs/Leetcode_Solutions/Java/903._Valid_Permutations_for_DI_Sequence.md

@@ -0,0 +1,95 @@
+### 903. Valid Permutations for DI Sequence
+
+
+
+题目:
+https://leetcode.com/problems/valid-permutations-for-di-sequence
+
+难度:
+Hard
+
+题意：
+
+1. 给定一个字符串，长度为n，D代表前一个数比下一个数大而I代表前一个数比下一个数小
+2. 求出在所有0-n的排列中，满足上面字符串所代表的排列两两之间大小比较的排列的个数
+
+思路：
+
+- 最大的那个数，可能出现在下面三种情况：
+  - 出现在位置0，a[0]>a[1]
+  - 出现在位置i，a[i]>a[i+1]且a[i]<a[i-1]
+  - 出现在位置n，a[n]>a[n-1]
+- 枚举最大的数出现的位置，假设为i，当i选定为最大的数后，剩下的数要分配给左右两边，有c(n, i)种情况，并且左右两边的队列互相独立
+- 这时候左右两边分别成了一个命题相同的子问题，求出即可
+- 注意：需要注意的是，不是所有的动态规划都需要用递推的方式求解。这道题可以选择另一种写法，就是递归+缓存，代码量会少不少
+
+代码：
+
+```java
+class Solution {
+    private static int[][] c;
+    private static int MOD = 1000000007;
+    private static int[][] cache = new int[202][202];
+
+    private void init() {
+        c = new int[202][202];
+        c[0][0] = 1;
+        for (int i = 1;i <= 201;i++) {
+            c[i][0] = 1;
+            for (int j = 1;j < i;j++) {
+                c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
+                if (c[i][j] >= MOD) {
+                    c[i][j] -= MOD;
+                }
+            }
+            c[i][i] = 1;
+        }
+    }
+
+    public int find(String S, int left, int right) {
+        int ret = 0;
+        if (right - left == 0) {
+            return 1;
+        }
+        if (cache[left][right] != -1) {
+            return cache[left][right];
+        }
+        if (S.charAt(left) == 'D') {
+            ret += find(S, left + 1, right);
+            if (ret >= MOD) {
+                ret -= MOD;
+            }
+        }
+        if (S.charAt(right - 1) == 'I') {
+            ret += find(S, left, right - 1);
+            if (ret >= MOD) {
+                ret -= MOD;
+            }
+        }
+        for (int i = left + 1;i < right;i++) {
+            if (S.charAt(i) == 'D' && S.charAt(i - 1) == 'I') {
+                ret += ((long) find(S, left, i - 1) * find(S, i + 1, right) % MOD) * c[right - left][i - left] % MOD;
+                if (ret >= MOD) {
+                    ret -= MOD;
+                }
+            }
+        }
+        if (ret == 0) {
+            return cache[left][right] = 1;
+        }
+        return cache[left][right] = ret;
+    }
+
+    public int numPermsDISequence(String S) {
+        init();
+        for (int i = 0;i < 202;i++) {
+            for (int j = 0;j < 202;j++) {
+                cache[i][j] = -1;
+            }
+        }
+        int ret = find(S, 0, S.length());
+        return ret;
+    }
+}
+```
+