Rust

Author: MaskRay

change-minimum-characters-to-satisfy-one-of-three-conditions.rs

@@ -0,0 +1,20 @@
+// Change Minimum Characters to Satisfy One of Three Conditions
+impl Solution {
+    pub fn min_characters(a: String, b: String) -> i32 {
+        let na = a.as_bytes().len();
+        let nb = b.as_bytes().len();
+        let mut ca = vec![0; 26];
+        let mut cb = vec![0; 26];
+        for c in a.into_bytes().iter() { ca[(c-b'a') as usize] += 1; }
+        for c in b.into_bytes().iter() { cb[(c-b'a') as usize] += 1; }
+        let mut pa = 0;
+        let mut pb = 0;
+        let mut ans = na-ca[25]+nb-cb[25];
+        for i in 0..25 {
+            pa += ca[i];
+            pb += cb[i];
+            ans = ans.min(na-pa+pb).min(nb-pb+pa).min(na-ca[i]+nb-cb[i]);
+        }
+        ans as i32
+    }
+}

describe-the-painting.rs

@@ -0,0 +1,22 @@
+// Describe the Painting
+impl Solution {
+    pub fn split_painting(segments: Vec<Vec<i32>>) -> Vec<Vec<i64>> {
+        use std::collections::BTreeMap;
+        let mut c = BTreeMap::new();
+        for seg in segments.into_iter() {
+            c.insert(seg[0], c.get(&seg[0]).unwrap_or(&0)+seg[2] as i64);
+            c.insert(seg[1], c.get(&seg[1]).unwrap_or(&0)-seg[2] as i64);
+        }
+        let mut ans = vec![];
+        let mut i = 0;
+        let mut sum = 0;
+        for (k, v) in c.into_iter() {
+            if sum > 0 {
+                ans.push(vec![i as i64, k as i64, sum]);
+            }
+            sum += v;
+            i = k;
+        }
+        ans
+    }
+}

longest-word-in-dictionary-through-deleting.rs

@@ -0,0 +1,14 @@
+// Longest Word in Dictionary through Deleting
+impl Solution {
+    pub fn find_longest_word(s: String, dictionary: Vec<String>) -> String {
+        let mut p = vec![0; dictionary.len()];
+        let ws: Vec<&[u8]> = dictionary.iter().map(|s| s.as_bytes()).collect();
+        for &c in s.as_bytes().iter() {
+            ws.iter().enumerate().for_each(|(i,w)| if p[i] < w.len() && w[p[i]] == c {p[i]+=1;});
+        }
+        String::from_utf8_lossy(
+            ws.into_iter().zip(p.iter()).fold(&[], |acc,(w,&i)|
+                if w.len()==i && (w.len()>acc.len() || w.len()==acc.len() && w < acc) {w} else {acc})
+        ).into_owned()
+    }
+}

maximum-genetic-difference-query.rs

@@ -0,0 +1,45 @@
+// Maximum Genetic Difference Query
+impl Solution {
+    pub fn max_genetic_difference(parents: Vec<i32>, queries: Vec<Vec<i32>>) -> Vec<i32> {
+        const LN: usize = 18;
+        fn dfs(u: usize, dep: i32, fenwick: &mut Vec<i32>, g: &Vec<Vec<usize>>, q: &Vec<Vec<(i32, usize)>>, ans: &mut Vec<i32>) {
+            let mut x = u;
+            while x < 1<<LN { fenwick[x] += 1; x |= x+1; }
+            for qu in q[u].iter() {
+                let mut c = dep;
+                x = 0;
+                for i in (0..LN).rev().map(|i| 1<<i) {
+                    let c1 = fenwick[x+i-1];
+                    if c1 < c && ((qu.0 & i as i32) == 0 || c1 == 0) {
+                        c -= c1;
+                        x += i;
+                    } else {
+                        c = c1
+                    }
+                }
+                ans[qu.1] = qu.0 ^ x as i32;
+            }
+            for &v in g[u].iter() {
+                dfs(v, dep+1, fenwick, g, q, ans);
+            }
+            x = u;
+            while x < 1<<LN { fenwick[x] -= 1; x |= x+1; }
+        }
+
+        let n = parents.len();
+        let mut root = 0;
+        let mut g = vec![vec![]; n];
+        let mut q = vec![vec![]; n];
+        for (i, p) in parents.into_iter().enumerate() {
+            if p == -1 { root = i; }
+            else { g[p as usize].push(i as usize); }
+        }
+        for (i, que) in queries.iter().enumerate() {
+            q[que[0] as usize].push((que[1], i));
+        }
+        let mut fenwick = vec![0; 1<<LN];
+        let mut ans = vec![0; queries.len()];
+        dfs(root, 1, &mut fenwick, &g, &q, &mut ans);
+        ans
+    }
+}

maximum-number-of-points-with-cost.rs

@@ -0,0 +1,22 @@
+// Maximum Number of Points with Cost
+impl Solution {
+    pub fn max_points(points: Vec<Vec<i32>>) -> i64 {
+        let n = points[0].len();
+        let mut f = vec![0i64; n];
+        let mut g = vec![0i64; n];
+        for a in points.iter() {
+            let mut mx = std::i64::MIN;
+            for i in 0..n {
+                mx = mx.max(f[i]+i as i64);
+                g[i] = mx+a[i] as i64-i as i64;
+            }
+            mx = std::i64::MIN;
+            for i in (0..n).rev() {
+                mx = mx.max(f[i]-i as i64);
+                g[i] = g[i].max(mx+a[i] as i64+i as i64);
+            }
+            f.clone_from_slice(&g);
+        }
+        f.iter().fold(0, |acc,v| acc.max(*v))
+    }
+}

maximum-xor-of-two-numbers-in-an-array.rs

@@ -0,0 +1,11 @@
+impl Solution {
+    pub fn find_maximum_xor(nums: Vec<i32>) -> i32 {
+        use std::collections::HashSet;
+        use std::iter::FromIterator;
+        (0..32).rev().fold(0, |acc,i| {
+            let m = acc | 1<<i;
+            let s: HashSet<i32> = HashSet::from_iter(nums.iter().map(|x| x&m));
+            if s.iter().any(|&x| s.contains(&(x^m))) {m} else {acc}
+        })
+    }
+}

minimum-cost-to-reach-destination-in-time.rs

@@ -0,0 +1,27 @@
+// Minimum Cost to Reach Destination in Time
+impl Solution {
+    pub fn min_cost(max_time: i32, edges: Vec<Vec<i32>>, passing_fees: Vec<i32>) -> i32 {
+        use std::cmp::Reverse;
+        use std::collections::BinaryHeap;
+        let n = passing_fees.len();
+        let mut g = vec![vec![]; n];
+        for e in edges.into_iter() {
+            g[e[0] as usize].push((e[1], e[2]));
+            g[e[1] as usize].push((e[0], e[2]));
+        }
+        let mut dist = vec![max_time+1; n];
+        let mut h: BinaryHeap<Reverse<(i32, i32, i32)>> = BinaryHeap::from(vec![Reverse((passing_fees[0], 0, 0))]);
+        while let Some(Reverse((fee, c, t))) = h.pop() {
+            let c = c as usize;
+            if dist[c] <= t { continue; }
+            dist[c] = t;
+            if c == n-1 { return fee; }
+            for &e in g[c].iter() {
+                if t+e.1 < dist[e.0 as usize] {
+                    h.push(Reverse((fee+passing_fees[e.0 as usize], e.0, t+e.1)));
+                }
+            }
+        }
+        -1
+    }
+}

number-of-subarrays-with-bounded-maximum.rs

@@ -0,0 +1,20 @@
+// Number of Subarrays with Bounded Maximum
+impl Solution {
+    pub fn num_subarray_bounded_max(nums: Vec<i32>, left: i32, right: i32) -> i32 {
+        let mut ans = 0;
+        let mut cnt = 0;
+        let mut bgn = 0;
+        for (i, x) in nums.into_iter().enumerate() {
+            if x > right {
+                cnt = 0;
+                bgn = i+1;
+            } else {
+                if x >= left {
+                    cnt = i+1-bgn;
+                }
+                ans += cnt;
+            }
+        }
+        ans as i32
+    }
+}

number-of-visible-people-in-a-queue.rs

@@ -0,0 +1,51 @@
+// Number of Visible People in a Queue
+impl Solution {
+    pub fn can_see_persons_count(heights: Vec<i32>) -> Vec<i32> {
+        let mut st: Vec<usize> = vec![];
+        let mut ans = vec![0; heights.len()];
+        for (i, &h) in heights.iter().enumerate() {
+            while st.len() > 0 && heights[*st.last().unwrap()] <= h {
+                ans[st.pop().unwrap()] += 1;
+            }
+            if let Some(x) = st.last() {
+                ans[*x] += 1;
+            }
+            st.push(i);
+        }
+        ans
+    }
+}
+
+///
+
+impl Solution {
+    pub fn can_see_persons_count(heights: Vec<i32>) -> Vec<i32> {
+        let mut st = vec![];
+        let mut ans = vec![0; heights.len()];
+        for (i, &h) in heights.iter().enumerate().rev() {
+            let c = st.len();
+            while st.len() > 0 && *st.last().unwrap() <= h {
+                st.pop();
+            }
+            ans[i] = (c-st.len()) as i32 + if st.is_empty() {0} else {1};
+            st.push(h);
+        }
+        ans
+    }
+}
+
+///
+
+impl Solution {
+    pub fn can_see_persons_count(heights: Vec<i32>) -> Vec<i32> {
+        let mut st = vec![];
+        let mut ans = heights.into_iter().rev().map(|h| {
+            let c = st.len();
+            st.truncate(st.iter().rposition(|&x| x > h).and_then(|i| Some(i+1)).unwrap_or(0));
+            st.push(h);
+            (c+1-st.len()) as i32 + if st.len()==1 {0} else {1}
+        }).collect::<Vec<_>>();
+        ans.reverse();
+        ans
+    }
+}

painting-a-grid-with-three-different-colors.rs

@@ -0,0 +1,33 @@
+// Painting a Grid With Three Different Colors
+impl Solution {
+    pub fn color_the_grid(m: i32, n: i32) -> i32 {
+        const MOD: i32 = 1000000007;
+        let ns = 3<<m-1;
+        let mut tr = vec![vec![]; ns];
+        for i in 0..ns {
+            for j in 0..ns {
+                let mut i0 = i>>m-1;
+                let mut j0 = j>>m-1;
+                let mut ok = i0 != j0;
+                for k in 0..m-1 {
+                    i0 = (i0+1+(i>>k&1))%3;
+                    j0 = (j0+1+(j>>k&1))%3;
+                    ok = ok && i0 != j0;
+                }
+                if ok { tr[i].push(j); }
+            }
+        }
+        let mut f = vec![1; ns];
+        let mut g = vec![0; ns];
+        for i in 1..n {
+            for j in 0..ns { g[j] = 0; }
+            for j in 0..ns {
+                for &k in tr[j].iter() {
+                    g[k] = (f[j]+g[k])%MOD;
+                }
+            }
+            for j in 0..ns { f[j] = g[j]; }
+        }
+        f.iter().fold(0, |acc,v| (acc+v)%MOD)
+    }
+}

the-number-of-the-smallest-unoccupied-chair.rs

@@ -0,0 +1,29 @@
+// The Number of the Smallest Unoccupied Chair
+impl Solution {
+    pub fn smallest_chair(mut times: Vec<Vec<i32>>, target_friend: i32) -> i32 {
+        use std::cmp::Reverse;
+        use std::collections::{BinaryHeap,BTreeSet};
+        let start = times[target_friend as usize][0];
+        times.sort_unstable_by_key(|t| t[0]);
+        let mut used: BinaryHeap<Reverse<(i32, i32)>> = BinaryHeap::new();
+        let mut free: BinaryHeap<Reverse<i32>> = BinaryHeap::new();
+        let mut allo = 0;
+        let mut sit = 0;
+        for t in times.into_iter() {
+            if start < t[0] { break; }
+            while let Some(Reverse(x)) = used.peek() {
+                if t[0] < x.0 { break; }
+                free.push(Reverse(x.1));
+                used.pop();
+            }
+            if let Some(Reverse(x)) = free.pop() {
+                sit = x;
+            } else {
+                sit = allo;
+                allo += 1;
+            }
+            used.push(Reverse((t[1], sit)));
+        }
+        sit
+    }
+}