feat: add solutions to lc problems: No.2044

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

Author: YangFong

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

@@ -140,6 +140,30 @@ function countMaxOrSubsets(nums: number[]): number {
 }
 ```
 
+```ts
+function countMaxOrSubsets(nums: number[]): number {
+    const n = nums.length;
+    let res = 0;
+    let max = -Infinity;
+    const dfs = (i: number, sum: number) => {
+        for (let j = i; j < n; j++) {
+            const num = sum | nums[j];
+            if (num >= max) {
+                if (num > max) {
+                    max = num;
+                    res = 0;
+                }
+                res++;
+            }
+            dfs(j + 1, num);
+        }
+    };
+    dfs(0, 0);
+
+    return res;
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -196,6 +220,41 @@ func countMaxOrSubsets(nums []int) int {
 }
 ```
 
+### **Rust**
+
+```rust
+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;
+                }
+                res += r_res;
+            }
+        }
+        (max, res)
+    }
+
+    pub fn count_max_or_subsets(nums: Vec<i32>) -> i32 {
+        Self::dfs(&nums, 0, 0).1
+    }
+}
+```
+
 ### **...**
 
 ```

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

@@ -130,6 +130,30 @@ function countMaxOrSubsets(nums: number[]): number {
 }
 ```
 
+```ts
+function countMaxOrSubsets(nums: number[]): number {
+    const n = nums.length;
+    let res = 0;
+    let max = -Infinity;
+    const dfs = (i: number, sum: number) => {
+        for (let j = i; j < n; j++) {
+            const num = sum | nums[j];
+            if (num >= max) {
+                if (num > max) {
+                    max = num;
+                    res = 0;
+                }
+                res++;
+            }
+            dfs(j + 1, num);
+        }
+    };
+    dfs(0, 0);
+
+    return res;
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -186,6 +210,41 @@ func countMaxOrSubsets(nums []int) int {
 }
 ```
 
+### **Rust**
+
+```rust
+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;
+                }
+                res += r_res;
+            }
+        }
+        (max, res)
+    }
+
+    pub fn count_max_or_subsets(nums: Vec<i32>) -> i32 {
+        Self::dfs(&nums, 0, 0).1
+    }
+}
+```
+
 ### **...**
 
 ```

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

@@ -0,0 +1,30 @@
+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;
+                }
+                res += r_res;
+            }
+        }
+        (max, res)
+    }
+
+    pub fn count_max_or_subsets(nums: Vec<i32>) -> i32 {
+        Self::dfs(&nums, 0, 0).1
+    }
+}