蓝桥杯基础知识巩固--矩阵填数和BFS的应用

最新推荐文章于 2022-03-21 18:54:42 发布
最新推荐文章于 2022-03-21 18:54:42 发布
阅读量143 收藏
点赞数
分类专栏： # 蓝桥杯 # Java理论与实践 数据结构&算法设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44654974/article/details/115675030
版权

一、前言

今天，进行了近两年的蓝桥杯JavaB组真题整理，发现存在严重的基础薄弱问题。于是做了以下的基础知识巩固梳理。

二、代码

矩阵填数

package lq.questions.consolidate;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @AUTHOR LYF
 * @DATE 2021/4/13
 * @VERSION 1.0
 * @DESC
 * 矩阵的填数以及遍历
 * 采用链表+String构成矩阵
 */
public class Count {

    static List<String> lists = new ArrayList<>();
    static {
        // 读入数据
        try{
            InputStream ips = new FileInputStream("E:\\IdeaProjects\\java-base\\src\\main\\java\\lq\\questions\\consolidate\\files\\Find2020");
            InputStreamReader isr = new InputStreamReader(ips);//读入输入流
            BufferedReader br = new BufferedReader(isr);//缓存读取

            String temp = null;
            while((temp=br.readLine())!=null){
                lists.add(temp);
            }

            // 验证结果
            System.out.println("读入数据为:");
            lists.stream().forEach(System.out::println);

        }catch (Exception e){
            e.printStackTrace();
        }
    }

    // 寻找2020
    // 遍历行列、斜方向
    // 关于斜方向如何遍历？
    // 截取从(0,0)-直到row为最大或者列为最大或者字符串长度判断

    // 判断字符串含有的2020的数量
    Integer count2020(String str){
        String regex = "2020";
        Pattern p = Pattern.compile(regex);
        Matcher m =p.matcher(str);
        int count =0;
        while(m.find())
        {
            count++;
            System.out.println("在"+m.start()+"匹配到2020");
        }
        return count;
    }

    // 进行总体计数
    void handleFind2020(){

        // 原子计数，Atomic了解
        AtomicReference<Integer> sum1 = new AtomicReference<>(0);
        // 每一行计数,即lists的遍历
        lists.stream().forEach((str)->{
            sum1.updateAndGet(v -> v + count2020(str));
        });

        // 处理列
        int len = lists.get(0).length();
        String[] rowStr = new String[len];
        Arrays.fill(rowStr,"");
        for(int i =0;i<lists.size();i++){
            for(int j=0;j<len;j++){
                rowStr[j]=rowStr[j]+lists.get(i).charAt(j);
            }
        }
        for(String str :rowStr){
            sum1.updateAndGet(v->v+count2020(str));//{}则有返回值
        }

        // 斜方向！！
        // 突然发现还是矩阵方便处理，于是转换为矩阵
        Character[][] map = new Character[lists.size()][len];
        int row=lists.size(),col=len;
        for(int i =0;i<lists.size();i++){
            for(int j=0;j<len;j++) {
                map[i][j] = lists.get(i).charAt(j);
            }
        }

        // 从左斜方向到右斜方向，确定起点和终点以及变化规则
        // 起点: (rowMax-字符串"2020"len,0) 终点:(0,colMax-"2020".length())
        // 规则:截取点开始到无法截取的长度，点的变化规则i--到0,j

        List<String> biasList=new ArrayList<>();

        int i=row-4,j=0;

        while(i!=0||j!=len-4){//字符串开始的点(i,j)，终点结束

            String temp ="";
            int vaI=i,vaJ=j;
            while(vaI<row&&vaJ<col){
                temp=temp+map[vaI++][vaJ++];
            }
            biasList.add(temp);

            //起点移动
            if(i!=0){
                i--;
            }else{
                j++;
            }
        }

        int vaI=i,vaJ=j;
        String temp=""; //最后一个点
        while(vaI<row&&vaJ<col){
            temp=temp+map[vaI++][vaJ++];
        }

        biasList.add(temp);
        System.out.println("测试:");
        biasList.stream().forEach(System.out::println);
    }

    // 相关补充
    // 蛇形填数
    int[][] map = new int[41][41];//方便验证
    void printRs(){
        System.out.println("验证:");
        for(int row=0;row<40;row++){
            for(int col=0;col<40;col++){
                System.out.print(map[row][col]+" ");
            }
            System.out.println();
        }
    }

    void handleSnake(){

        int i=0,j=0,count=1;

        while(i!=19||j!=19){
            map[i][j]=count;

            if(i==0){// 行为0则col++
                map[0][++j]=++count;
            }

            while(j>0){
                map[++i][--j]=++count;
                if(i==19&&j==19){
                   printRs();
                    return;
                }
            }

            if(j==0){
                map[++i][0]=++count;
            }

            while (i>0){
                map[--i][++j]=++count;
                if(i==19&&j==19){
                   printRs();
                    return;
                }
            }
        }
    }

    int len=5;// 矩阵长度
    int[][] map2=new int[len][len];
    void writeMap(int endRow,int endCol){
//        Arrays.fill(map2,0);
        for(int i =0;i<len;i++){
            Arrays.fill(map2[i],0);
        }
        int row=0,col=0,count=1;
        while(row!=endRow||col!=endCol){
            // 向右进行填数
            while(col<len&&map2[row][col]==0){//注意需要先进行边界判断
                map2[row][col++]=count++;
            }
            col--;//col回退
            row++;// 下一列
            while (row<len&&map2[row][col]==0){
                map2[row++][col]=count++;
            }
            row--;//row回退
            col--;//向左一列
            while (col>=0&&map2[row][col]==0){
                map2[row][col--]=count++;
            }
            col++;
            row--;
            while(row>=0&&map2[row][col]==0){
                map2[row--][col]=count++;
            }
            row++;
            col++;
        }
        // 处理最后一个数
        map2[endRow][endCol] =count;
        print();
    }
    void print(){
        for(int i =0;i<len;i++){
            for(int j=0;j<len;j++){
                System.out.print(map2[i][j]+" ");
            }
            System.out.println();
        }
    }
    // 回形填写矩阵
    void handleCircle(){

        // 与蛇形填数类似
        // 起点（0，0）
        // 终点（ 奇数则是 (len/2,len/2),偶数则是 (len/2-1,len/2-1)
        // 规则 当遇到未进行填写就递进（ col++直到下一个为已填或者边界，col保持不变，row++到已填或者边界，

        if(len%2==0){
            writeMap(len/2-1,len/2-1);
        }else{
            writeMap(len/2,len/2);
        }
    }

    public static void main(String[]args){
        Count c= new Count();
        c.handleCircle();
    }

}

BFS的简单应用（其实之前已经做过，今天只是再次熟悉）

package lq.questions.consolidate;


import lq.questions.consolidate.domain.Point;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;

/**
 * @AUTHOR LYF
 * @DATE 2021/4/13
 * @VERSION 1.0
 * @DESC
 */
public class Graph {

    // 前置:BFS\DFS
    // 连通性和深搜 见lq\base\structrure\graph\BFS.java

    // 模拟数据
    static int[][]map = new int[100][100];//连通性
    static int[][]maze= new int[100][100];//迷宫
    // 读取测试文件
    static void printMap(int command){
//        if(command==1){
//           for(int i =0;i<)
//        }else {
//
//        }
    }
    static {

        try{
            String path = "E:\\IdeaProjects\\java-base\\src\\main\\java\\lq\\questions\\consolidate\\files\\maze";
            InputStream ips = new FileInputStream(path);
            InputStreamReader isr = new InputStreamReader(ips);
            BufferedReader br =  new BufferedReader(isr);

            int row=0,col=0;
            String line = "";
            while((line=br.readLine())!=null){
                col=line.length();
                for(int i =0;i<line.length();i++){
                  maze[row][i]=Integer.valueOf(line.substring(i,i+1));
                }
                row++;
            }

            for(int i=0;i<row;i++){
                for(int j =0;j<col;j++){
                    System.out.print(maze[i][j]+" ");
                }
                System.out.println();
            }

        }catch (Exception e){
            e.printStackTrace();
        }
    }

    // BFS => 最短路径，如何走
    // 迷宫问题（可行》最短路径》路径》  BFS）
    // 定义Point
    // 设置方向量方便进行四个放行广度搜索
    int toRow[]={0,-1,0,1};
    int toCol[]={1,0,-1,0}; // 右下左上

    // 广搜
    // 重点理解，最先搜到的即为最短的，也就相当于树的深度。另外采用队列进行先加入的先进行搜索
    void bfs(){

        Queue<Point> queue = new ArrayDeque<Point>();

        // 启动
        //Point startP = new Point(0,0,null,1);// 若在类的属性中进行赋值对象则不能这样写
        Point startP = new Point(0,0,null,1);

        queue.add(startP);//添加启动
        while(!queue.isEmpty()){ //未找完则一直寻找，若找到目标点则进行退出

            Point cur = queue.poll();

            if(cur.getI()== 3&&cur.getJ()==5){
                // 找到目标点
                // cur就是一个链表头进行逆向打印即可，size()
                List<Point> list = new ArrayList<>();

                Point p = cur;
                while(p!=null)
                {
                    list.add(p);
                    p=p.getPre();
                }

                System.out.println("最短路径长度:"+list.size());
                System.out.println("最短路径:");

                for(int i =list.size()-1;i>=0;i--){
                    System.out.print("("+list.get(i).getI()+","+list.get(i).getJ()+")=>");
                }

                return;
            }

            // 遍历四个方向，寻找可进行加入的点
            for(int i = 0;i<4;i++){
                int nextI = cur.getI()+toRow[i];
                int nextJ = cur.getJ()+toCol[i];
                // 先进行边界判断
                if(nextI>=0&&nextJ>=0&&nextI<4&&nextJ<6&&maze[nextI][nextJ]==0){
                    Point next=new Point(nextI,nextJ,cur,0);//其实没有必要设立val,可以附加其他信息
                    queue.add(next);
                    // 需要标记当前点进行标记了吗
                    // 需要吧，因为加入队列已经标记搜索过该地方，其他能够搜索到该地方也只能慢于此，所以说没有必要在进行搜索了
                    // 那么思考，如何考虑所有的路径呢？？，就无需设立吗
                    maze[nextI][nextJ]=1;
                }
            }
        }
    }


    // 连通性判断
    // 思路进行遍历矩阵，发现1就进行深搜，并将其搜索的点进行visited二维数组标记
    static boolean[][] visited=new boolean[4][6];
    static {
        for(int i =0;i<4;i++){
            Arrays.fill(visited[i],false);
        }
    }


    // 无需前驱
    class Point2{
        int i,j;

        public Point2() {
        }

        public Point2(int i, int j) {
            this.i = i;
            this.j = j;
        }

        public int getI() {
            return i;
        }

        public void setI(int i) {
            this.i = i;
        }

        public int getJ() {
            return j;
        }

        public void setJ(int j) {
            this.j = j;
        }
    }


    // 深搜起点
    void handleBfs(int startI,int startJ){

        Point2 startP = new Point2(startI,startJ);
        Queue<Point2> queue = new ArrayDeque<>();
        queue.add(startP);
        while (!queue.isEmpty()){

            Point2 cur = queue.poll();

            for(int i =0;i<4;i++){
                int nextI = cur.getI()+toRow[i];
                int nextJ = cur.getJ()+toCol[i];

                if(nextI<4&&nextJ<6&&nextI>=0&&nextJ>=0&&maze[nextI][nextJ]==1){
                    Point2 next = new Point2(nextI,nextJ);
                    queue.add(next);
                    System.out.println("进入在("+nextI+","+nextJ+")深搜");
                    maze[nextI][nextJ]=0;//若不设置此处未0，会进行一直搜索，死循环，或者判断时使用visited数组进行判断
                   // this.visited[nextI][nextJ]=true;//直接在maze上进行标记呢？？影响下次深搜》？
                    // 其实没有必要设立visited，直接使用maze即可，搜过的地方直接跳过
                }
            }
            if(queue.size()==0)
            {
                return;
            }
        }

    }

    // 判断联通的岛屿（处理大量时，此处简单小量数据只做展示）
    void connectivity(){
        int count=0;
        for(int i =0;i<4;i++){
            for(int j =0;j<6;j++){
                if(maze[i][j]==1){//未访问则进行深搜，且是在岛屿上  &&this.visited[i][j]==false
                    handleBfs(i,j);

                    count++;
                }
            }
        }
        System.out.println("岛屿数"+count);
    }



    public static void main(String[]args){
        Graph g= new Graph();
        g.connectivity();
    }


    // 七段码
}

七段码（蓝桥杯）
排列组合时可以递归简化代码

package lq.questions.consolidate.graph;


import lq.questions.consolidate.domain.Point;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;

/**
 * @AUTHOR LYF
 * @DATE 2021/4/13
 * @VERSION 1.0
 * @DESC
 */
public class Graph {

    // 前置:BFS\DFS
    // 连通性和深搜 见lq\base\structrure\graph\BFS.java

    // 模拟数据
    static int[][]map = new int[100][100];//连通性
    static int[][]maze= new int[100][100];//迷宫
    // 读取测试文件
    static void printMap(int command){
//        if(command==1){
//           for(int i =0;i<)
//        }else {
//
//        }
    }
    static {

        try{
            String path = "E:\\IdeaProjects\\java-base\\src\\main\\java\\lq\\questions\\consolidate\\files\\maze";
            InputStream ips = new FileInputStream(path);
            InputStreamReader isr = new InputStreamReader(ips);
            BufferedReader br =  new BufferedReader(isr);

            int row=0,col=0;
            String line = "";
            while((line=br.readLine())!=null){
                col=line.length();
                for(int i =0;i<line.length();i++){
                  maze[row][i]=Integer.valueOf(line.substring(i,i+1));
                }
                row++;
            }

            for(int i=0;i<row;i++){
                for(int j =0;j<col;j++){
                    System.out.print(maze[i][j]+" ");
                }
                System.out.println();
            }

        }catch (Exception e){
            e.printStackTrace();
        }
    }

    // BFS => 最短路径，如何走
    // 迷宫问题（可行》最短路径》路径》  BFS）
    // 定义Point
    // 设置方向量方便进行四个放行广度搜索
    int toRow[]={0,-1,0,1};
    int toCol[]={1,0,-1,0}; // 右下左上

    // 广搜
    // 重点理解，最先搜到的即为最短的，也就相当于树的深度。另外采用队列进行先加入的先进行搜索
    void bfs(){

        Queue<Point> queue = new ArrayDeque<Point>();

        // 启动
        //Point startP = new Point(0,0,null,1);// 若在类的属性中进行赋值对象则不能这样写
        Point startP = new Point(0,0,null,1);

        queue.add(startP);//添加启动
        while(!queue.isEmpty()){ //未找完则一直寻找，若找到目标点则进行退出

            Point cur = queue.poll();

            if(cur.getI()== 3&&cur.getJ()==5){
                // 找到目标点
                // cur就是一个链表头进行逆向打印即可，size()
                List<Point> list = new ArrayList<>();

                Point p = cur;
                while(p!=null)
                {
                    list.add(p);
                    p=p.getPre();
                }

                System.out.println("最短路径长度:"+list.size());
                System.out.println("最短路径:");

                for(int i =list.size()-1;i>=0;i--){
                    System.out.print("("+list.get(i).getI()+","+list.get(i).getJ()+")=>");
                }

                return;
            }

            // 遍历四个方向，寻找可进行加入的点
            for(int i = 0;i<4;i++){
                int nextI = cur.getI()+toRow[i];
                int nextJ = cur.getJ()+toCol[i];
                // 先进行边界判断
                if(nextI>=0&&nextJ>=0&&nextI<4&&nextJ<6&&maze[nextI][nextJ]==0){
                    Point next=new Point(nextI,nextJ,cur,0);//其实没有必要设立val,可以附加其他信息
                    queue.add(next);
                    // 需要标记当前点进行标记了吗
                    // 需要吧，因为加入队列已经标记搜索过该地方，其他能够搜索到该地方也只能慢于此，所以说没有必要在进行搜索了
                    // 那么思考，如何考虑所有的路径呢？？，就无需设立吗
                    maze[nextI][nextJ]=1;
                }
            }
        }
    }


    // 连通性判断
    // 思路进行遍历矩阵，发现1就进行深搜，并将其搜索的点进行visited二维数组标记
    static boolean[][] visited=new boolean[4][6];
    static {
        for(int i =0;i<4;i++){
            Arrays.fill(visited[i],false);
        }
    }


    // 无需前驱
    class Point2{
        int i,j;

        public Point2() {
        }

        public Point2(int i, int j) {
            this.i = i;
            this.j = j;
        }

        public int getI() {
            return i;
        }

        public void setI(int i) {
            this.i = i;
        }

        public int getJ() {
            return j;
        }

        public void setJ(int j) {
            this.j = j;
        }
    }


    // 深搜起点
    void handleBfs(int startI,int startJ){

        Point2 startP = new Point2(startI,startJ);
        Queue<Point2> queue = new ArrayDeque<>();
        queue.add(startP);
        while (!queue.isEmpty()){

            Point2 cur = queue.poll();

            for(int i =0;i<4;i++){
                int nextI = cur.getI()+toRow[i];
                int nextJ = cur.getJ()+toCol[i];

                if(nextI<4&&nextJ<6&&nextI>=0&&nextJ>=0&&maze[nextI][nextJ]==1){
                    Point2 next = new Point2(nextI,nextJ);
                    queue.add(next);
                    System.out.println("进入在("+nextI+","+nextJ+")深搜");
                    maze[nextI][nextJ]=0;//若不设置此处未0，会进行一直搜索，死循环，或者判断时使用visited数组进行判断
                   // this.visited[nextI][nextJ]=true;//直接在maze上进行标记呢？？影响下次深搜》？
                    // 其实没有必要设立visited，直接使用maze即可，搜过的地方直接跳过
                }
            }
            if(queue.size()==0)
            {
                return;
            }
        }

    }

    // 判断联通的岛屿（处理大量时，此处简单小量数据只做展示）
    void connectivity(){
        int count=0;
        for(int i =0;i<4;i++){
            for(int j =0;j<6;j++){
                if(maze[i][j]==1){//未访问则进行深搜，且是在岛屿上  &&this.visited[i][j]==false
                    handleBfs(i,j);

                    count++;
                }
            }
        }
        System.out.println("岛屿数"+count);
    }


    // 七段码 a-g分别对应0-6
    //
    // 采用矩阵判断连通性比较方便
    int[][] map3={
            {0,1,0,0,0,0,1},
            {1,0,1,0,0,1,0},
            {0,1,0,1,0,1,0},
            {0,0,1,0,1,0,0},
            {0,0,0,1,0,1,1},
            {0,1,1,0,0,0,1},
            {1,0,0,0,1,1,0}
    };

    // 排列组合查看是否联通
    // 两两判断是否联通？
    void handle(){
        for(int i =1;i<=7;i++){//依次判断选取1-7个的组合
        }

        // 选1个为7
        // 选7个为1
        // 选6个为
    }


    // 法二，抽象成点
    /*
    0 0
    0 0
    0 0
    0 0
    a : (0,0)和(0,1)设置为1

    判断连通性：BFS
     */

    static int[][] map7={
            {0,0,0},
            {0,0,0},
            {0,0,0},
            {0,0,0},
            {0,0,0}
    };

    static {

    }
    void writeMap(String str){
        System.out.println("写入棋盘"+str);
        for(int i =0;i<str.length();i++){
            String temp = str.substring(i,i+1);
            switch (temp){
                case "a":{map7[0][0]=map7[0][1]=map7[0][2]=1;break;}
                case "b":{map7[0][2]=map7[1][2]=map7[2][2]=1;break;}
                case "c":{map7[2][2]=map7[3][2]=map7[4][2]=1;break;}
                case "d":{map7[4][2]=map7[4][1]=map7[4][0]=1;break;}
                case "e":{map7[4][0]=map7[3][0]=map7[2][0]=1;break;}
                case "f":{map7[2][0]=map7[1][0]=map7[0][0]=1;break;}
                case "g":{map7[2][0]=map7[2][1]=map7[2][2]=1;break;}
            }
        }


        printMap7();


    }

    void bfs3(int startI,int startJ){

        Point2 startP = new Point2(startI,startJ);
        Queue<Point2> queue = new ArrayDeque<>();
        queue.add(startP);

        while (!queue.isEmpty())
        {
            Point2 cur = queue.poll();

            for(int i =0;i<4;i++){
                int nextI = cur.getI()+toRow[i];
                int nextJ = cur.getJ()+toCol[i];

                if(nextI>=0&&nextJ>=0&&nextI<5&&nextJ<3&&map7[nextI][nextJ]==1){
                    queue.add(new Point2(nextI,nextJ));
                    map7[nextI][nextJ]=0;//标记访问了
//                    printMap7();
                }
            }
        }
    }

    void toZero(){
        for(int i=0;i<5;i++){
            Arrays.fill(map7[i],0);
        }
    }

    boolean judge(String str){
        writeMap(str);// 填写棋盘
        int count=0;

        System.out.println("棋盘:");
        printMap7();

        for(int i =0;i<5;i++){
            for(int j=0;j<3;j++){
                if(map7[i][j]==1){
                    bfs3(i,j);
                    count++;
                }
            }
        }
        //count>1则非联通

        System.out.println(count);
        toZero();//归零

        if(count>1){
            return false;
        }else {
            return true;
        }

    }

    void printMap7(){
        for(int i =0;i<5;i++){
            for(int j = 0;j<3;j++){
                System.out.print(map7[i][j]+" ");
            }
            System.out.println();
        }
    }

    // 简化多重循环
    String simplyCirculation(String str,int n){// 循环的次数
    return "";
    }


    // 递归处理选取问题
    void recursion(String str,int start,int end,int val){
        if(end-start==val){
            System.out.println();
        }
        for(int i=start;i<end;i++){// 开始结束位置

        }
    }

    void handle2(){

        String str = "abcdefg";
        // 同样，1和7不用去考虑分配

        int sum =0;

        // 选取1个
        for(int i =0;i<str.length();i++){
            if(judge(str.substring(i,i+1))){
                sum++;
            }

        }

        // 如何排列组合 ，

        for(int i =1;i<=7;i++){ //选取问题，无需排列


        }

        // 选取2个数
        for(int i =0;i<6;i++){
            for(int j=i+1;j<7;j++){//多重循环
                String strs= str.substring(i,i+1)+str.substring(j,j+1);
                if(judge(strs)){
                    sum++;
                }
            }
        }

        // 选取3个数
        for(int i =0;i<5;i++){
            for(int j=i+1;j<6;j++){//多重循环
                for(int k=j+1;k<7;k++){
                    String strs= str.substring(i,i+1)+str.substring(j,j+1)+str.substring(k,k+1);
                    if(judge(strs)){
                        sum++;
                    }
                }
            }
        }


        // 选取4个数
        for(int i =0;i<4;i++){
            for(int j=i+1;j<5;j++){//多重循环
                for(int k=j+1;k<6;k++){
                   for(int l=k+1;l<7;l++){
                       String strs= str.substring(l,l+1)+str.substring(i,i+1)+str.substring(j,j+1)+str.substring(k,k+1);
                       if(judge(strs)){
                           sum++;
                       }
                   }
                }
            }
        }


        // 选取5个数
        for(int i =0;i<3;i++){
            for(int j=i+1;j<4;j++){//多重循环
                for(int k=j+1;k<5;k++){
                    for(int l=k+1;l<6;l++){
                        for(int n=l+1;n<7;n++){
                            String strs= str.substring(n,n+1)+str.substring(l,l+1)+str.substring(i,i+1)+str.substring(j,j+1)+str.substring(k,k+1);
                            if(judge(strs)){
                                sum++;
                            }
                        }
                    }
                }
            }
        }

        for(int i =0;i<2;i++){
            for(int j=i+1;j<3;j++){//多重循环
                for(int k=j+1;k<4;k++){
                    for(int l=k+1;l<5;l++){
                        for(int n=l+1;n<6;n++){
                           for(int c=n+1;c<7;c++){
                               String strs= str.substring(c,c+1)+str.substring(n,n+1)+str.substring(l,l+1)+str.substring(i,i+1)+str.substring(j,j+1)+str.substring(k,k+1);
                               if(judge(strs)){
                                   sum++;
                               }
                           }
                        }
                    }
                }
            }
        }

        System.out.println(sum);
    }


    // DFS
    // 规定一个方向进行搜索
//   （1）访问顶点v；
//   （2）依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问；
//   （3）若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止。　
//     当然，当人们刚刚掌握深度优先搜索的时候常常用它来走迷宫.事实上我们还有别的方法，那就是广度优先搜索(BFS).

    // DFS 对比: DFS进行单条遍历直到走不通再回溯到另外一条，而BFS是将所有可能的都加入队列进行同时搜索
    // DFS 递归思想  BFS 队列
    // 采用邻阶表
    class DfsNode{
        int val;//该边的值
        List<DfsNode> nextNodeList =new ArrayList<>();
        //

        public DfsNode() {
        }

        public DfsNode(int val, List<DfsNode> nextNodeList) {
            this.val = val;
            this.nextNodeList = nextNodeList;
        }

        public int getVal() {
            return val;
        }

        public void setVal(int val) {
            this.val = val;
        }

        public List<DfsNode> getNextNodeList() {
            return nextNodeList;
        }

        public void setNextNodeList(List<DfsNode> nextNodeList) {
            this.nextNodeList = nextNodeList;
        }
    }

    int step =1;
    static int[] visited1 =new int[100];// 如果值为对象可以使用map建立映射，或者hash函数
    static {
        Arrays.fill(visited1,0);
    }
    void dfs(DfsNode node){//目标边值
        System.out.println("第"+step+"步搜索");
        step++;
        visited1[node.getVal()]=1;//被访问
        if(node.getVal()==10){
            System.out.println("寻找到该边");
        }else if(node.getNextNodeList()==null){//需要前驱？？,八皇后，棋盘控制
            //回溯
             // 停止操作即可，即进入下一个
        }else {// 深搜
                for(int i =0;i<node.getNextNodeList().size();i++){
                    if(visited1[node.getNextNodeList().get(i).getVal()]==0){// 该边为被访问
                        dfs(node.getNextNodeList().get(i));
                    }
                }
             }
    }



    void test(){
        DfsNode node0= new DfsNode(0,null);
        DfsNode node1= new DfsNode(1,null);
        DfsNode node2= new DfsNode(2,null);
        DfsNode node3= new DfsNode(3,null);
        DfsNode node4= new DfsNode(4,null);
        DfsNode node10= new DfsNode(10,null);


        List<DfsNode> node0List = new ArrayList<>();
        node0List.add(node2);// 先搜索2
        node0List.add(node1);
        node0.setNextNodeList(node0List);

        List<DfsNode> node2List = new ArrayList<>();
        node2List.add(node3);
        node2List.add(node10);
        node2.setNextNodeList(node2List);

        dfs(node0);



    }



    public static void main(String[]args){
        Graph g= new Graph();
        g.test();
    }
}
adventure.Li
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java蛇形填数
Lu_Xiao_Yue的博客
08-19 1145
在n*n方阵里填入1,2,…,n*n,要求填成蛇形。例如n=4时方陈阵为： 10 11 12 1 9 16 13 2 8 15 14 3 7 6 5 4 思路：先建一个二维数组，在这个数组里面填数。 写一个方法，参数是 一个二维数组arr，填数的起始位置 m n，填的第一数字，对于main方法中就是先把 建立的数组、右上角的位置的坐标，填的第一个1，...
java算法：螺旋添数(二维数组)
weixin_45492761的博客
09-05 867
问题： 读入两个整数m,n，输出一个m行n列的矩阵，这个矩阵是1~m*n这些自然数按照右、下、左、上螺旋填入的结果。 例如读入数字4,5，则输出结果为： 1 2  3 4 5 14 15  16  17  6 13  20  19  18  7 12  11  10   9 &nbsp...
蓝桥杯蛇形填数Java
GX_666的博客
01-24 523
题目： 本题总分：10 分 【问题描述】 如下图所示，小明用从 1 开始的正整数“蛇形”填充无限大的矩阵。 1 2 6 7 15 … 3 5 8 14 … 4 9 13 … 10 12 … 11 … … (1) 容易看出矩阵第二行第二列中的数是 5。请你计算矩阵中第 20 行第 20 列 的数是多少？ 【答案提交】 这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分 题目解析： 这一题有规律可循， 像第一行第一列为1，第二行第二列为
＜7＞手动创建Servlet程序
dizzy256的博客
10-26 306
  一般在实际项目开发中，都是使用继承 HttpServlet 类的方式去实现 Servlet 程序。 1、编写一个类去继承 HttpServlet 类 2、根据业务需要重写 doGet 或 doPost 方法 3、到 web.xml 中的配置 Servlet 程序的访问地址 1.HttpServlet抽象类   HttpServlet 也是一个抽象类，它进一步继承并封装了 GenericServlet，使得使用更加简单方便，由于是扩展了 Http 的内容，所以还需要使用 HttpServletReq
leetcode 二维矩阵BFS（130、542、200、934、864(hard)）
qq_41807225的博客
01-14 410
130 被围绕的区域 题目描述： 给定一个二维的矩阵，包含 ‘X’ 和 ‘O’（字母 O）。找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。 解释： 被围绕的区间不会存在于边界上，换句话说，任何边界上的 ‘O’ 都不会被填充为 ‘X’。 任何不在边界上，或不与边界上的 ‘O’ 相连的 ‘O’ 最终都会被填充为 ‘X’。如果两个元素在水平或垂直方向相邻，则称它们是“相...
蓝桥杯python基础知识和算法
最新发布
01-22
"蓝桥杯Python基础知识和算法"是一个针对编程竞赛——蓝桥杯所准备的学习资源，主要聚焦于Python语言的基础知识和算法应用。蓝桥杯是一项全国性的编程竞赛，旨在提升大学生和青少年的计算机科学素养，特别是在算法...
dfs-bfs-master.zip_bfs_dfs
09-24
深度优先搜索（DFS，Depth-First Search）与广度优先搜索（BFS，Breadth-First Search）是图论和树形结构中常用的两种遍历...通过分析和实践"dfs-bfs-master"项目，可以加深对这两种算法的理解，并提升解决问题的能力。
蓝桥杯学习资料大全-题目参考代码-危险系数.zip
05-25
然后，通过阅读参考代码，你可以看到如何将这些基础知识应用到实际问题中，例如如何使用循环和条件语句实现特定的算法。 对于数据结构部分，理解它们的工作原理和优缺点至关重要。例如，栈是后进先出（LIFO）的数据...
蓝桥杯学习资料大全-题目参考代码-殖民地.zip
05-25
1. **算法基础**：殖民地问题可能涉及到不同的算法，如图论、搜索算法（深度优先搜索DFS或广度优先搜索BFS）、动态规划、贪心算法等。这些算法是解决复杂问题的基础，通过理解并运用它们，可以更高效地解决问题。 2...
dfs_bfs.rar_C-C++_bfs
09-23
标题中的“dfs_bfs.rar”指的是一个压缩文件，其中包含了关于深度优先搜索（DFS, Depth First Search）和广度优先搜索（BFS, Breadth First Search）的C++程序。这两种算法是图论和计算机科学中常用的数据结构遍历...
矩阵填数
weixin_38970751的博客
02-02 1032
题目1 : 矩阵填数 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 小Hi在玩一个游戏，他需要把1, 2, 3, ... NM填入一个N行M列的矩阵中，使得矩阵每一行从左到右、每一列从上到下都是递增的。   例如如下是3x3的一种填法： 136 247 589 给定N和M，小Hi希望知道一共有多少种不同的填法。 输入 一行包含两个整数N...
算法题 八数码 Python版
blowfire123的博客
11-26 3791
在一个3×3的网格中，1~8这8个数字和一个“x”恰好不重不漏地分布在这3×3的网格中。 例如： 1 2 3 x 4 6 7 5 8 在游戏过程中，可以把“x”与其上、下、左、右四个方向之一的数字交换（如果存在）。 我们的目的是通过交换，使得网格变为如下排列（称为正确排列）： 1 2 3 4 5 6 7 8 x 例如，示例中图形就可以通过让“x”先后与右、下、右三个方向的数字交换成功得到正确排列。 交换过程如下： 1 2 3 1 2 3 1 2 3 1 2 3 x 4
蓝桥杯——一篇搞懂广度优先搜索（BFS）
m0_47963315的博客
03-21 4421
大家好，我是璐画 📒博客主页：璐画的个人主页 🎉欢迎关注🔎点赞👍收藏⭐️留言📝 📌本文由璐画原创，CSDN首发！ 📆首发时间：🌴2022年3月21日🌴 ✉️坚持下去的，都是因为热爱吧！ 💭参考书籍：📚《labuladong的算法小抄》 💬参考在线编程网站：🌐牛客网🌐力扣 🍭作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！ 特别声明：本文我是学习过labuladong大佬的书然后总结出来的文章，这位大佬在csdn上好像没有账号，想学习的小伙伴可以买大佬那本《labuladong的算法小抄》
蓝桥杯算法竞赛系列第八章——提高篇之广度优先搜索（BFS）
安然无虞的博客
12-12 1万+
欢迎回到：遇见蓝桥遇见你，不负代码不负卿！ 【前言】 搜索算法在蓝桥中考的还是比较频繁的，之前发表了二叉树数据结构以及深度优先搜索章节，前面还是比较简单的，这里的广度优先搜索可能稍微复杂那么一丢丢，因为要用到队列，不过我们可以使用STL容器也是很方便就解决了。 【声明】：由于前半部分是基础知识点定义部分，所以前半部分赘述笔者是参考力扣官方给出的定义以及《算法笔记》一书。 一、广度优先搜索算法（BFS） 对于广度优先搜索的定义及特点，力扣官方是这样给出的： 广度优...
【OJ练习】关于矩阵填数那些事儿
qq_44654974的博客
05-25 508
一、背景 最近，学校的OJ截止日期快截止了，于是开始猛补。遇到一道回折矩阵的题目。想起来去年蓝桥杯也考了一道蛇形填数，说难不难，但动手实现起来，还是有点磕磕绊绊，下面来总结一下。 二、解决思路 分析数的填充路径规律 可以动手在草稿纸上面画画，看看填数的规律，一般是走几步就重复此规律进行下去，所以说分析填充规律其实很简单，拿回形矩阵来说，规律就是往右走到尽头在下走到尽头再左、上如此循环直到结束。 分析控制坐标 设立一个计数的counter和一个i,j表示矩阵的横纵坐标，i控制左右，j控制 上下，然后注意
java矩阵输入_opencv(Java)的矩阵创建与基础操作
weixin_27066963的博客
02-21 1773
opencv(Java)的矩阵创建与操作(1)创建矩阵OpenCV Java中矩阵就是一个类 Mat，和它扩展出来的MatOfDouble之类的类。通常创建一个矩阵对象的方法是：Mat A = new Mat(3, 4, CvType.CV_64FC1);或者分两步：Mat A = new Mat();A.create(3,4,CvType.CV_64FC1);矩阵使用完毕不用了，要记得销毁：A....
关于Id returned 1exit status的解决办法
热门推荐
qq_44654974的博客
04-27 24万+
问题描述： 今天做了一个C++的类组合的作业，编写之后一直出现Id returned 1exit status的情况。。。 网上查了一些解决办法，总结如下： （1）有正在运行的程序，，解决办法：打卡任务管理器（ctrl+Alt+delete）关闭正在运行的程序 （2）函数、变量出现重名（想起蓝桥杯时，我count变量打成cout也出现此情况的低级错误），于是我又寻找了此错误，但是并没有。 （3）...
vector找最大元素
qq_44654974的博客
04-07 2651
今天做了一道huffman题，这是一道贪心算法的入门题。我突然想起使用vector来解决，在解决过程中发现了一些vector使用的不熟悉和误区。 刚开始使用pop_back()里面加入元素删除此元素，但是一直报错，还以为是min_element()使用错误，于是查了cplusplus，结果发现并没有错。于是又查了一些vector 的使用，才反应过来pop_back 是删除 末尾元素， 引发关于m...
寻找能被3整除的斐波拿契数问题
qq_44654974的博客
03-31 1926
今天晚上做了两道OJ题，其中寻找能被3整除的斐波拿契数一直不通过，明明给的例子都能通过，我甚至怀疑机器出错了。后面看了看报错原因：complie error，runtime。猜测估计是时间复杂度过大，还没算了算的确递归的复杂度过大，于是换为迭代，结果还是不通过。然后又重新读题，发现规模n在1-100000，突然焕然大悟，问题出在存储长度。果然看似简单的题也不能掉以轻心啊，多注意时间复杂度和规模！！...
用邻接矩阵实现DFS和BFS
03-12
使用邻接矩阵实现DFS和BFS是常见的图遍历算法。DFS（深度优先搜索）从起点开始，尽可能深地搜索每个节点，直到找到目标节点或者无法继续搜索为止。BFS（广度优先搜索）从起点开始，逐层遍历每个节点，直到找到目标...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值