NOIP2016 愤怒的小鸟

传送门

这道题，因数据范围很小，可判断使用状压或爆搜，但因本人菜鸡，就直接选择爆搜。

我原本思路是，将所有的猪两两配对，把所有的函数预处理，再dfs深搜，把所有情况遍历一次，找出答案即可，但忽略了可能有的猪无法与其他的猪构成函数，只能单独在一条曲线上，还忽略了实数的精度问题。

看了题解后， 得知：实数判断大小，因其精度问题，小数部分可能有随机部分，只能用两数差的绝对值与1e-9(一个微小的误差)相比，其次，我先前的想法过于复杂，其实可以边搜索边算函数，dfs(c,u,e)表示搜索到第c只猪，有u个函数，有e个单独的猪，还有一个关键点就是可以最优化剪枝，如果抛物线的总数量已经大于等于当前的最优解时，搜下去也不会比当前更优了，就不用继续搜下去了。

代码：

#include<bits/stdc++.h>
#define ll long long
#define db double
using namespace std;
inline int read()
{
	int x=0,f=1;
	char ch;
	while(ch>'9'||ch<'0')
	{
		if(ch=='-')	f=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9')
	{
		x=x*10+ch-'0';
		ch=getchar();
	}
	return f*x;
}
const db eps=1e-9;
bool pd(db x,db y)
{
	return fabs(x-y)<eps;
}
struct node
{
	db a,b;	
}w[20];
struct vode
{
	db x,y;
}v[20],only[20];
int t,m,n,ans,num,anss;
bool mark;
db worka(int i,int j)
{
	return (v[j].y*only[i].x-only[i].y*v[j].x)/(only[i].x*v[j].x*(v[j].x-only[i].x));
}
db workb(int j,int i)
{
	return (v[j].y-worka(i,j)*v[j].x*v[j].x)/v[j].x;//注意函数的变量要对应准确 
}
void dfs(int c,int u,int e)
{	
	if(u+e>=ans)	return;
	if(c>n)
	{
		ans=u+e;
		return;
	}
	mark=0;
	for(int i=1;i<=u;i++)
	{
		if(pd(w[i].a*v[c].x*v[c].x+w[i].b*v[c].x,v[c].y))
		{
			dfs(c+1,u,e);
			mark=true;
			break;
		}
	}
	if(!mark)
	{
		for(int i=1;i<=e;i++)
		{
			if(pd(v[c].x,only[i].x))	continue;//与当前的i比 
			if(worka(i,c)<0)
			{
				w[u+1].a=worka(i,c);
				w[u+1].b=workb(c,i);
				db d=only[i].x,d2=only[i].y;
				for(int j=i;j<e;j++)
				{
					only[j].x=only[j+1].x;
					only[j].y=only[j+1].y;
				}
				dfs(c+1,u+1,e-1);
				for(int j=e;j>i;j--)
				{
					only[j].x=only[j-1].x;
					only[j].y=only[j-1].y;
				}
				only[i].x=d,only[i].y=d2;
			}
		}
	}
	only[e+1].x=v[c].x;
	only[e+1].y=v[c].y;
	dfs(c+1,u,e+1);
}
int main()
{
	t=read();
	while(t--)
	{
		n=read();
		m=read();
		for(int i=1;i<=n;i++)
		{
			scanf("%lf",&v[i].x);
			scanf("%lf",&v[i].y);
		}
		ans=1000;
		dfs(1,0,0);
		printf("%d\n",ans);
	}
}