[NOIP2016]愤怒的小鸟 DP

～～～题面～～～

题解：

　　首先观察数据范围，n <= 18,很明显是状压DP。所以设f[i]表示状态为i时的最小代价。然后考虑转移。

　　注意到出发点(0, 0)已经被固定，因此只需要2点就可以确定一条抛物线，所以每次转移时枚举是哪两只猪确定了这条抛物线，然后由于一条抛物线可能会恰好打中别的猪，所以再枚举判断一下哪些猪会被打中，然后就获得了一个后续状态，直接转移即可。

　　但是这样是$2^nn^3T$的复杂度，显然过不去，因此考虑优化。

　　1，因为一旦确定抛物线的2只猪确定了，这条抛物线会经过哪些其他的猪也就确定了，所以我们可以预处理出g[i][j],表示用第i和第j只猪确定抛物线时总共可以打到哪些猪。

　　2，因为观察到对于2条抛物线，先发射哪条不影响答案，同理，因为所有猪都必须被打，所以那只猪先被打掉也不影响答案，所以每次转移时只打状态中第一个没被打的猪，然后就可以break进入下一个状态了。因为这次没打的猪，下次还是会打掉的，因此不影响正确性。

　　于是复杂度$2^nnT$

#include<bits/stdc++.h>
using namespace std;
#define R register int
#define eps 1e-9
#define AC 20
#define ac 300000
#define ld long double

int T, n, m, maxn;
int f[ac], g[AC][AC];
struct node{
    ld x, y;
}pig[AC], func;

inline int read()
{
    int x = 0;char c = getchar();
    while(c > '9' || c < '0') c = getchar();
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x;
}

node cal(node x, node y)//计算解析式
{
    ld a, b;
    a = (x.y * y.x - y.y * x.x) / (x.x * x.x * y.x - y.x * y.x * x.x);
    b = x.y / x.x - a * x.x;
    return (node){a, b};
}

inline void upmin(int &a, int b)
{
    if(b < a) a = b;
}

bool check(node ff, node x)//计算一个点是否过解析式
{
    ld a = ff.x, b = ff.y;
    return (fabs(x.y - (a * x.x * x.x + b * x.x)) <= eps);
}

void pre()
{
    int x = 1, tmp;
    n = read(), m = read();
    maxn = (1 << n) - 1;
    memset(g, 0, sizeof(g));
    memset(f, 127, sizeof(f));
    f[0] = 0;
    for(R i = 1; i <= n; i ++) 
        scanf("%Lf%Lf", &pig[i].x, &pig[i].y);
    for(R i = 1; i <= n; i ++, x <<= 1)
    {
        int now = 1;
        for(R j = 1; j <= n; j ++, now <<= 1)
        {
            if(i == j) {g[i][j] = x; continue;}
            tmp = x | now; func = cal(pig[i], pig[j]);
            if(func.x >= 0) {g[i][j] = 0; continue;}//不合法
            int t = 1;
            for(R k = 1; k <= n; k ++, t <<= 1)
            {
                if(k == i || k == j) continue;
                if(!check(func, pig[k])) continue;
                tmp |= t;
            }
            g[i][j] = tmp;
        }
    }
}

void get()
{
    for(R i = 0; i <= maxn; i ++)
    {
        int x = 1;
        for(R j = 1; j <= n; j ++, x <<= 1)
        {
            if(i & x) continue;
            for(R k = 1; k <= n; k ++)
                upmin(f[i | g[j][k]], f[i] + 1);
            break;
        }
    }
    printf("%d
", f[maxn]);
}

void work()
{
    T = read();
    while(T --) 
        pre(), get();
}

int main()
{
//    freopen("in.in", "r", stdin);
    work();
//    fclose(stdin);
    return 0;
}