Refactor Java solution in 3.java to improve code clarity and maintainability by optimizing logic flow and enhancing variable naming.

Author: tkzzzzzz6

leetcode/Study Plan/104. 二叉树的最大深度/1.py

@@ -0,0 +1,11 @@
+# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
+        if root is None:
+            return 0
+        return max(self.maxDepth(root.left),self.maxDepth(root.right))+1

leetcode/Study Plan/104. 二叉树的最大深度/2.py

@@ -0,0 +1,19 @@
+# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
+        cnt = 0
+        def dfs(node,depth):
+            if node is None:
+                return
+            depth+=1
+            nonlocal cnt
+            cnt = max(cnt,depth)
+            dfs(node.left,depth)
+            dfs(node.right,depth)
+        dfs(root,0)
+        return cnt

leetcode/Study Plan/2141. 同时运行 N 台电脑的最长时间/1.cpp

@@ -0,0 +1,36 @@
+class Solution {
+    public:
+        long long maxRunTime(int n, vector<int>& batteries) {
+            // 计算所有电池的总容量
+            long long tot = reduce(batteries.begin(),batteries.end(),0LL);
+            
+            // 二分查找的左右边界
+            // 理论上最多能运行 tot/n 分钟（平均分配），所以上界设为 tot/n+1
+            long long l = 0, r = tot / n + 1;
+            
+            // 二分查找：找到最大的运行时间 x，使得 n 台电脑可以同时运行 x 分钟
+            // 使用左闭右开区间 [l, r)
+            while(l + 1 < r)
+            {
+                // 候选的运行时间
+                long long x = l + (r - l) / 2;
+                
+                // 计算所有电池能提供的总能量
+                // 对于每个电池，最多只能给一台电脑供电 x 分钟
+                // 所以每个电池最多贡献 min(b, x) 的能量
+                long long sum = 0;
+                for(long long b : batteries)
+                {
+                    sum += min(b, x);
+                }
+                
+                // 判断：如果总能量 sum >= n * x，说明可以让 n 台电脑运行 x 分钟
+                // 此时可以尝试更大的 x（更新左边界）
+                // 否则需要减小 x（更新右边界）
+                (n * x <= sum ? l : r) = x;
+            }
+            
+            // 返回最大的满足条件的运行时间
+            return l;
+        }
+    };

leetcode/Study Plan/2141. 同时运行 N 台电脑的最长时间/1.rs

@@ -0,0 +1,32 @@
+impl Solution {
+    pub fn max_run_time(n: i32, batteries: Vec<i32>) -> i64 {
+        // 计算所有电池容量的总和
+        let sum: i64 = batteries.iter().map(|&x| x as i64).sum();
+        // 将 n 转为 i64 方便计算
+        let n = n as i64;
+        // 二分查找的左边界，表示最短运行时间
+        let mut left: i64 = 0;
+        // 二分查找的右边界，最大平均运行时间
+        let mut right: i64 = sum / n;
+        // 用于记录满足条件的最大运行时间
+        let mut ans: i64 = 0;
+
+        // 二分查找，寻找最大的可行运行时间
+        while left <= right {
+            let mid = (left + right) / 2; // 尝试的运行时间
+            let mut total: i64 = 0;
+            // 计算所有电池在最多每台电脑运行 mid 分钟时能提供的电量
+            for (&cap) in &batteries {
+                total += std::cmp::min(cap as i64, mid);
+            }
+            // 如果总电量可以支持 n 台电脑运行 mid 分钟
+            if total >= n * mid {
+                ans = mid;             // 更新答案
+                left = mid + 1;        // 尝试更大的运行时间
+            } else {
+                right = mid - 1;       // 尝试更小的运行时间
+            }
+        }
+        ans // 返回最大运行时间
+    }
+}

leetcode/Study Plan/2141. 同时运行 N 台电脑的最长时间/2.cpp

@@ -0,0 +1,16 @@
+class Solution {
+    public:
+        long long maxRunTime(int n, vector<int>& batteries) {
+            ranges::sort(batteries,greater<int>());
+            long long sum = reduce(batteries.begin(),batteries.end(),0LL);
+            for(int i =0; ;++i)
+            {
+                if(batteries[i] <= sum / n)
+                {
+                    return sum / n;
+                }
+                sum -= batteries[i];
+                --n;
+            }
+        }
+    };

niuke/daily_problem/25_12-1构造数独/1.cpp

@@ -0,0 +1,50 @@
+// 采用对角矩阵的方法构造
+#include<bits/stdc++.h>
+#define il inline
+using namespace std;
+
+#define pb push_back
+#define fastio \
+  ios::sync_with_stdio(false); \
+  cin.tie(0);
+
+typedef long long ll;
+typedef unsigned long long ull;
+
+const ll N = 5e5+5, mod = 1e9+7, inf = 2e18;
+const double eps = 1e-9;
+const double PI = 3.1415926;
+
+il void solve(){
+    int n,k;
+    cin >> n >> k;
+    for(int i = 0;i<n;++i)
+    {
+        for(int j = 0;j<n;++j)
+        {
+            if(i == j)
+            {
+                cout << k << ' ';
+            }
+            else
+            {
+                cout << 0 << ' ';
+            }
+        }
+        cout << '\n';
+    }
+}
+
+int main()
+{
+    fastio
+    
+    int t = 1;
+    // cin >> t;
+    while(t--)
+    {
+        solve();
+    }
+    
+    return 0;
+}

niuke/daily_problem/25_12-1构造数独/2.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+)
+
+var sc = bufio.NewScanner(os.Stdin)
+var out = bufio.NewWriter(os.Stdout)
+
+func next() string {
+	sc.Scan()
+	return sc.Text()
+}
+
+func nextInt() int {
+	v, _ := strconv.Atoi(next())
+	return v
+}
+
+func main() {
+	defer out.Flush()
+	sc.Split(bufio.ScanWords)
+	t := 1
+	// t = nextInt()
+	for ; t > 0; t-- {
+		solve()
+	}
+}
+
+func solve() {
+	n, s := nextInt(), nextInt()
+	first_row := make([]int, n)
+	q := s / n
+	r := s % n
+
+	// 构造第一行
+	for i := 0; i < n; i++ {
+		if i < r {
+			first_row[i] = q + 1
+		} else {
+			first_row[i] = q
+		}
+	}
+
+	// 构造并打印整个矩阵
+	for i := 0; i < n; i++ {
+		for j := 0; j < n; j++ {
+			sep := " "
+			if j == n-1 {
+				sep = ""
+			}
+			fmt.Printf("%d%s", first_row[(j-i+n)%n], sep)
+		}
+		fmt.Println()
+	}
+
+}