feat: add solutions to lc problem: No.2044

No.2044.Count Number of Maximum Bitwise-OR Subsets

Author: yanglbme

solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README.md

@@ -1,24 +1,19 @@
 class Solution {
 public:
-    int mx;
-    int ans;
-    vector<int> nums;
-
     int countMaxOrSubsets(vector<int>& nums) {
-        this->nums = nums;
-        mx = 0;
-        ans = 0;
-        for (int x : nums) mx |= x;
+        int ans = 0;
+        int mx = accumulate(nums.begin(), nums.end(), 0, bit_or<int>());
+        auto dfs = [&](this auto&& dfs, int i, int t) {
+            if (i == nums.size()) {
+                if (t == mx) {
+                    ans++;
+                }
+                return;
+            }
+            dfs(i + 1, t);
+            dfs(i + 1, t | nums[i]);
+        };
         dfs(0, 0);
         return ans;
     }
-
-    void dfs(int i, int t) {
-        if (i == nums.size()) {
-            if (t == mx) ++ans;
-            return;
-        }
-        dfs(i + 1, t);
-        dfs(i + 1, t | nums[i]);
-    }
-};
+};

solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README_EN.md

@@ -1,5 +1,5 @@
-func countMaxOrSubsets(nums []int) int {
-	mx, ans := 0, 0
+func countMaxOrSubsets(nums []int) (ans int) {
+	mx := 0
 	for _, x := range nums {
 		mx |= x
 	}
@@ -17,5 +17,5 @@ func countMaxOrSubsets(nums []int) int {
 	}
 
 	dfs(0, 0)
-	return ans
+	return
 }

solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.cpp

@@ -1,17 +1,15 @@
 class Solution:
     def countMaxOrSubsets(self, nums: List[int]) -> int:
-        mx = ans = 0
-        for x in nums:
-            mx |= x
-
         def dfs(i, t):
-            nonlocal mx, ans
+            nonlocal ans, mx
             if i == len(nums):
                 if t == mx:
                     ans += 1
                 return
             dfs(i + 1, t)
             dfs(i + 1, t | nums[i])
 
+        ans = 0
+        mx = reduce(lambda x, y: x | y, nums)
         dfs(0, 0)
         return ans

solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.go

@@ -1,30 +1,20 @@
 impl Solution {
-    fn dfs(nums: &Vec<i32>, i: usize, sum: i32) -> (i32, i32) {
-        let n = nums.len();
-        let mut max = i32::MIN;
-        let mut res = 0;
-        for j in i..n {
-            let num = sum | nums[j];
-            if num >= max {
-                if num > max {
-                    max = num;
-                    res = 0;
-                }
-                res += 1;
-            }
-            let (r_max, r_res) = Self::dfs(nums, j + 1, num);
-            if r_max >= max {
-                if r_max > max {
-                    max = r_max;
-                    res = 0;
+    pub fn count_max_or_subsets(nums: Vec<i32>) -> i32 {
+        let mut ans = 0;
+        let mx = nums.iter().fold(0, |x, &y| x | y);
+
+        fn dfs(i: usize, t: i32, nums: &Vec<i32>, mx: i32, ans: &mut i32) {
+            if i == nums.len() {
+                if t == mx {
+                    *ans += 1;
                 }
-                res += r_res;
+                return;
             }
+            dfs(i + 1, t, nums, mx, ans);
+            dfs(i + 1, t | nums[i], nums, mx, ans);
         }
-        (max, res)
-    }
 
-    pub fn count_max_or_subsets(nums: Vec<i32>) -> i32 {
-        Self::dfs(&nums, 0, 0).1
+        dfs(0, 0, &nums, mx, &mut ans);
+        ans
     }
 }

solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.py

@@ -1,18 +1,18 @@
 function countMaxOrSubsets(nums: number[]): number {
-    let n = nums.length;
-    let max = 0;
-    for (let i = 0; i < n; i++) {
-        max |= nums[i];
-    }
     let ans = 0;
-    function dfs(pre: number, depth: number): void {
-        if (depth == n) {
-            if (pre == max) ++ans;
+    const mx = nums.reduce((x, y) => x | y, 0);
+
+    const dfs = (i: number, t: number) => {
+        if (i === nums.length) {
+            if (t === mx) {
+                ans++;
+            }
             return;
         }
-        dfs(pre, depth + 1);
-        dfs(pre | nums[depth], depth + 1);
-    }
+        dfs(i + 1, t);
+        dfs(i + 1, t | nums[i]);
+    };
+
     dfs(0, 0);
     return ans;
 }

solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.rs

@@ -1,23 +1,22 @@
 class Solution {
 public:
-    int mx;
-    int ans;
-
     int countMaxOrSubsets(vector<int>& nums) {
-        dfs(0, 0, nums);
-        return ans;
-    }
-
-    void dfs(int u, int t, vector<int>& nums) {
-        if (u == nums.size()) {
-            if (t > mx) {
+        int n = nums.size();
+        int ans = 0;
+        int mx = 0;
+        for (int mask = 1; mask < 1 << n; ++mask) {
+            int t = 0;
+            for (int i = 0; i < n; ++i) {
+                if ((mask >> i) & 1) {
+                    t |= nums[i];
+                }
+            }
+            if (mx < t) {
                 mx = t;
                 ans = 1;
-            } else if (t == mx)
+            } else if (mx == t)
                 ++ans;
-            return;
         }
-        dfs(u + 1, t, nums);
-        dfs(u + 1, t | nums[u], nums);
+        return ans;
     }
 };

solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.ts

@@ -1,11 +1,11 @@
-func countMaxOrSubsets(nums []int) int {
+func countMaxOrSubsets(nums []int) (ans int) {
 	n := len(nums)
-	ans := 0
 	mx := 0
-	for mask := 1; mask < 1<<n; mask++ {
+
+	for mask := 0; mask < (1 << n); mask++ {
 		t := 0
 		for i, v := range nums {
-			if ((mask >> i) & 1) == 1 {
+			if (mask>>i)&1 == 1 {
 				t |= v
 			}
 		}
@@ -16,5 +16,6 @@ func countMaxOrSubsets(nums []int) int {
 			ans++
 		}
 	}
-	return ans
-}
+
+	return
+}

solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.cpp

@@ -1,25 +1,22 @@
 class Solution {
-    private int mx;
-    private int ans;
-    private int[] nums;
-
     public int countMaxOrSubsets(int[] nums) {
-        this.nums = nums;
-        dfs(0, 0);
-        return ans;
-    }
-
-    private void dfs(int u, int t) {
-        if (u == nums.length) {
-            if (t > mx) {
+        int n = nums.length;
+        int ans = 0;
+        int mx = 0;
+        for (int mask = 1; mask < 1 << n; ++mask) {
+            int t = 0;
+            for (int i = 0; i < n; ++i) {
+                if (((mask >> i) & 1) == 1) {
+                    t |= nums[i];
+                }
+            }
+            if (mx < t) {
                 mx = t;
                 ans = 1;
-            } else if (t == mx) {
+            } else if (mx == t) {
                 ++ans;
             }
-            return;
         }
-        dfs(u + 1, t);
-        dfs(u + 1, t | nums[u]);
+        return ans;
     }
 }