19-20

Author: DengBoCong

README.md

@@ -85,3 +85,9 @@ $=link=$: 题目原题链接
 
 17.[N 叉树的层序遍历](https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/)（[Java解法](https://github.com/DengBoCong/Algorithm/blob/master/core/NAryTreeLevelOrderTraversal/NAryTreeLevelOrderTraversal.java) | [Python解法](https://github.com/DengBoCong/Algorithm/blob/master/core/NAryTreeLevelOrderTraversal/NAryTreeLevelOrderTraversal.py)）：题目难度(中等)，题目类型(树_广度优先搜索)
 
+18.[统计最高分的节点数目](https://leetcode-cn.com/problems/count-nodes-with-the-highest-score/)（[Java解法](https://github.com/DengBoCong/Algorithm/blob/master/core/CountNodesWithTheHighestScore/CountNodesWithTheHighestScore.java) | [Python解法](https://github.com/DengBoCong/Algorithm/blob/master/core/CountNodesWithTheHighestScore/CountNodesWithTheHighestScore.py)）：题目难度(中等)，题目类型(树_深度优先搜索_数组_二叉树)
+
+19.[寻找最近的回文数](https://leetcode-cn.com/problems/find-the-closest-palindrome/)（[Java解法](https://github.com/DengBoCong/Algorithm/blob/master/core/FindTheClosestPalindrome/FindTheClosestPalindrome.java) | [Python解法](https://github.com/DengBoCong/Algorithm/blob/master/core/FindTheClosestPalindrome/FindTheClosestPalindrome.py)）：题目难度(困难)，题目类型(数学_字符串)
+
+20.[Z 字形变换](https://leetcode-cn.com/problems/zigzag-conversion/)（[Java解法](https://github.com/DengBoCong/Algorithm/blob/master/core/ZigzagConversion/ZigzagConversion.java) | [Python解法](https://github.com/DengBoCong/Algorithm/blob/master/core/ZigzagConversion/ZigzagConversion.py)）：题目难度(中等)，题目类型(字符串)
+

core/CountNodesWithTheHighestScore/CountNodesWithTheHighestScore.java

@@ -0,0 +1,45 @@
+package com.dbc;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CountNodesWithTheHighestScore {
+    private long maxScores = 0;
+    private int count = 0;
+    private List<List<Integer>> children = null;
+    private int length = 0;
+
+    private int dfs(int node) {
+        long scores = 1;
+        int size = this.length - 1;
+        for (int i = 0; i < this.children.get(node).size(); i++) {
+            int sz = dfs(this.children.get(node).get(i));
+            scores *= sz;
+            size -= sz;
+        }
+        if (node != 0) {
+            scores *= size;
+        }
+        if (scores > this.maxScores) {
+            this.maxScores = scores;
+            this.count = 1;
+        } else if (scores == this.maxScores) {
+            this.count++;
+        }
+        return this.length - size;
+    }
+
+    public int countHighestScoreNodes(int[] parents) {
+        this.length = parents.length;
+        this.children = new ArrayList<>();
+        for (int i = 0; i < parents.length; i++) {
+            this.children.add(new ArrayList<>());
+        }
+        for (int i = 1; i < parents.length; i++) {
+            this.children.get(parents[i]).add(i);
+        }
+
+        dfs(0);
+        return this.count;
+    }
+}

core/CountNodesWithTheHighestScore/CountNodesWithTheHighestScore.py

@@ -0,0 +1,34 @@
+from typing import List
+
+
+def countHighestScoreNodes(parents: List[int]) -> int:
+    n = len(parents)
+    children = [[] for _ in range(n)]
+    for index in range(1, n):
+        children[parents[index]].append(index)
+
+    max_scores, count = 0, 0
+
+    def dfs(root):
+        size, scores = n - 1, 1
+        for child in children[root]:
+            sz = dfs(child)
+            scores *= sz
+            size -= sz
+        if root != 0:
+            scores *= size
+        nonlocal max_scores, count
+        if scores > max_scores:
+            count = 1
+            max_scores = scores
+        elif scores == max_scores:
+            count += 1
+
+        return n - size
+
+    dfs(0)
+    return count
+
+
+if __name__ == '__main__':
+    print(countHighestScoreNodes([-1, 2, 0, 2, 0]))

core/FindTheClosestPalindrome/FindTheClosestPalindrome.java

@@ -0,0 +1,34 @@
+package com.dbc;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FindTheClosestPalindrome {
+    public String nearestPalindromic(String n) {
+        int length = n.length();
+        long int_n = Long.parseLong(n);
+        long prefix = Long.parseLong(n.substring(0, (length + 1) / 2));
+        List<Long> candidate = new ArrayList<>();
+        candidate.add((long) (Math.pow(10, (length - 1)) - 1));
+        candidate.add((long) (Math.pow(10, length) + 1));
+        for (long i = prefix - 1; i < prefix + 2; i++) {
+            long y = length % 2 == 0 ? i : i / 10;
+            long x = i;
+            while (y != 0) {
+                x = x * 10 + y % 10;
+                y /= 10;
+            }
+            candidate.add(x);
+        }
+
+        long res = -1;
+        for (long candi : candidate) {
+            if (candi - int_n != 0) {
+                if (res == -1 || Math.abs(int_n - candi) < Math.abs(int_n - res)) {
+                    res = candi;
+                }
+            }
+        }
+        return Long.toString(res);
+    }
+}

core/FindTheClosestPalindrome/FindTheClosestPalindrome.py

@@ -0,0 +1,23 @@
+def nearestPalindromic(n: str) -> str:
+    left, right, temp, length = 0, len(n) - 1, list(n), len(n)
+    int_n = int(n)
+    candidate = [10 ** (length - 1) - 1, 10 ** length + 1]
+    self_prefix = int(n[:(length + 1) // 2])
+    for prefix in range(self_prefix - 1, self_prefix + 2):
+        y = prefix if length % 2 == 0 else prefix // 10
+        while y != 0:
+            prefix = prefix * 10 + y % 10
+            y //= 10
+        candidate.append(prefix)
+
+    res = -1
+    for candi in candidate:
+        if str(candi) != n:
+            if res == -1 or abs(int_n - candi) < abs(int_n - res):
+                res = candi
+
+    return str(res)
+
+
+if __name__ == '__main__':
+    print(nearestPalindromic("1283"))

core/ZigzagConversion/ZigzagConversion.java

@@ -0,0 +1,36 @@
+package com.dbc;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ZigzagConversion {
+    public static String convert(String s, int numRows) {
+        List<Character>[] resMatrix = new List[numRows];
+        for (int i = 0; i < numRows; i++) {
+            resMatrix[i] = new ArrayList<>();
+        }
+        int curPoint = 0, flag = 0;
+        for (int i = 0; i < s.length(); i++) {
+            resMatrix[curPoint].add(s.charAt(i));
+            if (flag == 0 && curPoint + 1 < numRows) {
+                curPoint++;
+            } else if (flag == 0 && curPoint - 1 >= 0) {
+                curPoint--;
+                flag = 1;
+            } else if (curPoint - 1 >= 0) {
+                curPoint--;
+            } else if (curPoint + 1 < numRows) {
+                curPoint++;
+                flag = 0;
+            }
+        }
+
+        StringBuffer res = new StringBuffer();
+        for (List<Character> chList : resMatrix) {
+            for (Character ch : chList) {
+                res.append(ch);
+            }
+        }
+        return res.toString();
+    }
+}

core/ZigzagConversion/ZigzagConversion.py

@@ -0,0 +1,21 @@
+def convert(s: str, numRows: int) -> str:
+    res_matrix = [[] for _ in range(numRows)]
+    cur_point, flag = 0, "down"
+    for ch in s:
+        res_matrix[cur_point].append(ch)
+        if flag == "down" and cur_point + 1 < numRows:
+            cur_point += 1
+        elif flag == "down":
+            cur_point -= 1
+            flag = "up"
+        elif flag == "up" and cur_point - 1 >= 0:
+            cur_point -= 1
+        else:
+            cur_point += 1
+            flag = "down"
+
+    return "".join(["".join(item) for item in res_matrix])
+
+
+if __name__ == '__main__':
+    print(convert(s="AB", numRows=1))