bfs转弯问题

hdu1175
题目链接；http://acm.hdu.edu.cn/showproblem.php?pid=1175；
题目大意；就是转弯只能转两次；只能走0的地方；首末位置的数字要相同；这题还要注意减枝容易超时
hdu1728
题目链接；http://acm.hdu.edu.cn/showproblem.php?pid=1728；
题目大意；给定转弯次数；问在要求内是否可以达到目的地；注意首末地址的输入方式；可以先进行处理；
NBUT；1642；
题目链接；https://ac.2333.moe/Problem/view.xhtml?id=1642；
题目大意；只看第二种情况；
要求每次都必须转弯；也就是说每个节点到下个节点的方向要不是相同的；这个有点点难理解；
题目源代码最后面摆出来;
分析；；；；；；

题型分类
暂时把bfs法转弯问题分为两类；
1；列如1175和1728的那种，限制了转弯的次数求最优解；
2；列如1642；第二次bfs时每次都必须转弯

先看第一种；这个一样的可以套模板；转弯次数一定，那么我们就每次每个点方向搜索的时候把一个方向全部搜索完；搜索到尽头；
然后在出队列；后面照旧；如果达到了转弯次数还没有搜到就不能按要求搜到了；；；
可以自己模拟一下；看这部分代码实现；

这是1175的那部分代码；还要注意减枝一下
while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.x==x2&&now.y==y2&&now.w<=2)
        {
            return 1;
        }
        if(now.w>2)//减枝；；
        {
            //q.pop();
            continue;
        }
        for(i = 0; i < 4; i++)
        {
            a=now.x+dir[i][0];
            b=now.y+dir[i][1];
            while(a>=1&&a<=n&&b>=1&&b<=m&&mp[a][b]==0)//一条方向走到底；；这里也是while；
            {
                if(mark[a][b]==0)
                {
                    next.x=a;next.y=b;next.w=now.w+1;
                    mark[a][b]=1;
                    q.push(next);
                }
                a+=dir[i][0];//在while内部；；；；
                b+=dir[i][1];
            }
        }
    }

方向问题的第一种就这样解决了；基本上可以套用这样的模板；

要在k次转弯内问是否可以达到要求；
可以每次搜索方向的时候一条方向搜完；这样可以很好的解决这个问题；
**要特别注意；**最先初始化方向次数，一般是为-1；这样才能保证；从起点开始的4个方向的节点都是0转弯；****
先全部是不用转弯的；全部搜索一遍；达到要求的入队列；
然后在在0转弯并且达到要求的点的前提下再搜索；
每次都这样；看是否可以在k次之内在要求之内达到目的地；

第一种类型的说完了；看第二种类型的吧；
每次都要转弯；我看到这个知识点的时候就有两个东西一直搞混了；
我把方向搜索过程中的不同向和节点路径的转弯搞混淆了；
其实节点路径的转弯就跟我们普通的bfs那个标记路径是否重复类似的只是这里变成三维数组；标记方向是否重复；三维数组的第三维表示这个节点的这个方向是否走过；mark1[now.x][now.y][i]==0；就是看next.x，next.y的i方向是否走过；走过那么就会标记成1了；
而搜索方向就是；now.bj!=i；就是问上一节点的方向bj是否还是i如果是那么我们则不能再走这个方向了；
注意这两个方向都是；上个节点对要走的节点的方向；因此都是now，而不是next；这个要注意；
可以看代码了；对着代码理解吧；特别看那个if判断的方向判断；；；

就是1642的部分代码
now.x=r1;now.y=l1;now.num=mp[r1][l1];now.bj=-1;
    q.push(now);
    while(!q.empty())
    {
        now = q.top();
        q.pop();
        for(i = 0; i < 4; i++)
        {    
            next.x=now.x+dir[i][0];
            next.y=now.y+dir[i][1];
            if(next.x>=0&&next.x<n&&next.y>=0&&next.y<m&&mp[next.x][next.y]!=-1&&now.bj!=i&&mark1[now.x][now.y][i]==0)
            {
                next.bj = i;
                mark1[now.x][now.y][i]=1;
                next.num=now.num+mp[next.x][next.y];
                if(next.x==r2&&next.y==l2)
                {
                    printf("%d\n",next.num);
                    return 1;
                }
                q.push(next);
            }
        }
    }

暂时关于转弯的bfs就到这了；

/*
“连连看”相信很多人都玩过。没玩过也没关系，下面我给大家介绍一下游戏规则：
在一个棋盘中，放了很多的棋子。如果某两个相同的棋子，可以通过一条线连起来（这条线不能经过其它棋子），
而且线的转折次数不超过两次，那么这两个棋子就可以在棋盘上消去。不好意思，由于我以前没有玩过连连看，
咨询了同学的意见，连线不能从外面绕过去的，但事实上这是错的。现在已经酿成大祸，就
只能将错就错了，连线不能从外围绕过。
玩家鼠标先后点击两块棋子，试图将他们消去，然后游戏的后台判断这两个方格能不能消去。现在你的任务就是写这个后台程序。
Input
输入数据有多组。每组数据的第一行有两个正整数n,m(0<n<=1000,0<m<1000)，
分别表示棋盘的行数与列数。在接下来的n行中，每行有m个非负整数描述棋盘的方格分布。
0表示这个位置没有棋子，正整数表示棋子的类型。接下来的一行是一个正整数q(0<q<50)，表示下面有q次询问。
在接下来的q行里，每行有四个正整数x1,y1,x2,y2,表示询问第x1行y1列的棋子与第x2行y2列的棋子能不能消去。
n=0,m=0时，输入结束。
注意：询问之间无先后关系，都是针对当前状态的！
*/ 
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<queue>
#include<algorithm>
#include<stack>
#include<set>
#include<string.h>
using namespace std;
//依据是转弯问题的bfs；套路依旧；一个方向走到底；不过这个题目容易超时所以要剪纸加限定条件
//超时了几次，wa了几次；
//没有减枝，没有考虑是同一点的情况；bfs时终点没有先处理一下；；；
int mp[1005][1005];
int mark[1005][1005];
int n, m,x1,x2,y11,y2;
struct node
{
    int x, y,w;
};
int dir[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
int bfs()
{
    mp[x2][y2]=0;//处理终点；；因为下面要搜到终点，因此要处理一下；；；
    int i, a,b;
    memset(mark,0,sizeof(mark));
    queue<node> q;
    node now,next;
    now.x=x1;now.y=y11;now.w=-1;//依据处理为-1；
    mark[x1][y11]=1;
    q.push(now);
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.x==x2&&now.y==y2&&now.w<=2)
        {
            return 1;
        }
        if(now.w>2)//减枝；；
        {
            //q.pop();
            continue;
        }
        for(i = 0; i < 4; i++)
        {
            a=now.x+dir[i][0];
            b=now.y+dir[i][1];
            while(a>=1&&a<=n&&b>=1&&b<=m&&mp[a][b]==0)//一条方向走到底；；
            {
                if(mark[a][b]==0)
                {
                    next.x=a;next.y=b;next.w=now.w+1;
                    mark[a][b]=1;
                    q.push(next);
                }
                a+=dir[i][0];
                b+=dir[i][1];
            }
        }
    }
    return 0;
}
int main()
{
    int i, j, tt,p;
    while(~scanf("%d %d",&n, &m))
    {
        if(n==0&&m==0)
            break;
        for(i = 1; i <= n; i++)
        {
            for(j = 1; j <= m; j++)
                scanf("%d",&mp[i][j]);
        }
        scanf("%d",&tt);
        while(tt--)
        {
            scanf("%d %d %d %d",&x1,&y11,&x2,&y2);
            //mp[x2][y2]=0;
            if((mp[x1][y11]!=mp[x2][y2])||(mp[x1][y11]==0))//减支处理；；；
            {
                printf("NO\n");
            }
            else if(x1==x2&&y11==y2)
                printf("NO\n");
            else
            {
                p = bfs();
                mp[x2][y2]=mp[x1][y11];
                if(p==1)
                {
                    printf("YES\n");
                }
                else
                    printf("NO\n");
            }
        }
    }

    return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<iostream>
#include<queue>
#include<algorithm>
#include<stack>
#include<set>
#include<string.h>
using namespace std;
//hdu1728;bfs限制条件为转弯次数限制不大于k；因此bfs搜索时要有个方向走到底；意思就是说队列不是相邻距离存放的而是一个方向的存放；
//还有就是要注意输入；输入字符串的时候要注意；（下面以注释）
//注意他参数的输入；先列再行；所以要记得处理一下；
//对于队列压入的问题；将这个元素((结构体)压入队列；则这个元素原有的值也不存在了；；；(这个bug搞了好久；）
int s1,s2,e1,e2,k,n,m;
char mp[105][105];
int mark[105][105];
struct node
{
    int x, y,w;
};
int dir[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
void bfs()
{
    int i;
    queue<node> q;
    memset(mark,0,sizeof(mark));
    node now,next;
    now.x=s1;now.y=s2;now.w=-1;
    mark[now.x][now.y] = 1;
    q.push(now);
    while(!q.empty())
    {
        now = q.front();
        q.pop();
        if(now.x==e1&&now.y==e2&&now.w<=k)
        {
            printf("yes\n");
            return ;
        }
        for(i = 0; i < 4; i++)
        {
            int a=now.x+dir[i][0];
            int b=now.y+dir[i][1];
            while(a>=0&&a<n&&b>=0&&b<m&&mp[a][b]=='.')
            {
                if(mark[a][b]==0)
                {
                    next.x=a;next.y=b;
                    next.w = now.w+1;//这个要放里面；意思就是每次压入队列后next原有的值也没有了；
                    //printf("%d %d\n",a,b);
                    mark[a][b]=1;
                    q.push(next);
                }
                a=a+dir[i][0];
                b=b+dir[i][1];
            }
        }
    }
    printf("no\n");
    return ;
}
int main()
{
    int tt,i,j;
    scanf("%d",&tt);
    while(tt--)
    {
        scanf("%d %d",&n, &m);
        for(i = 0; i < n; i++)
        {
            scanf("%s",mp[i]);//尽量别用i=1还用%s输入；这种情况j还是从0开始
        }
//        for(i = 0; i < n; i++)
//       {
//          for(j = 0; j < m; j++)
//                printf("%c",mp[i][j]);
//            printf("\n");
//        }
        scanf("%d %d %d %d %d",&k,&s2,&s1,&e2,&e1);
        s2--;s1--;e1--;e2--;
        bfs();
    }

    return 0;
}

#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#include<iostream>
#include <bits/stl_queue.h>
using namespace std;
int mp[505][505];
int n, m, r1,r2,l1,l2;
struct node
{
    int x, y, num,bj;
    friend bool operator<(node a, node b) {return a.num>b.num;}
};
int dir[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
int mark1[505][505][4];
bool bfs()//第二种；；； 
{
    int i;
    priority_queue<node> q;
    node now,next;
    memset(mark1,0,sizeof(mark1));
    now.x=r1;now.y=l1;now.num=mp[r1][l1];now.bj=-1;
    q.push(now);
    while(!q.empty())
    {
        now = q.top();
        q.pop();
        for(i = 0; i < 4; i++)
        {    
            next.x=now.x+dir[i][0];
            next.y=now.y+dir[i][1];

            if(next.x>=0&&next.x<n&&next.y>=0&&next.y<m&&mp[next.x][next.y]!=-1&&now.bj!=i&&mark1[now.x][now.y][i]==0)
            {
                next.bj = i;
                mark1[now.x][now.y][i]=1;
                next.num=now.num+mp[next.x][next.y];
                if(next.x==r2&&next.y==l2)
                {
                    printf("%d\n",next.num);
                    return 1;
                }
                q.push(next);
            }
        }
    }
    return 0;
}

bool bfs2()
{
    int i;
    priority_queue<node> q;
    node now,next;
    int mark[505][505]={0};
    now.x=r1;now.y=l1;now.num=mp[r1][l1];
    mark[r1][l1]=1;
    q.push(now);
    while(!q.empty())
    {
        now = q.top();
        q.pop();
        for(i = 0; i < 4; i++)
        {    
            next.x=now.x+dir[i][0];
            next.y=now.y+dir[i][1];
            if(next.x>=0&&next.x<n&&next.y>=0&&next.y<m&&mp[next.x][next.y]!=-1&&mark[next.x][next.y]!=1)
            {
                mark[next.x][next.y]=1;
                next.num=now.num+mp[next.x][next.y];
                if(next.x==r2&&next.y==l2)
                {
                    printf("%d ",next.num);
                    return 1;
                }
                q.push(next);
            }
        }
    }
    return 0;
} 

int main()
{
    int num,i, j, l,len,kk=1;
    char ch[5000];
    while(~scanf("%d %d %d %d %d %d",&n,&m,&r1,&l1,&r2,&l2))
    {
        r1=r1-1;r2=r2-1;
        l1=l1-1;l2=l2-1;
        getchar();
        for(i = 0; i < n;i++)
        {
            l=0;
            gets(ch);
            len = strlen(ch);
            for(j = 0; j < len; j++)
            {
                if(ch[j]=='*')
                {
                    mp[i][l]=-1;
                    l++;
                }
                else if(ch[j]>='0'&&ch[j]<='9')
                {
                    num = ch[j]-'0';
                    if(ch[j+1]>='0'&&ch[j+1]<='9')
                    {
                        num = num*10+(ch[j+1]-'0');
                        j++;
                        if(ch[j+1]>='0'&&ch[j+1]<='9')
                        {
                            num = num*10+(ch[j+1]-'0');
                            j++;
                        }
                    }
                    mp[i][l]=num;
                    l++;
                }
            }
        }
        printf("Case %d: ",kk++);
        if(bfs2()==0)
        {
            printf("-1 ");
        }
        int aa=bfs();
        if(aa==0)
        {
            printf("-1\n");
        }
        //printf("iwdffuf\n");

    }

    return 0 ;
}