790. Domino and Tromino Tiling

We have two types of tiles: a 2x1 domino shape, and an "L" tromino shape. These shapes may be rotated.

XX  <- domino

XX  <- "L" tromino
X

Given N, how many ways are there to tile a 2 x N board? Return your answer modulo 10^9 + 7.

(In a tiling, every square must be covered by a tile. Two tilings are different if and only if there are two 4-directionally adjacent cells on the board such that exactly one of the tilings has both squares occupied by a tile.)

Example:
Input: 3
Output: 5
Explanation: 
The five different ways are listed below, different letters indicates different tiles:
XYZ XXZ XYY XXY XYY
XYZ YYZ XZZ XYY XXY

Note:

  • N  will be in range [1, 1000].

 

Rust Solution

struct Solution;

const MOD: usize = 1_000_000_007;

impl Solution {
    fn num_tilings(n: i32) -> i32 {
        let n = n as usize;
        if n == 0 {
            return 0;
        }
        let mut memo: Vec<usize> = vec![0; n + 1];
        Self::dp(n, &mut memo) as i32
    }
    fn dp(n: usize, memo: &mut Vec<usize>) -> usize {
        match n {
            0 => 1,
            1 => 1,
            2 => 2,
            3 => 5,
            _ => {
                if memo[n] > 0 {
                    return memo[n];
                }
                let mut res = 0;
                res += Self::dp(n - 3, memo);
                res %= MOD;
                res += 2 * Self::dp(n - 1, memo);
                res %= MOD;
                memo[n] = res;
                res
            }
        }
    }
}

#[test]
fn test() {
    let n = 3;
    let res = 5;
    assert_eq!(Solution::num_tilings(n), res);
    let n = 4;
    let res = 11;
    assert_eq!(Solution::num_tilings(n), res);
}

Having problems with this solution? Click here to submit an issue on github.