[搜索] ZOJ1002、ZOJ1008、ZOJ1019、POJ1011

ZOJ1002

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1002

一个迷宫有一些围墙障碍，如果防止的两个碉堡可以直接连线且中间没有围墙挡住，则是不可以放置的。

因为数据范围小，直接DFS递归就好了。

用col,row表示该行和列是否可以放置，当碰到围墙的时候，围墙所在的行和列都变成可以放置了（因为递归是从上到下从左到右的，所以不会影响之前的情况。

#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
using namespace std;
int ans;

void _cal(vector<string>& vs,int k,vector<int>& col,vector<int>& row,int cur)
{
int x,y;
int n=vs.size();
if (k==n*n)
{
ans=max(cur,ans);
return;
}
x=k/n;
y=k%n;
if ( vs[x][y]=='X' )
{
int r=row[x];
int c=col[y];
row[x]=col[y]=0;
_cal(vs,k+1,col,row,cur);
row[x]=r;
col[y]=c;
}
else
{
if ( row[x]==0&&col[y]==0 ) //can put
{
row[x]=col[y]=1;
_cal(vs,k+1,col,row,cur+1);
row[x]=col[y]=0;
}
_cal(vs,k+1,col,row,cur);
}
}

void cal(vector<string>& vs)
{
int n=vs.size();
vector<int> col(n,0);
vector<int> row(n,0);
_cal(vs,0,col,row,0);
}

int main()
{
int n;
while((cin>>n)&&n!=0)
{
vector<string> vs;
vs.reserve(n);
string s;
while(n--)
{
cin>>s;
vs.push_back(s);
}
ans=0;
cal(vs);
cout<<ans<<endl;
}
}

ZOJ 1008：

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=8

刚开始看觉得挺简单的搜索，然后看数据范围最大才5X5的格子，心想就算是暴力时间应该也差不多，于是先写了个毫无剪枝的搜索，理所当然超时了。

然后自己想了几个剪枝：

1.首先用一个大小为10的数组gLeft，数组中每个值记录的是 left == i 的格子编号，比如有3个格子的left=1 ,那么gLeft[1] 里保存这3个格子的编号值；

2.同理设置一个大小为10的数组gTop；

3.再设置一个大小为10的数组 nLeft，数组记录的是有多少个格子的 left ==i ， 比如如条件1，初始时 nLeft[1] = 3;但是值会在搜索中变化；

4.同理设置nTop；

想法是这样的：

1.如果格子不在第一列，我们要在该位置放置一个格子，这个格子的left == 前一个格子的right ；

2.如果格子不在第一行，我们要在该位置放置一个格子，这个格子的top == 上一个格子的bottom；

3.所以既然知道前一个格子的 right （上一个格子的bottom),那么我们当前可以放置的格子就应当是 gLeft [right] , gTop[bottom] 里的这些格子，这样我们就不必每次都遍历所有的格子来尝试；

4.当我们决定在当前位置放置一个格子之后，如果它不在第一行，那么它的bottom肯定要被之后的某个格子匹配，如果不在第一列，它的right肯定要被某个格子的left匹配，所以我们用nLeft和nTop记录的每个值当前还有多少个格子可用，比如当前格子的right = 8，但是nLeft[8]=0,即left为8的格子全用完的，那么很显然当前这个格子肯定不应该放，也没有必要往下搜索了~

基本用了这两个思路来剪枝之后试了一下，结果还是超时，略有点失望，只好百度一下别人的思路。

发现结果别人只用了一个剪枝：就是除去重复格子，比如25个格子里有10个是相同的，那么搜索空间只是在15个格子里，这么简单一个剪枝效果却是巨大的！

思路是如果当前放格子A不行，那么很明显跟它相同的格子B当然也不可能行。

发下自己的代码，也提醒自己在搜索时除去冗余数据是多么的重要！

#include<iostream>
#include<vector>
#include<cstdio>
#include<algorithm>
using namespace std;
struct grid
{
int bot,top,left,right;
grid(int b=0,int t=0,int l=0,int  r=0):bot(b),top(t),left(l),right(r){}
bool operator==(const grid& other)const
{
return bot==other.bot&&top==other.top&&left==other.left&&right==other.right;
}
};

grid G[5][5];

vector<grid> able;
vector<int> ncount;

int n;
int t;

bool test(int k)
{
if ( k==n*n )
return true;

int x=k/n;
int y=k%n;

bool ok=false;
for (int i=0;i<able.size();i++)
{
if (ncount[i]==0)
continue;

G[x][y]=able[i];
bool lok=true,tok=true;
if(x>0)
tok=G[x][y].top==G[x-1][y].bot;
if(y>0)
lok=G[x][y].left==G[x][y-1].right;
if ( lok && tok )
{
ncount[i]--;
ok=test(k+1);
ncount[i]++;
if ( ok )
return ok;
}
}
return ok;
}

int main()
{
int nCase=0;
while(scanf("%d",&n)&&n)
{
nCase++;
t=n*n;
able.clear();
ncount.clear();

for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
{
int b,t,l,r;
scanf("%d%d%d%d",&t,&r,&b,&l);
grid tmp=grid(b,t,l,r);
vector<grid>::iterator it=find(able.begin(),able.end(),tmp);
if ( it==able.end())
{
able.push_back(tmp);
ncount.push_back(1);
}
else
{
ncount[it-able.begin()]++;
}
}
if (nCase > 1)
printf("\n");

printf("Game %d: ",nCase);
if ( test(0) )
printf("Possible\n");
else
printf("Impossible\n");
}
}

ZOJ1019：

http://acm.zju.edu.cn/onlinejudge/showRuns.do?contestId=1

读了题之后，心想也想不出什么剪枝来啊，结果写了一个没有剪枝的居然也没有超时，这数据太水了。

#include<cstdio>
#include<iostream>
using namespace std;

typedef struct step
{
int x,y;
char direction;
}step;

step steps[10000];
int maps[101][101];
int m,n,nSteps;

bool move(int& x,int& y, char d)
{
if (d=='U')
{
if ( x>1 && maps[x-1][y]==0 )
{
x--;
return true;
}
return false;
}
if (d=='D')
{
if ( x<n && maps[x+1][y]==0 )
{
x++;
return true;
}
return false;
}
if (d=='L')
{
if ( y>1 && maps[x][y-1]==0 )
{
y--;
return true;
}
return false;
}
if (d=='R')
{
if ( y<m && maps[x][y+1]==0 )
{
y++;
return true;
}
return false;
}
return false;
}

int walk(int x,int y,int k)
{
if (x<1||x>n||y<1||y>m||maps[x][y]==1)
return 0;
if ( k==nSteps)
return 1;

int i=1;
int tx=x;
int ty=y;
char dir=steps[k].direction;
for(;i<=steps[k].x-1;i++)
{
if(!move(tx,ty,dir))
return 0;
}

for(;i<=steps[k].y;i++)
{
if(move(tx,ty,dir))
{
if (walk(tx,ty,k+1))
return 1;
}
else
break;
}
return 0;
}

int main()
{
int k,t;
int i,j,tx,ty;
int count=0;
char ch;
scanf("%d",&k);
while(k--)
{
t=0;count=0;nSteps=0;
scanf("%d%d",&n,&m);
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
scanf("%d",&maps[i][j]);
while(1)
{
scanf("%d%d",&tx,&ty);
if(tx==0 || ty==0)break;
steps[t].x = tx;
steps[t].y = ty;
scanf(" %c",&ch);
steps[t].direction = ch;
t++;
nSteps++;
}

for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
count += walk(i,j,0);

printf("%d\n",count);
}
return 0;

}

ZOJ 1084

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=84

其实就是给相邻的城市间着色的问题，由于四色问题已经被证明过了，所以我们知道四色肯定是可以的。只需要检查1色（全不相连），2色和3色是否可以就行了。

搜索还是蛮简单的，先尝试给当前节点着色，然后查看所有相邻节点来检查该色是否有效，向下搜索即可。

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

bool g[26][26];
int used[26];
int n;

bool dfs(int id,int col)
{
if ( id==n)
return true;

bool flag;
for(int i=0;i<col;i++)
{
flag=true;
used[id]=i;

for(int j=0;j<n;j++)
if (g[id][j]==1&&used[j]==i)
{
flag=false;
break;
}
if ( flag )
{
return dfs(id+1,col);
}
}
return false;
}

int main()
{
int i,j;
bool one;
char adj[50];
while(scanf("%d",&n)&&n)
{
memset(g,0,sizeof(g));
memset(used,0,sizeof(used));
one =true;
for(i=0;i<n;i++)
{
scanf("%s",adj);
for(j=2;adj[j];j++,one=false)
{
g[i][adj[j]-'A']=1;
g[adj[j]-'A'][i]=1;
}
}
if (one)
printf("1 channel needed.\n");
else if (dfs(1,2))
printf("2 channels needed.\n");
else if (dfs(1,3))
printf("3 channels needed.\n");
else
printf("4 channels needed.\n");
}
return 0;
}

POJ1011 STICKS 搜索

#include <iostream>
#include <algorithm>
using namespace std;

int sticks[64], n, len, num;
bool used[64];

bool compare(int a, int b)
{
return a > b;
}

bool dfs(int cur, int left, int level)
{	//cur: 当前已经计算的木棒编号，left:该段还剩的长度，level:已经成功的木棒数
if(left == 0) {//匹配一根木棒成功
if(level == num-2)
return true;
for(cur = 0; used[cur]; cur++)
;
used[cur] = true;
if(dfs(cur+1, len-sticks[cur], level+1))
return true;
used[cur] = false;
return false;
} else {
if(cur >= n-1)
return false;
for(int i = cur; i < n; i++) {
if(used[i])
continue;
if((sticks[i] == sticks[i-1]) && !used[i-1])
continue;
if(sticks[i] > left)
continue;
used[i] = true;
if(dfs(i, left-sticks[i], level))
return true;
used[i] = false;
}
return false;
}
}

int main()
{
while(cin>>n) {
if(n == 0)
break;
int sum = 0;
for(int i = 0; i < n; i++) {
scanf("%d", &sticks[i]);
sum += sticks[i];
}
sort(sticks, sticks+n, compare); //由大到小排序
bool end = false;
for(len = sticks[0]; len <= sum/2; len++) {
if(sum%len == 0) {
used[0] = true;
num = sum/len;
if(dfs(0, len-sticks[0], 0)) {
end = true;
printf("%d\n", len);
break;
}
used[0] = false;
}
}
if(!end)
printf("%d\n", sum);
memset(used, 0, sizeof(used));
}
//system("pause");
return 0;
}