feat: add solutions to lc problem: No.0465

No.0465.Optimal Account Balancing

Author: yanglbme

solution/0400-0499/0465.Optimal Account Balancing/README.md

@@ -51,22 +51,222 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：状态压缩动态规划 + 子集枚举**
+
+我们先遍历数组 `transactions`，统计每个人的收支情况，然后将所有收支不为零的人的收支情况存入数组 $nums$ 中。如果我们可以找到一个子集，子集中共有 $k$ 个人，且这 $k$ 个人的收支情况之和为零，那么我们最多通过 $k-1$ 次交易，就能够使得这 $k$ 个人的收支情况全部清零。这样，我们就能将原问题转化成一个子集枚举的问题。
+
+我们定义 $f[i]$ 表示将集合 $i$ 的所有元素的收支情况全部清零，所需的最少交易次数，初始时 $f[0]=0$，其余 $f[i]=+\infty$。
+
+考虑 $f[i]$，其中 $i \in [1,2^m)$, $m$ 是数组 $nums$ 的长度。我们可以统计集合 $i$ 中所有元素的收支情况之和 $s$，如果 $s=0$，那么 $f[i]$ 的取值不超过 $|i|-1$，其中 $|i|$ 表示集合 $i$ 中的元素个数。然后我们可以枚举 $i$ 的所有非空子集 $j$，计算 $f[j]+f[i-j]$，其中 $f[j]$ 和 $f[i-j]$ 分别表示将集合 $j$ 和 $i-j$ 的所有元素的收支情况全部清零，所需的最少交易次数。我们可以得到状态转移方程：
+
+$$
+f[i]=
+\begin{cases}
+0, & i=0 \\
++\infty, & i \neq 0, s \neq 0 \\
+\min(|i|-1, \min_{j \subset i, j \neq \emptyset} \{f[j]+f[i-j]\}), & i \neq 0, s = 0
+\end{cases}
+$$
+
+其中 $j \subset i$ 表示 $j$ 是 $i$ 的子集，且 $j \neq \emptyset$。
+
+最终答案即为 $f[2^m-1]$。
+
+时间复杂度 $O(3^n)$，空间复杂度 $O(2^n)$。其中 $n$ 是人的数量，本题中 $n \leq 12$。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def minTransfers(self, transactions: List[List[int]]) -> int:
+        g = defaultdict(int)
+        for f, t, x in transactions:
+            g[f] -= x
+            g[t] += x
+        nums = [x for x in g.values() if x]
+        m = len(nums)
+        f = [inf] * (1 << m)
+        f[0] = 0
+        for i in range(1, 1 << m):
+            s = 0
+            for j, x in enumerate(nums):
+                if i >> j & 1:
+                    s += x
+            if s == 0:
+                f[i] = i.bit_count() - 1
+                j = (i - 1) & i
+                while j > 0:
+                    f[i] = min(f[i], f[j] + f[i ^ j])
+                    j = (j - 1) & i
+        return f[-1]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int minTransfers(int[][] transactions) {
+        int[] g = new int[12];
+        for (var t : transactions) {
+            g[t[0]] -= t[2];
+            g[t[1]] += t[2];
+        }
+        List<Integer> nums = new ArrayList<>();
+        for (int x : g) {
+            if (x != 0) {
+                nums.add(x);
+            }
+        }
+        int m = nums.size();
+        int[] f = new int[1 << m];
+        Arrays.fill(f, 1 << 29);
+        f[0] = 0;
+        for (int i = 1; i < 1 << m; ++i) {
+            int s = 0;
+            for (int j = 0; j < m; ++j) {
+                if ((i >> j & 1) == 1) {
+                    s += nums.get(j);
+                }
+            }
+            if (s == 0) {
+                f[i] = Integer.bitCount(i) - 1;
+                for (int j = (i - 1) & i; j > 0; j = (j - 1) & i) {
+                    f[i] = Math.min(f[i], f[j] + f[i ^ j]);
+                }
+            }
+        }
+        return f[(1 << m) - 1];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int minTransfers(vector<vector<int>>& transactions) {
+        int g[12]{};
+        for (auto& t : transactions) {
+            g[t[0]] -= t[2];
+            g[t[1]] += t[2];
+        }
+        vector<int> nums;
+        for (int x : g) {
+            if (x) {
+                nums.push_back(x);
+            }
+        }
+        int m = nums.size();
+        int f[1 << m];
+        memset(f, 0x3f, sizeof(f));
+        f[0] = 0;
+        for (int i = 1; i < 1 << m; ++i) {
+            int s = 0;
+            for (int j = 0; j < m; ++j) {
+                if (i >> j & 1) {
+                    s += nums[j];
+                }
+            }
+            if (s == 0) {
+                f[i] = __builtin_popcount(i) - 1;
+                for (int j = (i - 1) & i; j; j = (j - 1) & i) {
+                    f[i] = min(f[i], f[j] + f[i ^ j]);
+                }
+            }
+        }
+        return f[(1 << m) - 1];
+    }
+};
+```
+
+### **Go**
+
+```go
+func minTransfers(transactions [][]int) int {
+	g := [12]int{}
+	for _, t := range transactions {
+		g[t[0]] -= t[2]
+		g[t[1]] += t[2]
+	}
+	nums := []int{}
+	for _, x := range g {
+		if x != 0 {
+			nums = append(nums, x)
+		}
+	}
+	m := len(nums)
+	f := make([]int, 1<<m)
+	for i := 1; i < 1<<m; i++ {
+		f[i] = 1 << 29
+		s := 0
+		for j, x := range nums {
+			if i>>j&1 == 1 {
+				s += x
+			}
+		}
+		if s == 0 {
+			f[i] = bits.OnesCount(uint(i)) - 1
+			for j := (i - 1) & i; j > 0; j = (j - 1) & i {
+				f[i] = min(f[i], f[j]+f[i^j])
+			}
+		}
+	}
+	return f[1<<m-1]
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+```
+
+### **TypeScript**
+
+```ts
+function minTransfers(transactions: number[][]): number {
+    const g: number[] = new Array(12).fill(0);
+    for (const [f, t, x] of transactions) {
+        g[f] -= x;
+        g[t] += x;
+    }
+    const nums = g.filter(x => x !== 0);
+    const m = nums.length;
+    const f: number[] = new Array(1 << m).fill(1 << 29);
+    f[0] = 0;
+    for (let i = 1; i < 1 << m; ++i) {
+        let s = 0;
+        for (let j = 0; j < m; ++j) {
+            if (((i >> j) & 1) === 1) {
+                s += nums[j];
+            }
+        }
+        if (s === 0) {
+            f[i] = bitCount(i) - 1;
+            for (let j = (i - 1) & i; j; j = (j - 1) & i) {
+                f[i] = Math.min(f[i], f[j] + f[i ^ j]);
+            }
+        }
+    }
+    return f[(1 << m) - 1];
+}
 
+function bitCount(i: number): number {
+    i = i - ((i >>> 1) & 0x55555555);
+    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
+    i = (i + (i >>> 4)) & 0x0f0f0f0f;
+    i = i + (i >>> 8);
+    i = i + (i >>> 16);
+    return i & 0x3f;
+}
 ```
 
 ### **...**