¿Alguien puede explicar la solución a SPOJ.com – Problema M3TILE?

Deje que T (n) denote la cantidad de formas en que puede llenar una matriz 3xn.
Suponga que hemos llenado la matriz 3xn con dominó 2 × 1. ¿Cómo sería la solución final? Piensa en las fichas de dominó en las últimas dos columnas.

Caso 1:
… .Xxxx t1-t1… .xxxx t1-t1… .xxxx t1 t2
… .Xxxx t2-t2… .xxxx t2 t3… .xxxx t1 t2
… .Xxxx t3-t3… .xxxx t2 t3… .xxxx t3-t3

t1-t1, t2-t2, t3-t3 denotan 3 dominós 2 × 1 diferentes.

En todos los casos anteriores, solo necesita encontrar T (n-2) para encontrar la cantidad de formas de llenar la matriz final.

Caso – 2:

… .Xx x x t1-t1… .xxx t4 t4 t1
… .Xxx t4 t4 t2… .xxx t3 t3 t1
… .Xxx t3 t3-t2… .xx x x t2 t2

Esto se ve un poco diferente. hay un espacio en la columna 3 desde la derecha. ¿Qué hacer?
Bien, definamos una nueva función F (m) que denota el número de formas de llenar una matriz [(3xm) y un elemento adicional en la parte superior después de la última columna]
Siempre podemos voltear F (m) para obtener una solución para la cantidad de formas de llenar una matriz [(3xm) y un elemento adicional en la parte inferior después de la última columna]
Es fácil ver que F (n) = T (n-1) + F (n-2) porque para llegar a nuestro llamado elemento adicional en la forma final solo hay dos formas posibles en las últimas dos columnas
xxxx t2-t2 xxx x t2-t2
xxxx t1 xxx t1 t1
xxxx t1 xxx t3 t3
T (n-1) F (n-2)

Poniéndolo todo junto:

T (n) = 3 * T (n-2) + 2 * F (n-3)
F (n) = T (n-1) + F (n-2)

con estuches base:

T (0) = 1;
F (0) = 0;
T (x) = 0 y F (x) = 0 si (x <0)

Código C ++:

  #include 
 int main () {
	 int n, T [31], F [31];
	 T [0] = 1;  F [0] = 0;
	 // memoriza primero los valores
	 para (int i = 1; i  = 2)? 3 * T [i-2]: 0) + ((i> = 3)? 2 * F [i-3]: 0);
		 F [i] = T [i-1] + ((i> = 2)? F [i-2]: 0);
	 }
	 while (verdadero) {
		 scanf ("% d", & n);
		 if (n == - 1) descanso;
		 printf ("% d \ n", T [n]);
	 }
	 devuelve 0;
 } 

Espero que esto tenga sentido!

Así es como lo veo. Comience a colocar fichas desde la izquierda y en el diagrama se muestran los diferentes tipos de subproblemas en los que termina. En todos los casos, primero coloco el mosaico rojo, luego el amarillo y finalmente el verde.

x (n) = x (n-2) + 2 * f (n-1) de los casos (a), (b), (c)

f (n) = x (n-1) + f (n-2) de los casos (d), (e)

Podemos expresar f (n) en términos de x (n).

Referencia http://www.iarcs.org.in/inoi/onl

Mira la imagen para más explicaciones.

Considera completar la primera fila. Nosotros podríamos tener:

112 o 122 o 123
2 1 123

Los restos son subproblemas * casi * recursivos con una (o dos) filas menos, excepto que la primera fila no siempre está vacía. Manejamos esto resolviendo un problema más general: ¿de cuántas maneras existen las N filas en mosaico donde la primera fila se parece a BITMASK? Este nuevo problema * es * recursivo, y si recordamos la recursividad (es decir, programación dinámica), esta solución es muy eficiente: solo hay N * 2 ^ 3 estados.

Se puede encontrar una buena explicación en esta página en Stackoverflow