【bfs】【分支限界函数】【蓝桥杯】

已于 2023-08-28 11:10:02 修改
阅读量216 收藏
点赞数
分类专栏： 算法 文章标签： bfs 队列 java
于 2020-10-02 16:40:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45682738/article/details/108902808
版权

【【【可能有代码是借鉴大神的，如果有问题会删掉并道歉！】】】

题目

1.青蛙跳杯子

蓝桥杯 试题 历届试题 青蛙跳杯子

题目：http://lx.lanqiao.cn/problem.page?gpid=T448

package 练习;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;

public class _44青蛙跳杯子_ {

	static String inStr,targetStr;
	static Map<String,Boolean> mapp=new HashMap<String,Boolean>();
	
	public static void main(String[] args) throws IOException {
        BufferedReader bReader = new BufferedReader(new InputStreamReader(System.in));
        inStr = bReader.readLine();
        targetStr = bReader.readLine();
        bReader.close();
        System.out.println(bfs());
		
	}
    public static int bfs()
    {
    	//新建队列+新建头结点+头结点入队列+头结点标记hashmap
    	Queue<Node> queue =new LinkedList<Node>();
    	Node now = new Node(inStr,0);
    	queue.add(now);
    	mapp.put(now.string,true);
    	
    	//当队列非空
    	while(queue.size()!=0)
    	{
    		//头结点出队列
    		now=queue.poll();
    		//判断此时的结点是否满足最终的结果
    		if(isOk(now.string))
    		{
    			return now.step;
    		}
    		//当前头结点的一些信息
    		char s[]=now.string.toCharArray();
    		int stepp=now.step;
    		
    		//以now为头结点的各种情况（各个青蛙都跳）
    		for(int i=0;i<s.length;i++)
    		{
    			//杯子跳过
    			if(s[i]=='*')
    				continue;
    			//当前青蛙可跳的方向
    			for(int j=-3;j<=3;j++)
    			{
    				if(i+j<0||i+j>=s.length||j==0||s[i+j]!='*')
    					continue;
    				s=swap(s,i,i+j);
    				
    				Node node= new Node (String.valueOf(s),stepp+1); 
    				
    				if(!mapp.containsKey(node.string))
    				{
    					queue.add(node);
    					mapp.put(node.string,true);
    				}
    				//当前青蛙跳完要回归原样，下一个青蛙跳
    				s=swap(s,i,i+j);
    			}
    		}
    	}
		return -1;
    }
    
    public static char[] swap(char [] s,int i,int j)
    {
    	char temp;
    	temp=s[i];
    	s[i]=s[j];
    	s[j]=temp;
    	return s;
    }
    
    public static boolean isOk(String s)
    {
        if (targetStr.equalsIgnoreCase(s)) {
            return true;
        } 
        else {
            return false;
        }
    }
}

class Node
{
	String string;
	int step;
	public Node(String string,int step)
	{
		this.string=string;
		this.step=step;
	}
}

1.Map接口,HashMap实现,<k,v>
新建： Map<String,Boolean> mapp=new HashMap<String,Boolean>();
添加： mapp.put(now.string,true);
查询： mapp.containsKey(node.string)

2.队列， queue接口，LinkedList实现
新建： Queue<Node> queue =new LinkedList<Node>();
进队列： queue.add(now);
出队列： now=queue.poll();

3.字符数组
字符串变数组：char s[]=now.string.toCharArray();
数组变字符串：String str=String.valueOf(s)

2.九宫重排

题目：http://lx.lanqiao.cn/problem.page?gpid=T42

package 练习;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;

public class _19九宫重排_ {
	
	static String start,end,now;
	static Map<String,Integer> mapp=new HashMap<String,Integer>();
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		start = scan.next();
		end = scan.next();
		System.out.print(bfs());
	}
	
	public static int bfs()
	{
		//新建队列+头结点入队列+map记录
		Queue <String> queue=new LinkedList<String>();
		queue.add(start);
		mapp.put(start, 0);
		
		while(queue.size()!=0)
		{
			//头结点出队列
			now=queue.poll();
			//判断终止
			if (now.equals(end))
			{
				return mapp.get(now);
			}
			
			//处理头结点
			char s[]=now.toCharArray();
			
			int temp=0;
			int[] d = {-3,3,-1,1};//方向数组，分别表示上下左右
			for(int k=0;k<s.length;k++)
			{
				if(s[k]=='.')
				{
					temp=k;
					break;
				}
			}
			for(int i=0;i<4;i++)
			{
				//约束条件
				if(temp+d[i]<0||temp+d[i]>8||((temp+d[i])%3!=temp%3&&(temp+d[i])/3!=temp/3))
					continue;
				s=swap(s,temp,temp+d[i]);
				
				//判断新结点并入队列
				if(!mapp.containsKey(String.valueOf(s)))
				{
					mapp.put(String.valueOf(s), mapp.get(now)+1);
					queue.add(String.valueOf(s));
				}
				
				//恢复原字符串
				s=swap(s,temp,temp+d[i]);
			}
			
		}
		return 0;
	}
	public static char [] swap(char[] s,int i,int j)
	{
		char tempp;
		tempp=s[i];
		s[i]=s[j];
		s[j]=tempp;
		return s;
	}
}


1.这个bfs框架和上面那个基本相同
2.不同之处：用HashMap的<k,v>里的value来记录步数，去掉了Node类
    取HashMap中的value值： mapp.get(now)
     (其中now为key值)
3.bfs能搜到所有结果，且第一次输出的结果为最小值（？）

3.学霸的迷宫

题目：http://lx.lanqiao.cn/problem.page?gpid=T291

package 算法提高;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

public class _147学霸的迷宫 
{   static int a[][];
    //static int b[][]={{-1,0},{1,0},{0,-1},{0,1}};//这个顺序是不能随便调换的，是为了满足字典顺序的需求DLRU
    static int b[][]={{1,0},{0,-1},{0,1},{-1,0}};
    public static void main(String[]agrs)
    {       
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        a=new int[n][m];
        for(int i=0;i<n;i++)
        {
            String s=sc.next();
            for(int j=0;j<m;j++)
                a[i][j]=s.charAt(j)-'0';
        }//输入细节就不多讲了
        Queue<P> queue=new LinkedList<>();        //创建队列
        queue.add(new P(0,0,null,'n'));           //把第一个加入队列     加入起点，P这个类的信息见最下面
        a[0][0]=1;//置1说明不可访问；
        boolean sign=true;
        P tail=null;//指向终点
        while(!queue.isEmpty()&&sign)             //while
        {
            P p=queue.poll();//出一个头节点              //第一个出队列
            int x=p.x;
            int y=p.y;                            //对刚才出队列的点进行处理
            for(int i=0;i<4;i++)                  //for循环
            {
                int x1=x+b[i][0];                   
                int y1=y+b[i][1];
                if(x1<0||x1>=n||y1<0||y1>=m||a[x1][y1]==1)//排除不合理 continue
                    continue;
                a[x1][y1]=1;//这个要注意
                queue.add(new P(x1,y1,p,get(i)));          //把新点加入队列
                //x1，y1即为这点的位置信息，p即指向上一个节点，get(i)即为由p到当前点的方向
                if(x1==n-1&&y1==m-1)               //如果找到终点，则终止搜索
                {
                    tail=new P(x1,y1,p,get(i));//tail的作用
                    sign=false;//终止标志
                    break;//退出子循环
                }

            }
        }
        queue=null;
        Stack<P> stack=new Stack<>();
        P p=tail;
        while(p.last!=null)//从tail开始一个一个开始入栈；如果p.last为null则说明已经到了起点
        {
            stack.push(p);
            p=p.last;
        }
        System.out.println(stack.size());
        while(!stack.isEmpty())
        {
            System.out.print(stack.pop().d);//依次出栈即可
        }
    }
    static char get(int index)//满足字典顺序要求
    {
        switch(index)
        { 
        case 0:return 'D';
        case 1:return 'L';
        case 2:return 'R';
        case 3:return 'U';
        
        }
        return ' ';
    }
}
class P//实质上就是一个链表的node
{
    int x;
    int y;
    P last;//指向上一个位置，学c的可以看成是指针
    char d;//记录由上一个为到到当前位置的转向
    P(int x,int y,P last,char d)
    {
        this.x=x;
        this.y=y;
        this.last=last;
        this.d=d;
    }
}

4.迷宫

题目可见试题D：迷宫

package 第二次;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class _C迷宫 {
    static boolean[][] vis = new boolean[60][60];
	
	static HashSet <node> sets = new HashSet<node>();
	static int m=30,n=50;
	static char[][] mapp;

	public static void main(String[] args) throws FileNotFoundException {
		Scanner in = new Scanner (new File("/1.课程（项目相关）/蓝桥杯训练/2019A/maze.txt"));
		
		mapp= new char[m+1][n+1];
		for(int i=0;i<m;i++)
		{
			String temp=in.next();  //读取一行
			mapp[i]=temp.toCharArray();
		}
		bfs();
	}
	
	public static void bfs()
	{
		int zuobiao[][] = new int[][] {{1,0},{0,-1},{0,1},{-1,0}};
		String fangxiang[] = new String [] {"D","L","R","U"};
		int  newx,newy;
		
		Queue<node> que = new LinkedList<node>();  //建队列
		node first= new node(0,0,"",0);  
		que.add(first);   //头结点入队列

		while(que.size()!=0)
		{
			node now = que.peek();
			que.poll(); 
			vis[now.x][now.y]=true;
			if(now.x==m-1 && now.y==n-1)
			{
				System.out.print(now.path);
				return;
			}
			for(int i=0;i<4;i++)
			{
				newx=now.x+zuobiao[i][0];
				newy=now.y+zuobiao[i][1];
				
				if(newx<0||newy<0||newx>=m||newy>=n||mapp[newx][newy]=='1'||vis[newx][newy]==true)
				{
					continue;
				}
				node newnode = new node(newx,newy,now.path+fangxiang[i],now.step+1);
				que.add(newnode);
			}
		}
	}
}



class node
{
	String path;
	int step=0;
	int x,y;
	node(int x,int y ,String path,int step)
	{
		this.x=x;
		this.y=y;
		this.path=path;
		this.step=step;
	}
}

5.二叉树的层序遍历

链接

class Solution {

    public List<List<Integer>> resList = new ArrayList<List<Integer>>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        checkFun02(root);

        return resList;
    }

    public void checkFun02(TreeNode node) {
        if (node == null) return;
        // 新建队列+头结点入队列
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(node);

        // 所有数据通过队列进行处理
        while (!que.isEmpty()) {
            // 通过len记录每一层
            // 对每一层进行处理，由于上一层已经都poll出去了，下一层还没开始，
            // 所以当前len就是本层数量
            List<Integer> itemList = new ArrayList<Integer>();
            int len = que.size();

            // 处理当前层
            while (len > 0) {
                // 本层节点相关处理：出队列，入结果列表
                TreeNode tmpNode = que.poll();
                itemList.add(tmpNode.val);

                // 下层结果预处理，进队列
                if (tmpNode.left != null) que.offer(tmpNode.left);
                if (tmpNode.right != null) que.offer(tmpNode.right);

                // 本层数量--
                len--;
            }

            //本层处理完了，放入结果列表
            resList.add(itemList);
        }

    }
}

6.二找树左下角的值

链接

class Solution {

    public int findBottomLeftValue(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int res = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode poll = queue.poll();
                if (i == 0) {
                    res = poll.val;
                }
                if (poll.left != null) {
                    queue.offer(poll.left);
                }
                if (poll.right != null) {
                    queue.offer(poll.right);
                }
            }
        }
        return res;
    }
}
菜菜子-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分支界限算法--细胞个数问题
weixin_45435509的博客
10-29 551
一矩形阵列由数字0到9组成,数字1到9代表细胞,细胞的定义为沿细胞数字上下左右还是细胞数字则为同一细胞,求给定矩形阵列的细胞个数。 【算法分析】 ⑴从文件中读入m*n矩阵阵列，将其转换为boolean矩阵存入bz数组中； ⑵沿bz数组矩阵从上到下，从左到右，找到遇到的第一个细胞； ⑶将细胞的位置入队h，并沿其上、下、左、右四个方向上的细胞位置入队，入队后的位置bz数组置为false； ⑷将h队的队...
蓝桥杯题目总结
DKchaos的博客
01-05 1192
蓝桥杯题目总结 这不蓝桥杯大赛和GDCPC快到了，提前准备好学习重点 目录 1. 题目类型 字符串处理 特殊数字处理 树与图 数列求值 队列与栈 排序与查找 时间问题 数学问题 2. 常用算法 分治算法 贪心算法 动态规划 分支限界 题目类型 字符串处理 特殊数字处理 树与图 数列求值 队列与栈 排序与查找 排序 排序按照原理可分为比较排序和非比较排序，其中比较排序包括转换，插入，选择...
【算法】【殊途同归】搜索算法之（深度优先 || 广度优先）& （约束条件 || 限界函数）
X
11-17 1947
对于所谓的分支限界法和回溯法，我们完全可以更加灵活，请看表格。 深度优先 广度优先 约束条件 限界函数 算法 策略 √ √ 回溯法 局部判定 √ √ √ 分支限界法 局部判定 √ √ √ 加限界的回溯法 局部判定 √ 枚举法 全局判定 √ 枚举法 全局判定 前两种是我们常见的，但是，事实上，这几种方式， 怎么玩都行，看实际需求了。 一般来说，剪枝策略使用 约束条件 + 限界函数，然后再配合深度优先或者广度优先，是最好不过的了，也就是后两种。 这样一来，
回溯法中的约束函数和界限函数
strdhgthbbh的博客
05-30 9424
约束函数用于选取满足条件的一个解 而界限函数用于剪除不可能存在解的节点 if(tw+w[i]<=W) { x[i]=1; dfs(tw+w[i],rw-w[i],x,i+1); } if(tw+rw>W) { x[i]=0; dfs(tw,rw-[i],x,i+1); //rw 为剩下的整数和 } ...
第七章 分支界限算法
weixin_44923678的博客
10-31 402
文章目录一、分支界限算法二、分支界限算法策略三、界限函数四、迷宫问题 一、分支界限算法 分支限界法类似于回溯法，是一种在问题的解空间树上搜索问题解的算法。 分支限界法的求解目标则是找出满足约束条件的一个解，或是在满足约束条件的解中找出使某一目标函数值达到极大或极小的解，即在某种意义下的最优解。 二、分支界限算法策略 分支限界法常以广度优先的方式搜索问题的解空间树。 在分支限界法中，每一个活结点只有...
C++分支限界法(BFS求解01背包问题)
12-14
C++分支限界法(BFS求解01背包问题)
Java实现 蓝桥杯 算法提高 八数码（BFS）
12-21
试题 算法提高 八数码 问题描述 　RXY八数码 输入格式 　输入两个33表格 　第一个为目标表格 　第二个为检索表格 输出格式 　输出步数 样例输入 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 0 8 样例输出 ... public
PUZZLE15_dfs_C++求解15拼图问题_bfs_
10-02
使用深度优先和广度优先搜索算法以及迭代加深的深度优先算法求解15拼图问题
15届蓝桥杯知识点大纲
最新发布
01-17
21. 数学：包括生成函数、莫比乌斯反演、快速傅里叶变换等高级数学知识点。 22. 数据结构：包括树链剖分、二维/动态开点线段树、平衡树、可持久化数据结构、树套树、动态树等高级数据结构。 需要注意的是，本大纲仅...
回溯算法
Claire的博客
02-11 1120
回溯算法 介绍 加入你要在许多不同的选择中做一系列的决策，那么 你没有足够的信息来帮助做出选择 每个决策都将产生一些新的选择 一些决策的序列（可能不只一个）也许就是问题的解 回溯算法系统的尝试搜索各种决策序列知道找到一个令你满意的决策序列 术语 一个有节点构成的树 根节点（开始节点） 内部节点（既有孩子节点，又有父节点） 叶子节点（没有任何的孩子节点） 活动节点（当一个节点被考察到了，意味着我们下...
背包问题.docx
05-31
吉林大学数据结构第二次上机，背包问题，试题题目，可以看看，要代码的话私聊哦
分支限界--数据结构实现
sky的博客
05-13 1975
转载自：算法学习——分支限界法 回溯法和分支限界都是以构造一颗解空间树为基础的。回溯法通过深度优先搜索的思想，选择一条可行的路径，一路走下去；而分支限界法可以根据多种规则生成节点，如广度优先搜索，再结合剪枝函数（我们在回溯法里也可以使用）进行剪枝，得出最优解。 限界函数的使用我们在回溯法里也提到过，是在寻找最优解时使用的一种优化方法，如果我们使用回溯法解决最优解问题也可以使用（其实回溯法寻找最优解的过程本身就可以看作是分枝限界通过深度优先LIFO的栈实现）。而在分枝限界中，这是必不可少的一部..
回溯法
晴。
01-07 1507
文章目录回溯思想适用范围经典解空间树子集树排列树关于作者 回溯 回溯的思想比较简单，但是却可以解决很多问题。 思想 回溯的思想是穷举所有可能的结果去尝试，如果走的通就继续前进，否则就退回重新选择。在穷举的过程中可以利用剪枝去过滤一部分不可能的结果。 适用范围 回溯法是穷举，那么必然会得到一个问题的全部解，进而又可以得到一个问题的最优解。这两点也正是回溯法的适用范围。 这两种不同的情况又引出了两个属...
算法分析与设计：分支限界法
AlexTu的博客
04-16 1万+
一、分支限界法 1. 基本思想 分支是使用广度优先策略，依次生成扩展结点的所有分支。 限界是在结点扩展过程中，计算结点的上界，搜索的同时剪掉某些分支。 分支限界法就是把问题的可行解展开，再由各个分支寻找最佳解。 与回溯法类似，分支限界法也是在解空间中搜索得到解； 不同的是，分支限界法会生成所有扩展结点，并舍弃不可能通向最优解的结点，然后根据广度优先/最小耗费优先，从活结点中选择一个作为扩展结点，使...
【回溯与分支限界法】运动员最优匹配问题
怪&的个人博客
12-22 2045
一、题目如下： 问题描述： 羽毛球队有男女运动员各n 人。给定2 个n×n 矩阵P 和Q。P[i][j]是男运动员i 和女运动员j配对组成混合双打的男运动员竞赛优势；Q[i][j]是女运动员i和男运动员j配合的女运动员竞赛优势。由于技术配合和心理状态等各种因素影响，P[i][j]不一定等于Q[j][i]。男运动员i和女运动员j配对组成混合双打的男女双方竞赛优势为P[i][j]*Q[j][i]。设计一个算法，对于给定的男女运动员竞赛优势，计算男女运动员最佳配对法，使各组男女双方竞赛优势的总和达到最大。
五大常用算法——分支限界算法详解及经典例题
热门推荐
qq_37763204的博客
03-13 2万+
一、对比回溯法回溯法的求解目标是找出解空间中满足约束条件的所有解，想必之下，分支限界法的求解目标则是找出满足约束条件的一个解，或是满足约束条件的解中找出使某一目标函数值达到极大或极小的解，即在某种意义下的最优解。另外还有一个非常大的不同点就是，回溯法以深度优先的方式搜索解空间，而分支界限法则以广度优先的方式或以最小耗费优先的方式搜索解空间。二、分支限界法的搜索策略在当前节点（扩展节点）处，先生成其...
算法设计与分析案例代码总结(四)：分支界限法
zycode1561的博客
12-17 2182
分支界限法 简单概述 分支界限法类似与回溯法，也是在问题解空间中搜索问题解的一种算法。 分支界限法与回溯法对比： 1. 求解目标不同：回溯法可以用于求解目标是找出解空间树中满足约束条件的所有解，而分支界限法求解的目标通常是找出一个满足约束条件的解，或者最优解。 2. 搜索方式不同：回溯法主要以深度优先的方式搜索解空间树，而分支界限法则主要以广度优先或者函数优先的方式搜索解空间树。 基本思想 在分支...
分支限界算法-BFS
zzu::myorange
05-23 1991
分支限界算法类似于宽度优先搜索 算法模板 定义根节点t0为初始化扩展节点 根节点t0入队 while(队不空) { 出队 --t; for (j = r0; j <= rn; ++j) { 对 t 利用规则j发展新节点tj; 利用限界函数判断tj是否可行； if(可行) { 若是目标解，找到结果，return 否则进队 } } } 上午上
分支限界（branch and bound）——概念、Java结构 及 TSP实现
sky的博客
05-12 2537
转载自：分支限界法 例1 代码文件层次如下： 其中branch and bound算法主要部分在BnB_Guide.java这个文件。 ExampleProblem.java内置了三个整数规划模型的实例。 调用的是scpsolver这个求解器的wrapper，实际调用的还是lpsolver这个求解器用以求解线性松弛模型。下面着重讲讲BnB_Guide.java这个文件。 public BnB_Guide(int demoProblem){ exam.
n后问题分支限界法剪枝函数
12-12
分支限界法是解决n后问题的一种有效方法，其中剪枝函数可以帮助我们剪除状态空间图中的不可行解和非最优解，从而提高算法效率。 下面是n后问题分支限界法剪枝函数的实现过程： 1.定义一个棋盘board，其中board[i]...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值