【算法笔记】状态压缩dp（noip）

 在acwing学习算法的一点思考和总结

---

 状态压缩dp可以用来解决两种问题：一种是棋盘式的，也就是表示一行有2^N种摆法，另一种是表示一类集合

状压——棋盘式

 思路：可以类比一下蒙德里安的梦想的解题过程，每一行的状态都只会受到上一层状态的影响。那么我们在更新第i行的状态时，我们枚举一下第i - 1行的状态。也就是当这两行的对应状态是个合法状态的话，我们就进行方案数的累加。

确定状态转移方程：f[i][a] += f[i-1][b]，表示前i行，并且第i行是第j种摆法 的最大种植方案数

预处理：为了判断哪两种行状态是对应合法的，我们需要进行预处理，找出相邻两行能进行转移的状态（二进制表达）。具体题目具体分析，在这个题目中，第一要满足左右相邻不能都是1，第二要满足上下相邻不能都是1

/*
前i行，并且第i行是第j种摆法 的最大种植方法
*/
#include
#include
#include
#include

using namespace std;
const int N = 14, M = 1<<12, mod = 1e8;
vector head[M]; //存储合法的转移状态
vector state;
int f[N][M];
int n,m;
int g[N];

bool check(int x)
{
    for(int i = 0; i < m; i ++)
    {
        if(( (x >> i) & 1) && (x>> (i+1) & 1) )
            return false;
    }
    return true;
}

int main()
{
    cin>>n>>m;
    for(int i = 1; i <= n; i ++)
        for(int j = 0; j < m; j ++)
        {
            int t;
            cin>>t;
            g[i] += !t * (1 << j);            
        }
        
    for(int i = 0; i < 1<

状压——集合

所有小猪击中状态由一串二进制数来表达，若一个小猪能被击中，那么该小猪对应到二进制表达上的位置就制成1。那么我们接下来要做的就是枚举所有抛物线，并求一下抛物线能击中哪些小猪。并将这个结果存放在path数组里。

state: 二进制表达式，如1100，表示前两只小猪没被击中，后两只被击中了

path[i][j] = state : 含义：经过点i和j的抛物线； 属性：遗传二进制数，表示所有小猪的状态

f[i]: i其实就是state，从0~2^N枚举i的二进制表达，直到枚举到111111（所有位上都是1时）说明所有小猪均已经被击落。 那么f[i]的含义就是所有小猪在该状态下最少可以用多少条抛物线覆盖

那么接下来就是枚举所有状态下的小猪的覆盖方式，更新最小覆盖的抛物线数量

#include
#include
#include
#include
#include

#define x first
#define y second

using namespace std;
typedef pair PDD;
const int N = 18, M = 1<<18;
const double eps = 1e-8;
int f[M];
PDD q[N];
int path[N][N];
int n,m;

int cmp(double x, double y)
{
    if(fabs(x - y) < eps) return 0;
    if(x < y) return -1;
    return 1;
}

int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        cin>>n>>m;
        
        for(int i = 0; i>q[i].x>>q[i].y;
        
        memset(path, 0, sizeof path);
        
        for(int i = 0; i < n; i ++)  //枚举所有的二次函数方程（两点确定一个抛物线，因为抛物线过原点），这里是找第一个点
        {
            path[i][i] = 1 << i;
            for(int j = i; j < n; j ++) //找这个函数的第二个点
            {
                double x1 = q[i].x, x2 = q[j].x;
                double y1 = q[i].y, y2 = q[j].y;
                
                if(!cmp(x1,x2)) continue;
                double a = (y1 / x1 - y2 / x2) / (x1 - x2); //通过两点，解出抛物线方程
                double b = y1 / x1 - a * x1;
                
                if(cmp(a, 0) >= 0) continue;
                int state = 0;
                        
                for(int k = 0; k < n; k ++) //计算有多少点在这条抛物线上
                {   
                    double x = q[k].x, y = q[k].y;
                    if(!cmp(a*x*x + b * x, y)) state +=1 << k;
                }
                path[i][j] = state;
            }
        }
        
        memset(f, 0x3f, sizeof f);
        f[0] = 0;                          
        for(int i = 0; i < 1<> j & 1))
                {
                    x = j;
                    break; //注意到这里是break，即只用更新一次，因为后面还会进行一次更新，避免掉重复的更新工作
                }
            }
            
            for(int k = 0; k < n; k ++)
            {
                f[i | path[x][k]] = min(f[i | path[x][k]], f[i] + 1);
            }
        }
        cout<