栈与搜索的应用

文章目录：

1.栈

2.搜索

一、有关栈与搜索的相关概念
       1.栈：栈(stack)是限定仅在表尾进行插入或者删除的线性表，表尾被成为栈顶，表头被称为栈底。对于栈来说，对他只能在栈顶进行操作。所以，栈又被称为先进后出的线性表。栈可分为空栈，栈满，栈溢的情况。

在创立栈（stack）时要注意存储空间是否盈余，在计算之后记得要释放空间。

                                

 2.搜索：搜索算法是利用计算机的高性能来有目的的穷举一个问题解空间的部分或所有的可能情况，从而求出问题的解的一种方法。现阶段一般有枚举算法、深度优先搜索、广度优先搜索、A*算法、回溯算法、蒙特卡洛树搜索、散列函数等算法。

下面介绍两种：dfs（深度搜索）与bfs(广度搜索）

DFS

如算法名称那样，深度优先搜索所遵循的搜索策略是尽可能“深”地搜索。它的基本思想是：为了求得问题的解，先选择某一种可能情况向前（子结点）探索，在探索过程中，一旦发现原来的选择不符合要求，就回溯至父亲结点重新选择另一结点，继续向前探索，如此反复进行，直至求得最优解。深度优先搜索的实现方式可以采用递归或者栈来实现。

在这种搜索方式里要尽可能的减少探索的节点数，以及回溯的相关设计

相较于bfs而言它消耗时间节省空间，适合递归类的问题

BFS

类似树的按层遍历，其过程为：首先访问初始点Vi，并将其标记为已访问过，接着访问Vi的所有未被访问过可到达的邻接点Vi1、Vi2……Vit，并均标记为已访问过，然后再按照Vi1、Vi2……Vit的次序，访问每一个顶点的所有未被访问过的邻接点，并均标记为已访问过，依此类推，直到图中所有和初始点Vi有路径相通的顶点都被访问过为止。

在这种搜索方式里需要记录走过的点

相较于dfs而言它消耗空间节省时间，适合最短路径等最少类问题，有queue（队列）的一定基础

会更好理解

 如果使用深度搜索，则上图的探索顺序为：1→2→5→2（回溯）→6→1→3→7→3（回溯）→1→4

如果使用广度搜索，则上图的探索顺序为：从1开始存2、3、4；从2开始存5、6；...直到所有点存完，判断后找到条件点

二.相关题目

1.

题面：现在有n个元素分别是1,2,3,...,n，我们想知道通过一个栈，在n次push/pop后，出栈序列可能是什么样的。例如n是5，那么入栈次序就是1,2,3,4,5，如果我们希望出栈次序同样是1,2,3,4,5，那只要每push一个数，就立即pop一个数。如果我们希望出栈次序是3,2,4,5,1，那么我们先让1,2,3入栈，然后pop出来3和2，接着4入栈后马上pop，再就是5入栈后马上pop，最后再把栈里的1pop出。再例如，如果我们希望出栈次序是5,4,1,2,3，这是办不到的，如果要让5最先出栈，那么出栈次序只可能是5,4,3,2,1

input：

输入由多块输入构成，每块的第一行是n，（1≤n≤1000），接着是多组测试数据，每组一行，每行由n个1到n的整数组成，直到某一行第一个数是0表示此输入块结束，然后是下一块数据。

当某一块的第一行的n是0的时候结束所有输入

Output

对每组数据，只要输出Yes或No，Yes表示能产生那样的出栈序列，No表示不能。 输入块与输入块之间要多输出一个空行分隔。注意对于最后一个n为0的输入块不要多输出空行。

Sample Input

5
1 2 3 4 5
5 4 1 2 3
0
6
6 5 4 3 2 1
0
0

Sample Output

Yes
No

Yes

———————————————————————————————————————————

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100000
int a[MAXSIZE];
int main()
{
    int i,j,n,s;//s为判断是否满足条件的标志
    int key;
    scanf("%d",&n);
    while(n!=0)
    {
        s=0;

        for(i=0; i<n; i++)
        {
            scanf("%d", &a[i]);
            if(a[0]==0)
            {
                printf("\n");
                scanf("%d",&n);
                break;
            }
        }
        if(a[0]!=0)
        {
            for(i=0; i<n; i++)
            {
                key = a[i];
                for(j=i+1; j<n; j++)
                {
                    if( a[i]>a[j] )
                    {
                        if(key < a[j])//判断下标小的数是否呈递减序列
                        {
                            s=1;
                        }
                        else
                        {
                            key = a[j];
                        }
                    }
                }
            }
            if(s==1)//判断条件
            {
                printf("No\n");
            }
            if(s==0)
            {
                printf("Yes\n");
            }

        }


    }
}

2.

题面：

定义一个二维数组：

int maze[5][5] = {

	0, 1, 0, 0, 0,

	0, 1, 0, 1, 0,

	0, 0, 0, 0, 0,

	0, 1, 1, 1, 0,

	0, 0, 0, 1, 0,

};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

Input

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

Output

左上角到右下角的最短路径，格式如样例所示。

Sample Input

0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

Sample Output

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

———————————————————————————————————————————

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

int map[10][10];//整个地图的范围
int vis[10][10];//需要遍历的数组
int dir[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};

typedef struct {
	int x,y;//设置棋子的坐标

	int x1,y1;
}node;

queue<node> q;

node where[10][10];

void print(node head)
{

	while( head.x1 != -1  && head.y1 != -1 )
	{
		print(where[head.x1][head.y1]);
		printf("(%d, %d)\n",head.x, head.y);

		return;
	}
	printf("(0, 0)\n");
}



void bfs(int x,int y)
{
    node one;
    one.x1=one.y1=-1;
    one.x=x;
    one.y=y;
    vis[x][y] = 1;
    //where[x][y].x1=where[x][y].y1=-1;
    //where[x][y].x=x;
    //where[x][y].y=y;


    where[x][y]=one;

	q.push(one);
	while( !q.empty() )
	{
	    node zhong;
	    zhong=q.front();
	    q.pop();

		if(zhong.x == 4 && zhong.y == 4)
		{
			print(zhong);
			return;
		}
		for(int i = 0;i < 4;i++)
		{
		    node now;
			now.x = zhong.x + dir[i][0];
			now.y = zhong.y + dir[i][1];
			now.x1 = zhong.x;
			now.y1 = zhong.y;//棋子探索遍历数组时的方向判定

			if(now.x >= 0 && now.x <= 4 && now.y >= 0 && now.y <= 4)/*避免特殊情况（出界，碰壁等）*/
			{
				if(!vis[now.x][now.y] && !map[now.x][now.y])
				{

					vis[now.x][now.y] = 1;
					where[now.x][now.y]=now;
					q.push(now);

				}
			}
		}

	}
}

int main()
{
	int i,j;
	for(i = 0;i < 5;i++)
	{
		for(j = 0;j < 5;j++)
		{
			scanf("%d",&map[i][j]);//存储地图的情况
		}
	}
	memset(vis,0,sizeof(vis));
	bfs(0,0);
	return 0;
}