[light oj 1018]Brush(IV)[状压DP]

最新推荐文章于 2019-04-22 20:37:04 发布

iYUNDI

最新推荐文章于 2019-04-22 20:37:04 发布

阅读量1.7k

点赞数

分类专栏： DP

本文链接：https://blog.csdn.net/iyundi/article/details/12285249

版权

DP 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

题意:

给出n个点, 求过这n个点所需的最少直线条数.

思路:

state表示点的状态,

目的是求出对于某个state, 所需的最小直线条数.

朴素地想state之间的转移情况, 记得要体现"半隐半显"的方法... 那就是枚举一个state中的任意一对点, 去掉这对点所在的直线经过的所有点, 得到state' , 答案就是ans[state] = min(ans[state], ans[state' ] + 1); 枚举所有点对即可. 因为这个state的转移是非线性的, 所以需要用dfs... 现在问题就是如何求出state到state' 的转移. 是否可以想到预处理捏?

预处理出任意两点(i, j)所在直线覆盖的点对应的state(与正文中的state形式相同, 便于使用). 那么就可以暴力地判共线了...居然...这个思路如此理所当然....

拜读的代码:

http://blog.csdn.net/crazy_ac/article/details/7781886

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int inf = ~0u>>2;
int dp[20][20];
int n;
int f[1<<16];
struct point {
    int x,y;
}in[20];
int cross(point a,point b,point c){return (b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x);}
bool col(int a,int b,int c){
    return cross(in[a],in[b],in[c])==0;
}
void init(){
    memset(dp,0,sizeof(dp));
    for(int i=0;i<n;i++)
        for(int j=i+1;j<n;j++)
            for(int k=0;k<n;k++)//枚举任意两个点和第三个点的id
                if(col(i,j,k))//若三点共线
                    dp[i][j]+=(1<<k);//(上三角矩阵)表示i,j两点连线上有k点
}
int DP(int s)//覆盖s状态的点所需最小直线数
{
    if(f[s]!=inf) return f[s];
    int cnt=0;
    for(int i=0;i<n;i++) if(s&(1<<i)) cnt++;//cnt = __builtin_popcount(s);
    if(cnt==0) return f[s]=0;
    if(cnt<=2) return f[s]=1;
    for(int i=0;i<n;i++)//大于等于三个点时
        if(s&(1<<i))//若有一点为i点(正序扫描),只找第一点
        {
            for(int j=i+1;j<n;j++)//枚举其后的点
                if(s&(1<<j))//若找到第二点
                {//dp数组居然在下标里用到了!
                    f[s]=min(f[s],DP(s-(s&dp[i][j]))+1);
                }//核心语句就一个,就是用"去掉"操作,来转移到"已知成分更大的状态"
            break;//else TLE
        }
    return f[s];
}//原本我的想法大致相同,只是不会实现...
//这种处理太帅了orz...
int main()
{
    int t,ca=1;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&in[i].x,&in[i].y);
        }
        init();
        fill(f,f+(1<<16),inf);
        printf("Case %d: %d\n",ca++,DP((1<<n)-1));//考虑所有点
    }
    return 0;
}

自己实现一遍:

/*
    为何不遍历所有组合而只是选定首个最低位的点,遍历其他的点?
    因为这样做(O(n))使得在dfs的每一层,都新选择了一个点;
    否则(O(n^2))在不同的层,会多搜索很多重复的情况.
    这里有一点贪心的意思,
    对于一个点来说,它总是要连掉的,那么每次就考察最低位的点.
    这样逐步前进,是不会漏掉什么情况的.
    (但整体来说不是很一目了然)

#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 20;
const int INF = 0x3f3f3f3f;
int dp[N][N],ans[1<<16],n;
int x[N],y[N];
inline bool col(int i, int j, int k)
{
    return !((x[j]-x[i])*(y[k]-y[i])-(x[k]-x[i])*(y[j]-y[i]));
}

void preproc()
{
    memset(dp,0,sizeof(dp));
    for(int i=0;i<n;i++)
        for(int j=i+1;j<n;j++)
            for(int k=0;k<n;k++)
                if(col(i,j,k))
                    dp[i][j] += 1<<k;
}

int dfs(int s)
{
    if(ans[s]!=INF) return ans[s];
    int cnt = __builtin_popcount(s);
    if(!cnt)    return ans[s] = 0;
    if(cnt<=2)  return ans[s] = 1;
    int i=0;
    while(!((1<<i)&s))  i++;//!
    for(int j=i+1;j<n;j++)
    {
        if((1<<j)&s)
            ans[s] = min(ans[s], dfs((s-(s&dp[i][j])))+1);
    }
    return ans[s];
}

int main()
{
    int T,cas = 0;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        for(int i=0;i<n;i++)
            scanf("%d%d",x+i,y+i);
        preproc();//only use j>i
        memset(ans,0x3f,sizeof(ans));
        printf("Case %d: %d\n",++cas,dfs((1<<n)-1));
    }
}