a lot of not needed logic i fear

src/common_subsequence/db.rs

@@ -3,7 +3,7 @@ use std::ops::Range;
 /// a vec like struct, where everything is ever increasing and not by anything more than one.
 ///
 /// so you can have 1, 2, 3, 4, 5 but not 0, 1, 1, 1, 3
-#[derive(Debug, Default, PartialEq)]
+#[derive(Debug, Default, PartialEq, Clone)]
 pub struct DB {
     /// inner starts from index 0 but inner\[0\] is the point where DB::vec is 1
     inner: Vec<u32>,
@@ -40,7 +40,7 @@ impl DB {
     fn new() -> Self {
         Default::default()
     }
-    fn with_len(len: u32) -> Self {
+    pub fn with_len(len: u32) -> Self {
         Self {
             len,
             ..Default::default()
@@ -84,13 +84,13 @@ impl DB {
     fn len(&self) -> u32 {
         self.len
     }
-    /// at looks the same as [`DB::vec`](DB::vec)(&self).[`get`](core::slice::get)(ind as usize)
-    fn get(&self, ind: u32) -> Option<u32> {
+    /// looks the same as [`DB::vec`](DB::vec)(&self).[`get`](core::slice::get)(ind as usize)
+    pub fn get(&self, ind: u32) -> Option<u32> {
         if self.len() <= ind {
             // panic!("index {ind} >= len {selflen} which is ugly")
             return None;
         }
-        self.inner
+        dbg!(&self.inner)
             .iter()
             .rposition(|f| ind >= *f) // imagine got 7 > 4, and 4 is at index 2, so the value of 7 is 2
             .map(|c| c as u32 + 1) // hack
@@ -170,7 +170,7 @@ impl DB {
         (None, None)
     }
 
-    fn change(&mut self, ind: u32, val: u32) {
+    pub fn change(&mut self, ind: u32, val: u32) {
         let (avail, up) = self.available_values(ind);
         if let (Some(avail), Some(up)) = (avail, up) {
             if val == avail[0] && up {
@@ -190,7 +190,39 @@ impl DB {
         }
     }
 
-    fn vec(&self) -> Vec<u32> {
+    /// override everything from ind on, that is if ind / val is good
+    pub fn propagate_to_end(&mut self, ind: u32, val: u32) {
+        println!("idn = {ind}, vala{val}");
+        if ind >= self.len() {
+            panic!("uh oh out of bounds: {ind} >={}", self.len())
+        }
+        if self.len() > 0 {
+            if matches!(self.last(), Some(x) if dbg!(x) > 0) {
+                match dbg!(self.get(ind)) {
+                    Some(vecv) if vecv == val => {
+                        self.inner.truncate(val as usize);
+                    }
+                    Some(vecv) if val == vecv + 1 => {
+                        self.inner.truncate(val as usize + 1);
+                        self.inner.push(ind);
+                    }
+                    Some(x) if val == x - 1 && self.inner[val as usize] == ind => {
+                        self.inner.truncate(val as usize);
+                    }
+                    None => {
+                        unreachable!("len is > 0")
+                    }
+                    _ => {}
+                }
+            } else {
+                if val == 1 {
+                    self.inner.push(ind);
+                }
+            }
+            println!("{:?}", self.inner)
+        }
+    }
+    pub fn vec(&self) -> Vec<u32> {
         let mut count = (0..).into_iter();
         self.inner
             .iter()
@@ -487,6 +519,70 @@ mod test {
             assert_eq!(db, db2);
         }
     }
+    #[test]
+    fn prop_idk() {
+        let c = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13];
+        let mut db = DB::try_from_vec(c.clone()).unwrap();
+        dbg!(&mut db).propagate_to_end(2, 2);
+        dbg!(&db);
+        println!("{:?}", db.vec());
+        assert_eq!(db.inner, vec![0, 1]);
+        let mut db = DB::try_from_vec(c.clone()).unwrap();
+        db.propagate_to_end(2, 3);
+        println!("{:?}", db.vec());
+        assert_eq!(db.inner, vec![0, 1, 2]);
+    }
+    #[test]
+    fn prop() {
+        let base = [
+            0, 1, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 10, 10, 10, 11, 12, 12, 12, 13,
+            14, 15, 16, 17, 17, 18, 18, 18, 18, 18, 19, 20, 21, 21, 21, 21, 22, 23, 23, 24, 25, 26,
+            26, 26,
+        ];
+
+        let prop = |bd: &mut DB, cc: &mut Vec<u32>, i, v: u32| {
+            cc.get_mut(i as usize..).unwrap().fill(v);
+            bd.propagate_to_end(i, v);
+        };
+        {
+            let mut c = base.to_vec();
+            let mut db = DB::try_from_vec(c.to_vec()).unwrap();
+
+            prop(&mut db, &mut c, 15, 7);
+            prop(&mut db, &mut c, 28, 8);
+
+            println!("{db:?}, {c:?}");
+
+            assert_eq!(db, DB::try_from_vec(c.clone()).unwrap());
+            assert_eq!(db.vec(), c);
+        }
+    }
+    #[test]
+    #[should_panic]
+    fn prop_failcase() {
+        let base = [
+            0, 1, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 10, 10, 10, 11, 12, 12, 12, 13,
+            14, 15, 16, 17, 17, 18, 18, 18, 18, 18, 19, 20, 21, 21, 21, 21, 22, 23, 23, 24, 25, 26,
+            26, 26,
+        ];
+
+        let prop = |bd: &mut DB, cc: &mut Vec<u32>, i, v: u32| {
+            cc.get_mut(i as usize..).unwrap().fill(v);
+            bd.propagate_to_end(i, v);
+        };
+        {
+            let mut c = base.to_vec();
+            let mut db = DB::try_from_vec(c.to_vec()).unwrap();
+
+            // prop(&mut db, &mut c, 12, 6);
+            prop(&mut db, &mut c, 28, 14);
+
+            println!("{db:?}, {c:?}");
+
+            assert_eq!(db.vec(), c);
+            assert_eq!(db, DB::try_from_vec(c.clone()).unwrap());
+        }
+    }
 }
 
 // // [0,0,0,1,1,1,2,2,3] 9

src/common_subsequence/mod.rs

@@ -1,3 +1,5 @@
+use db::DB;
+
 mod db;
 
 pub fn lcs_gen(str1: &str, str2: &str) -> Vec<Vec<u32>> {
@@ -27,16 +29,50 @@ pub fn lcs_gen(str1: &str, str2: &str) -> Vec<Vec<u32>> {
     db
 }
 
+pub fn lcs_gen_DB(str1: &str, str2: &str) -> Vec<DB> {
+    let c1: Vec<char> = str1.chars().collect();
+    let c1len = c1.len();
+    let c2: Vec<char> = str2.chars().collect();
+    let c2len = c2.len();
+    let mut db: Vec<DB> = vec![DB::with_len(c2len as u32 + 1); c1len + 1];
+    if c1len * c2len == 0 {
+        // for i in &db {
+        //     println!("{i:?}")
+        // }
+        return db;
+    }
+    let estr: &str = "out bounds";
+    for i in 1..=c1len {
+        for j in 1..=c2len {
+            if c1[i - 1] == c2[j - 1] {
+                let val = db[i - 1].get(j as u32 - 1).expect(estr) + 1;
+                db[i].propagate_to_end(j as u32, val);
+            } else {
+                let val = db[i]
+                    .get(j as u32 - 1)
+                    .expect(estr)
+                    .max(db[i - 1].get(j as _).expect(estr));
+                db[i].propagate_to_end(j as _, val)
+            }
+        }
+    }
+    // for i in &db {
+    //     println!("{i:?}")
+    // }
+    db
+}
+
 #[cfg(test)]
 mod test {
-    use super::lcs_gen;
+
+    use super::{lcs_gen, lcs_gen_DB, DB};
     #[test]
     fn test_normal_case() {
         lcs_gen("asjhdgasdhj", "gajhdgashjd");
         // lcs_gen("", "");
     }
-    #[test]
 
+    #[test]
     fn test_wiki() {
         //      		0	1	2	3	4	5	6	7
         //      		ε	M	Z	J	A	W	X	U
@@ -62,6 +98,24 @@ mod test {
         assert_eq!(lcs_gen("XMJYAUZ", "MZJAWXU"), s)
     }
     #[test]
+    fn test_db() {
+        let s: Vec<Vec<u32>> = vec![
+            vec![0, 0, 0, 0, 0, 0, 0, 0],
+            vec![0, 0, 0, 0, 0, 0, 1, 1],
+            vec![0, 1, 1, 1, 1, 1, 1, 1],
+            vec![0, 1, 1, 2, 2, 2, 2, 2],
+            vec![0, 1, 1, 2, 2, 2, 2, 2],
+            vec![0, 1, 1, 2, 3, 3, 3, 3],
+            vec![0, 1, 1, 2, 3, 3, 3, 4],
+            vec![0, 1, 2, 2, 3, 3, 3, 4],
+        ];
+        let c: Vec<Vec<u32>> = lcs_gen_DB("XMJYAUZ", "MZJAWXU")
+            .iter()
+            .map(DB::vec)
+            .collect();
+        assert_eq!(c, s)
+    }
+    #[test]
     fn test_empty() {
         lcs_gen("", "");
     }