poj 2663 Tri Tiling

题目：poj 2663 Tri Tiling

题意：覆盖问题

思路：状态压缩？ 反正可以

对于当前列的状态表示成长度为3的01串之后，枚举可以得到下一个状态的情况，构造操作矩阵，然后对初始矩阵从000出发（所以该值为1）

    构造一个8 * 8 （2^3）的矩阵  注意枚举仅处理当前列的状态，不然对于下一列的状态会重复计算

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
struct Matrix
{
    int m[9][9];
}E,D;
void init()
{
    for(int i=1;i<=8;i++)
        for(int j=1;j<=8;j++)
        {
            E.m[i][j]=(i==j);
            D.m[i][j]=0;
        }

    D.m[1][2]=1;
    D.m[1][5]=1;
    D.m[1][8]=1;

    D.m[2][1]=1;
    D.m[2][7]=1;

    D.m[3][6]=1;

    D.m[4][5]=1;

    D.m[5][1]=1;
    D.m[5][4]=1;

    D.m[6][3]=1;

    D.m[7][2]=1;

    D.m[8][1]=1;
}
Matrix Multi(Matrix A,Matrix B)
{
    Matrix ans;
    for(int i=1;i<=8;i++)
        for(int j=1;j<=8;j++)
        {
            ans.m[i][j]=0;
            for(int k=1;k<=8;k++)
                ans.m[i][j]+=A.m[i][k]*B.m[k][j];
        }
    return ans;
}
Matrix Pow(Matrix A,int k)
{
    Matrix ans=E;
    while(k)
    {
        if(k&1)
        {
            k--;
            ans=Multi(ans,A);
        }
        else
        {
            k/=2;
            A=Multi(A,A);
        }
    }
    return ans;
}
int main()
{
    int n;
    init();
    while(scanf("%d",&n)!=EOF)
    {
        if(n==-1)
            break;
        Matrix cnt=Pow(D,n);
        /*
        for(int i=1;i<=8;i++)
        {
            for(int j=1;j<=8;j++)
                printf("%d ",cnt.m[i][j]);
            printf("\n");
        }
        */
        Matrix tmp;
        tmp.m[1][1]=1;
        for(int i=2;i<=8;i++)
            tmp.m[i][1]=0;
        Matrix ans;
        for(int i=1;i<=8;i++)
            for(int j=1;j<=1;j++)
            {
                ans.m[i][j]=0;
                for(int k=1;k<=8;k++)
                    ans.m[i][j]+=cnt.m[i][k]*tmp.m[k][j];
            }
        printf("%d\n",ans.m[1][1]);
    }
    return 0;
}

按喵呜所说，这题其实没那么麻烦，也有不需要处理的方法，那就是找规律，然后dp ,对于当前的一个3*n可以进行多次切割，已知3*2的情况会有3种（三个横着的，一个横着两个竖着的上下交换就有两种），题目中的图中存在的那一种可以拓展的，我们可以理解成，中间放m个，上面或者下面放m+1个，两边分别加上两个竖着的，那么对于任意一个大于2的情况 F(n) = 3*F(n-2) + 2* (F(n-4) + F(n-6) + .... + F(2) + F(0) ) ，数据只有30，就把表打出来就ok了

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
using namespace std;
int dp[31];
int solution(int n)
{
    if(n&1)
        return 0;
    if(n==0)
        return 1;
    if(n==2)
        return 3;
    int ans=3*solution(n-2);
    for(int i=0;i<n-2;i+=2)
        ans+=2*solution(i);
    return ans;
}
void solve()
{
    for(int i=0;i<=30;i++)
        dp[i]=solution(i);
}
int main()
{
    int n;
    solve();
    while(scanf("%d",&n)!=EOF)
    {
        if(n==-1)
            break;
        printf("%d\n",dp[n]);
    }
    return 0;
}

按喵呜所说，这个题没必要用矩阵快速幂做，直接做，然后我根据状态压缩的做法，把上面第一个代码简化了一下写成dp,就像下面写的这样

#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
int dp[31][8];
int main()
{
    memset(dp,0,sizeof(dp));
    dp[0][0]=1;
    for(int i=1;i<=30;i++)
    {
        dp[i][0]=dp[i-1][1]+dp[i-1][4]+dp[i-1][7];
        dp[i][1]=dp[i-1][0]+dp[i-1][6];
        dp[i][2]=dp[i-1][5];
        dp[i][3]=dp[i-1][4];
        dp[i][4]=dp[i-1][3]+dp[i-1][0];
        dp[i][5]=dp[i-1][2];
        dp[i][6]=dp[i-1][1];
        dp[i][7]=dp[i-1][0];
    }
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        if(n==-1)
            break;
        printf("%d\n",dp[n][0]);
    }
    return 0;
}