成都day1t1

芯片 （ chip .pas/cpp ）
【问题描述】
企鹅集成电路公司生产了一种大小为 2×3 的芯片。每块芯片是从一块大小为 N×M 的硅
片上切下来的，但由于原材料纯度问题，因而有若干的单位正方形并不能作为芯片的一部分。
企鹅集成电路公司想要知道，给定一块 N×M 大小的硅片和坏掉的单位正方形的位置，最
多能使用这块硅片生产多少芯片？
【输入格式】
输入的第一行由一个正整数 D 构成，表示硅片的个数。
随后跟着 D 个数据，每个数据第一行包含三个整数 N，M，K，分别表示硅片的长和宽，
以及硅片坏掉的单位正方形个数。
接下 K 行，每行两个整数 X ， Y ，表示单位正方形的坐标。
注：左上角的单位正方形用 (1,1) 表示，右下角的单位正方形用 (N,M) 表示。
【输出格式】
共 D 行，每行一个整数，即最多能切出多少个芯片。
【输入样例】
1
6 6 5
1 4
4 6
2 2
3 6
6 4
【输出样例】
3
【样例说明】

【数据范围】
对于 10% 的数据，K=0；
对于另 外 10%的数据，1≤M≤5，K≤1；
对于 40%的数据，1≤M≤8；
最后一个测试点，空间限制 8MB，其余限制 64MB。

对于所有数据，1≤D≤5，1≤N≤150，1≤M≤10，0≤K≤M。

分析：

这是一道非常显然的一个轮廓线DP，时间复杂度为O(nm3^m)。

3进制状压两行的情况，滚动数组优化空间以及常数。3进制存储可以采用3进制压位或者4进制使用short。DP 状态为 DP[r][mask]，滚动数组优化后为DP[0/1][mask]

每次转移有以下判断：

当前为坏点

当前为好点，并且什么都不放

当前为好点，横着放得下一个2*3

当前为好点，竖着放得下一个2*3

然后照此写出轮廓线DP即可。

这是正解，然而，当场考试时打了搜索，就是普通的dfs，显然超时。

当时的分析和正解是一样的，分这些种情况，但是没想到三进制压位，状压dp。

下面给出标程：

#include<bits/stdc++.h>
using namespace std;


const int tri[15] = {0, 1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683, 59049};
int n, m, k, dp[2][59049], pre[15], now[15];  //滚动数组来记录
bool g[155][15];
int getTen(int *a)//把一个用数组表示的状态转化为一个10进制整数
{
        int ans = 0;
        for(int i = 1; i <= m; ++i)
                ans += a[i]*tri[i];
        return ans;
}
void getTri(int v, int *a)//把一个整数转化为一个数组来表示状态
{
        for(int i = 1; i <= m; ++i) {
                a[i] = v%3;
                v /= 3;
        }
}
void dfs(int x, int y, int last, int key)
{
        int k;
        dp[x&1][key] = max(dp[x&1][key], last);
        if(y >= m) return;
        if(!pre[y] && !pre[y+1] && !now[y] && !now[y+1]) {//竖着切割
                now[y] = now[y+1] = 2;
                k = getTen(now);
                dfs(x, y+2, last+1, k);
                now[y] = now[y+1] = 0;
        }
        if(y<m-1 && !now[y] && !now[y+1] && !now[y+2]) {  //横着切割
 
                now[y] = now[y+1] = now[y+2] = 2;
                k = getTen(now);
                dfs(x, y+3, last+1, k);
                now[y] = now[y+1] = now[y+2] = 0;
        }
        dfs(x, y+1, last, key); //不做改动，直接下一行
}
int main()
{
freopen("chip.in","r",stdin);
freopen("chip.out","w",stdout);
        int t, a, b, tmp;
        scanf("%d", &t);
        while(t--) {
                scanf("%d%d%d", &n, &m, &k);
                memset(g, 0, sizeof(g));
                for(int i = 0; i < tri[m+1]; ++i) dp[1][i] = -1;
                for(int i = 0; i < k; ++i) {
                        scanf("%d%d", &a, &b);
                        g[a][b] = 1;
                }
                for(int i = 1; i <= m; ++i)
                        pre[i] = g[1][i]+1; //设置第一行的状态，第0行的方块全部视为不可用
                tmp = getTen(pre);
                dp[1][tmp] = 0;
                for(int i = 2; i <= n; ++i) {
                        for(int j = 0; j < tri[m+1]; ++j) dp[i&1][j] = -1;
                        for(int j = 0; j < tri[m+1]; ++j) {
                                if(dp[(i+1)&1][j] == -1) continue; //跳过不可能的子状态
                                getTri(j, pre);
                                for(int l = 1; l <= m; ++l)  //根据上一行的状态得到本行的状态
                                        if(g[i][l]) now[l] = 2;
                                        else now[l] = max(pre[l]-1, 0);
                                tmp = getTen(now);
                                dfs(i, 1, dp[(i+1)&1][j], tmp);
                        }
                }
                int ans = 0;
                for(int i = 0; i < tri[m+1]; ++i)
                        ans = max(ans, dp[n&1][i]);
                printf("%d\n", ans);
        }
        return 0;
}