feat: add solutions to lc problem: No.0828

No.0828.Count Unique Characters of All Substrings of a Given String

Author: yanglbme

solution/0800-0899/0828.Count Unique Characters of All Substrings of a Given String/README.md

@@ -54,22 +54,101 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：计算每个字符的贡献**
+
+对于字符串 `s` 的每个字符 $c_i$，当它在某个子字符串中仅出现一次时，它会对这个子字符串统计唯一字符时有贡献。只需对每个字符 $c_i$，计算有多少子字符串仅包含该字符一次即可。
+
+时间复杂度 $O(n)$，其中 $n$ 为字符串 `s` 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def uniqueLetterString(self, s: str) -> int:
+        d = defaultdict(list)
+        for i, c in enumerate(s):
+            d[c].append(i)
+        ans = 0
+        for v in d.values():
+            v = [-1] + v + [len(s)]
+            for i in range(1, len(v) - 1):
+                ans += (v[i] - v[i - 1]) * (v[i + 1] - v[i])
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int uniqueLetterString(String s) {
+        List<Integer>[] d = new List[26];
+        for (int i = 0; i < 26; ++i) {
+            d[i] = new ArrayList<>();
+            d[i].add(-1);
+        }
+        for (int i = 0; i < s.length(); ++i) {
+            d[s.charAt(i) - 'A'].add(i);
+        }
+        int ans = 0;
+        for (var v : d) {
+            v.add(s.length());
+            for (int i = 1; i < v.size() - 1; ++i) {
+                ans += (v.get(i) - v.get(i - 1)) * (v.get(i + 1) - v.get(i));
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int uniqueLetterString(string s) {
+        vector<vector<int>> d(26, {-1});
+        for (int i = 0; i < s.size(); ++i) {
+            d[s[i] - 'A'].push_back(i);
+        }
+        int ans = 0;
+        for (auto& v : d) {
+            v.push_back(s.size());
+            for (int i = 1; i < v.size() - 1; ++i) {
+                ans += (v[i] - v[i - 1]) * (v[i + 1] - v[i]);
+            }
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func uniqueLetterString(s string) int {
+	d := make([][]int, 26)
+	for i := range d {
+		d[i] = []int{-1}
+	}
+	for i, c := range s {
+		d[c-'A'] = append(d[c-'A'], i)
+	}
+	ans := 0
+	for _, v := range d {
+		v = append(v, len(s))
+		for i := 1; i < len(v)-1; i++ {
+			ans += (v[i] - v[i-1]) * (v[i+1] - v[i])
+		}
+	}
+	return ans
+}
 ```
 
 ### **...**

solution/0800-0899/0828.Count Unique Characters of All Substrings of a Given String/README_EN.md

@@ -55,13 +55,86 @@ Sum of lengths of all substring is 1 + 1 + 1 + 2 + 2 + 3 = 10
 ### **Python3**
 
 ```python
-
+class Solution:
+    def uniqueLetterString(self, s: str) -> int:
+        d = defaultdict(list)
+        for i, c in enumerate(s):
+            d[c].append(i)
+        ans = 0
+        for v in d.values():
+            v = [-1] + v + [len(s)]
+            for i in range(1, len(v) - 1):
+                ans += (v[i] - v[i - 1]) * (v[i + 1] - v[i])
+        return ans
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int uniqueLetterString(String s) {
+        List<Integer>[] d = new List[26];
+        for (int i = 0; i < 26; ++i) {
+            d[i] = new ArrayList<>();
+            d[i].add(-1);
+        }
+        for (int i = 0; i < s.length(); ++i) {
+            d[s.charAt(i) - 'A'].add(i);
+        }
+        int ans = 0;
+        for (var v : d) {
+            v.add(s.length());
+            for (int i = 1; i < v.size() - 1; ++i) {
+                ans += (v.get(i) - v.get(i - 1)) * (v.get(i + 1) - v.get(i));
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int uniqueLetterString(string s) {
+        vector<vector<int>> d(26, {-1});
+        for (int i = 0; i < s.size(); ++i) {
+            d[s[i] - 'A'].push_back(i);
+        }
+        int ans = 0;
+        for (auto& v : d) {
+            v.push_back(s.size());
+            for (int i = 1; i < v.size() - 1; ++i) {
+                ans += (v[i] - v[i - 1]) * (v[i + 1] - v[i]);
+            }
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func uniqueLetterString(s string) int {
+	d := make([][]int, 26)
+	for i := range d {
+		d[i] = []int{-1}
+	}
+	for i, c := range s {
+		d[c-'A'] = append(d[c-'A'], i)
+	}
+	ans := 0
+	for _, v := range d {
+		v = append(v, len(s))
+		for i := 1; i < len(v)-1; i++ {
+			ans += (v[i] - v[i-1]) * (v[i+1] - v[i])
+		}
+	}
+	return ans
+}
 ```
 
 ### **...**

solution/0800-0899/0828.Count Unique Characters of All Substrings of a Given String/Solution.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int uniqueLetterString(string s) {
+        vector<vector<int>> d(26, {-1});
+        for (int i = 0; i < s.size(); ++i) {
+            d[s[i] - 'A'].push_back(i);
+        }
+        int ans = 0;
+        for (auto& v : d) {
+            v.push_back(s.size());
+            for (int i = 1; i < v.size() - 1; ++i) {
+                ans += (v[i] - v[i - 1]) * (v[i + 1] - v[i]);
+            }
+        }
+        return ans;
+    }
+};

solution/0800-0899/0828.Count Unique Characters of All Substrings of a Given String/Solution.go

@@ -0,0 +1,17 @@
+func uniqueLetterString(s string) int {
+	d := make([][]int, 26)
+	for i := range d {
+		d[i] = []int{-1}
+	}
+	for i, c := range s {
+		d[c-'A'] = append(d[c-'A'], i)
+	}
+	ans := 0
+	for _, v := range d {
+		v = append(v, len(s))
+		for i := 1; i < len(v)-1; i++ {
+			ans += (v[i] - v[i-1]) * (v[i+1] - v[i])
+		}
+	}
+	return ans
+}

solution/0800-0899/0828.Count Unique Characters of All Substrings of a Given String/Solution.java

@@ -0,0 +1,20 @@
+class Solution {
+    public int uniqueLetterString(String s) {
+        List<Integer>[] d = new List[26];
+        for (int i = 0; i < 26; ++i) {
+            d[i] = new ArrayList<>();
+            d[i].add(-1);
+        }
+        for (int i = 0; i < s.length(); ++i) {
+            d[s.charAt(i) - 'A'].add(i);
+        }
+        int ans = 0;
+        for (var v : d) {
+            v.add(s.length());
+            for (int i = 1; i < v.size() - 1; ++i) {
+                ans += (v.get(i) - v.get(i - 1)) * (v.get(i + 1) - v.get(i));
+            }
+        }
+        return ans;
+    }
+}

solution/0800-0899/0828.Count Unique Characters of All Substrings of a Given String/Solution.py

@@ -0,0 +1,11 @@
+class Solution:
+    def uniqueLetterString(self, s: str) -> int:
+        d = defaultdict(list)
+        for i, c in enumerate(s):
+            d[c].append(i)
+        ans = 0
+        for v in d.values():
+            v = [-1] + v + [len(s)]
+            for i in range(1, len(v) - 1):
+                ans += (v[i] - v[i - 1]) * (v[i + 1] - v[i])
+        return ans

solution/2100-2199/2104.Sum of Subarray Ranges/README.md

@@ -70,21 +70,21 @@
 
 **方法一：暴力枚举**
 
-循环遍历 i，作为子数组的起始位置。对于每个 i，遍历每个 j 作为子数组的终止位置，此过程中不断求解子数组的最大值、最小值，然后累加差值到结果 ans 中。
+循环遍历 $i$，作为子数组的起始位置。对于每个 $i$，遍历每个 $j$ 作为子数组的终止位置，此过程中不断求解子数组的最大值、最小值，然后累加差值到结果 `ans` 中。
 
-最后返回 ans 即可。
+最后返回 `ans` 即可。
 
-时间复杂度 O(n²)。
+时间复杂度 $O(n^2)$。
 
 **方法二：单调栈**
 
 枚举每个元素 `nums[i]` 作为最大值出现在了多少个子数组中，以及作为最小值出现在多少个子数组中。
 
 其中 `nums[i]` 作为最大值的贡献为正，作为最小值的贡献为负。
 
-我们以 `nums[i]` 作为最大值为例。找出左侧第一个比 `nums[i]` 大的位置 `left[i]`，右侧第一个大于等于 `nums[i]` 的位置 `right[i]`。计算每个 `nums[i]` 的贡献 `(i - left[i]) * (right[i] - i) * arr[i]`，累加得到结果。
+我们以 `nums[i]` 作为最大值为例。找出左侧第一个比 `nums[i]` 大的位置 `left[i]`，右侧第一个大于等于 `nums[i]` 的位置 `right[i]`。计算每个 `nums[i]` 的贡献 $(i - left[i])\times (right[i] - i)\times arr[i]$，累加得到结果。
 
-时间复杂度 O(n)。
+时间复杂度 $O(n)$。
 
 相似题目：[907. 子数组的最小值之和](/solution/0900-0999/0907.Sum%20of%20Subarray%20Minimums/README.md)