JZOJsenior4908.【NOIP2016提高组复赛】愤怒的小鸟

problem

Description

Input

Output

Sample Input

Sample Input1:
2
2 0
1.00 3.00
3.00 3.00
5 2
1.00 5.00
2.00 8.00
3.00 9.00
4.00 8.00
5.00 5.00

Sample Input2:
3
2 0
1.41 2.00
1.73 3.00
3 0
1.11 1.41
2.34 1.79
2.98 1.49
5 0
2.72 2.72
2.72 3.14
3.14 2.72
3.14 3.14
5.00 5.00

Sample Input3:
1
10 0
7.16 6.28
2.02 0.38
8.33 7.78
7.68 2.09
7.46 7.86
5.77 7.44
8.24 6.72
4.42 5.11
5.42 7.79
8.15 4.99

Sample Output

Sample Output1:
1
1

Sample Output2:
2
2
3

Sample Output3:
6

Data Constraint

---

analysis

容易注意到一个很明显很关键的东西：

保证1≤n≤18

这种小的离奇的数据范围提醒着我们——正解状压DP
（打记忆化搜索暴力的我会告诉你2000ms的时间也能卡过去的）

其实$DP$方程可以非常容易地得到
设$f[i]$表示把$i$这种状态的猪给灭掉了的01状态，i为压缩的二进制状态，0没灭1灭掉了

这还没完，还得预处理，预处理什么呢？
设$sit[i][j]$表示穿过第$i$个猪和第$j$个猪的唯一抛物线所能打到的猪的二进制状态
（因为穿过$i$和$j$的唯一抛物线还是可能打死其他猪的嘛）直接枚举计算抛物线方程得出

$DP$方程瞬间就出来了

$$f[i|sit[j][k]]=min(f[i|sit[j][k],f[i]+1)$$

对了不要忘记一只鸟打一只猪的情况，没考虑这个是要WA的

---

code

听说c++的精度问题很迷，所以注意精度！！！
时间复杂度$O(n^22^n)$

code1（1766ms）

#include<bits/stdc++.h>

using namespace std;

int sit[20][20],f[1<<18];
double a[20][3];
double x[20],y[20];
int n,m,t,tot;

bool judge(double x,double y)
{
    return abs(x-y)<(1e-6); 
}

int main()
{
    freopen("angrybirds.in","r",stdin);
    freopen("angrybirds.out","w",stdout);
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d%d",&n,&m);
        for (int i=1;i<=n;i++)
        {
            scanf("%lf%lf",&x[i],&y[i]);
        }
        tot=0;
        memset(sit,0,sizeof(sit));
        for (int i=1;i<=n;i++)
        {
            for (int j=i+1;j<=n;j++)
            {
                if (judge(x[i],x[j]))continue;
                double xx=(y[j]/x[j]-y[i]/x[i])/(x[j]-x[i]),yy=y[i]/x[i]-xx*x[i];//算抛物线方程
                if (xx>=0)continue;

                int temp=0;
                for (int k=1;k<=n;k++)
                {
                    if (judge(xx*x[k]+yy,y[k]/x[k]))
                    {
                        temp+=(1<<(k-1));
                    }
                }
                sit[i][j]=temp;
            }
        }
        memset(f,127,sizeof(f));
        f[0]=0;
        for (int i=0;i<=(1<<n)-1;i++)
        {
            for (int j=1;j<=n;j++)
            {
                for (int k=j+1;k<=n;k++)
                {
                    f[i|sit[j][k]]=min(f[i|sit[j][k]],f[i]+1);  
                }
                f[i|(1<<(j-1))]=min(f[i|(1<<j-1)],f[i]+1);//一鸟打一猪
            }
        }
        printf("%d\n",f[(1<<n)-1]);
    }
    return 0;
} 

---

code2（981ms）

可以看出上面那个code慢的原因就是，可能抛物线经过的猪有重复
比如打$i$猪和$j$猪的抛物线和打$i$猪和$k$猪的抛物线一样，时间就慢了很多
判断状态是否重复，剪枝即可

时间复杂度$O(n2^n)$

#include<bits/stdc++.h>

using namespace std;

int sit[20][20],f[1<<18];
double a[20][3];
double x[20],y[20];
int n,m,t;

bool judge(double x,double y)
{
    return abs(x-y)<(1e-6); 
}

int main()
{
    freopen("angrybirds.in","r",stdin);
    freopen("angrybirds.out","w",stdout);
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d%d",&n,&m);
        for (int i=1;i<=n;i++)
        {
            scanf("%lf%lf",&x[i],&y[i]);
        }
        memset(sit,0,sizeof(sit));
        for (int i=1;i<=n;i++)
        {
            for (int j=i+1;j<=n;j++)
            {
                if (judge(x[i],x[j]))continue;
                double xx=(y[j]/x[j]-y[i]/x[i])/(x[j]-x[i]),yy=y[i]/x[i]-xx*x[i];
                if (xx>=0)continue;

                int temp=0;
                for (int k=1;k<=n;k++)
                {
                    if (judge(xx*x[k]+yy,y[k]/x[k]))
                    {
                        temp+=(1<<(k-1));
                    }
                }
                sit[i][j]=temp;
            }
        }
        memset(f,127,sizeof(f));
        f[0]=0;
        for (int i=0;i<=(1<<n)-1;i++)
        {
            for (int j=1;j<=n;j++)
            if(!(i&(1<<(j-1))))
            {
                for (int k=j+1;k<=n;k++)
                {
                    f[i|sit[j][k]]=min(f[i|sit[j][k]],f[i]+1);  
                }
                f[i|(1<<(j-1))]=min(f[i|(1<<j-1)],f[i]+1);
            }
        }
        printf("%d\n",f[(1<<n)-1]);
    }
    return 0;
} 

---

code3（179ms）

真心不知道那些打到200ms-的爷都怎么打的，点开一看——
——发现只是加了一个break？？？
好吧我输了……

#include<bits/stdc++.h>

using namespace std;

int sit[20][20],f[1<<18];
double a[20][3];
double x[20],y[20];
int n,m,t;

bool judge(double x,double y)
{
    return abs(x-y)<(1e-6); 
}

int main()
{
    freopen("angrybirds.in","r",stdin);
    freopen("angrybirds.out","w",stdout);
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d%d",&n,&m);
        for (int i=1;i<=n;i++)
        {
            scanf("%lf%lf",&x[i],&y[i]);
        }
        memset(sit,0,sizeof(sit));
        for (int i=1;i<=n;i++)
        {
            for (int j=i+1;j<=n;j++)
            {
                if (judge(x[i],x[j]))continue;
                double xx=(y[j]/x[j]-y[i]/x[i])/(x[j]-x[i]),yy=y[i]/x[i]-xx*x[i];
                if (xx>=0)continue;

                int temp=0;
                for (int k=1;k<=n;k++)
                {
                    if (judge(xx*x[k]+yy,y[k]/x[k]))
                    {
                        temp+=(1<<(k-1));
                    }
                }
                sit[i][j]=temp;
            }
        }
        memset(f,127,sizeof(f));
        f[0]=0;
        for (int i=0;i<=(1<<n)-1;i++)
        {
            for (int j=1;j<=n;j++)
            if(!(i&(1<<(j-1))))
            {
                for (int k=j+1;k<=n;k++)
                {
                    f[i|sit[j][k]]=min(f[i|sit[j][k]],f[i]+1);  
                }
                f[i|(1<<(j-1))]=min(f[i|(1<<j-1)],f[i]+1);
                break;
            }
        }
        printf("%d\n",f[(1<<n)-1]);
    }
    return 0;
}