HDU 5031：看脸的DFS

我仍然觉得这道题十分的不科学……

题目是说你有一个坐标系中的点阵，其中点的两个坐标范围分别为0~n和0~m，而且都是整数点。你的好基友在这坐标系上画了几条直线，每条直线保证只穿过整数点，而且至少穿过3个整数点。现在你得到了一个矩阵，矩阵描述了每个点都被穿过了多少次，你需要确定你的基友最少画了多少条直线。答案保证不超过14.

这真没什么好办法，只能搜索，但是如果真老老实实地搜，肯定会T到死……

既然要搜索，我们肯定要找到这里所有的直线，不妨先看看怎样不重不漏地找出这里所有的直线吧，我的算法是这样的：先预处理出所有不是0的点，从左向右，从上向下扫描每个点，以它为起点，然后从它开始继续从左向右，从上到下枚举每个点作为终点，如果这两个点确定的向量的两个分量不互质（例如（1，1）和（3，3）向量是（2，2）），那么肯定没戏，他们中间一定隔过了一个点，或者中间的点是0；设这个向量为vec；

然后从起点开始每次减去vec枚举，看到0就说明没戏，看到不为0的点也说明没戏，因为我是从左向右，从上到下扫描的，假如我看到一个在我上面的（或左边的）点，那么应该是这个点来找我才对，这说明这条直线已经被找过了，所以不要；

接下来从终点每次加上vec枚举，看到0说明没戏，而且要注意记录一下是否看到了至少一个1，如果是的话就ok，这就是一条满足要求的直线了。

然后说搜索，我最后AC时采用的搜索姿势是：

（1）找线的工作放在每层搜索之前做，这很重要，因为你会发现找到一条直线并划去这条直线之后，下一层的合法直线数会急剧下降，这对于这道题来说非常重要，如果你一开始就找出了所有直线，维护他们是否合法的代价就太大了，还不如每次都现找；

（2）找出所有直线后按照他们覆盖点的个数排序，当前层选取直线的时候从大到小选取，并且只取最大的5条（如果合法直线比5条多的话）。然后，第一次找到一个解，就认为这个解是最优解并退出。

这个真的是看脸，我至今都觉得这个算法不科学，只能说他对的概率不小就是了，但是拿这个算法AC简直糊我一脸……

不评论了，这个看脸的社会……

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<algorithm>
using namespace std;

const int INF=1<<30;
int n,m,t;

struct Point
{
int x,y;
Point(){}
Point(int _x, int _y)
{
x=_x;
y=_y;
}
void set(int _x, int _y)
{
x=_x;
y=_y;
}
Point operator + (const Point &b) const
{
return Point(x+b.x, y+b.y);
}
Point operator - (const Point &b) const
{
return Point(x-b.x, y-b.y);
}
int operator ^(const Point &b) const
{
return x*b.y - y*b.x;
}
};

struct Line
{
Point s,e;
int cover;
Line(){}
void set(Point _s, Point _e, int _c)
{
s=_s;
e=_e;
cover=_c;
}

bool operator < (const Line &b)
{
return cover < b.cover;
}
};

Point point[5000];
int p_point = 0;

int map[70][70];
int min_ans = 14;
bool found = false;

void init()
{
p_point=0;
memset(map, 0, sizeof(map));
min_ans = 14;
found = false;
return;
}

int gcd(int x, int y)
{
if(x<y)
swap(x,y);
if(y==0)
return x;
if(x%y==0)
return y;
return gcd(y, x%y);
}

bool valid(Point p)
{
return p.x >=0 && p.y >= 0 && p.x <=n && p.y <=m;
}

bool CheckLine(int p1, int p2, int &cover)//判断p1 p2组成的直线是否合法，顺便算出他们的覆盖点数
{
Point now_vec = point[p2] - point[p1];
if(gcd( abs(now_vec.x), abs(now_vec.y)) != 1)
return false;

int now_cover = 0;
Point tmp = point[p1];
tmp = tmp - now_vec;
while(valid(tmp))
{
if(map[tmp.x][tmp.y] == 0)
return false;
else if(tmp.x <= point[p1].x)
return false;

now_cover ++;
tmp = tmp - now_vec;
}

tmp = point[p2];
tmp = tmp + now_vec;
bool found_one = false;
while(valid(tmp))
{
found_one = true;
if(map[tmp.x][tmp.y] == 0)
return false;
now_cover++;
tmp = tmp + now_vec;
}
if(!found_one)
return false;

cover = now_cover;
return true;
}

void DetermineLines(Line line[], int &p_line)
{
int i,j;
for(i=1; i<=p_point -1;i++)
{
if(map[point[i].x][point[i].y] ==0)
continue;
for(j=i+1; j<=p_point; j++)
{
if(map[point[j].x][point[j].y]==0)
continue;
int cover;
if( CheckLine(i,j, cover) )
{
line[++p_line].set(point[i], point[j], cover);
}
}
}
return;
}

void drop(Line l)
{
Point p1 = l.s, p2 = l.e;

Point now_vec = p2 - p1;
Point tmp = p1;

while(valid(tmp))
{
map[tmp.x][tmp.y] --;
tmp = tmp - now_vec;
}

tmp = p2;
while(valid(tmp))
{
map[tmp.x][tmp.y] --;
tmp = tmp + now_vec;
}
return ;
}

void resume(Line l)
{
Point p1 = l.s, p2 = l.e;

Point now_vec = p2 - p1;
Point tmp = p1;
while(valid(tmp))
{
map[tmp.x][tmp.y]++;
tmp = tmp - now_vec;
}

tmp = p2;
while(valid(tmp))
{
map[tmp.x][tmp.y]++;
tmp = tmp + now_vec;
}
return ;
}

bool cmp(const Line &a, const Line &b)
{
return a.cover > b.cover;
}

bool check()
{
int i;
for(i=1; i<=p_point; i++)
{
if(map[point[i].x][point[i].y] != 0)
return false;
}
return true;
}

void DFS(int depth)
{
Line line[3000];
int p_line = 0;

DetermineLines(line, p_line);
sort(line+1, line + p_line +1, cmp);

if(check())
{
min_ans = depth-1;
found = true;
return ;
}

if(depth > min_ans)
return;

int i;

for(i=1; i<=min(p_line,4);i++)
{
drop(line[i]);

DFS(depth+1);
if(found)
break;

resume(line[i]);
}
return ;
}

int main()
{
scanf("%d", &t);
int files;
for(files=1; files<=t; files++)
{
init();
scanf("%d %d", &n, &m);
int i,j;
for(i=0; i<=n; i++)
{
for(j=0; j<=m; j++)
{
scanf("%d", &map[i][j]);
if(map[i][j]!=0)
{
point[++p_point].set(i,j);
}
}
}

DFS(1);
printf("%d\n", min_ans);

}

//system("pause");
return 0;
}