feat: add solutions to lc problem: No.1774

No.1774.Closest Dessert Cost

Author: yanglbme

solution/1700-1799/1755.Closest Subsequence Sum/README.md

@@ -60,6 +60,8 @@
 
 时间复杂度 $O(n\times 2^{n/2})$。
 
+相似题目：[1774. 最接近目标价格的甜点成本](/solution/1700-1799/1774.Closest%20Dessert%20Cost/README.md)
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1700-1799/1773.Count Items Matching a Rule/README.md

@@ -52,9 +52,9 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：直接模拟**
+**方法一：计数模拟**
 
-由于 `ruleKey` 只可能是 `"type"`、`"color"` 或 `"name"`，我们可以直接取 `ruleKey` 的第一个字符 $x$ 来确定 `item` 的下标 $i$。然后遍历 `items` 数组，统计 `item[i] == ruleValue` 的个数即可。
+由于 `ruleKey` 只可能是 `"type"`、`"color"` 或 `"name"`，我们可以直接取 `ruleKey` 的第一个字符来确定 `item` 的下标 $i$。然后遍历 `items` 数组，统计 `item[i] == ruleValue` 的个数即可。
 
 时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为 `items` 的长度。
 
@@ -78,8 +78,7 @@ class Solution:
 ```java
 class Solution {
     public int countMatches(List<List<String>> items, String ruleKey, String ruleValue) {
-        char x = ruleKey.charAt(0);
-        int i = x == 't' ? 0 : (x == 'c' ? 1 : 2);
+        int i = ruleKey.charAt(0) == 't' ? 0 : (ruleKey.charAt(0) == 'c' ? 1 : 2);
         int ans = 0;
         for (var v : items) {
             if (v.get(i).equals(ruleValue)) {
@@ -97,8 +96,7 @@ class Solution {
 class Solution {
 public:
     int countMatches(vector<vector<string>>& items, string ruleKey, string ruleValue) {
-        char x = ruleKey[0];
-        int i = x == 't' ? 0 : (x == 'c' ? 1 : 2);
+        int i = ruleKey[0] == 't' ? 0 : (ruleKey[0] == 'c' ? 1 : 2);
         return count_if(items.begin(), items.end(), [&](auto& v) { return v[i] == ruleValue; });
     }
 };

solution/1700-1799/1773.Count Items Matching a Rule/README_EN.md

@@ -60,8 +60,7 @@ class Solution:
 ```java
 class Solution {
     public int countMatches(List<List<String>> items, String ruleKey, String ruleValue) {
-        char x = ruleKey.charAt(0);
-        int i = x == 't' ? 0 : (x == 'c' ? 1 : 2);
+        int i = ruleKey.charAt(0) == 't' ? 0 : (ruleKey.charAt(0) == 'c' ? 1 : 2);
         int ans = 0;
         for (var v : items) {
             if (v.get(i).equals(ruleValue)) {
@@ -79,8 +78,7 @@ class Solution {
 class Solution {
 public:
     int countMatches(vector<vector<string>>& items, string ruleKey, string ruleValue) {
-        char x = ruleKey[0];
-        int i = x == 't' ? 0 : (x == 'c' ? 1 : 2);
+        int i = ruleKey[0] == 't' ? 0 : (ruleKey[0] == 'c' ? 1 : 2);
         return count_if(items.begin(), items.end(), [&](auto& v) { return v[i] == ruleValue; });
     }
 };

solution/1700-1799/1773.Count Items Matching a Rule/Solution.cpp

@@ -1,8 +1,7 @@
 class Solution {
 public:
     int countMatches(vector<vector<string>>& items, string ruleKey, string ruleValue) {
-        char x = ruleKey[0];
-        int i = x == 't' ? 0 : (x == 'c' ? 1 : 2);
+        int i = ruleKey[0] == 't' ? 0 : (ruleKey[0] == 'c' ? 1 : 2);
         return count_if(items.begin(), items.end(), [&](auto& v) { return v[i] == ruleValue; });
     }
 };

solution/1700-1799/1773.Count Items Matching a Rule/Solution.java

@@ -1,7 +1,6 @@
 class Solution {
     public int countMatches(List<List<String>> items, String ruleKey, String ruleValue) {
-        char x = ruleKey.charAt(0);
-        int i = x == 't' ? 0 : (x == 'c' ? 1 : 2);
+        int i = ruleKey.charAt(0) == 't' ? 0 : (ruleKey.charAt(0) == 'c' ? 1 : 2);
         int ans = 0;
         for (var v : items) {
             if (v.get(i).equals(ruleValue)) {

solution/1700-1799/1774.Closest Dessert Cost/README.md

@@ -84,22 +84,180 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：枚举子集和 + 排序 + 二分查找**
+
+每种类型的配料最多可以选两份，因此，我们可以复制一份配料，然后利用 `DFS` 枚举子集之和。在实现上，我们可以只枚举一半的配料，然后在另一半配料中利用二分查找找到最接近的配料。
+
+时间复杂度 $O(n\times 2^m \times \log {2^m})$。
+
+相似题目：[1755. 最接近目标值的子序列和](/solution/1700-1799/1755.Closest%20Subsequence%20Sum/README.md)
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def closestCost(self, baseCosts: List[int], toppingCosts: List[int], target: int) -> int:
+        def dfs(i, t):
+            if i >= len(toppingCosts):
+                arr.append(t)
+                return
+            dfs(i + 1, t)
+            dfs(i + 1, t + toppingCosts[i])
+
+        arr = []
+        dfs(0, 0)
+        arr.sort()
+        d = ans = inf
+        for x in baseCosts:
+            for y in arr:
+                i = bisect_left(arr, target - x - y)
+                for j in (i, i - 1):
+                    if 0 <= j < len(arr):
+                        t = abs(x + y + arr[j] - target)
+                        if d > t or (d == t and ans > x + y + arr[j]):
+                            d = t
+                            ans = x + y + arr[j]
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private List<Integer> arr = new ArrayList<>();
+    private int[] ts;
+    private int inf = 0x3f3f3f3f;
+
+    public int closestCost(int[] baseCosts, int[] toppingCosts, int target) {
+        ts = toppingCosts;
+        dfs(0, 0);
+        Collections.sort(arr);
+        int d = inf, ans = inf;
+        for (int x : baseCosts) {
+            for (int y : arr) {
+                int i = search(target - x - y);
+                for (int j : new int[] {i, i - 1}) {
+                    if (j >= 0 && j < arr.size()) {
+                        int t = Math.abs(x + y + arr.get(j) - target);
+                        if (d > t || (d == t && ans > x + y + arr.get(j))) {
+                            d = t;
+                            ans = x + y + arr.get(j);
+                        }
+                    }
+                }
+            }
+        }
+        return ans;
+    }
+
+    private int search(int x) {
+        int left = 0, right = arr.size();
+        while (left < right) {
+            int mid = (left + right) >> 1;
+            if (arr.get(mid) >= x) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+
+    private void dfs(int i, int t) {
+        if (i >= ts.length) {
+            arr.add(t);
+            return;
+        }
+        dfs(i + 1, t);
+        dfs(i + 1, t + ts[i]);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    const int inf = 0x3f3f3f3f;
+    int closestCost(vector<int>& baseCosts, vector<int>& toppingCosts, int target) {
+        vector<int> arr;
+        function<void(int, int)> dfs = [&](int i, int t) {
+            if (i >= toppingCosts.size()) {
+                arr.push_back(t);
+                return;
+            }
+            dfs(i + 1, t);
+            dfs(i + 1, t + toppingCosts[i]);
+        };
+        dfs(0, 0);
+        sort(arr.begin(), arr.end());
+        int d = inf, ans = inf;
+        for (int x : baseCosts) {
+            for (int y : arr) {
+                int i = lower_bound(arr.begin(), arr.end(), target - x - y) - arr.begin();
+                for (int j = i - 1; j < i + 1; ++j) {
+                    if (j >= 0 && j < arr.size()) {
+                        int t = abs(x + y + arr[j] - target);
+                        if (d > t || (d == t && ans > x + y + arr[j])) {
+                            d = t;
+                            ans = x + y + arr[j];
+                        }
+                    }
+                }
+            }
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func closestCost(baseCosts []int, toppingCosts []int, target int) int {
+	arr := []int{}
+	var dfs func(int, int)
+	dfs = func(i, t int) {
+		if i >= len(toppingCosts) {
+			arr = append(arr, t)
+			return
+		}
+		dfs(i+1, t)
+		dfs(i+1, t+toppingCosts[i])
+	}
+	dfs(0, 0)
+	sort.Ints(arr)
+	ans, d := math.MaxInt32, math.MaxInt32
+	for _, x := range baseCosts {
+		for _, y := range arr {
+			i := sort.Search(len(arr), func(i int) bool { return arr[i] >= target-x-y })
+			for j := i - 1; j < i+1; j++ {
+				if j >= 0 && j < len(arr) {
+					t := abs(x + y + arr[j] - target)
+					if d > t || (d == t && ans > x+y+arr[j]) {
+						d = t
+						ans = x + y + arr[j]
+					}
+				}
+			}
+		}
+	}
+	return ans
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
 ```
 
 ### **...**