Codeforces1696 C. Fishingprince Plays With Array

首先将两个数组切分到不能切分为止，然后判断是否相等，数组的表示经过了一定的压缩。

rust：

#[allow(unused_imports)]
use std::cmp::{min,max};
use std::io::{BufWriter, stdin, stdout, Write};

#[derive(Default)]
struct Scanner {
    buffer: Vec<String>
}
impl Scanner {
    fn next<T: std::str::FromStr>(&mut self) -> T {
        loop {
            if let Some(token) = self.buffer.pop() {
                return token.parse().ok().expect("Failed parse");
            }
            let mut input = String::new();
            stdin().read_line(&mut input).expect("Failed read");
            self.buffer = input.split_whitespace().rev().map(String::from).collect();
        }
    }
    #[allow(dead_code)]
    fn next_n<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.next::<T>()).collect()
    }
}

fn work(m: i32, a: Vec<i32>, b: Vec<i32>) -> String {
    fn get_impl(m: i32, a: Vec<i32>) -> Vec<(i32, usize)> {
        let mut res = vec![(0i32, 0usize); 0];
        for mut x in a {
            let mut cnt = 1;
            while x % m == 0 {
                x /= m;
                cnt *= m;
            }
            let rem = x;

            let len = res.len();
            if len == 0 || res[len-1].0 != rem {
                res.push((rem, cnt as usize));
            } else {
                res[len-1].1 += cnt as usize;
            }
        }
        // println!("res={:?}", res);
        res
    }
    return if get_impl(m, a) == get_impl(m, b) {
        "Yes".to_string()
    } else {
        "No".to_string()
    };
}

fn main() {
    let mut scanner = Scanner::default();
    let out = &mut BufWriter::new(stdout());

    let t = scanner.next::<usize>();

    for _ in 0..t {
        let n = scanner.next::<usize>();
        let m = scanner.next::<i32>();
        let a = scanner.next_n::<i32>(n);
        let k = scanner.next::<usize>();
        let b = scanner.next_n::<i32>(k);

        let res = work(m, a, b);
        writeln!(out, "{}", res).ok();
    }
}

#[test]
fn test() {

}