misc

Author: MaskRay

count-ways-to-build-rooms-in-an-ant-colony.rs

@@ -0,0 +1,45 @@
+// Count Ways to Build Rooms in an Ant Colony
+impl Solution {
+    pub fn ways_to_build_rooms(prev: Vec<i32>) -> i32 {
+        const MOD: usize = 1000000007;
+        let n = prev.len();
+        let mut inv = vec![1; n];
+        let mut fac = vec![1; n];
+        let mut invfac = vec![1; n];
+        fac[0] = 1; invfac[0] = 1;
+        fac[1] = 1; invfac[1] = 1; inv[1] = 1;
+        for i in 2..n {
+            inv[i] = ((MOD-MOD/i)*(inv[MOD%i] as usize)%MOD) as i32;
+            fac[i] = (fac[i-1] as usize*i%MOD) as i32;
+            invfac[i] = (invfac[i-1] as usize*inv[i] as usize%MOD) as i32;
+        }
+
+        let mut d = vec![0; n];
+        let mut top = std::usize::MAX;
+        for &p in prev.iter() { if p >= 0 { d[p as usize] += 1; }}
+        for i in 0..n { if d[i] == 0 { d[i] = top; top = i; }}
+
+        let mut num = vec![0; n];
+        let mut cnt = vec![1; n];
+        let mut ans = 1;
+        while top != std::usize::MAX {
+            let u = top;
+            let p = prev[u] as usize;
+            top = d[top];
+            cnt[u] = cnt[u] *fac[num[u]] as usize%MOD;
+            num[u] += 1;
+            if p == std::usize::MAX {
+                ans = cnt[u];
+            } else {
+                cnt[p] = cnt[p] *cnt[u]%MOD *invfac[num[u]] as usize%MOD;
+                num[p] += num[u];
+                d[p] -= 1;
+                if d[p] == 0 {
+                    d[p] = top;
+                    top = p;
+                }
+            }
+        }
+        ans as i32
+    }
+}

course-schedule-iii.rs

@@ -0,0 +1,17 @@
+// Course Schedule III
+impl Solution {
+    pub fn schedule_course(mut courses: Vec<Vec<i32>>) -> i32 {
+        use std::collections::BinaryHeap;
+        courses.sort_unstable_by_key(|x| x[1]);
+        let mut h = BinaryHeap::new();
+        let mut s = 0;
+        for c in courses.into_iter() {
+            s += c[0];
+            h.push(c[0]);
+            if s > c[1] {
+                s -= h.pop().unwrap();
+            }
+        }
+        h.len() as i32
+    }
+}

cyclically-rotating-a-grid.rs

@@ -0,0 +1,22 @@
+// Cyclically Rotating a Grid
+impl Solution {
+    pub fn rotate_grid(mut a: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {
+        let m = a.len()-1;
+        let n = a[0].len()-1;
+        let mut b = vec![];
+        for q in 0..(m.min(n)+1)/2 {
+            b.clear();
+            for i in q..n-q { b.push(a[q][i]); }
+            for i in q..m-q { b.push(a[i][n-q]); }
+            for i in (q+1..=n-q).rev() { b.push(a[m-q][i]); }
+            for i in (q+1..=m-q).rev() { b.push(a[i][q]); }
+            b.rotate_left(k as usize%(2*(m+n)-q*8));
+            let mut j = 0;
+            for i in q..n-q { a[q][i] = b[j]; j += 1; }
+            for i in q..m-q { a[i][n-q] = b[j]; j += 1; }
+            for i in (q+1..=n-q).rev() { a[m-q][i] = b[j]; j += 1; }
+            for i in (q+1..=m-q).rev() { a[i][q] = b[j]; j += 1; }
+        }
+        a
+    }
+}

find-longest-awesome-substring.rs

@@ -0,0 +1,25 @@
+// Find Longest Awesome Substring
+impl Solution {
+    pub fn longest_awesome(s: String) -> i32 {
+        let mut pos = vec![-1i32; 1<<10];
+        let mut sum = 0;
+        let mut ans = 0;
+        pos[0] = 0;
+        for (i, c) in s.as_bytes().iter().enumerate() {
+            let i = i as i32;
+            sum ^= 1 << c-b'0';
+            if pos[sum] >= 0 {
+                ans = ans.max(i+1-pos[sum]);
+            } else {
+                pos[sum] = i+1;
+            }
+            for j in 0..10 {
+                let p = pos[sum ^ 1<<j];
+                if p >= 0 {
+                    ans = ans.max(i+1-p);
+                }
+            }
+        }
+        ans
+    }
+}

find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.rs

@@ -0,0 +1,19 @@
+// Find the Kth Smallest Sum of a Matrix With Sorted Rows
+impl Solution {
+    pub fn kth_smallest(mat: Vec<Vec<i32>>, k: i32) -> i32 {
+        use std::collections::BinaryHeap;
+        let mut h = BinaryHeap::new();
+        h.push(0);
+        for a in mat.into_iter() {
+            let mut h1 = BinaryHeap::new();
+            for x in h.iter() {
+                for y in a.iter() {
+                    h1.push(x+y);
+                    if h1.len() > k as usize { h1.pop(); }
+                }
+            }
+            h = h1;
+        }
+        *h.peek().unwrap()
+    }
+}

find-the-longest-substring-containing-vowels-in-even-counts.rs

@@ -0,0 +1,26 @@
+// Find the Longest Substring Containing Vowels in Even Counts
+impl Solution {
+    pub fn find_the_longest_substring(s: String) -> i32 {
+        let mut pos = vec![-1; 1<<5];
+        pos[0] = 0;
+        let mut sum = 0;
+        let mut ans = 0;
+        for (i, c) in s.as_bytes().iter().enumerate() {
+            let i = i as i32;
+            match c {
+                b'a' => sum ^= 1,
+                b'e' => sum ^= 2,
+                b'i' => sum ^= 4,
+                b'o' => sum ^= 8,
+                b'u' => sum ^= 16,
+                _ => (),
+            }
+            if pos[sum] < 0 {
+                pos[sum] = i+1;
+            } else {
+                ans = ans.max(i+1-pos[sum]);
+            }
+        }
+        ans
+    }
+}

largest-palindrome-product.rs

@@ -0,0 +1,21 @@
+// Largest Palindrome Product
+impl Solution {
+    pub fn largest_palindrome(n: i32) -> i32 {
+        let l = 10i64.pow(n as u32-1);
+        let h = 10i64.pow(n as u32)-1;
+        for mut i in (l..=h).rev() {
+            let mut s = i;
+            while i > 0 {
+                s = s*10+i%10;
+                i /= 10;
+            }
+            let mut j = (s+h-1)/h;
+            loop {
+                if s/j < j { break; }
+                if s%j == 0 { return (s%1337) as i32; }
+                j += 1;
+            }
+        }
+        9
+    }
+}

maximum-alternating-subsequence-sum.rs

@@ -0,0 +1,12 @@
+// Maximum Alternating Subsequence Sum
+impl Solution {
+    pub fn max_alternating_sum(nums: Vec<i32>) -> i64 {
+        let mut s = nums[0] as i64;
+        for i in 1..nums.len() {
+            if nums[i] > nums[i-1] {
+                s += (nums[i]-nums[i-1]) as i64;
+            }
+        }
+        s
+    }
+}

maximum-number-of-events-that-can-be-attended.rs

@@ -0,0 +1,21 @@
+// Maximum Number of Events That Can Be Attended
+impl Solution {
+    pub fn max_events(mut events: Vec<Vec<i32>>) -> i32 {
+        let n = events.iter().fold(0, |acc,e| acc.max(e[1])) + 2;
+        events.sort_unstable_by_key(|x| x[1]);
+        let mut uf: Vec<i32> = (0..n).collect();
+        let mut ans = 0;
+        for e in events.into_iter() {
+            let mut x = e[0];
+            while uf[x as usize] != x {
+                uf[x as usize] = uf[uf[x as usize] as usize];
+                x = uf[x as usize];
+            }
+            if x <= e[1] {
+                uf[x as usize] = x+1;
+                ans += 1;
+            }
+        }
+        ans
+    }
+}

maximum-number-of-removable-characters.rs

@@ -0,0 +1,28 @@
+// Maximum Number of Removable Characters
+impl Solution {
+    pub fn maximum_removals(s: String, p: String, removable: Vec<i32>) -> i32 {
+        let s = s.as_bytes();
+        let p = p.as_bytes();
+        let mut l = 0;
+        let mut h = removable.len();
+        let mut del = vec![false; s.len()];
+        while l < h {
+            let m = l+h+1 >> 1;
+            for i in 0..m { del[removable[i] as usize] = true; }
+            let mut j = 0;
+            for i in 0..s.len() {
+                if !del[i] && s[i] == p[j] {
+                    j += 1;
+                    if j == p.len() { break; }
+                }
+            }
+            for i in 0..m { del[removable[i] as usize] = false; }
+            if j == p.len() {
+                l = m;
+            } else {
+                h = m-1;
+            }
+        }
+        l as i32
+    }
+}

maximum-performance-of-a-team.rs

@@ -0,0 +1,18 @@
+// Maximum Performance of a Team
+impl Solution {
+    pub fn max_performance(n: i32, speed: Vec<i32>, efficiency: Vec<i32>, k: i32) -> i32 {
+        use std::{cmp::Reverse,collections::BinaryHeap};
+        let mut h: BinaryHeap<Reverse<i32>> = BinaryHeap::new();
+        let mut a = efficiency.into_iter().zip(speed).collect::<Vec<(i32,i32)>>();
+        a.sort_unstable_by_key(|x| Reverse(x.0));
+        let mut sum = 0;
+        let mut ans = 0;
+        for (e, s) in a.into_iter() {
+            if h.len() == k as usize { sum -= h.pop().unwrap().0 as i64; }
+            sum += s as i64;
+            h.push(Reverse(s));
+            ans = ans.max(e as i64 * sum)
+        }
+        (ans % 1000000007) as i32
+    }
+}

minimum-absolute-difference-queries.rs

@@ -0,0 +1,28 @@
+// Minimum Absolute Difference Queries
+impl Solution {
+    pub fn min_difference(a: Vec<i32>, queries: Vec<Vec<i32>>) -> Vec<i32> {
+        const V: usize = 100;
+        let n = a.len();
+        let mut s = vec![[0i32; V]; n+1];
+        for i in 0..n {
+            let (before, after) = s.split_at_mut(i+1);
+            after[0].clone_from_slice(&before[i]);
+            s[i+1][a[i] as usize-1] += 1;
+        }
+        let mut ans = vec![];
+        for q in queries.into_iter() {
+            let mut x = std::i32::MAX;
+            let mut last = -1;
+            let l = &s[q[0] as usize];
+            let r = &s[q[1] as usize+1];
+            for i in 0..100 {
+                if (*r)[i as usize] != (*l)[i as usize] {
+                    if last >= 0 { x = x.min(i-last); }
+                    last = i;
+                }
+            }
+            ans.push(if x==std::i32::MAX {-1} else {x});
+        }
+        ans
+    }
+}

minimum-cost-to-change-the-final-value-of-expression.rs

@@ -0,0 +1,74 @@
+// Minimum Cost to Change the Final Value of Expression
+impl Solution {
+    pub fn min_operations_to_flip(e: String) -> i32 {
+        let mut isp = vec![0; 127];
+        isp[b'&' as usize]=3; isp[b'|' as usize]=3; isp[b'(' as usize]=1;
+        let mut icp = vec![0; 127];
+        icp[b'&' as usize]=2; icp[b'|' as usize]=2; icp[b'(' as usize]=4; icp[b')' as usize]=1;
+        let mut op = vec![b'\0'];
+        let mut st = vec![];
+        for &c in e.as_bytes().iter().chain(std::iter::once(&b'\0')) {
+            if c == b'0' || c == b'1' {
+                let v = (c-b'0') as i32;
+                st.push((v, 1-v));
+                continue;
+            }
+            while isp[op[op.len()-1] as usize] > icp[c as usize] {
+                let y = st.pop().unwrap();
+                let x = st.pop().unwrap();
+                let c00 = x.0+y.0; let c01 = x.0+y.1;
+                let c10 = x.1+y.0; let c11 = x.1+y.1;
+                st.push(if op.pop().unwrap() == b'&' {
+                    (c00.min(c01).min(c10), c11.min(c01+1).min(c10+1))
+                } else {
+                    (c00.min(c01+1).min(c10+1), c11.min(c01).min(c10))
+                });
+            }
+            if isp[op[op.len()-1] as usize] == icp[c as usize] {
+                op.pop();
+            } else {
+                op.push(c);
+            }
+        }
+        let x = st.pop().unwrap();
+        x.0.max(x.1)
+    }
+}
+
+///
+
+impl Solution {
+    pub fn min_operations_to_flip(e: String) -> i32 {
+        let mut isp = vec![0; 127];
+        isp[b'&' as usize]=3; isp[b'|' as usize]=3; isp[b'(' as usize]=1;
+        let mut icp = vec![0; 127];
+        icp[b'&' as usize]=2; icp[b'|' as usize]=2; icp[b'(' as usize]=4; icp[b')' as usize]=1;
+        let mut op = vec![b'\0'];
+        let mut st = vec![];
+        for &c in e.as_bytes().iter().chain(std::iter::once(&b'\0')) {
+            if c == b'0' || c == b'1' {
+                let v = (c-b'0') as i32;
+                st.push((v, 1-v));
+                continue;
+            }
+            while isp[op[op.len()-1] as usize] > icp[c as usize] {
+                let y = st.pop().unwrap();
+                let x = st.pop().unwrap();
+                let c00 = x.0+y.0; let c01 = x.0+y.1;
+                let c10 = x.1+y.0; let c11 = x.1+y.1;
+                st.push(if op.pop().unwrap() == b'&' {
+                    (c00.min(c01).min(c10), c11.min(c01+1).min(c10+1))
+                } else {
+                    (c00.min(c01+1).min(c10+1), c11.min(c01).min(c10))
+                });
+            }
+            if isp[op[op.len()-1] as usize] == icp[c as usize] {
+                op.pop();
+            } else {
+                op.push(c);
+            }
+        }
+        let x = st.pop().unwrap();
+        x.0.max(x.1)
+    }
+}