暑假训练第10天，简单的搜索，POJ 1426，POJ 3984。

题目 POJ 1426

输入一个小于n的数之后给一个输出一个十进制只有10组成并且能整除n。

我用的BFS 从从1开始，

然后除以n，

然后遍历10，11，实质就是1*10的两个

再遍历（101，100），（110，111），

。。。。。。。

每次遍历的数都是2，这就是个2叉树，

下面是代码

#include<iostream>
#include<stdio.h>
#include<queue>
using namespace std;
void bfs(int n)
{
    queue<long long>q;
    q.push(1);
    while(!q.empty())
    {
        int i;
        long long x;
        x=q.front();
        q.pop();
        if(x%n==0)
        {
            printf("%lld\n",x);
            return ;
        }
        q.push(x*10);
        q.push(x*10+1);
    }
}
int main()
{
    int n;
    while(scanf("%d",&n)&&n)
    {
        bfs(n);
    }
    return 0;
}

 

终于终于我弄懂了一个迷宫输出，崩溃了2天了，POJ 3984

好不容易会了一点点，一点点！！！BFS，然后他竟然让我输出路径，我emmmmm。。。。

题目让从左上角走到右下角，然后输出路径，一天前我是实现的，需要走几步

#include<queue>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
char map[7][7];
int vis[7][7];
int to[4][2]={{1,0},{-1,0},{0,1},{0,-1}}; //下上，右左 
struct Node{
	int x,y;
	int step;
};
queue<Node> q;
int bfs(){
	int i;
	Node a,next;
	
	a.x=0;
	a.y=0;
	a.step=0;
	vis[0][0]=1;
	q.push(a);
	while(!q.empty()){
		a=q.front();
		q.pop();
		if(a.x==4&&a.y==4)
		return a.step;
		for(i=0;i<4;i++){
			next.x=a.x+to[i][0];
			next.y=a.y+to[i][1];
			if(next.x<0||next.y<0||next.x>5||next.y>5||next.x=='1'||next.y=='1'||vis[next.x][next.y]==1)
			continue;
			
			vis[next.x][next.y]=1;
			next.step=a.step+1;
			q.push(next);
		}
	}
	return 0; 
}
int main(){
	memset(map,0,sizeof(map));
	memset(vis,0,sizeof(vis));
	for(int i=0;i<5;i++)
	for(int j=0;j<5;j++)
	cin>>map[i][j];
	int ans;
	ans=bfs();
	if(ans)
	cout<<ans<<endl;
	else
	cout<<"NO Way"<<endl;
		
	return 0;
}

 

之后我终于找到了一个大佬的代码，下面是我对他的代码的理解

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
 
int Map[6][6],vis[6][6],pre[110];
//pre[]记录每个状态的前一个状态
struct Cam
{
    int x,y;
}List[110];
 
int Dire[4][2] = {-1,0,1,0,0,-1,0,1};   //上下左右四个方向
 
int Go(int x,int y) //判断是否可走
{
    if(x >= 0 && x < 5 && y >= 0 && y < 5 && Map[x][y] == 0)
        return 1;
    return 0;
}
 
void Print(int x)   //留下宝藏路线
{
    int t;
    t = pre[x];
    if(t == 0)
    {
        printf("(0, 0)\n");
        printf("(%d, %d)\n",List[x].x,List[x].y);
        return ;
    }
    else//递归输出大法，意思就是说你找到宝藏也是不容易的，进入递归然后一层进（进入上一个位置），在一层一层进，（直到t==0开始输入），（从（0，0）开始返回）再一层一层输出
        Print(t);
    printf("(%d, %d)\n",List[x].x,List[x].y);
}
 
void BFS()
{
    memset(vis,0,sizeof(vis));
    int Head = 0,Tail = 1;
    List[0].x = 0;
    List[0].y = 0;
    pre[0] = -1;//这个pre设置的非常巧妙，直接解决了如何准确找上一步的操作（在下佩服，希望大家下去好好理解下怎么实现，为什么需要这个pre，很重要，是这个题的难点）
    while(Head < Tail)  
    {
        int x = List[Head].x;//更新目前的位置
        int y = List[Head].y;
        if(x == 4 && y == 4)
        {
            Print(Head);//我找到了海贼王留下的宝藏
            return ;
        }
        for(int i = 0; i < 4; ++i)
        {
            int xx = x + Dire[i][0];//遍历4个位置
            int yy = y + Dire[i][1];
            if( !vis[xx][yy] && Go(xx,yy) )//能走并且没有走过
            {
                vis[xx][yy] = 1;//标记
                List[Tail].x = xx;//把这个点给标记下存下来，为了输出路径
                List[Tail].y = yy;
                pre[Tail] = Head;//标记前一个位置，就是你现在位置是Tail，上一个位置是Head,与你标记的路径是匹配输出的
                Tail++;为了更新pre
            }
        }
        Head++;
    }
    return ;
}
 
int main()
{
    for(int i = 0; i < 5; ++i)
        for(int j = 0; j < 5; ++j)
            scanf("%d",&Map[i][j]);//建造迷宫
    BFS();//开始搜索宝藏哈哈哈
    return 0;
}

 

好吧下面我需要把自己的改进一下，变成自己的灵活运用 come on！！！

 

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

int map[7][7];
int vis[7][7];
int to[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
struct none{
	int x;
	int y;
	int pre;
}List[100];

int go(int x,int y){
	if(x>=0&&y>=0&&x<5&&y<5&&map[x][y]==0)
	return 1;
	
	return 0;
}

int couts(int i){
	if(List[i].pre!=-1)
	{
		couts(List[i].pre);
		cout<<"("<<List[i].x<<", "<<List[i].y<<")"<<endl;
	}
}
void bfs(){

	int rear=1,front=0;
	List[0].x=0;
	List[0].y=0;
	List[0].pre=-1;
	vis[0][0]=1;

	while(front<rear)
	{
		for(int i=0;i<4;i++)
		{
			int xx=List[front].x+to[i][0];
			int yy=List[front].y+to[i][1];
			if(vis[xx][yy]==0&&go(xx,yy)!=0)
			{
				vis[xx][yy]=1;
				List[rear].x=xx;
				List[rear].y=yy;
				List[rear].pre=front;
				rear++;
			}
			if(xx==4&&yy==4)
			{
				couts(front);
			}
		}
		front++;
	}
}
int main (){
	for(int i=0;i<5;i++)
	for(int j=0;j<5;j++)
	cin>>map[i][j];
	memset(vis,0,sizeof(vis));
	cout<<"(0, 0)"<<endl;
	bfs();
	cout<<"(4, 4)"<<endl;
	return 0;
}