2411. 按位或最大的最小子数组长度

src/main.rs

@@ -1,19 +1,79 @@
-struct Solution;
+use std::ops::{AddAssign, SubAssign};
-impl Solution {
+
-    pub fn count_max_or_subsets(nums: Vec<i32>) -> i32 {
+struct XorVal {
-        let max_or = nums.iter().fold(0, |acc, &x| acc | x);
+    data: Vec<i32>,
-        let mut dp = vec![0;1<<nums.len()];
+    count: usize,
-        for i in 0..nums.len() {
+}
-            for j in (1<<i)..(1<<(i+1)) {
+impl XorVal {
-                dp[j] = dp[j - (1<<i)] | nums[i];
+    pub fn new() -> Self {
+        XorVal { data: vec!(0; 32), count: 0 }
+    }
+    pub fn get_val(&self) -> i32 {
+        if self.count == 0 {
+            return -1;
+        }
+        let mut ans = 0;
+        for i in 0..32 {
+            if self.data[i] > 0 {
+                ans |= 1 << i;
             }
         }
-        dp.iter().filter(|x| **x == max_or ).count() as i32
+        ans
+    }
+}
+impl AddAssign<i32> for XorVal {
+    fn add_assign(&mut self, mut x: i32) {
+        self.count += 1;
+        let mut i = 0;
+        while x > 0 {
+            if x & 1 == 1 {
+                self.data[i] += 1;
+            }
+            x >>= 1;
+            i += 1;
+        }
+    }
+}
+impl SubAssign<i32> for XorVal {
+    fn sub_assign(&mut self, mut x: i32) {
+        self.count -= 1;
+        let mut i = 0;
+        while x > 0 {
+            if x & 1 == 1 {
+                self.data[i] -= 1;
+            }
+            x >>= 1;
+            i += 1;
+        }
+    }
+}
+struct Solution;
+impl Solution {
+    pub fn smallest_subarrays(nums: Vec<i32>) -> Vec<i32> {
+        let mut ans = vec![0; nums.len()];
+        let mut xor = vec![0; nums.len()];
+        xor[nums.len() - 1] = nums[nums.len() - 1];
+        for i in (0..nums.len() - 1).rev() {
+            xor[i] = xor[i + 1] | nums[i];
+        }
+        let mut xor_val = XorVal::new();
+        let (mut l, mut r) = (0, 0);
+        for i in 0..nums.len() {
+            while l < i && l <= r {
+                xor_val -= nums[l];
+                l += 1;
+            }
+            while xor_val.get_val() < xor[i] {
+                xor_val += nums[r];
+                r += 1;
+            }
+            ans[i] = (r - l) as i32;
+        }
+        ans
     }
 }
 
 fn main() {
-    let sl = Solution::count_max_or_subsets(vec![3,2,1,5]);
+    let sl = Solution::smallest_subarrays(vec![0]);
-    println!("{}", sl);
+    println!("{:?}", sl);
 }
-