Скачать или смотреть domino and tromino tiling leetcode 790 dynamic programming

Download 1M+ code from https://codegive.com/b693e8d
certainly! the problem of domino and tromino tiling is a classic dynamic programming problem that can be found in leetcode as problem 790. the problem can be described as follows:

problem statement

you are given a 2 x n board and you need to fill it with two types of tiles:

1. *domino* tiles (which cover 2 squares) - they can be placed either horizontally or vertically.
2. *tromino* tiles (which cover 3 squares) - they can be placed in two configurations (l-shape).

your task is to count the number of different ways to completely cover the board with these tiles.

constraints:
\( n \) is a non-negative integer.

dynamic programming approach

to solve this problem using dynamic programming, we define the following:

let `dp[i]` be the number of ways to fill a 2 x i board using the allowed tiles.

base cases
**dp[0] = 1**: there is one way to fill a 2 x 0 board (doing nothing).
**dp[1] = 1**: there is one way to fill a 2 x 1 board (one vertical domino).
**dp[2] = 2**: there are two ways to fill a 2 x 2 board (two vertical dominoes or two horizontal dominoes).

transition formula
for \( i \geq 3 \):
when you place a vertical domino, you reduce the problem to filling a 2 x (i-1) board: `dp[i-1]`.
when you place two horizontal dominoes, you reduce the problem to filling a 2 x (i-2) board: `dp[i-2]`.
when you place an l-shaped tromino in two different orientations, you reduce the problem to filling a 2 x (i-3) board: `dp[i-3]`.

thus, the recurrence relation can be expressed as:
\[ dp[i] = dp[i-1] + dp[i-2] + 2 \times dp[i-3] \]

implementation

here’s how you can implement this logic in python:



explanation of the code

1. **base cases**: we handle the cases for `n = 0`, `n = 1`, and `n = 2` explicitly.
2. **dynamic programming array**: we create an array `dp` of size \( n + 1 \) to store the number of ways to fill each board size.
3. **filling the dp array**: we use a for loop to fill in the values from `dp[3]` to `dp[n]` using our derive ...

#DominoTiling #TrominoTiling #numpy
Domino Tiling
Tromino Tiling
LeetCode 790
Dynamic Programming
Tiling Problem
Combinatorial Tiling
Recursive Approach
State Transition
Memoization
Grid Tiling
DP Array
Fibonacci Sequence
Floor Tiling
Subproblem Optimization
Counting Ways