feat: add solutions to lc problem: No.2792 (doocs#1307)

No.2792.Count Nodes That Are Great Enough

Author: yanglbme

solution/2700-2799/2792.Count Nodes That Are Great Enough/README.md

@@ -0,0 +1,274 @@
+# [2792. Count Nodes That Are Great Enough](https://leetcode.cn/problems/count-nodes-that-are-great-enough)
+
+[English Version](/solution/2700-2799/2792.Count%20Nodes%20That%20Are%20Great%20Enough/README_EN.md)
+
+## 题目描述
+
+<!-- 这里写题目描述 -->
+
+<p>You are given a <code>root</code> to a binary tree and an integer <code>k</code>. A node of this tree is called <strong>great enough</strong> if the followings hold:</p>
+
+<ul>
+	<li>Its subtree has <strong>at least</strong> <code>k</code> nodes.</li>
+	<li>Its value is <b>greater</b> than the value of <strong>at least</strong> <code>k</code> nodes in its subtree.</li>
+</ul>
+
+<p>Return<em> the number of nodes in this tree that are great enough.</em></p>
+
+<p>The node <code>u</code> is in the <strong>subtree</strong> of the node&nbsp;<code>v</code>, if <code><font face="monospace">u == v</font></code>&nbsp;or&nbsp;<code>v</code>&nbsp;is an&nbsp;ancestor of <code>u</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [7,6,5,4,3,2,1], k = 2
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Number the nodes from 1 to 7.
+The values in the subtree of node 1: {1,2,3,4,5,6,7}. Since node.val == 7, there are 6 nodes having a smaller value than its value. So it&#39;s great enough.
+The values in the subtree of node 2: {3,4,6}. Since node.val == 6, there are 2 nodes having a smaller value than its value. So it&#39;s great enough.
+The values in the subtree of node 3: {1,2,5}. Since node.val == 5, there are 2 nodes having a smaller value than its value. So it&#39;s great enough.
+It can be shown that other nodes are not great enough.
+See the picture below for a better understanding.</pre>
+
+<p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/2700-2799/2792.Count%20Nodes%20That%20Are%20Great%20Enough/images/1.png" style="padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; width: 300px; height: 167px;" /></p>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [1,2,3], k = 1
+<strong>Output:</strong> 0
+<strong>Explanation: </strong>Number the nodes from 1 to 3.
+The values in the subtree of node 1: {1,2,3}. Since node.val == 1, there are no nodes having a smaller value than its value. So it&#39;s not great enough.
+The values in the subtree of node 2: {2}. Since node.val == 2, there are no nodes having a smaller value than its value. So it&#39;s not great enough.
+The values in the subtree of node 3: {3}. Since node.val == 3, there are no nodes having a smaller value than its value. So it&#39;s not great enough.
+See the picture below for a better understanding.</pre>
+
+<p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/2700-2799/2792.Count%20Nodes%20That%20Are%20Great%20Enough/images/2.png" style="padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; width: 123px; height: 101px;" /></p>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [3,2,2], k = 2
+<strong>Output:</strong> 1
+<strong>Explanation: </strong>Number the nodes from 1 to 3.
+The values in the subtree of node 1: {2,2,3}. Since node.val == 3, there are 2 nodes having a smaller value than its value. So it&#39;s great enough.
+The values in the subtree of node 2: {2}. Since node.val == 2, there are no nodes having a smaller value than its value. So it&#39;s not great enough.
+The values in the subtree of node 3: {2}. Since node.val == 2, there are no nodes having a smaller value than its value. So it&#39;s not great enough.
+See the picture below for a better understanding.</pre>
+
+<p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/2700-2799/2792.Count%20Nodes%20That%20Are%20Great%20Enough/images/3.png" style="padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; width: 123px; height: 101px;" /></p>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range&nbsp;<code>[1, 10<sup>4</sup>]</code>.<span style="display: none;">&nbsp;</span></li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= k &lt;= 10</code></li>
+</ul>
+
+## 解法
+
+<!-- 这里可写通用的实现逻辑 -->
+
+**方法一：DFS + 大根堆**
+
+我们可以使用 DFS 后序遍历整棵树，对于每个节点，我们维护一个大根堆，堆中存储该节点的所有子树中最小的 k 个节点的值，如果当前节点的值大于堆顶元素，那么该节点就是一个「足够大」的节点，我们将答案加一。
+
+时间复杂度 $O(n \times k \times \log k)$，空间复杂度 $(n \times k)$。其中 $n$ 是树中节点的个数。
+
+<!-- tabs:start -->
+
+### **Python3**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def countGreatEnoughNodes(self, root: Optional[TreeNode], k: int) -> int:
+        def push(pq, x):
+            heappush(pq, x)
+            if len(pq) > k:
+                heappop(pq)
+
+        def dfs(root):
+            if root is None:
+                return []
+            l, r = dfs(root.left), dfs(root.right)
+            for x in r:
+                push(l, x)
+            if len(l) == k and -l[0] < root.val:
+                nonlocal ans
+                ans += 1
+            push(l, -root.val)
+            return l
+
+        ans = 0
+        dfs(root)
+        return ans
+```
+
+### **Java**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    private int ans;
+    private int k;
+
+    public int countGreatEnoughNodes(TreeNode root, int k) {
+        this.k = k;
+        dfs(root);
+        return ans;
+    }
+
+    private PriorityQueue<Integer> dfs(TreeNode root) {
+        if (root == null) {
+            return new PriorityQueue<>(Comparator.reverseOrder());
+        }
+        var l = dfs(root.left);
+        var r = dfs(root.right);
+        for (int x : r) {
+            l.offer(x);
+            if (l.size() > k) {
+                l.poll();
+            }
+        }
+        if (l.size() == k && l.peek() < root.val) {
+            ++ans;
+        }
+        l.offer(root.val);
+        if (l.size() > k) {
+            l.poll();
+        }
+        return l;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    int countGreatEnoughNodes(TreeNode* root, int k) {
+        int ans = 0;
+        function<priority_queue<int>(TreeNode*)> dfs = [&](TreeNode* root) {
+            if (!root) {
+                return priority_queue<int>();
+            }
+            auto left = dfs(root->left);
+            auto right = dfs(root->right);
+            while (right.size()) {
+                left.push(right.top());
+                right.pop();
+                if (left.size() > k) {
+                    left.pop();
+                }
+            }
+            if (left.size() == k && left.top() < root->val) {
+                ++ans;
+            }
+            left.push(root->val);
+            if (left.size() > k) {
+                left.pop();
+            }
+            return left;
+        };
+        dfs(root);
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+ func countGreatEnoughNodes(root *TreeNode, k int) (ans int) {
+	var dfs func(*TreeNode) hp
+	dfs = func(root *TreeNode) hp {
+		if root == nil {
+			return hp{}
+		}
+		l, r := dfs(root.Left), dfs(root.Right)
+		for _, x := range r.IntSlice {
+			l.push(x)
+			if l.Len() > k {
+				l.pop()
+			}
+		}
+		if l.Len() == k && root.Val > l.IntSlice[0] {
+			ans++
+		}
+		l.push(root.Val)
+		if l.Len() > k {
+			l.pop()
+		}
+		return l
+	}
+	dfs(root)
+	return
+}
+
+type hp struct{ sort.IntSlice }
+
+func (h hp) Less(i, j int) bool  { return h.IntSlice[i] > h.IntSlice[j] }
+func (h *hp) Push(v interface{}) { h.IntSlice = append(h.IntSlice, v.(int)) }
+func (h *hp) Pop() interface{} {
+	a := h.IntSlice
+	v := a[len(a)-1]
+	h.IntSlice = a[:len(a)-1]
+	return v
+}
+func (h *hp) push(v int) { heap.Push(h, v) }
+func (h *hp) pop() int   { return heap.Pop(h).(int) }
+```
+
+### **...**
+
+```
+
+```
+
+<!-- tabs:end -->