提交若干题目

Author: 932413237@qq.com

leetcode4java/src/main/java/Problem_5211_概率最大的路径/Description.md

@@ -0,0 +1,91 @@
+给你一个整数 n，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。
+
+示例 1：
+--
+```
+输入：n = 234
+输出：15 
+解释：### [5211\. 概率最大的路径](https://leetcode-cn.com/contest/weekly-contest-197/problems/path-with-maximum-probability/)
+   
+   Difficulty: **Medium**
+   
+   给你一个由 `n` 个节点（下标从 0 开始）组成的无向加权图，该图由一个描述边的列表组成，其中 `edges[i] = [a, b]` 表示连接节点 a 和 b 的一条无向边，且该边遍历成功的概率为 `succProb[i]` 。
+   
+   指定两个节点分别作为起点 `start` 和终点 `end` ，请你找出从起点到终点成功概率最大的路径，并返回其成功概率。
+   
+   如果不存在从 `start` 到 `end` 的路径，请 **返回 0** 。只要答案与标准答案的误差不超过 **1e-5** ，就会被视作正确答案。
+   
+   **示例 1：**
+   
+   **![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/12/1558_ex1.png)**
+   
+   ```
+   输入：n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.2], start = 0, end = 2
+   输出：0.25000
+   解释：从起点到终点有两条路径，其中一条的成功概率为 0.2 ，而另一条为 0.5 * 0.5 = 0.25
+   ```
+   
+   **示例 2：**
+   
+   **![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/12/1558_ex2.png)**
+   
+   ```
+   输入：n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.3], start = 0, end = 2
+   输出：0.30000
+   ```
+   
+   **示例 3：**
+   
+   **![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/12/1558_ex3.png)**
+   
+   ```
+   输入：n = 3, edges = [[0,1]], succProb = [0.5], start = 0, end = 2
+   输出：0.00000
+   解释：节点 0 和 节点 2 之间不存在路径
+   ```
+   
+   **提示：**
+   
+   *   `2 <= n <= 10^4`
+   *   `0 <= start, end < n`
+   *   `start != end`
+   *   `0 <= a, b < n`
+   *   `a != b`
+   *   `0 <= succProb.length == edges.length <= 2*10^4`
+   *   `0 <= succProb[i] <= 1`
+   *   每两个节点之间最多有一条边
+   
+   #### Solution
+   
+   Language: **Java**
+   
+   ```java
+   class Solution {
+       public double maxProbability(int n, int[][] edges, double[] succProb, int start, int end) {
+   ​
+       }
+   }
+   ```
+各位数之积 = 2 * 3 * 4 = 24 
+各位数之和 = 2 + 3 + 4 = 9 
+结果 = 24 - 9 = 15
+```
+示例 2：
+--
+```
+输入：n = 4421
+输出：21
+解释： 
+各位数之积 = 4 * 4 * 2 * 1 = 32 
+各位数之和 = 4 + 4 + 2 + 1 = 11 
+结果 = 32 - 11 = 21
+```
+
+提示：
+--
+```
+1 <= n <= 10^5
+```
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/subtract-the-product-and-sum-of-digits-of-an-integer
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

leetcode4java/src/main/java/Problem_5211_概率最大的路径/Solution.java

@@ -0,0 +1,70 @@
+package Problem_5211_概率最大的路径;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+class Solution {
+    Map<Entry, Integer> indexMap = new HashMap<>();
+
+    public double maxProbability(int n, int[][] edges, double[] succProb, int start, int end) {
+        Entry[] point = new Entry[n];
+        for (int i = 0; i < point.length; i++) {
+            point[i] = new Entry();
+            indexMap.put(point[i], i);
+        }
+        for (int i = 0; i < edges.length; i++) {
+            int pointIndex1 = edges[i][0];
+            int pointIndex2 = edges[i][1];
+            double thisSuccProb = succProb[i];
+            point[pointIndex1].map.put(point[pointIndex2], thisSuccProb);
+            point[pointIndex2].map.put(point[pointIndex1], thisSuccProb);
+        }
+        memo = new Double[n][n];
+        return findMin(point[start], point[end], new HashSet<>());
+    }
+
+    Double[][] memo;
+
+    private Double findMin(Entry entry1, Entry entry2, Set<Entry> path) {
+        Double result = memo[indexMap.get(entry1)][indexMap.get(entry2)];
+        if (result != null) return result;
+        result = memo[indexMap.get(entry2)][indexMap.get(entry1)];
+        if (result != null) return result;
+        Set<Map.Entry<Entry, Double>> entries = entry1.map.entrySet();
+        for (Map.Entry<Entry, Double> entry : entries) {
+            if (path.contains(entry.getKey())) continue;
+            path.add(entry.getKey());
+            Double min = findMin(entry.getKey(), entry2, path);
+            if (min != null) {
+                if (result == null) result = min * entry.getValue();
+                else result = Math.min(result, min * entry.getValue());
+            }
+            path.remove(entry.getKey());
+        }
+        memo[indexMap.get(entry2)][indexMap.get(entry1)] = result;
+        memo[indexMap.get(entry1)][indexMap.get(entry2)] = result;
+        return memo[indexMap.get(entry2)][indexMap.get(entry1)];
+    }
+
+    class Entry {
+        Map<Entry, Double> map = new HashMap<>();
+    }
+}
+
+class Test {
+    public static void main(String[] args) {
+        double v = new Solution().maxProbability(
+                3,
+                new int[][]{
+                        {0, 1},
+                        {1, 2},
+                        {0, 2}
+                },
+                new double[]{0.5, 0.5, 0.2},
+                0,
+                2);
+        System.out.println(v);
+    }
+}

leetcode4java/src/main/java/Problem_5460_好数对的数目/Description.md

@@ -0,0 +1,49 @@
+### [5460\. 好数对的数目](https://leetcode-cn.com/contest/weekly-contest-197/problems/number-of-good-pairs/)
+
+Difficulty: **Easy**
+
+给你一个整数数组 `nums` 。
+
+如果一组数字 `(i,j)` 满足 `nums[i]` == `nums[j]` 且 `i` < `j` ，就可以认为这是一组 **好数对** 。
+
+返回好数对的数目。
+
+**示例 1：**
+
+```
+输入：nums = [1,2,3,1,1,3]
+输出：4
+解释：有 4 组好数对，分别是 (0,3), (0,4), (3,4), (2,5) ，下标从 0 开始
+```
+
+**示例 2：**
+
+```
+输入：nums = [1,1,1,1]
+输出：6
+解释：数组中的每组数字都是好数对
+```
+
+**示例 3：**
+
+```
+输入：nums = [1,2,3]
+输出：0
+```
+
+**提示：**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 100`
+
+#### Solution
+
+Language: **Java**
+
+```java
+class Solution {
+    public int numIdenticalPairs(int[] nums) {
+​
+    }
+}
+```

leetcode4java/src/main/java/Problem_5460_好数对的数目/Solution.java

@@ -0,0 +1,35 @@
+package Problem_5460_好数对的数目;
+
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    public int numIdenticalPairs(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>(); //key:nums value   value:count
+        for (int i = 0; i < nums.length; i++) {
+            Integer count = map.get(nums[i]);
+            if (count == null) count = 0;
+            count++;
+            map.put(nums[i], count);
+        }
+        int totalCount = 0;
+        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
+            int count;
+            if ((count = entry.getValue()) <= 1) continue;
+            int sum = 1;
+            for (int i = 0; i < 2; i++) sum *= (count - i);
+            sum /= 2;
+            totalCount += sum;
+        }
+        return totalCount;
+    }
+}
+
+class Test {
+    public static void main(String[] args) {
+        int i = new Solution().numIdenticalPairs(
+                new int[]{1,2,3,1,1,3}
+        );
+        System.out.println(i);
+    }
+}

leetcode4java/src/main/java/Problem_5461_仅含1的子串数/Description.md

@@ -0,0 +1,60 @@
+### [5461\. 仅含 1 的子串数](https://leetcode-cn.com/contest/weekly-contest-197/problems/number-of-substrings-with-only-1s/)
+
+Difficulty: **Medium**
+
+给你一个二进制字符串 `s`（仅由 '0' 和 '1' 组成的字符串）。
+
+返回所有字符都为 1 的子字符串的数目。
+
+由于答案可能很大，请你将它对 10^9 + 7 取模后返回。
+
+**示例 1：**
+
+```
+输入：s = "0110111"
+输出：9
+解释：共有 9 个子字符串仅由 '1' 组成
+"1" -> 5 次
+"11" -> 3 次
+"111" -> 1 次
+```
+
+**示例 2：**
+
+```
+输入：s = "101"
+输出：2
+解释：子字符串 "1" 在 s 中共出现 2 次
+```
+
+**示例 3：**
+
+```
+输入：s = "111111"
+输出：21
+解释：每个子字符串都仅由 '1' 组成
+```
+
+**示例 4：**
+
+```
+输入：s = "000"
+输出：0
+```
+
+**提示：**
+
+*   `s[i] == '0'` 或 `s[i] == '1'`
+*   `1 <= s.length <= 10^5`
+
+#### Solution
+
+Language: **Java**
+
+```java
+class Solution {
+    public int numSub(String s) {
+​
+    }
+}
+```

leetcode4java/src/main/java/Problem_5461_仅含1的子串数/Solution.java

@@ -0,0 +1,38 @@
+package Problem_5461_仅含1的子串数;
+
+import javafx.beans.binding.When;
+
+import java.math.BigInteger;
+
+class Solution {
+    public int numSub(String s) {
+        char[] chars = s.toCharArray();
+        Integer start = null;
+        BigInteger count = BigInteger.valueOf(0);
+        int length = chars.length;
+        for (int i = 0; i < length; i++) {
+            if (chars[i] == '0') {
+                if (start != null) {
+                    int tempLength = i - start;
+                    BigInteger result = BigInteger.valueOf(1 + tempLength).multiply(BigInteger.valueOf(tempLength)).divide(BigInteger.valueOf(2));
+                    count = count.add(result);
+                    start = null;
+                }
+            } else if (start == null)
+                start = i;
+        }
+        if (start != null) {
+            int tempLength = length - start;
+            BigInteger result = BigInteger.valueOf(1 + tempLength).multiply(BigInteger.valueOf(tempLength)).divide(BigInteger.valueOf(2));
+            count = count.add(result);
+        }
+        return count.mod(new BigInteger("1000000007")).intValue();
+    }
+}
+
+class Test {
+    public static void main(String[] args) {
+        int i = new Solution().numSub("0110111");
+        System.out.println(i);
+    }
+}

leetcode4java/src/main/java/Problem_5464_换酒问题/Description.md

@@ -0,0 +1,38 @@
+小区便利店正在促销，用 numExchange 个空酒瓶可以兑换一瓶新酒。你购入了 numBottles 瓶酒。
+
+如果喝掉了酒瓶中的酒，那么酒瓶就会变成空的。
+
+请你计算 最多 能喝到多少瓶酒。
+
+ 
+
+示例 1：
+
+
+
+输入：numBottles = 9, numExchange = 3
+输出：13
+解释：你可以用 3 个空酒瓶兑换 1 瓶酒。
+所以最多能喝到 9 + 3 + 1 = 13 瓶酒。
+示例 2：
+
+
+
+输入：numBottles = 15, numExchange = 4
+输出：19
+解释：你可以用 4 个空酒瓶兑换 1 瓶酒。
+所以最多能喝到 15 + 3 + 1 = 19 瓶酒。
+示例 3：
+
+输入：numBottles = 5, numExchange = 5
+输出：6
+示例 4：
+
+输入：numBottles = 2, numExchange = 3
+输出：2
+ 
+
+提示：
+
+1 <= numBottles <= 100
+2 <= numExchange <= 100