题意：给一幅地图，P为起点，D为终点，‘*‘为传送阵，到达传送阵可以传到任意一个其他的传送阵，传到以后可以正常走或者再传回来，问P->D最短步数。
分析：这题一定要细心，分析要到位才能搞定，错一点都WA。有两种思路：
1.走到一个传送点之后，将所有能传到的地方都加入队列，然后清除传送阵向量（vector），因为以后不用再互相传了，对于某个传送阵k，以后从别的点传到k的效果还不如从这个点传到k,所以清空传送阵，又因为其他传送阵可以传回来，此时传送阵向量要把当前传送阵push_back进去，以便其他点传过来，每个传送点设一个标记，flag=0说明这个传送点还没用过，flag=1说明这个传送点是被传过来的，还可以传一次，use[][]数组记录某个传送点被用过没有（即通过它传出去过没有），然后搞即可。
代码：（63ms, 0KB）
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#define Mod 1000000007
using namespace std;
#define N 1000017
char ss[205][205];
bool vis[205][205],use[205][205];
int n,m,step;
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
struct node
{
int x,y,tag;
node(int _x,int _y,int _tag)
{
x = _x;
y = _y;
tag = _tag;
}
node(){}
}P,D;
vector<node> trans;
bool OK(int nx,int ny)
{
if(nx >= 0 && nx < n && ny >= 0 && ny < m)
return 1;
return 0;
}
bool bfs()
{
queue<node> que;
memset(vis,0,sizeof(vis));
memset(use,0,sizeof(use));
que.push(P);
int i,j,k;
vis[P.x][P.y] = 1;
while(!que.empty())
{
int SIZE = que.size();
while(SIZE--)
{
node tmp = que.front();
que.pop();
int nx = tmp.x;
int ny = tmp.y;
if(nx == D.x && ny == D.y)
return 1;
if(ss[nx][ny] == ‘*‘) //tag = 1 : 被传过来的，tag = 0 : 传出去
{
if(tmp.tag == 0 || (tmp.tag==1 && !use[nx][ny]))
{
for(i=0;i<trans.size();i++)
{
int x = trans[i].x;
int y = trans[i].y;
if(vis[x][y] || (nx == x && ny == y))
continue;
trans[i].tag = 1;
que.push(trans[i]);
}
trans.clear();
trans.push_back(tmp); //这个点还可以被传回来
if(tmp.tag == 1) //被传过来并且没用过的,现在用过了
vis[nx][ny] = 1;
use[nx][ny] = 1;
}
if(tmp.tag == 1) //被传，用过了，就当做普通点好了 别用else if
{
for(k=0;k<4;k++)
{
int kx = nx + dx[k];
int ky = ny + dy[k];
if(!OK(kx,ky) || ss[kx][ky] == ‘#‘ || ss[kx][ky] == ‘*‘ || vis[kx][ky])
continue;
vis[kx][ky] = 1;
que.push(node(kx,ky,0));
}
vis[nx][ny] = 1;
}
}
else //普通点，普通走法
{
for(k=0;k<4;k++)
{
int kx = nx + dx[k];
int ky = ny + dy[k];
if(!OK(kx,ky) || ss[kx][ky] == ‘#‘ || vis[kx][ky])
continue;
if(ss[kx][ky] != ‘*‘ ) //如果是‘*‘，则不能确定
vis[kx][ky] = 1;
que.push(node(kx,ky,0));
}
}
}
step++;
}
return 0;
}
int main()
{
int t,cs = 1,i,j;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&m);
trans.clear();
for(i=0;i<n;i++)
{
scanf("%s",ss[i]);
for(j=0;j<m;j++)
{
if(ss[i][j] == ‘*‘)
trans.push_back(node(i,j,0));
else if(ss[i][j] == ‘P‘)
P = node(i,j,0);
else if(ss[i][j] == ‘D‘)
D = node(i,j,0);
}
}
step = 0;
if(bfs())
printf("Case %d: %d\n",cs++,step);
else
printf("Case %d: impossible\n",cs++);
}
return 0;
}
2.统计传送点的数量，如果只有一个传送点，那么不能经过传送点到达，只能走普通路到终点。否则，先走一遍普通路ans = bfs()，再从P搜一个与他最近的传送点，从D搜一个与它最近的传送点，判断这两个传送点是不是同一个，如果是只能再通过图中另一个传送点作为终中继，此时ans = bfsP()+bfsD()+2，不是同一个那就更好处理了，ans = bfsP+bfsD+1。细节问题看代码吧。
代码：（22ms, 0KB）
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#define Mod 1000000007
using namespace std;
#define N 1000017
struct node
{
int x,y,step;
}P,D;
int n,m;
int cnt1,cnt2;
char ss[205][205];
int vis[205][205];
queue<node> que;
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
int X1,X2,Y1,Y2;
int OK(int nx,int ny)
{
if(nx >= 0 && nx < n && ny >= 0 && ny < m && ss[nx][ny] == ‘.‘)
return 1;
return 0;
}
int bfsPD()
{
while(!que.empty())
que.pop();
P.step = 0;
memset(vis,0,sizeof(vis));
que.push(P);
vis[P.x][P.y] = 1;
while(!que.empty())
{
node now = que.front();
que.pop();
int nx = now.x;
int ny = now.y;
int step = now.step;
for(int k=0;k<4;k++)
{
int kx = nx + dx[k];
int ky = ny + dy[k];
if(ss[kx][ky] == ‘D‘)
return step+1;
if(!OK(kx,ky) || vis[kx][ky]) //不考虑‘*‘
continue;
node tmp;
tmp.x = kx;
tmp.y = ky;
tmp.step = step + 1;
vis[kx][ky] = 1;
que.push(tmp);
}
}
return Mod;
}
int bfsP() //从P找‘*‘
{
int dis = Mod;
while(!que.empty())
que.pop();
memset(vis,0,sizeof(vis));
P.step = 0;
que.push(P);
vis[P.x][P.y] = 1;
while(!que.empty())
{
node now = que.front();
que.pop();
int nx = now.x;
int ny = now.y;
int step = now.step;
if(step >= dis)
return dis;
for(int k=0;k<4;k++)
{
int kx = nx + dx[k];
int ky = ny + dy[k];
if(ss[kx][ky] == ‘*‘)
{
X1 = kx;
Y1 = ky;
cnt1++;
dis = step + 1;
}
else if(OK(kx,ky))
{
if(!vis[kx][ky])
{
node tmp;
tmp.x = kx;
tmp.y = ky;
tmp.step = step+1;
vis[kx][ky] = 1;
que.push(tmp);
}
}
}
}
return dis;
}
int bfsD() //从D找‘*‘
{
int dis = Mod;
while(!que.empty())
que.pop();
memset(vis,0,sizeof(vis));
D.step = 0;
que.push(D);
vis[D.x][D.y] = 1;
while(!que.empty())
{
node now = que.front();
que.pop();
int nx = now.x;
int ny = now.y;
int step = now.step;
if(step >= dis)
return dis;
for(int k=0;k<4;k++)
{
int kx = nx + dx[k];
int ky = ny + dy[k];
if(ss[kx][ky] == ‘*‘)
{
X2 = kx;
Y2 = ky;
cnt2++;
dis = step + 1;
}
else if(OK(kx,ky))
{
if(!vis[kx][ky])
{
node tmp;
tmp.x = kx;
tmp.y = ky;
tmp.step = step+1;
vis[kx][ky] = 1;
que.push(tmp);
}
}
}
}
return dis;
}
int main()
{
int t,cs = 1,i,j;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&m);
int cnt = 0;
for(i=0;i<n;i++)
{
scanf("%s",ss[i]);
for(j=0;j<m;j++)
{
if(ss[i][j] == ‘P‘)
P.x = i,P.y = j;
else if(ss[i][j] == ‘D‘)
D.x = i,D.y = j;
else if(ss[i][j] == ‘*‘)
cnt++;
}
}
int ans = 0;
cnt1 = cnt2 = 0;
if(cnt <= 1) //少于等于1个传送点，就只能按普通路走过去
ans = bfsPD();
else
{
int d1,d2;
ans = bfsPD();
d1 = bfsP();
d2 = bfsD();
if(cnt1 == cnt2 && cnt1 == 1) //周围都只有一个点，通过这两个点中介
{
if(X1 == X2 && Y1 == Y2) //是同一个点,因为至少还有一个点，所以可以传回来
ans = min(ans,d1+d2+2);
else
ans = min(ans,d1+d2+1);
}
else //有不止一个点,可以用不同点传
ans = min(ans,d1+d2+1);
}
if(ans >= Mod)
printf("Case %d: impossible\n",cs++);
else
printf("Case %d: %d\n",cs++,ans);
}
return 0;
}
Written by Whatbeg
UVALive 5966 Blade and Sword -- 搜索（中等题）
时间： 2024-08-01 14:47:44