misc

Author: MaskRay

Diff for: course-schedule-iv.rs

@@ -0,0 +1,16 @@
+// Course Schedule IV
+impl Solution {
+    pub fn check_if_prerequisite(n: i32, prerequisites: Vec<Vec<i32>>, queries: Vec<Vec<i32>>) -> Vec<bool> {
+        let n = n as usize;
+        let mut g = vec![vec![false; n]; n];
+        for p in prerequisites.iter() {
+            g[p[0] as usize][p[1] as usize] = true;
+        }
+        for k in 0..n {
+            for i in 0..n {
+                for j in 0..n {
+                    if g[i][k] && g[k][j] {
+                        g[i][j] = true; }}}}
+        queries.into_iter().map(|q| g[q[0] as usize][q[1] as usize]).collect()
+    }
+}

Diff for: largest-color-value-in-a-directed-graph.rs

@@ -0,0 +1,46 @@
+impl Solution {
+    pub fn largest_path_value(colors: String, edges: Vec<Vec<i32>>) -> i32 {
+        let n = colors.len();
+        let mut deg = vec![0; n];
+        let mut head = vec![0; n];
+        let mut es: Vec<(usize, usize)> = vec![(0,0)];
+        for e in edges.iter() {
+            deg[e[1] as usize] += 1;
+            es.push((e[1] as usize, head[e[0] as usize]));
+            head[e[0] as usize] = es.len()-1;
+        }
+        let mut q = vec![];
+        for i in 0..n {
+            if deg[i] == 0 {
+                q.push(i); }}
+        let mut i = 0;
+        while i < q.len() {
+            let u = q[i];
+            i += 1;
+            let mut j = head[u];
+            while j != 0 {
+                let v = es[j].0;
+                j = es[j].1;
+                deg[v] -= 1;
+                if deg[v] == 0 { q.push(v); }
+            }
+        }
+        if q.len() != n { return -1; }
+
+        let mut ans = 0;
+        for c in b'a'..(b'z'+1) {
+            let mut dp = vec![0; n];
+            for &u in q.iter() {
+                if colors.as_bytes()[u] == c { dp[u] += 1; }
+                let mut j = head[u];
+                while j != 0 {
+                    let v = es[j].0;
+                    j = es[j].1;
+                    dp[v] = dp[v].max(dp[u]);
+                }
+            }
+            ans = dp.iter().fold(ans, |acc,&v| acc.max(v));
+        }
+        ans
+    }
+}

Diff for: maximum-subarray-min-product.rs

@@ -0,0 +1,41 @@
+impl Solution {
+    pub fn max_sum_min_product(a: Vec<i32>) -> i32 {
+        let mut st = vec![];
+        let mut l: Vec<usize> = vec![0; a.len()];
+        let mut r: Vec<usize> = vec![a.len(); a.len()];
+        for (i, &x) in a.iter().enumerate() {
+            while let Some(&j) = st.last() {
+                if a[j] < x { break; }
+                r[j] = i;
+                st.pop();
+            }
+            if let Some(&j) = st.last() { l[i] = j+1; }
+            st.push(i);
+        }
+        let sum: Box<[i64]> = std::iter::once(0).chain(a.iter().scan(0, |s,&y| { *s += y as i64; Some(*s) })).collect();
+        let mut ans = 0;
+        for i in 0..a.len() {
+            ans = ans.max((sum[r[i]]-sum[l[i]]) * a[i] as i64);
+        }
+        (ans % 1000000007) as i32
+    }
+}
+
+///
+
+impl Solution {
+    pub fn max_sum_min_product(a: Vec<i32>) -> i32 {
+        use std::{iter,usize::MAX};
+        let sum: Box<[i64]> = iter::once(0).chain(a.iter().scan(0, |s,&y| { *s += y as i64; Some(*s) })).collect();
+        let mut b: Vec<(usize,i32)> = a.into_iter().enumerate().collect();
+        b.sort_unstable_by_key(|v| std::cmp::Reverse(v.1));
+        let mut c: Vec<usize> = vec![MAX; b.len()];
+        (b.iter().fold(0, |acc,&(i,v)| {
+            let l = if i>0 && c[i-1]!=MAX { c[i-1] } else { i };
+            let r = if i+1<b.len() && c[i+1]!=MAX { c[i+1] } else { i };
+            c[l] = r;
+            c[r] = l;
+            acc.max((sum[r+1]-sum[l]) * v as i64)
+        }) % 1000000007) as i32
+    }
+}

Diff for: strange-printer-ii.rs

@@ -0,0 +1,35 @@
+// Strange Printer II
+impl Solution {
+    pub fn is_printable(grid: Vec<Vec<i32>>) -> bool {
+        use std::collections::HashSet;
+        fn cycle(u: usize, vis: &mut Vec<usize>, adj: &Vec<HashSet<usize>>) -> bool {
+            vis[u] = 1;
+            if adj[u].iter().any(|&v| vis[v] == 1 || vis[v] == 0 && cycle(v, vis, adj)) {
+                return true;
+            }
+            vis[u] = 2;
+            false
+        }
+        let nc = 61;
+        let m = grid.len();
+        let n = grid[0].len();
+        let mut adj: Vec<HashSet<usize>> = vec![HashSet::new(); nc];
+        for c in 1..nc {
+            let mut x0 = m; let mut x1 = 0;
+            let mut y0 = n; let mut y1 = 0;
+            for i in 0..m {
+                for j in 0..n {
+                    if grid[i][j] == c as i32 {
+                        x0 = x0.min(i);
+                        x1 = x1.max(i);
+                        y0 = y0.min(j);
+                        y1 = y1.max(j); }}}
+            for i in x0..x1+1 {
+                for j in y0..y1+1 {
+                    if grid[i][j] != c as i32 {
+                        adj[c].insert(grid[i][j] as usize); }}}
+        }
+        let mut vis = vec![0; nc];
+        !(1..nc).any(|c| vis[c] == 0 && cycle(c, &mut vis, &adj))
+    }
+}