Lis (#76)

* first draft of LIS

* nit

* add yosupo test

* add helpful comment

* rename

* finish docs

* allow pop

* fix clippy

* about to add another test

* rng

* now AC's

* fix

* fix

* fix one comment

* more nits

* another nit

* nit

* saving

* changing

---------

Co-authored-by: Luke Videckis <lukevideckis@gmail.com>

Author: lrvideckis

Cargo.toml

@@ -10,6 +10,7 @@ edition = "2024"
 [dependencies]
 proconio = "0.4.5"
 ac-library-rs = "0.1.1"
+rand = "0.8.5"
 
 [[example]]
 name = "binary_trie"
@@ -186,3 +187,15 @@ path = "examples/graphs/bridges_aizu.rs"
 [[example]]
 name = "ext_gcd"
 path = "examples/numbers/ext_gcd.rs"
+
+[[example]]
+name = "lis_aizu"
+path = "examples/helpers/lis_aizu.rs"
+
+[[example]]
+name = "lis_yosupo"
+path = "examples/helpers/lis_yosupo.rs"
+
+[[example]]
+name = "lis_pop"
+path = "examples/helpers/lis_pop.rs"

examples/helpers/lis_aizu.rs

@@ -0,0 +1,19 @@
+// verification-helper: PROBLEM https://onlinejudge.u-aizu.ac.jp/problems/DPL_1_D
+
+use proconio::input;
+use programming_team_code_rust::helpers::lis::Lis;
+
+fn main() {
+    input! {
+        n: usize,
+        a: [u32; n]
+    }
+
+    let mut lis = Lis::default();
+
+    for elem in a {
+        lis.push(elem);
+    }
+
+    println!("{}", lis.dp.len());
+}

examples/helpers/lis_pop.rs

@@ -0,0 +1,51 @@
+// verification-helper: PROBLEM https://onlinejudge.u-aizu.ac.jp/courses/lesson/2/ITP1/all/ITP1_1_A
+
+use programming_team_code_rust::helpers::lis::Lis;
+
+fn lis_quadratic(a: &[i32]) -> usize {
+    let n = a.len();
+    if n == 0 {
+        return 0;
+    }
+    let mut dp = vec![1; n];
+    for i in 0..n {
+        for j in 0..i {
+            if a[j] < a[i] {
+                dp[i] = dp[i].max(1 + dp[j]);
+            }
+        }
+    }
+    *dp.iter().max().unwrap()
+}
+
+fn main() {
+    for _ in 0..100 {
+        let mut lis = Lis::default();
+        let mut a = Vec::new();
+        for _ in 0..1000 {
+            match rand::random::<u8>() % 3 {
+                0 => {
+                    let new_num = rand::random::<i32>();
+                    lis.push(new_num);
+                    a.push(new_num);
+                }
+                1 => {
+                    if !a.is_empty() {
+                        lis.pop();
+                        a.pop();
+                    }
+                }
+                _ => {
+                    let idxs = lis.get_lis();
+
+                    assert_eq!(idxs.len(), lis_quadratic(&a));
+                    for i in 1..idxs.len() {
+                        assert!(a[idxs[i - 1]] < a[idxs[i]]);
+                    }
+                }
+            }
+        }
+    }
+
+    println!("Hello World");
+}

examples/helpers/lis_yosupo.rs

@@ -0,0 +1,28 @@
+// verification-helper: PROBLEM https://judge.yosupo.jp/problem/longest_increasing_subsequence
+
+use proconio::input;
+use programming_team_code_rust::helpers::lis::Lis;
+
+fn main() {
+    input! {
+        n: usize,
+        a: [i64; n]
+    }
+
+    let mut lis = Lis::default();
+
+    for &elem in &a {
+        lis.push(elem);
+    }
+
+    let idxs = lis.get_lis();
+
+    println!("{}", idxs.len());
+    println!(
+        "{}",
+        idxs.iter()
+            .map(|&x| x.to_string())
+            .collect::<Vec<_>>()
+            .join(" ")
+    );
+}

src/helpers/lis.rs

@@ -0,0 +1,90 @@
+//! # Longest Increasing Subsequence
+
+/// # Example
+/// ```
+/// use programming_team_code_rust::helpers::lis::Lis;
+///
+/// let a = [1, 1, -2, 1];
+///
+/// let mut lis = Lis::default();
+/// for &num in &a {
+///    lis.push(num);
+/// }
+///
+/// assert_eq!(lis.dp.len(), 2);
+/// assert_eq!(lis.get_lis(), [2, 3]);
+///
+/// lis.pop();
+///
+/// assert_eq!(lis.dp.len(), 1);
+/// assert_eq!(lis.get_lis(), [2]);
+/// ```
+#[derive(Default)]
+pub struct Lis<T> {
+    /// dp\[i\].0 = smallest number such that there exists a LIS of length i+1 ending in this number
+    /// dp\[i\].1 = index in original array of dp\[i\].0
+    pub dp: Vec<(T, usize)>,
+    #[allow(clippy::type_complexity)]
+    st: Vec<(Option<usize>, Option<(usize, (T, usize))>)>,
+}
+
+impl<T: Copy + Ord> Lis<T> {
+    /// Pushes new_elem onto back of vec
+    ///
+    /// # Complexity
+    /// - n: length of vec
+    /// - Time: O(log(LIS.len()))
+    /// - Space: O(n) total
+    pub fn push(&mut self, new_elem: T) {
+        // change to `elem <= new_elem` for longest non-decreasing subsequence
+        let idx = self.dp.partition_point(|&(elem, _)| elem < new_elem);
+        let mut prev = None;
+        if idx == self.dp.len() {
+            self.dp.push((new_elem, self.st.len()));
+        } else {
+            prev = Some((idx, self.dp[idx]));
+            self.dp[idx] = (new_elem, self.st.len());
+        }
+        self.st.push((
+            match idx {
+                0 => None,
+                _ => Some(self.dp[idx - 1].1),
+            },
+            prev,
+        ));
+    }
+
+    /// Pop off back of vec
+    ///
+    /// # Complexity
+    /// - Time: O(1)
+    /// - Space: O(1)
+    pub fn pop(&mut self) {
+        let (_, prev) = self.st.pop().unwrap();
+        if let Some((idx, prev)) = prev {
+            self.dp[idx] = prev;
+        } else {
+            self.dp.pop();
+        }
+    }
+
+    /// Gets indexes of LIS of vec
+    ///
+    /// # Complexity
+    /// - Time: O(LIS.len())
+    /// - Space: O(LIS.len())
+    pub fn get_lis(&self) -> Vec<usize> {
+        if self.dp.is_empty() {
+            return Vec::new();
+        }
+        let mut idxs = Vec::with_capacity(self.dp.len());
+        let mut idx = self.dp.last().unwrap().1;
+        idxs.push(idx);
+        while let Some(prev) = self.st[idx].0 {
+            idx = prev;
+            idxs.push(idx);
+        }
+        idxs.reverse();
+        idxs
+    }
+}

src/helpers/mod.rs

@@ -1,3 +1,4 @@
 //! # Helpers
 pub mod compress;
+pub mod lis;
 pub mod unsafe_recursive_closure;