Suf ary add extra methods

examples/strings/suf_ary_cmp_aizu.rs

@@ -7,26 +7,23 @@ use programming_team_code_rust::strings::suf_ary::SufAry;
 fn main() {
     input! {
         n: usize,
-        mut a: [i32; n],
+        mut a: [usize; n],
         m: usize,
-        b: [i32; m]
+        b: [usize; m]
     }
 
     let are_equal = a == b;
 
-    a.push(-1);
     a.extend(b);
 
     let (cmps, max_val) = compress(&a);
     let suf_ary = SufAry::new(&cmps, max_val);
-    let res = suf_ary.cmp_substrs(0..n, n + 1..n + 1 + m);
+    let res = suf_ary.cmp_substrs(0..n, n..n + m);
 
     if are_equal {
         assert_eq!(res, std::cmp::Ordering::Equal);
-        assert_eq!(suf_ary.cmp_sufs(0, n + 1), std::cmp::Ordering::Greater);
         println!("0");
     } else {
-        assert_eq!(res, suf_ary.cmp_sufs(0, n + 1));
         println!("{}", (res == std::cmp::Ordering::Less) as usize);
     }
 }

examples/strings/suf_ary_find_many_strs_aizu.rs

@@ -3,6 +3,9 @@
 use proconio::input;
 use programming_team_code_rust::strings::suf_ary::SufAry;
 
+mod suf_ary_push_pop_char_asserts;
+use suf_ary_push_pop_char_asserts::suf_ary_push_pop_char_asserts;
+
 fn main() {
     input! {
         s: String,
@@ -16,8 +19,9 @@ fn main() {
         input! {
             t: String
         }
-        let t_vec = t.chars().map(|x| x as usize).collect::<Vec<usize>>();
-        let range = suf_ary.find_str(&t_vec);
+        let t = t.chars().map(|x| x as usize).collect::<Vec<usize>>();
+        let range = suf_ary.find_str(&t);
+        suf_ary_push_pop_char_asserts(s.len(), &suf_ary, &range, &t);
         println!("{}", !range.is_empty() as usize);
     }
 }

examples/strings/suf_ary_find_str_aizu.rs

@@ -3,17 +3,23 @@
 use proconio::input;
 use programming_team_code_rust::strings::suf_ary::SufAry;
 
+mod suf_ary_push_pop_char_asserts;
+use suf_ary_push_pop_char_asserts::suf_ary_push_pop_char_asserts;
+
 fn main() {
     input! {
         s: String,
         t: String
     }
 
-    let s_vec = s.chars().map(|x| x as usize).collect::<Vec<usize>>();
-    let t_vec = t.chars().map(|x| x as usize).collect::<Vec<usize>>();
+    let s = s.chars().map(|x| x as usize).collect::<Vec<usize>>();
+    let t = t.chars().map(|x| x as usize).collect::<Vec<usize>>();
+
+    let suf_ary = SufAry::new(&s, 255);
+    let range = suf_ary.find_str(&t);
+
+    suf_ary_push_pop_char_asserts(s.len(), &suf_ary, &range, &t);
 
-    let suf_ary = SufAry::new(&s_vec, 255);
-    let range = suf_ary.find_str(&t_vec);
     let mut res: Vec<usize> = Vec::new();
     res.extend_from_slice(&suf_ary.sa[range]);
     res.sort();

examples/strings/suf_ary_find_substr_aizu.rs

@@ -3,6 +3,9 @@
 use proconio::input;
 use programming_team_code_rust::strings::suf_ary::SufAry;
 
+mod suf_ary_push_pop_substr_asserts;
+use suf_ary_push_pop_substr_asserts::suf_ary_push_pop_substr_asserts;
+
 fn main() {
     input! {
         s: String,
@@ -14,7 +17,11 @@ fn main() {
     both.extend(s.chars().map(|x| x as usize).collect::<Vec<usize>>());
 
     let suf_ary = SufAry::new(&both, 255);
-    let mut res = suf_ary.sa[suf_ary.find_substr(0..m)]
+    let range = suf_ary.find_substr(0..m);
+
+    suf_ary_push_pop_substr_asserts(both.len(), &suf_ary, &range, &(0..m));
+
+    let mut res = suf_ary.sa[range]
         .iter()
         .copied()
         .filter(|&i| i >= m)

examples/strings/suf_ary_find_substr_many_aizu.rs

@@ -4,13 +4,16 @@ use proconio::input;
 use programming_team_code_rust::data_structures::rmq::RMQ;
 use programming_team_code_rust::strings::suf_ary::SufAry;
 
+mod suf_ary_push_pop_substr_asserts;
+use suf_ary_push_pop_substr_asserts::suf_ary_push_pop_substr_asserts;
+
 fn main() {
     input! {
         s: String,
         q: usize
     }
 
-    let num_queries_find_substr = q.min(100);
+    let num_queries_find_substr = q.min(3);
 
     let mut s = s.chars().map(|x| x as usize).collect::<Vec<usize>>();
 
@@ -29,7 +32,11 @@ fn main() {
     let rmq = RMQ::new(&suf_ary.sa, std::cmp::min);
 
     for i in 0..num_queries_find_substr {
-        let idx = rmq.query(suf_ary.find_substr(length[i]..length[i + 1]));
+        let s_to_look_for_range = length[i]..length[i + 1];
+        let range = suf_ary.find_substr(s_to_look_for_range.clone());
+        suf_ary_push_pop_substr_asserts(s.len(), &suf_ary, &range, &s_to_look_for_range);
+
+        let idx = rmq.query(range);
         println!(
             "{}",
             (idx + length[i + 1] - length[i] <= length[0]) as usize

examples/strings/suf_ary_push_pop_char_asserts.rs

@@ -0,0 +1,41 @@
+use programming_team_code_rust::strings::suf_ary::SufAry;
+use std::ops::Range;
+pub fn suf_ary_push_pop_char_asserts(
+    n: usize,
+    suf_ary: &SufAry,
+    range: &Range<usize>,
+    t: &[usize],
+) {
+    let mut push_pop_sa_range = 0..n;
+    let mut push_pop_t_range = t.len() / 2..t.len() / 2;
+    loop {
+        let mut found = false;
+
+        if push_pop_t_range.start > 0 {
+            found = true;
+            let lcp_len = push_pop_t_range.len();
+            push_pop_t_range.start -= 1;
+            push_pop_sa_range =
+                suf_ary.push_front_char(t[push_pop_t_range.start], push_pop_sa_range, lcp_len);
+        }
+
+        if push_pop_t_range.end < t.len() {
+            found = true;
+            push_pop_sa_range = suf_ary.push_back_char(
+                t[push_pop_t_range.end],
+                push_pop_sa_range,
+                push_pop_t_range.len(),
+            );
+            push_pop_t_range.end += 1;
+        }
+
+        if !found {
+            break;
+        }
+    }
+
+    assert_eq!(range.is_empty(), push_pop_sa_range.is_empty());
+    if !range.is_empty() {
+        assert_eq!(*range, push_pop_sa_range);
+    }
+}

examples/strings/suf_ary_push_pop_substr_asserts.rs

@@ -0,0 +1,52 @@
+use programming_team_code_rust::strings::suf_ary::SufAry;
+use std::ops::Range;
+pub fn suf_ary_push_pop_substr_asserts(
+    tot_len: usize,
+    suf_ary: &SufAry,
+    range: &Range<usize>,
+    s_to_look_for_range: &Range<usize>,
+) {
+    assert_eq!(
+        suf_ary.push_front_substr(0..tot_len, tot_len..tot_len, 0),
+        tot_len..tot_len
+    );
+    let mut splits = (0..6)
+        .map(|_| {
+            s_to_look_for_range.start + (rand::random::<usize>() % (s_to_look_for_range.len() + 1))
+        })
+        .collect::<Vec<_>>();
+    splits.push(s_to_look_for_range.start);
+    splits.push(s_to_look_for_range.end);
+    splits.sort();
+    let subarrays = (1..splits.len())
+        .map(|i| splits[i - 1]..splits[i])
+        .collect::<Vec<_>>();
+    let mut push_pop_range = 0..tot_len;
+    let mut push_pop_lcp_len = 0;
+    let mut range_subarray = subarrays.len() / 2..subarrays.len() / 2;
+    loop {
+        let mut found = false;
+        if range_subarray.start > 0 {
+            found = true;
+            range_subarray.start -= 1;
+            let curr_substr = &subarrays[range_subarray.start];
+            push_pop_range =
+                suf_ary.push_front_substr(curr_substr.clone(), push_pop_range, push_pop_lcp_len);
+            push_pop_lcp_len += curr_substr.len();
+        }
+
+        if range_subarray.end < subarrays.len() {
+            found = true;
+            let curr_substr = &subarrays[range_subarray.end];
+            push_pop_range =
+                suf_ary.push_back_substr(curr_substr.clone(), push_pop_range, push_pop_lcp_len);
+            push_pop_lcp_len += curr_substr.len();
+            range_subarray.end += 1;
+        }
+
+        if !found {
+            break;
+        }
+    }
+    assert_eq!(*range, push_pop_range);
+}