Created 834._Sum_of_Distances_in_Tree.md

yudaer · yudaer · commit d3ae44454b53 · 2018-10-07T22:40:36.000+08:00
diff --git a/docs/Leetcode_Solutions/Java/828._Unique_Letter_String.md b/docs/Leetcode_Solutions/Java/828._Unique_Letter_String.md
@@ -0,0 +1,169 @@
+### 828. Unique Letter String
+
+
+
+题目:
+https://leetcode.com/problems/unique-letter-string
+
+难度:
+Hard
+
+题意：
+
+1. 求一个字符串中的所有非空子字符串，这些字符串当中的唯一字符数的总和
+2. 唯一字符数就是在字符串中出现只有一次的字符的个数
+
+思路：
+
+- 枚举左右端点，暴力统计子字符串的唯一字符数，复杂度是o(n^3)
+- 枚举左端点，然后遍历右端点，每次保存上一次的字符统计个数，和唯一字符数，并更新为当前的数值，复杂度是o(n^2)
+- 注意到，当某个字符出现次数大于1个后，后面不管怎么遍历，该字符都不会是唯一字符，因此，有个剪枝动作，如果此时某个字符出现次数大于1个后，后面直接跳过该字符
+- 因此我们需要实现把每个字符出现的位置记录下来，以便可以跳过某些字符
+- 枚举左端点，然后遍历右端点，加上剪枝之后，每个字符至多被扫描2次。把字符串拆成26个字符后，从左边遍历到右边，就需要一个堆来维持，类似于归并排序的merge操作，这个堆最多26个元素，时间复杂度是o(52nlog26)
+- 我们可以另外想一种解决方案。假设我们把26个字母全部拆开，当某个字符第一次出现到第二次出现中间，它就能贡献一个唯一字符。假设A这个字符，第一次出现是位置1，第二次出现是位置10，于是1-10中间就可以增加一个唯一字符，同理，其他字符也是这样的。假设左端点移动，所需要改变的，也只有一个字符而已，这个字符的第一次出现的位置，到第二次出现的位置，改变了位置。我们不要想着每个字符串有多少唯一字符，而是从总体来看，每个字符贡献了多少次唯一字符。还是上面那个例子，A这个字符，第一次出现是位置1，第二次出现是位置10，那么贡献了10-1=9次唯一字符。扫描左端点时，只需要不断用上一个左端点字符移动来更新总唯一字符数即可。复杂度是o(n)
+
+解法一：
+
+```java
+class Solution {
+	 private class Item implements Comparable<Item> {
+        int alph;
+        int idx;
+        int pos;
+
+        public Item(int alph, int idx, int pos) {
+            this.alph = alph;
+            this.idx = idx;
+            this.pos = pos;
+        }
+
+        @Override
+        public int compareTo(Item o) {
+            return Integer.compare(pos, o.pos);
+        }
+    }
+
+    private int solve(List[] idxList, int start, int len, int[] init) {
+        PriorityQueue<Item> queue = new PriorityQueue<Item>();
+        boolean[] flag = new boolean[26];
+        for (int i = 0;i < 26;i++) {
+            flag[i] = false;
+        }
+        int ret = 0;
+        int res = 0;
+        int pre = start - 1;
+
+        for (int i = 0;i < 26;i++) {
+            int idx = init[i];
+            if (idx != idxList[i].size()) {
+                queue.add(new Item(i, idx, (Integer) idxList[i].get(idx)));
+            }
+        }
+
+        while (!queue.isEmpty()) {
+            Item top = queue.poll();
+            ret += (long) res * (top.pos - pre) % MOD;
+            if (ret >= MOD) {
+                ret -= MOD;
+            }
+            if (flag[top.alph]) {
+                res--;
+            } else {
+                flag[top.alph] = true;
+                if (top.idx + 1 != idxList[top.alph].size()) {
+                    queue.add(new Item(top.alph, top.idx + 1, (Integer) idxList[top.alph].get(top.idx + 1)));
+                }
+                res++;
+            }
+            pre = top.pos;
+        }
+
+        ret += (long) res * (len - pre) % MOD;
+        if (ret >= MOD) {
+            ret -= MOD;
+        }
+        return ret;
+    }
+
+    private static int MOD = 1000000007;
+
+    public int uniqueLetterString(String S) {
+        List[] idxList = new List[26];
+        int[] init = new int[26];
+        for (int i = 0;i < 26;i++) {
+            idxList[i] = new ArrayList<Integer>();
+            init[i] = 0;
+        }
+        for (int i = 0;i < S.length();i++) {
+            idxList[S.charAt(i) - 'A'].add(i);
+        }
+
+        int ret = 0;
+        for (int i = 0;i < S.length();i++) {
+            ret += solve(idxList, i, S.length(), init);
+            if (ret >= MOD) {
+                ret -= MOD;
+            }
+            init[S.charAt(i) - 'A']++;
+        }
+
+        return ret;
+    }
+}
+```
+
+解法二：
+
+```java
+class Solution {
+	 private static int MOD = 1000000007;
+
+    public int uniqueLetterString(String S) {
+        List<Integer>[] idxList = new List[26];
+        int[] pos = new int[26];
+        for (int i = 0;i < 26;i++) {
+            idxList[i] = new ArrayList<Integer>();
+            pos[i] = 0;
+        }
+        for (int i = 0;i < S.length();i++) {
+            idxList[S.charAt(i) - 'A'].add(i);
+        }
+
+        int ret = 0;
+        int res = 0;
+        for (int i = 0;i < 26;i++) {
+            if (pos[i] < idxList[i].size()) {
+                if (pos[i] + 1 < idxList[i].size()) {
+                    res += idxList[i].get(pos[i] + 1) - idxList[i].get(pos[i]);
+                } else {
+                    res += S.length() - idxList[i].get(pos[i]);
+                }
+            }
+        }
+
+        for (int i = 0;i < S.length();i++) {
+            ret += res;
+            if (ret >= MOD) {
+                ret -= MOD;
+            }
+            int j = S.charAt(i) - 'A';
+            if (pos[j] + 1 < idxList[j].size()) {
+                res -= idxList[j].get(pos[j] + 1) - idxList[j].get(pos[j]);
+            } else {
+                res -= S.length() - idxList[j].get(pos[j]);
+            }
+            pos[j]++;
+            if (pos[j] < idxList[j].size()) {
+                if (pos[j] + 1 < idxList[j].size()) {
+                    res += idxList[j].get(pos[j] + 1) - idxList[j].get(pos[j]);
+                } else {
+                    res += S.length() - idxList[j].get(pos[j]);
+                }
+            }
+        }
+
+        return ret;
+    }
+}
+```
+
diff --git a/docs/Leetcode_Solutions/Java/834._Sum_of_Distances_in_Tree.md b/docs/Leetcode_Solutions/Java/834._Sum_of_Distances_in_Tree.md
@@ -0,0 +1,144 @@
+### 834. Sum of Distances in Tree
+
+
+
+题目:
+https://leetcode.com/problems/sum-of-distances-in-tree/
+
+难度:
+Hard
+
+题意：
+
+1. 给定一棵树
+2. 问每个节点到其他节点的距离之和是多少
+3. N <= 10000
+
+思路：
+
+- 最简单的方法，假设我们要求节点0与其他节点的距离之和，只需要一遍dfs即可，其他节点同理。复杂度是o(n^2)
+
+- 注意到，树中每个边都是一个桥（就是去掉这个边图就变成非连通了），树中的任意两个节点都是一个固定的路径。当我们计算不同节点的dfs，其实是有一部分路径是重复计算的（自己拿笔画一下）
+
+- 来看看分析的思路。从问题出发，要问每个节点到其他节点的距离和，想象这个点A是树根（每个点都可以是树根），那么我们遍历一下所有连接这个节点的边。想象一下某个边e连接的是一个子树，点A跟这个子树所有的点都得经过边e，因此我们把问题下推，计算这个子树的树根与其他节点的距离之和，然后加上这个子树的数量就等于点A跟这个子树所有的点的距离和
+
+- 有个点需要注意的，由于边是无向的，我们动态规划的方向也需要两个方向，怎么理解呢。比如说，假设A和B连着。以A为树根计算子问题的时候，顺序是A->B，以B为树根计算子问题的时候，顺序是B->A，相当于对边进行动态规划，规划两个方向
+
+- 解法知道了，就需要编码。注意到，N <= 10000，如果递归的话，小心stack over flow。需要自己模拟栈
+
+
+代码：
+
+```java
+class Solution {
+	 private class Edge {
+        private int x;
+        private int y;
+        private int num;
+        private int dist;
+
+        public Edge(int x, int y, int num, int dist) {
+            this.x = x;
+            this.y = y;
+            this.num = num;
+            this.dist = dist;
+        }
+
+        public int getX() {
+            return x;
+        }
+
+        public void setX(int x) {
+            this.x = x;
+        }
+
+        public int getY() {
+            return y;
+        }
+
+        public void setY(int y) {
+            this.y = y;
+        }
+
+        public int getNum() {
+            return num;
+        }
+
+        public void setNum(int num) {
+            this.num = num;
+        }
+
+        public int getDist() {
+            return dist;
+        }
+
+        public void setDist(int dist) {
+            this.dist = dist;
+        }
+    }
+
+    private void solve(Edge edge, List[] edgeList) {
+        if (edge.num != -1) {
+            return;
+        }
+
+        LinkedList<Edge> queue = new LinkedList<Edge>();
+        Stack<Edge> stack = new Stack<Edge>();
+
+        queue.addLast(edge);
+        stack.add(edge);
+
+        while (!queue.isEmpty()) {
+            Edge e = queue.pollFirst();
+            for (Edge next: (List<Edge>) edgeList[e.y]) {
+                if (next.y == e.x) {
+                    continue;
+                }
+                if (next.num != -1) {
+                    continue;
+                }
+                queue.addLast(next);
+                stack.add(next);
+            }
+        }
+
+        while (!stack.empty()) {
+            Edge e = stack.pop();
+            e.num = e.dist = 0;
+            for (Edge next: (List<Edge>) edgeList[e.y]) {
+                if (next.y == e.x) {
+                    continue;
+                }
+                e.num += next.num;
+                e.dist += next.num + next.dist;
+            }
+            e.num ++;
+        }
+    }
+
+    public int[] sumOfDistancesInTree(int N, int[][] edges) {
+        List[] edgeList = new List[N];
+        for (int i = 0;i < edgeList.length;i++) {
+            edgeList[i] = new ArrayList<Edge>();
+        }
+
+        for (int i = 0;i < edges.length;i++) {
+            edgeList[edges[i][0]].add(new Edge(edges[i][0], edges[i][1], -1, -1));
+            edgeList[edges[i][1]].add(new Edge(edges[i][1], edges[i][0], -1, -1));
+        }
+
+        int[] result = new int[N];
+        for (int i = 0;i < N;i++) {
+            result[i] = 0;
+            for (Edge next: (List<Edge>) edgeList[i]) {
+                if (next.dist == -1) {
+                    solve(next, edgeList);
+                }
+                result[i] += next.dist + next.num;
+            }
+        }
+        return result;
+    }
+}
+```
+
