Rust : 递归、效率与替代、溢出

还是codewars:

给定： u(0) = 1, u(1) = 2 ,
有关系：6u(n)*u(n+1)-5u(n)*u(n+2)+u(n+1)*u(n+2) = 0 计算任何满足条件的n >= 0.

#Examples

fct(n) returns un: fct(17) -> 131072, fct(21) -> 2097152

很显然 ，上递归

一、递归

fn fcn(n: i32) -> i64 {
    // your code
    match n {
        0 => return 1i64,
        1 => return 2i64,
        _ => {
            return 6i64 * fcn(n - 1) * fcn(n - 2) / (5i64 * fcn(n - 2) - fcn(n - 1));
        }

    }
}

经测试，通过测试。但是，提交时，运行超时，无法通过。只能作罢，换算法。

二、新算法

fn fcn(n: i32) -> i64 {
    // your code
    let mut hp: HashMap<i32, i64> = HashMap::new();
    hp.insert(0i32, 1i64);
    hp.insert(1i32, 2i64);
    hp.insert(2i32, 4i64);
    for i in 3..(n + 1) {
        let i_1 = hp.get(&(i - 1)).unwrap().clone();
        let i_2 = hp.get(&(i - 2)).unwrap().clone();
        let temp = 5i64 * i_2 - i_1;
        //println!("i_1:{}, i_2:{} temp:{}", i_1, i_2, temp);
        let val = 6i64 * i_2 * i_1 / temp;
        hp.insert(i, val);
    }
    *(hp.get(&n).unwrap())
}

但是新问题来了，当n很大时，你看一下：

let val = 6i64 * i_2 * i_1 / temp;

会导致i64溢出.这个如何处理？

三、数学归纳法

实际上，你如果试算一下，你会发现这些数有规律：

fn fcn(n: i32) -> i64 {
    2i64.pow(n as u32)
}