22.01.08总结

守护最好的>>启东<<

已于 2022-01-18 22:55:17 修改

阅读量577

点赞数 1

文章标签： c++ 算法

于 2022-01-08 22:57:11 首次发布

本文链接：https://blog.youkuaiyun.com/Liu2003abc/article/details/122387640

版权

dfs

必要芝士

queue
头文件 #include<queue>
队列操作
r.push(start)  入队
r.front()     首元素
r.pop()       出队
r.empty()     值为非0  表示空   值为0表示非空

就这么多吧

貌似深度优先搜索和广度优先搜索与先序，层序遍历有联系？

这里先不管了

思路：

定义一个结构体类型来保存点集的信息

struct point
{
    int x;
    int y;
    int step;

};

定义一个队列动态保存拓展点信息

queue<point>  r;

将该点拓展点入队，该点出队

终止条件为队列为空

判断能走的情况那一行随题目改变

while(!r.empty())//为空队判断
    {
        //取队首的x ， y
        int x =r.front().x;
        int y =r.front().y;
        if(x==p &&y==q)
        {
            f=1;
            cout<<r.front().step<<endl;
            break;
        }
        for( k=0; k<4; k++)
        {
            //拓展点坐标
            int tx,ty;
            tx=x+dx[k];
            ty=y+dy[k];
            if(a[tx][ty]=='0' && v[tx][ty]==0 &&tx>=1&&tx<=n&&ty>=0&&ty<=m)
                //a  迷宫中能走   标记数组表示未访问
            {
                //入队
                //队列是结构体类型
                //要存起来
                point temp;
                temp.x=tx;
                temp.y=ty;
                temp.step=r.front().step+1;
                //将数据入队
                r.push(temp);
                //标记访问信息
                v[tx][ty]=1;
            }
            //出队出早了

        }
        //将队首出队
        r.pop();
    }

然后就是找路径了

但是这有一个致命bug

在找归路遵循方向优先级（上右左下）的时候

因为在尝试的时候这条路的时候走过了，但是走不通，也给上了标记

或许在回溯的时候要是能把路径标记也复原应该能解决

路径回溯代码

//这个顺序是有问题的，但是如果路径单一，换一下顺序算法是可以的
while(p!=startx || q!=starty)
    {
        if(v[p][q-1]==1)//左边过来
        {
            path+="R";
            v[p][q-1]=0;
            q--;

            cout<<"左"<<endl;
            continue;
        }
        if(v[p-1][q]==1)//上边过来
        {
            path+="D";
            v[p-1][q]=0;
            p--;

            cout<<"上"<<endl;

            continue;
        }
        if(v[p][q+1]==1)//右边过来
        {
            path+="L";
            v[p][q+1]=0;
            q++;

            cout<<"右"<<endl;
            continue;
        }
        if(v[p+1][q]==1)//下边过来
        {
            path+="U";
            v[p+1][q]=0;
            p++;

            cout<<"下"<<endl;
            continue;
        }
        //printf("test\n");
       printf("当前坐标(%d , %d)\n",p,q);

    }

特殊测试样例优先级上右左下

但是如果这样可想而知会走到（4,8）

所以还要改进（裂开）

全代码

#include<bits/stdc++.h>
//偷懒了
using namespace std;
char a[100][100];
int v[100][100]= {0};

string path;
//a  迷宫数组
//v  访问数组

//右  下  左  上   x ,y对应的偏移量

//int dx[4]= {0, 1,  0,-1};
//int dy[4]= {1, 0, -1, 0};

//下 左 右 上  就是字典序  DLRU
int dx[4]= {1,  0,  0, -1};
int dy[4]= {0, -1,  1,  0};

struct point
{
    int x;
    int y;
    int step;

};

queue<point>  r;
int main()
{
    /*  debug logs:
     *  1.方向数组由  从右开始顺时针 改为字典序搜索  DLRU
     *  2.  79行忘记了 越界判断  造成了输出路径错误
     *  3.检索路径时忘记将来的路赋值为0  造成死循环
     *  4.赋值为0  和  p、q  自增减顺序反了  逻辑错误
     *  5.找路径的算法有问题，需要重构
     *  6.找路径的逻辑本身也有问题，优先级不对，但没有去改了，算法都不对
     */
    int n,m;//数组长宽
    int startx,starty;//起点
    int p,q;//终点
    int f=0;//方案有无  标记
    //cout<<"请输入数组规模 行 / 列"<<endl;
    cin>>n>>m;
    int i,j,k;
    //cout<<"请输入"<<endl;
    for(i=1; i<=n; i++)
        for(j=1; j<=m; j++)
            cin>>a[i][j];
    //cout<<"输入起始地点"<<endl;
    //cin>>  startx>>starty;
    //cout<<"请输入终点"<<endl;
    // cin>> p>>q;
    startx=1;
    starty=1;
    p=n;
    q=m;

    //广搜
    point start;
    start.x=startx;
    start.y=starty;
    start.step=0;

    //起点入队
    r.push(start);
    v[startx][starty]=1;//标记起点

    while(!r.empty())//为空队判断
    {
        //取队首的x ， y
        int x =r.front().x;
        int y =r.front().y;
        if(x==p &&y==q)
        {
            f=1;
            cout<<r.front().step<<endl;
            break;
        }
        for( k=0; k<4; k++)
        {
            //拓展点坐标
            int tx,ty;
            tx=x+dx[k];
            ty=y+dy[k];
            if(a[tx][ty]=='0' && v[tx][ty]==0 &&tx>=1&&tx<=n&&ty>=0&&ty<=m)
                //a  迷宫中能走   标记数组表示未访问
            {
                //入队
                //队列是结构体类型
                //要存起来
                point temp;
                temp.x=tx;
                temp.y=ty;
                temp.step=r.front().step+1;
                //将数据入队
                r.push(temp);
                //标记访问信息
                v[tx][ty]=1;
            }
            //出队出早了

        }
        //将队首出队
        r.pop();
    }
    //if(!f)
      //  cout<<"no answer!"<<endl;
    //cout<<"道路状况"<<endl;



    for(i=1; i<=n; i++)
    {
        for(j=1; j<=m; j++)
        {
            cout<<v[i][j]<< " ";
        }
        cout<<endl;
    }

    //system("pause");
    cout<<"起始位置"<<startx<<starty<<endl;
    cout<<"终点位置"<<p<<q<<endl;

    cout<<"开始溯源"<<endl;//p,q;
    //p   行   搞错了  淦
    while(p!=startx || q!=starty)
    {
        if(v[p][q-1]==1)//左边过来
        {
            path+="R";
            v[p][q-1]=0;
            q--;

            cout<<"左"<<endl;
            continue;
        }
        if(v[p-1][q]==1)//上边过来
        {
            path+="D";
            v[p-1][q]=0;
            p--;

            cout<<"上"<<endl;

            continue;
        }
        if(v[p][q+1]==1)//右边过来
        {
            path+="L";
            v[p][q+1]=0;
            q++;

            cout<<"右"<<endl;
            continue;
        }
        if(v[p+1][q]==1)//下边过来
        {
            path+="U";
            v[p+1][q]=0;
            p++;

            cout<<"下"<<endl;
            continue;
        }
        //printf("test\n");
       printf("当前坐标(%d , %d)\n",p,q);

    }
    //cout<<path<<endl;
    int len=path.length();
    //倒置输出
    for(i=len-1;i>=0;i--)
    {
        cout<<path[i];
    }



    /*
    cout<<"道路状况"<<endl;
    for(i=1; i<=n; i++)
    {
        for(j=1; j<=m; j++)
        {
            cout<<v[i][j]<< " ";
        }
        cout<<endl;
    }
    *///DLRU
    //优先级  上右左下
    //能上就上
/*
测试数据：
8 8
00000101
01010011
10101001
11110000
01101001
00011000
00101000
01111100
*/

    return 0;
}

今天就这样吧