题目描述
Kiana
最近沉迷于一款神奇的游戏无法自拔。
简单来说,这款游戏是在一个平面上进行的。
有一架弹弓位于 (0,0)(0,0) 处,每次 Kiana
可以用它向第一象限发射一只红色的小鸟,小鸟们的飞行轨迹均为形如 y=ax^2+bxy=ax2+bx 的曲线,其中 a,ba,b 是Kiana
指定的参数,且必须满足 a < 0a<0,a,ba,b 都是实数。
当小鸟落回地面(即 xx 轴)时,它就会瞬间消失。
在游戏的某个关卡里,平面的第一象限中有 nn 只绿色的小猪,其中第 ii 只小猪所在的坐标为 \left(x_i,y_i \right)(xi,yi)。
如果某只小鸟的飞行轨迹经过了 \left( x_i, y_i \right)(xi,yi),那么第 ii 只小猪就会被消灭掉,同时小鸟将会沿着原先的轨迹继续飞行;
如果一只小鸟的飞行轨迹没有经过 \left( x_i, y_i \right)(xi,yi),那么这只小鸟飞行的全过程就不会对第 ii 只小猪产生任何影响。
例如,若两只小猪分别位于 (1,3)(1,3) 和 (3,3)(3,3),Kiana
可以选择发射一只飞行轨迹为 y=-x^2+4xy=−x2+4x 的小鸟,这样两只小猪就会被这只小鸟一起消灭。
而这个游戏的目的,就是通过发射小鸟消灭所有的小猪。
这款神奇游戏的每个关卡对 Kiana
来说都很难,所以Kiana
还输入了一些神秘的指令,使得自己能更轻松地完成这个游戏。这些指令将在【输入格式】中详述。
假设这款游戏一共有 TT 个关卡,现在 Kiana
想知道,对于每一个关卡,至少需要发射多少只小鸟才能消灭所有的小猪。由于她不会算,所以希望由你告诉她。
输入输出格式
输入格式:
第一行包含一个正整数 TT,表示游戏的关卡总数。
下面依次输入这 TT 个关卡的信息。每个关卡第一行包含两个非负整数 n,mn,m,分别表示该关卡中的小猪数量和 Kiana 输入的神秘指令类型。接下来的 nn 行中,第 ii 行包含两个正实数 x_i,y_ixi,yi,表示第 ii 只小猪坐标为 (x_i,y_i)(xi,yi)。数据保证同一个关卡中不存在两只坐标完全相同的小猪。
如果 m=0m=0,表示Kiana
输入了一个没有任何作用的指令。
如果 m=1m=1,则这个关卡将会满足:至多用 \lceil n/3 + 1 \rceil⌈n/3+1⌉ 只小鸟即可消灭所有小猪。
如果 m=2m=2,则这个关卡将会满足:一定存在一种最优解,其中有一只小鸟消灭了至少 \lfloor n/3 \rfloor⌊n/3⌋ 只小猪。
保证 1\leq n \leq 181≤n≤18,0\leq m \leq 20≤m≤2,0 < x_i,y_i < 100<xi,yi<10,输入中的实数均保留到小数点后两位。
上文中,符号 \lceil c \rceil⌈c⌉ 和 \lfloor c \rfloor⌊c⌋ 分别表示对 cc 向上取整和向下取整,例如:\lceil 2.1 \rceil = \lceil 2.9 \rceil = \lceil 3.0 \rceil = \lfloor 3.0 \rfloor = \lfloor 3.1 \rfloor = \lfloor 3.9 \rfloor = 3⌈2.1⌉=⌈2.9⌉=⌈3.0⌉=⌊3.0⌋=⌊3.1⌋=⌊3.9⌋=3。
输出格式:
对每个关卡依次输出一行答案。
输出的每一行包含一个正整数,表示相应的关卡中,消灭所有小猪最少需要的小鸟数量。
输入输出样例
输入样例#1: 复制
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
输出样例#1: 复制
1
1
输入样例#2: 复制
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
输出样例#2: 复制
2
2
3
输入样例#3: 复制
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
输出样例#3: 复制
6
说明
【样例解释1】
这组数据中一共有两个关卡。
第一个关卡与【问题描述】中的情形相同,22只小猪分别位于(1.00,3.00)(1.00,3.00)和 (3.00,3.00)(3.00,3.00),只需发射一只飞行轨迹为y = -x^2 + 4xy=−x2+4x的小鸟即可消灭它们。
第二个关卡中有55只小猪,但经过观察我们可以发现它们的坐标都在抛物线 y = -x^2 + 6xy=−x2+6x上,故Kiana
只需要发射一只小鸟即可消灭所有小猪。
【数据范围】
解法一:预处理所有能一次打掉的鸟的集合sta,转移方程,f[i]=min{f[i^sta],若sta为i的子集。复杂度为4^n,常数很小。
#include<bits/stdc++.h>
#define f(i,l,r) for(i=(l);i<=(r);i++)
using namespace std;
const int MAXN=20;
double EPS=1e-6;
int T,n;
double x[MAXN],y[MAXN];
int sta[1<<MAXN],num;
int f[1<<MAXN];
int main()
{
ios::sync_with_stdio(false);
int i,j,k,m;
cin>>T;
while(T--){
memset(f,1,sizeof(f));
num=0;
cin>>n>>m;
f(i,0,n-1){
cin>>x[i]>>y[i];
sta[++num]=1<<i;
}
int ALL=(1<<n)-1;
f(i,0,n-1){
f(j,0,n-1){
if(i==j||fabs(x[i]-x[j])<=EPS) continue;
double a=(x[j]*y[i]-x[i]*y[j])/(x[i]*x[j]*(x[i]-x[j]));
double b=(x[j]*x[j]*y[i]-x[i]*x[i]*y[j])/(x[i]*x[j]*(x[j]-x[i]));
if(a>=-EPS) continue;
sta[++num]=(1<<i)|(1<<j);
f(k,0,n-1){
if(k==i||k==j) continue;
if(fabs(a*x[k]*x[k]+b*x[k]-y[k])<=EPS){
sta[++num]=sta[num-1]|(1<<k);
}
}
}
}
sort(sta+1,sta+1+num);
int L=unique(sta+1,sta+1+num)-(sta+1);
f[0]=0;
f(i,1,ALL){
f(j,1,L){
if((i|sta[j])==i){
f[i]=min(f[i],f[i^sta[j]]+1);
}
}
}
cout<<f[ALL]<<endl;
}
return 0;
}
解法二:预处理g[i][j]表示和i,j在同一条抛物线上的鸟。转移时分两种,一种是单独打一只鸟,一种是和其他鸟一起打。复杂度n^2*2^n。
#include<iostream>
#include<cstring>
#include<cmath>
#include<cstdio>
#define f(i,l,r) for(i=(l);i<=(r);i++)
#define EPS 1e-6
using namespace std;
double x[20],y[20];
int g[20][20],f[262150];
int T,n,m;
int main()
{
ios::sync_with_stdio(false);
int i,j,k;
cin>>T;
while(T--){
memset(g,0,sizeof(g));
cin>>n>>m;
f(i,0,n-1){
cin>>x[i]>>y[i];
}
f(i,0,n-1){
f(j,0,n-1){
if(i==j) continue;
double a=(x[j]*y[i]-x[i]*y[j])/(x[i]*x[j]*(x[i]-x[j]));
double b=(x[j]*x[j]*y[i]-x[i]*x[i]*y[j])/(x[i]*x[j]*(x[j]-x[i]));
if(a<=EPS)
f(k,0,n-1){
if(fabs(a*x[k]*x[k]+b*x[k]-y[k])<=EPS){
g[i][j]|=1<<k;
}
}
}
}
f[0]=0;
f(i,1,(1<<n)-1){
f(j,0,n-1){
if(i&(1<<j)) break;
}
f[i]=f[i^(1<<j)]+1;
f(k,0,n-1){
if(k==j||(i&(1<<k))==0) continue;
f[i]=min(f[i],f[i^(i&g[j][k])]+1);
}
}
cout<<f[(1<<n)-1]<<endl;
}
return 0;
}
解法三:
若令 xx为满足 S\&(1<<(x-1))=0 的最小正整数,则由 SS 扩展的转移的所有线都要经过 x。
为什么?这个是对的吗?不经过 x就会慢吗?
你想一想,先打 1,4,再打 2,3,和先打 2,3,再打 1,4 是不是一样的?
如果这一次转移不打 x,那以后还要再回过头来打 x。这就是多余的转移。
因为经过 x 的线数量是 n,所以每次转移涉及到的线就从 n^2 变成了 n。
只要预处理一下 0-2^{18} 的对应的 x就能做到 O(Tn2^n)了,这才是考场的正解。
#include<bits/stdc++.h>
using namespace std;
const double eps=1e-8;
int t,n,m,lines[19][19],lowunbit[1<<19],dp[1<<19]; //lowunbit就是题解中的x
double x[19],y[19];
void equation(double &x,double &y,double a1,double b1,double c1,double a2,double b2,double c2){ //解方程
y=(a1*c2-a2*c1)/(a1*b2-a2*b1);
x=(c1-b1*y)/a1;
}
int main(){
for(int i=0;i<(1<<18);i++){ //预处理lowunbit
int j=1;
for(;j<=18 && i&(1<<(j-1));j++);
lowunbit[i]=j;
}
scanf("%d",&t);
while(t--){
memset(lines,0,sizeof(lines)); //各种初始化
memset(dp,0x3f,sizeof(dp));
dp[0]=0;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) scanf("%lf%lf",x+i,y+i);
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++){ //处理所有抛物线
if(fabs(x[i]-x[j])<eps) continue; //x坐标相同,不可能有解
double a,b;
equation(a,b,x[i]*x[i],x[i],y[i],x[j]*x[j],x[j],y[j]);
if(a>-eps) continue; //解出a和b
for(int k=1;k<=n;k++)
if(fabs(a*x[k]*x[k]+b*x[k]-y[k])<eps) lines[i][j]|=(1<<(k-1));
}
for(int i=0;i<(1<<n);i++){ //重点!状压开始!
int j=lowunbit[i]; //必须经过lowunbit这个点
dp[i|(1<<(j-1))]=min(dp[i|(1<<(j-1))],dp[i]+1); //单独转移
for(int k=1;k<=n;k++) dp[i|lines[j][k]]=min(dp[i|lines[j][k]],dp[i]+1); //所有经过lowunbit的抛物线
}
printf("%d\n",dp[(1<<n)-1]); //答案
}
}
记忆化搜索写法:
#include<bits/stdc++.h>
#define f(i,l,r) for(i=(l);i<=(r);i++)
using namespace std;
const int MAXN=19;
double EPS=1e-6;
int T,n,m;
double x[MAXN],y[MAXN];
int g[MAXN][MAXN];
int f[1<<18];
void dfs(int sta)
{
int i,j;
f(i,0,n-1){
if((sta&(1<<i))==0) break;
}
f(j,0,n-1){
if(f[sta|g[i][j]]>f[sta]+1){
f[sta|g[i][j]]=f[sta]+1;
dfs(sta|g[i][j]);
}
}
}
int main()
{
ios::sync_with_stdio(false);
int i,j,k;
cin>>T;
while(T--){
memset(f,1,sizeof(f));
memset(g,0,sizeof(g));
cin>>n>>m;
f(i,0,n-1){
cin>>x[i]>>y[i];
}
f(i,0,n-1){
f(j,0,n-1){
if(i==j){
g[i][j]=1<<i;
continue;
}
double a=(x[j]*y[i]-x[i]*y[j])/(x[i]*x[j]*(x[i]-x[j]));
double b=(x[j]*x[j]*y[i]-x[i]*x[i]*y[j])/(x[i]*x[j]*(x[j]-x[i]));
if(a<=-EPS)
f(k,0,n-1){
if(fabs(a*x[k]*x[k]+b*x[k]-y[k])<=EPS){
g[i][j]|=1<<k;
}
}
}
}
f[0]=0;
dfs(0);
cout<<f[(1<<n)-1]<<endl;
}
return 0;
}
解法四:爆搜。
/*思路:搜索。
对于第i只猪,如果它已经被前面所构造的某条抛物线经过了,
就不用处理了,继续往下搜索。否则,就有两种选择,第一种
是与前面某一只单独的猪(即这只猪未与其它猪组成抛物线)
组成抛物线,因为两只猪最多也只能被一条抛物线相连;第二
种是暂时不与其它单独的猪组成抛物线。最后,将抛物线的条
数与余下的猪的个数相加(因为单独的一只猪也要一条抛物线
将其击中)就是搜索出来的一个合法的结果。*/
#include<iostream>
#include<cstdio>
#include<fstream>
#include<algorithm>
#include<string>
#include<sstream>
#include<cstring>
#include<cmath>
using namespace std;
const double eps=1e-8;
/*因为浮点数的精度计算太过复杂,像3.14这样的数存在浮
点型变量里存的可能是3.139999999,也有可能是3.140000001,
所以不能直接用“==”判断两个浮点数是否相等。在这种情况
下,就允许判断两个浮点数为相等时,两数之间存在微小的误差,
这个“微小的误差”要取一个较小的数,比如1e-8,这样就不
会判不出也不会误判了。*/
bool dy(double a,double b)//判断两个浮点数是否相等的函数
{
//如果a和b之间相差的值小于eps(即1e-8),就说明它们是相等的
return fabs(a-b)<eps;//fabs用于取浮点数的绝对值
}
int n=0,m=0,ans=0;
//x数组存每只猪的x坐标,y数组存每只猪的y坐标
//pwxa数组存每条已构造的抛物线的参数a,pwxb数组存每条已构造的抛物线的参数b
//tx数组存每只单独的猪的x坐标,ty数组存每只单独的猪的y坐标
double x[20],y[20],pwxa[20],pwxb[20],tx[20],ty[20];
//dfs(c,u,v)表示当前搜到第c只猪,已构造抛物线的数量为u,单独的猪的数量为v时的情况
//注意:当前抛物线的总数量为(u+v)条,因为除已有的抛物线外,每一只单独的猪也需要一条抛物线来击中它
void dfs(int c,int u,int v)
{
//最优性剪枝,因为即使后面的每一只猪都被当前已构造的抛物线击中,
//或者与其它单独的猪组成抛物线,抛物线的总数量还是(u+v),不会减少,
//所以如果抛物线的总数量已经大于等于当前的最优解时,搜下去也不会
//比当前更优了,就不用继续搜下去了。
if(u+v>=ans) return;
if(c>n)//如果搜完了
{
ans=u+v;//记录答案,因为前面已经有最优性剪枝了,所以没被剪掉的答案一定比当前更优
return;//结束
}
bool flag=false;//记录是否被已构造的抛物线经过
for(int i=1;i<=u;i++)//枚举已构造的抛物线
//将这一条抛物线的参数与当前猪的x坐标带进函数解析式算一遍,
//如果结果等于当前猪的y坐标,就说明当前猪已经被已构造的抛物线经过了
if(dy(pwxa[i]*x[c]*x[c]+pwxb[i]*x[c],y[c]))
{
dfs(c+1,u,v);//被经过了就直接往下搜
flag=true;//记录
break;//退出循环,既然当前猪已经被经过了,再继续判断也没有意义了
}
if(!flag)//如果没有被经过
{
for(int i=1;i<=v;i++)//枚举单独的猪
{
//如果当前猪与这一只单独的猪的x坐标相同,就说明它们不能组成一条
//抛物线。因为若想使它们组成一条抛物线,弹弓的位置就必须是它们的正下
//方,然后往上垂直发射,但是弹弓的位置固定在(0,0),而猪的x坐标又大于
//0(题目数据范围),所以它们不能组成一条抛物线。如果不加这个判
//断的话就会计算出一些奇奇怪怪的东西,影响后面的判断,所以还是加上为好。
if(dy(x[c],tx[i])) continue;//如果当前猪与这一只单独的猪的x坐标相同,跳过这一次循环
//求参数a、b的过程实际上就是解一个二元一次方程组,比如说有两只猪的坐标分别是(1,3)和(3,3),
//现在要求出它们所组成的抛物线的参数a与参数b。将两只猪的坐标分别代入到函数解析式中,
//就可以得出一个方程组: 3=a+b 3=9a+3b 。这是,我们可以用加减消元法消掉b,将两个方程
//分别乘上另一个方程的b的系数,得:9=3a+3b 3=9a+3b。这样,两个方程中的b的系数就一致了,
//然后直接用一个式子减去另一个式子,再将a的系数化为一即可。最后再将a带入到回任意一个方程求b即可。
//因为这里的所有方程都长一个样,所以这一种方法是通用的。
double a=(y[c]*tx[i]-ty[i]*x[c])/(x[c]*x[c]*tx[i]-tx[i]*tx[i]*x[c]);//求参数a
double b=(y[c]-x[c]*x[c]*a)/x[c];//将a代入求参数b
if(a<0)//如果这一个解是合法的,就说明当前猪与这一只单独的猪可以组成抛物线
{
pwxa[u+1]=a;//记录抛物线的参数a
pwxb[u+1]=b;//记录抛物线的参数b
//将这一只单独的猪从数组中删去,因为它已经和当前猪组成抛物线,不再单独了
double q=tx[i],w=ty[i];
for(int j=i;j<v;j++)
{
tx[j]=tx[j+1];
ty[j]=ty[j+1];
}
dfs(c+1,u+1,v-1);//继续往下搜
//将这一只单独的猪放回数组(回溯)
for(int j=v;j>i;j--)
{
tx[j]=tx[j-1];
ty[j]=ty[j-1];
}
tx[i]=q;
ty[i]=w;
}
}
//还有一种选择:暂时不与其它猪组成抛物线
tx[v+1]=x[c];
ty[v+1]=y[c];
dfs(c+1,u,v+1);//继续往下搜
}
}
int main()
{
int T=0;
scanf("%d",&T);
for(int Q=1;Q<=T;Q++)
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) scanf("%lf%lf",&x[i],&y[i]);
ans=100;//记得初始化
dfs(1,0,0);//搜
printf("%d\n",ans);
}
return 0;//完美地结束
}