2022-04-02：你只有1*1、1*2、1*3、1*4，四种规格的砖块。 你想铺满n行m列的区域，规则如下： 1）不管那种规格的砖，都只能横着摆

  比如1*3这种规格的砖，3长度是水平方向，1长度是竖直方向；

package main

import (
	"fmt"
)

func main() {
	ret := ways(4, 3)
	fmt.Println(ret)
}

var r = []int{0, 1, 2, 4, 8}

func ways(n, m int) int {
	if n <= 0 || m <= 1 {
		return 1
	}
	// len[i] = 一共有1行的情况下，列的长度为i的时候有几种摆法(所有，不分合法和非法)
	len0 := make([]int, m+1)
	for i := 1; i <= getMin(m, 4); i++ {
		len0[i] = r[i]
	}
	for i := 5; i <= m; i++ {
		len0[i] = len0[i-1] + len0[i-2] + len0[i-3] + len0[i-4]
	}
	// any[i] = 一共有n行的情况下，列的长度为i的时候有几种摆法(所有，不分合法和非法)
	any := make([]int, m+1)
	for i := 1; i <= m; i++ {
		// n * i的区域：总共的摆法！不区分合法、不合法
		any[i] = power(len0[i], n)
	}
	// solid[i] = 一共有n行的情况下，列的长度为i的时候有几种合法的摆法
	solid := make([]int, m+1)
	solid[1] = 1
	for i := 2; i <= m; i++ {
		invalid := 0
		// N * i
		// 1) （N * 1 合法） * （N * (i-1) 总共）
		// 2) （N * 2 合法） * （N * (i-2) 总共）
		// 3) （N * 3 合法） * （N * (i-3) 总共）
		//
		// j) （N * j 合法） * （N * (i-j) 总共）
		for j := 1; j < i; j++ {
			invalid += solid[j] * any[i-j]
		}
		solid[i] = any[i] - invalid
	}
	return solid[m]
}

func power(base, power int) int {
	ans := 1
	for power != 0 {
		if (power & 1) != 0 {
			ans *= base
		}
		base *= base
		power >>= 1
	}
	return ans
}

func getMin(a, b int) int {
	if a < b {
		return a
	} else {
		return b
	}
}