feat: add solutions to lc problem: No.1982

No.1982.Find Array Given Subset Sums

Author: yanglbme

solution/1000-1099/1096.Brace Expansion II/README.md

@@ -12,7 +12,6 @@
 
 <ul>
 	<li>如果只给出单一的元素&nbsp;<code>x</code>，那么表达式表示的字符串就只有&nbsp;<code>"x"</code>。<code>R(x) = {x}</code>
-
     <ul>
     	<li>例如，表达式 <code>"a"</code> 表示字符串 <code>"a"</code>。</li>
     	<li>而表达式 <code>"w"</code> 就表示字符串 <code>"w"</code>。</li>

solution/1900-1999/1966.Binary Searchable Numbers in an Unsorted Array/README.md

@@ -81,7 +81,7 @@ func(sequence, target)
 1. 这个元素大于它的左边所有元素，否则，如果左边存在比当前元素大的元素，那么就会被移除，导致无法找到当前元素；
 2. 这个元素小于它的右边所有元素，否则，如果右边存在比当前元素小的元素，那么就会被移除，导致无法找到当前元素。
 
-我们创建一个数组 $ok$，其中 $ok[i]$ 表示 $nums[i]$ 是否是可被二分搜索的。初始时，$ok[i]$ 都为 $1$。
+我们创建一个数组 $ok$，其中 $ok[i]$ 表示 $nums[i]$ 是否是可被二分搜索的。初始时 $ok[i]$ 都为 $1$。
 
 我们先从左到右遍历数组，维护前缀最大值 $mx$，如果当前元素 $x$ 比 $mx$ 小，那么 $x$ 就不是可被二分搜索的，我们将 $ok[i]$ 置为 $0$，否则，我们将 $mx$ 更新为 $x$。
 

solution/1900-1999/1976.Number of Ways to Arrive at Destination/README.md

@@ -60,7 +60,7 @@
 
 时间复杂度 $O(n^2)$。
 
-> 注意：最短路的长度可能会 超过 32 位整数的范围。
+> 注意：最短路的长度可能会超过 32 位整数的范围。
 
 <!-- tabs:start -->
 

solution/1900-1999/1982.Find Array Given Subset Sums/README.md

@@ -70,15 +70,207 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+from sortedcontainers import SortedList
+
+
+class Solution:
+    def recoverArray(self, n: int, sums: List[int]) -> List[int]:
+        m = -min(sums)
+        sl = SortedList(x + m for x in sums)
+        sl.remove(0)
+        ans = [sl[0]]
+        for i in range(1, n):
+            for j in range(1 << i):
+                if j >> (i - 1) & 1:
+                    s = sum(ans[k] for k in range(i) if j >> k & 1)
+                    sl.remove(s)
+            ans.append(sl[0])
+        for i in range(1 << n):
+            s = sum(ans[j] for j in range(n) if i >> j & 1)
+            if s == m:
+                for j in range(n):
+                    if i >> j & 1:
+                        ans[j] *= -1
+                break
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int[] recoverArray(int n, int[] sums) {
+        int m = 1 << 30;
+        for (int x : sums) {
+            m = Math.min(m, x);
+        }
+        m = -m;
+        TreeMap<Integer, Integer> tm = new TreeMap<>();
+        for (int x : sums) {
+            tm.merge(x + m, 1, Integer::sum);
+        }
+        int[] ans = new int[n];
+        if (tm.merge(0, -1, Integer::sum) == 0) {
+            tm.remove(0);
+        }
+        ans[0] = tm.firstKey();
+        for (int i = 1; i < n; ++i) {
+            for (int j = 0; j < 1 << i; ++j) {
+                if ((j >> (i - 1) & 1) == 1) {
+                    int s = 0;
+                    for (int k = 0; k < i; ++k) {
+                        if (((j >> k) & 1) == 1) {
+                            s += ans[k];
+                        }
+                    }
+                    if (tm.merge(s, -1, Integer::sum) == 0) {
+                        tm.remove(s);
+                    }
+                }
+            }
+            ans[i] = tm.firstKey();
+        }
+        for (int i = 0; i < 1 << n; ++i) {
+            int s = 0;
+            for (int j = 0; j < n; ++j) {
+                if (((i >> j) & 1) == 1) {
+                    s += ans[j];
+                }
+            }
+            if (s == m) {
+                for (int j = 0; j < n; ++j) {
+                    if (((i >> j) & 1) == 1) {
+                        ans[j] *= -1;
+                    }
+                }
+                break;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> recoverArray(int n, vector<int>& sums) {
+        int m = *min_element(sums.begin(), sums.end());
+        m = -m;
+        multiset<int> st;
+        for (int x : sums) {
+            st.insert(x + m);
+        }
+        st.erase(st.begin());
+        vector<int> ans;
+        ans.push_back(*st.begin());
+        for (int i = 1; i < n; ++i) {
+            for (int j = 0; j < 1 << i; ++j) {
+                if (j >> (i - 1) & 1) {
+                    int s = 0;
+                    for (int k = 0; k < i; ++k) {
+                        if (j >> k & 1) {
+                            s += ans[k];
+                        }
+                    }
+                    st.erase(st.find(s));
+                }
+            }
+            ans.push_back(*st.begin());
+        }
+        for (int i = 0; i < 1 << n; ++i) {
+            int s = 0;
+            for (int j = 0; j < n; ++j) {
+                if (i >> j & 1) {
+                    s += ans[j];
+                }
+            }
+            if (s == m) {
+                for (int j = 0; j < n; ++j) {
+                    if (i >> j & 1) {
+                        ans[j] = -ans[j];
+                    }
+                }
+                break;
+            }
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func recoverArray(n int, sums []int) []int {
+	m := 0
+	for _, x := range sums {
+		m = min(m, x)
+	}
+	m = -m
+	rbt := redblacktree.NewWithIntComparator()
+	merge := func(key int, value int) {
+		if v, ok := rbt.Get(key); ok {
+			nxt := v.(int) + value
+			if nxt == 0 {
+				rbt.Remove(key)
+			} else {
+				rbt.Put(key, nxt)
+			}
+		} else {
+			rbt.Put(key, value)
+		}
+	}
+	for _, x := range sums {
+		merge(x+m, 1)
+	}
+	ans := make([]int, n)
+	merge(ans[0], -1)
+	ans[0] = rbt.Left().Key.(int)
+	for i := 1; i < n; i++ {
+		for j := 0; j < 1<<i; j++ {
+			if j>>(i-1)&1 == 1 {
+				s := 0
+				for k := 0; k < i; k++ {
+					if j>>k&1 == 1 {
+						s += ans[k]
+					}
+				}
+				merge(s, -1)
+			}
+		}
+		ans[i] = rbt.Left().Key.(int)
+	}
+	for i := 0; i < 1<<n; i++ {
+		s := 0
+		for j := 0; j < n; j++ {
+			if i>>j&1 == 1 {
+				s += ans[j]
+			}
+		}
+		if s == m {
+			for j := 0; j < n; j++ {
+				if i>>j&1 == 1 {
+					ans[j] = -ans[j]
+				}
+			}
+			break
+		}
+	}
+	return ans
+
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**