feat: add Java solutions to lc problems: No.2873~2876

solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/README.md

@@ -68,6 +68,20 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public long maximumTripletValue(int[] nums) {
+        long max, maxDiff, ans;
+        max = 0;
+        maxDiff = 0;
+        ans = 0;
+        for (int num : nums) {
+            ans = Math.max(ans, num * maxDiff);
+            max = Math.max(max, num);
+            maxDiff = Math.max(maxDiff, max - num);
+        }
+        return ans;
+    }
+}
 
 ```
 

solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/README_EN.md

@@ -58,6 +58,20 @@ It can be shown that there are no ordered triplets of indices with a value great
 ### **Java**
 
 ```java
+class Solution {
+    public long maximumTripletValue(int[] nums) {
+        long max, maxDiff, ans;
+        max = 0;
+        maxDiff = 0;
+        ans = 0;
+        for (int num : nums) {
+            ans = Math.max(ans, num * maxDiff);
+            max = Math.max(max, num);
+            maxDiff = Math.max(maxDiff, max - num);
+        }
+        return ans;
+    }
+}
 
 ```
 

solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.java

@@ -0,0 +1,14 @@
+class Solution {
+    public long maximumTripletValue(int[] nums) {
+        long max, maxDiff, ans;
+        max = 0;
+        maxDiff = 0;
+        ans = 0;
+        for (int num : nums) {
+            ans = Math.max(ans, num * maxDiff);
+            max = Math.max(max, num);
+            maxDiff = Math.max(maxDiff, max - num);
+        }
+        return ans;
+    }
+}

solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/README.md

@@ -68,6 +68,20 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public long maximumTripletValue(int[] nums) {
+        long max, maxDiff, ans;
+        max = 0;
+        maxDiff = 0;
+        ans = 0;
+        for (int num : nums) {
+            ans = Math.max(ans, num * maxDiff);
+            max = Math.max(max, num);
+            maxDiff = Math.max(maxDiff, max - num);
+        }
+        return ans;
+    }
+}
 
 ```
 

solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/README_EN.md

@@ -58,6 +58,20 @@ It can be shown that there are no ordered triplets of indices with a value great
 ### **Java**
 
 ```java
+class Solution {
+    public long maximumTripletValue(int[] nums) {
+        long max, maxDiff, ans;
+        max = 0;
+        maxDiff = 0;
+        ans = 0;
+        for (int num : nums) {
+            ans = Math.max(ans, num * maxDiff);
+            max = Math.max(max, num);
+            maxDiff = Math.max(maxDiff, max - num);
+        }
+        return ans;
+    }
+}
 
 ```
 

solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.java

@@ -0,0 +1,14 @@
+class Solution {
+    public long maximumTripletValue(int[] nums) {
+        long max, maxDiff, ans;
+        max = 0;
+        maxDiff = 0;
+        ans = 0;
+        for (int num : nums) {
+            ans = Math.max(ans, num * maxDiff);
+            max = Math.max(max, num);
+            maxDiff = Math.max(maxDiff, max - num);
+        }
+        return ans;
+    }
+}

solution/2800-2899/2875.Minimum Size Subarray in Infinite Array/README.md

@@ -71,6 +71,51 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int shortestSubarray(int[] nums, int k) {
+        int n = nums.length;
+
+        int minLength = n * 2 + 1;
+        int l = 0;
+        int sum = 0;
+
+        for (int r = 0; r < n * 2; r++) {
+            int start = l % n;
+            int end = r % n;
+            sum += nums[end];
+
+            while (sum > k && l <= r) {
+                start = l % n;
+                sum -= nums[start];
+                l++;
+            }
+
+            if (sum == k) {
+                minLength = Math.min(minLength, r - l + 1);
+                start = l % n;
+                sum -= nums[start];
+                l++;
+            }
+        }
+
+        return minLength == n * 2 + 1 ? -1 : minLength;
+    }
+    public int minSizeSubarray(int[] nums, int target) {
+        int n = nums.length;
+        int sum = 0;
+
+        for (int num : nums) {
+            sum += num;
+        }
+        int k = target % sum;
+        int ans = target / sum * n;
+        if (k == 0) {
+            return ans;
+        }
+        int res = shortestSubarray(nums, k);
+        return res == -1 ? -1 : ans + res;
+    }
+}
 
 ```
 

solution/2800-2899/2875.Minimum Size Subarray in Infinite Array/README_EN.md

@@ -62,6 +62,51 @@ It can be proven that there is no subarray with sum equal to target = 3.
 ### **Java**
 
 ```java
+class Solution {
+    public int shortestSubarray(int[] nums, int k) {
+        int n = nums.length;
+
+        int minLength = n * 2 + 1;
+        int l = 0;
+        int sum = 0;
+
+        for (int r = 0; r < n * 2; r++) {
+            int start = l % n;
+            int end = r % n;
+            sum += nums[end];
+
+            while (sum > k && l <= r) {
+                start = l % n;
+                sum -= nums[start];
+                l++;
+            }
+
+            if (sum == k) {
+                minLength = Math.min(minLength, r - l + 1);
+                start = l % n;
+                sum -= nums[start];
+                l++;
+            }
+        }
+
+        return minLength == n * 2 + 1 ? -1 : minLength;
+    }
+    public int minSizeSubarray(int[] nums, int target) {
+        int n = nums.length;
+        int sum = 0;
+
+        for (int num : nums) {
+            sum += num;
+        }
+        int k = target % sum;
+        int ans = target / sum * n;
+        if (k == 0) {
+            return ans;
+        }
+        int res = shortestSubarray(nums, k);
+        return res == -1 ? -1 : ans + res;
+    }
+}
 
 ```
 

solution/2800-2899/2875.Minimum Size Subarray in Infinite Array/Solution.java

@@ -0,0 +1,45 @@
+class Solution {
+    public int shortestSubarray(int[] nums, int k) {
+        int n = nums.length;
+        int minLength = n * 2 + 1;
+        int l = 0;
+        int sum = 0;
+
+        for (int r = 0; r < n * 2; r++) {
+            int start = l % n;
+            int end = r % n;
+            sum += nums[end];
+
+            while (sum > k && l <= r) {
+                start = l % n;
+                sum -= nums[start];
+                l++;
+            }
+
+            if (sum == k) {
+                minLength = Math.min(minLength, r - l + 1);
+                start = l % n;
+                sum -= nums[start];
+                l++;
+            }
+        }
+
+        return minLength == n * 2 + 1 ? -1 : minLength;
+    }
+
+    public int minSizeSubarray(int[] nums, int target) {
+        int n = nums.length;
+        int sum = 0;
+
+        for (int num : nums) {
+            sum += num;
+        }
+        int k = target % sum;
+        int ans = target / sum * n;
+        if (k == 0) {
+            return ans;
+        }
+        int res = shortestSubarray(nums, k);
+        return res == -1 ? -1 : ans + res;
+    }
+}

solution/2800-2899/2876.Count Visited Nodes in a Directed Graph/README.md

@@ -70,6 +70,42 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    void dfs(int curr, List<Integer> edges, int[] ans) {
+
+        List<Integer> path = new ArrayList<>();
+        int prev = -1;
+        while (ans[curr] == 0) {
+            path.add(curr);
+            ans[curr] = prev == -1 ? -1 : ans[prev] - 1;
+            prev = curr;
+            curr = edges.get(curr);
+        }
+        int idx = path.size() - 1;
+        if (ans[curr] < 0) {
+            int cycle = ans[curr] - ans[path.get(idx)] + 1;
+            int start = ans[curr];
+            for (; idx >= 0 && ans[path.get(idx)] <= start; idx--) {
+                ans[path.get(idx)] = cycle;
+            }
+        }
+        for (; idx >= 0; idx--) {
+            ans[path.get(idx)] = ans[edges.get(path.get(idx))] + 1;
+        }
+    }
+
+    public int[] countVisitedNodes(List<Integer> edges) {
+        int n = edges.size();
+        int[] ans = new int[n];
+        for (int i = 0; i < n; i++) {
+            if (ans[i] > 0) {
+                continue;
+            }
+            dfs(i, edges, ans);
+        }
+        return ans;
+    }
+}
 
 ```
 

solution/2800-2899/2876.Count Visited Nodes in a Directed Graph/README_EN.md

@@ -60,6 +60,42 @@
 ### **Java**
 
 ```java
+class Solution {
+    void dfs(int curr, List<Integer> edges, int[] ans) {
+
+        List<Integer> path = new ArrayList<>();
+        int prev = -1;
+        while (ans[curr] == 0) {
+            path.add(curr);
+            ans[curr] = prev == -1 ? -1 : ans[prev] - 1;
+            prev = curr;
+            curr = edges.get(curr);
+        }
+        int idx = path.size() - 1;
+        if (ans[curr] < 0) {
+            int cycle = ans[curr] - ans[path.get(idx)] + 1;
+            int start = ans[curr];
+            for (; idx >= 0 && ans[path.get(idx)] <= start; idx--) {
+                ans[path.get(idx)] = cycle;
+            }
+        }
+        for (; idx >= 0; idx--) {
+            ans[path.get(idx)] = ans[edges.get(path.get(idx))] + 1;
+        }
+    }
+
+    public int[] countVisitedNodes(List<Integer> edges) {
+        int n = edges.size();
+        int[] ans = new int[n];
+        for (int i = 0; i < n; i++) {
+            if (ans[i] > 0) {
+                continue;
+            }
+            dfs(i, edges, ans);
+        }
+        return ans;
+    }
+}
 
 ```
 

solution/2800-2899/2876.Count Visited Nodes in a Directed Graph/Solution.java

@@ -0,0 +1,36 @@
+class Solution {
+    void dfs(int curr, List<Integer> edges, int[] ans) {
+
+        List<Integer> path = new ArrayList<>();
+        int prev = -1;
+        while (ans[curr] == 0) {
+            path.add(curr);
+            ans[curr] = prev == -1 ? -1 : ans[prev] - 1;
+            prev = curr;
+            curr = edges.get(curr);
+        }
+        int idx = path.size() - 1;
+        if (ans[curr] < 0) {
+            int cycle = ans[curr] - ans[path.get(idx)] + 1;
+            int start = ans[curr];
+            for (; idx >= 0 && ans[path.get(idx)] <= start; idx--) {
+                ans[path.get(idx)] = cycle;
+            }
+        }
+        for (; idx >= 0; idx--) {
+            ans[path.get(idx)] = ans[edges.get(path.get(idx))] + 1;
+        }
+    }
+
+    public int[] countVisitedNodes(List<Integer> edges) {
+        int n = edges.size();
+        int[] ans = new int[n];
+        for (int i = 0; i < n; i++) {
+            if (ans[i] > 0) {
+                continue;
+            }
+            dfs(i, edges, ans);
+        }
+        return ans;
+    }
+}