1018

1018 - Brush (IV)

PDF (English)

Statistics

Forum

Time Limit: 2 second(s)

Memory Limit: 32 MB

Mubashwir returned home from the contest and got angry after seeing his room dusty. Who likes to see a dusty room after a brain storming programming contest? After checking a bit he found an old toothbrush in his room. Since the dusts are scattered everywhere, he is a bit confused what to do. So, he called Shakib. Shkib said that, 'Use the brush recursively and clean all the dust, I am cleaning my dust in this way!'

So, Mubashwir got a bit confused, because it's just a tooth brush. So, he will move the brush in a straight line and remove all the dust. Assume that the tooth brush only removes the dusts which lie on the line. But since he has a tooth brush so, he can move the brush in any direction. So, he counts a move as driving the tooth brush in a straight line and removing the dusts in the line.

Now he wants to find the maximum number of moves to remove all dusts. You can assume that dusts are defined as 2D points, and if the brush touches a point, it's cleaned. Since he already had a contest, his head is messy. That's why he wants your help.

Input

Input starts with an integer T (≤ 1000), denoting the number of test cases.

Each case starts with a blank line. The next line contains three integers N (1 ≤ N ≤ 16). N means that there are N dust points. Each of the next N lines will contain two integers x_i y_i denoting the coordinate of a dust unit. You can assume that (-1000 ≤ x_i, y_i ≤ 1000) and all points are distinct.

Output

For each case print the case number and the minimum number of moves.

Sample Input	Output for Sample Input
2 3 0 0 1 1 2 2 3 0 0 1 1 2 3	Case 1: 1 Case 2: 2

---

PROBLEM SETTER: AKM MUBASHWIR ALAM

SPECIAL THANKS: JANE ALAM JAN (DESCRIPTION, SOLUTION, DATASE

题意：给你n个点，然后要你画直线覆盖这些点，问你最少需要几条线可以覆盖所有的点。

思路：状态压缩ｄｐ；

两个点决定一条直线，我们先打表将两点确定的直线和在这个直线上的点处理出来，然后 dp[i]表示 在 状态i时最少要 用的 直线 数，dp[de]=min(dp[i]+1,dp[de]);

那么说下状态i表示的是二进制数，那么i中的0为未覆盖的，1为已经覆盖的，那么当i中当且只有一个1时那么 这时直线数应该为1。那么枚举未覆盖 的点用上面的状态转移 方程 就行，最后dp[(1<<n)-1]就为答案。

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<iostream>
#include<math.h>
using namespace std;
typedef struct pp
{
    int x;
    int y;
} ss;
ss ans[200];
int line[20][20];
int ck[75550][20];
int dp[70000];
bool xian(pp a,pp b)
{
    return (a.x*b.y-a.y*b.x)==0?true:false;
}
int main(void)
{
    int i,j,k;
    scanf("%d",&k);
    int c;
    int n,m;
    for(i=0; i<(1<<16); i++)
    {
        int cc=i;
        int u=0;
        int t=1;
        while(u<16)
        {
            if(cc%2==0)
            {
                ck[i][t]=u;
                t++;
            }
            cc/=2;
            u++;
        }
        ck[i][0]=t-1;
    }
    for(c=1; c<=k; c++)
    {

        memset(line,0,sizeof(line));
        fill(dp,dp+65550,100);
        scanf("%d",&n);
        int xx;
        int yy;
        xx=0;
        yy=0;
        for(i=0; i<n; i++)
        {
            scanf("%d %d",&ans[i].x,&ans[i].y);
            if(ans[i].x!=0||ans[i].y!=0)
                xx=ans[i].x,yy=ans[i].y;
        }
        for(i=0; i<n; i++)
        {
            for(j=i+1; j<n; j++)
            {
                line[i][j]|=(1<<i);
                line[i][j]|=(1<<j);
                for(int s=0; s<n; s++)
                {
                    ss nn;
                    nn.x=ans[i].x-ans[j].x;
                    nn.y=ans[i].y-ans[j].y;
                    ss mm;
                    mm.x=ans[s].x-ans[j].x;
                    mm.y=ans[s].y-ans[j].y;
                    bool ask=xian(nn,mm);
                    if(ask)
                        line[i][j]|=(1<<s);
                }
                line[j][i]=line[i][j];
            }
        }
        int ak=(1<<n)-1;
        dp[0]=0;
        for(i=0; i<=ak; i++)
        {
            int uu=i;
            int cn=0;
            cn=ck[i][0];
            cn-=(16-n);
            if(n-cn==1)
              dp[i]=1;
            if(cn>=2)
            {
                int s;
                for(j=1; j<=1; j++)
                {
                    for(s=j+1; s<=cn; s++)
                    {
                        int v;
                        int t=line[ck[i][j]][ck[i][s]];
                        int de=i;
                        de|=t;
                        dp[de]=min(dp[de],dp[i]+1);
                    }
                } 
            }
        }
        printf("Case %d: ",c);
        printf("%d
",dp[ak]);
    }
    return 0;
}