蓝桥杯省一你一定不能错过的模板大全（第三期）

寸_铁2023-07-27 23:13

大家好 我是寸铁💪

冲刺蓝桥杯省一模板大全来啦 🔥

蓝桥杯4月8号就要开始了 🙏

距离蓝桥杯省赛倒数第4天 ❗️ ❗️ ❗️

还没背熟模板的伙伴们背起来 💪 💪 💪

真题千千万万遍，蓝桥省一自然现！ ✌️

日更3000里，蓝桥眷顾你 🌟

祝大家4月8号蓝桥杯上岸 ☀️ ~

还没背熟模板的伙伴们背起来 💪 💪 💪

祝大家4月8号蓝桥杯上岸 ☀️

不清楚蓝桥杯考什么的点点下方👇

考点秘籍

想背纯享模版的伙伴们点点下方👇

蓝桥杯省一你一定不能错过的模板大全(第一期)

蓝桥杯省一你一定不能错过的模板大全（第二期）

想背注释模版的伙伴们点点下方👇

蓝桥杯必背第一期

蓝桥杯必背第二期

往期精彩回顾

蓝桥杯上岸每日N题 第一期(一)！！！

蓝桥杯上岸每日N题第一期(二)！！！

蓝桥杯上岸每日N题第一期(三)！！！

蓝桥杯上岸每日N题第二期(一)！！！

蓝桥杯上岸每日N题第三期(一)！！！

操作系统期末题库 第九期(完结)

LeetCode Hot100 刷题(第三期)

idea创建SpringBoot项目报错解决方案

数据库SQL语句（期末冲刺）

想看JavaB组填空题的伙伴们点点下方 👇

填空题

竞赛干货

算法竞赛字符串常用操作大全

蓝桥杯上岸必刷！！！(模拟/枚举专题)

蓝桥杯上岸必背！！！ (第三期 DP)

蓝桥杯上岸必背！！！(第四期DFS)

蓝桥杯上岸必背！！！(第五期BFS)

蓝桥杯上岸必背！！！(第六期树与图的遍历)

蓝桥杯上岸必背！！！(第七期 最短路算法)

前言

考虑到部分同学觉得题解版背模板觉得比较不方便，整理纯模板放便大家背 ✌️ ~

题解也被我单独切出来，需要直接点击查看即可，是不是很贴心 💓

DFS

排列数字

题解

java 复制代码 
import java.util.*;
public class Main{
    static int n;
    static boolean st[]=new boolean[10];
    static int a[]=new int[10];
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        dfs(0);
    }
    public static void dfs(int u){
        if(u==n){
            for(int i=0;i<n;i++){
                System.out.print(a[i]+" ");
            }
            System.out.println();
        }
        for(int i=1;i<=n;i++){
            if(!st[i]){
                a[u]=i;
                st[i]=true;
                dfs(u+1);
                st[i]=false;
            }
        }
        
        
    }
    
    
}

n-皇后问题

题解

java 复制代码 
import java.util.*;
public class Main{
    static int N=10;
    static char g[][]=new char [N][N];
    static boolean col[]=new boolean[N];
    static boolean row[]=new boolean[N];
    static boolean dg[]=new boolean[2*N];
    static boolean udg[]=new boolean [2*N];
    static int n;
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        dfs(0,0,0);
    }
    public static void dfs(int x,int y,int s){
        if(s>n)return;
        if(y==n){
            y=0;
            x++;
        }
        if(x==n){
            if(s==n){
                for(int i=0;i<n;i++){
                    for(int j=0;j<n;j++){
                        System.out.print(g[i][j]);
                    }
                    System.out.println();
                }
                System.out.println();
            }
            return;
        }
        g[x][y]='.';
        dfs(x,y+1,s);
        if(!row[x]&&!col[y]&&!dg[x+y]&&!udg[x-y+n]){
            g[x][y]='Q';
            row[x]=col[y]=dg[x+y]=udg[x-y+n]=true;
            dfs(x,y+1,s+1);
            row[x]=col[y]=dg[x+y]=udg[x-y+n]=false;
            g[x][y]='.';
        }
        
        
    }
}

BFS

走迷宫

题解

java 复制代码 
import java.util.*;
public class Main{
    static int N=110;
    static int n,m;
    static PII q[]=new PII[N*N];
    static int d[][]=new int[N][N];
    static int dx[]={0,1,-1,0};
    static int dy[]={1,0,0,-1};
    static int g[][]=new int[N][N];
    static int  hh,tt;
    public static int bfs(){
        hh=0;
        tt=-1;
        q[++tt]=new PII(0,0);
        d[0][0]=0;
        while(hh<=tt){
            PII t=q[hh++];
            for(int i=0;i<4;i++){
            int a=t.x+dx[i];
            int b=t.y+dy[i];
            if(a>=0&&a<=n&&b>=0&&b<=m&&d[a][b]==-1&&g[a][b]==0){
                d[a][b]=d[t.x][t.y]+1;
                q[++tt]=new PII(a,b);
                
            }
            }
            
            
        }
        return d[n-1][m-1];
        
        
    }
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        m=sc.nextInt();
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                g[i][j]=sc.nextInt();
                d[i][j]=-1;
            }
        }
        System.out.println(bfs());
    }
    
    
}
class PII{
    int x;
    int y;
    public PII(int x,int y){
        this.x=x;
        this.y=y;
    }
}

八数码

题解

java 复制代码 
import java.util.*;
public class Main{
    public static void swap(char arr[],int x,int y){
        char temp=arr[x];
        arr[x]=arr[y];
        arr[y]=temp;
    }
    public static int bfs(String start ,String end){
        Map<String,Integer>map=new HashMap<>();
        //存一个键值对映射
        Queue<String >q=new LinkedList<>();
        q.offer(start);
        map.put(start,0);
        int dx[]={-1,0,1,0};
        int dy[]={0,1,0,-1};
        while(!q.isEmpty()){
        String t=q.poll();
        int k=t.indexOf('x');
        int x=k/3;
        int y=k%3;
        if(t.equals(end))return map.get(t);
        for(int i=0;i<4;i++){
            int a=x+dx[i];
            int b=y+dy[i];
            if(a<3&&a>=0&&b<3&&b>=0){
                char []str=t.toCharArray();
                swap(str,k,a*3+b);
                String s=new String(str);
                if(map.get(s)==null){
                    map.put(s,map.get(t)+1);
                    q.offer(s);
                }
            }
            
        }
    }
    return -1;
    }
    public static void main(String []args){
        Scanner in = new Scanner(System.in);
        String start="";
        for(int i=0;i<9;i++){
            String x=in.next();
            start+=x;
        }
        String end="12345678x";
        System.out.println(bfs(start,end));
    }
}

树与图的深度优先遍历

模板题

题解

java 复制代码 
import java.util.*;
public class Main{
    static int N=100010;
    static int e[]=new int[N*2];
    static int ne[]=new int[N*2];
    static int h[]=new int[N];
    static boolean st[]=new boolean[N];
    static int ans=0x3f3f3f3f,idx,n;
    public static void add(int a,int b){
        e[idx]=b;
        ne[idx]=h[a];
        h[a]=idx;
        idx++;
    }
    public static int dfs(int u){
        int sum=1;
        int res=0;
        st[u]=true;
        for(int i=h[u];i!=-1;i=ne[i]){
            int j=e[i];
            if(!st[j]){
                int s=dfs(j);
                res=Math.max(s,res);
                sum+=s;
            }
        }
        res=Math.max(res,n-sum);
        ans=Math.min(ans,res);
        return sum;
    }
    public static void main (String []args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        Arrays.fill(h,-1);
        for(int i=0;i<n-1;i++){
            int a=sc.nextInt();
            int b=sc.nextInt();
            add(a,b);
            add(b,a);
    }
    dfs(1);
    System.out.println(ans);
}
}

树与图的广度优先遍历

模板题

题解

java 复制代码 
import java.util.*;
public class Main{
    static int N=100010;
    static int e[]=new int[N];
    static int ne[]=new int[N];
    static int d[]=new int[N];
    static int q[]=new int[N];
    static int h[]=new int[N];
    static int idx,n,m,hh,tt;
    public static void add(int a,int b){
        e[idx]=b;
        ne[idx]=h[a];
        h[a]=idx;
        idx++;   
        
    }
    public static int bfs(){
        hh=0;
        tt=-1;
        q[++tt]=1;
        d[1]=0;
        while(hh<=tt){
            int t=q[hh++];
        for(int i=h[t];i!=-1;i=ne[i]){
            int j=e[i];
            if(d[j]==-1){
                d[j]=d[t]+1;
                q[++tt]=j;
            }
        }
    }
    return d[n];
    }
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
         n=sc.nextInt();
         m=sc.nextInt();
        Arrays.fill(h,-1);
        Arrays.fill(d,-1);
        for(int i=0;i<m;i++){
            int a=sc.nextInt();
            int b=sc.nextInt();
            add(a,b);
        }
        System.out.println(bfs());
    }
}

java容器类:Queue

java 复制代码 
import java.util.*;
public class Main{
    static int N=100010;
    static int e[]=new int[N];
    static int ne[]=new int[N];
    static int d[]=new int[N];
    static int q[]=new int[N];
    static int h[]=new int[N];
    static int idx,n,m,hh,tt;
    public static void add(int a,int b){
        e[idx]=b;
        ne[idx]=h[a];
        h[a]=idx;
        idx++;   
        
    }
    public static int bfs(){
        Queue<Integer>q=new LinkedList<Integer>();
        q.add(1);
        d[1]=0;
        while(!q.isEmpty()){
            int t=q.poll();
        for(int i=h[t];i!=-1;i=ne[i]){
            int j=e[i];
            if(d[j]==-1){
                d[j]=d[t]+1;
                q.add(j);
            }
        }
    }
    return d[n];
    }
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
         n=sc.nextInt();
         m=sc.nextInt();
        Arrays.fill(h,-1);
        Arrays.fill(d,-1);
        for(int i=0;i<m;i++){
            int a=sc.nextInt();
            int b=sc.nextInt();
            add(a,b);
        }
        System.out.println(bfs());
    }
}

Dijkstra朴素版

Dijkstra求最短路I

题解

java 复制代码 
import java.util.*;
public class Main{
    static int N=510,n,m,INF=0x3f3f3f3f;
    static int g[][]=new int[N][N];
    static int dist[]=new int[N];
    static boolean st[]=new boolean[N];
    public static int dijkstra(){
        Arrays.fill(dist,INF);
        dist[1]=0;
        for(int i=0;i<n;i++){
            int t=-1;
            for(int j=1;j<=n;j++){
            if(!st[j]&&(t==-1||dist[j]<dist[t])){
                t=j;
            }
        }
        st[t]=true;
        for(int j=1;j<=n;j++){
            dist[j]=Math.min(dist[j],dist[t]+g[t][j]);
            
        }
    }
    if(dist[n]==INF)return -1;
    return dist[n];
    }
    
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        m=sc.nextInt();
        for(int i=1;i<=n;i++){
            Arrays.fill(g[i],INF);
        }
        while(m-->0){
            int a=sc.nextInt();
            int b=sc.nextInt();
            int c=sc.nextInt();
            g[a][b]=Math.min(g[a][b],c);
        }
           System.out.println(dijkstra());
    }
}

Dijkstra求最短路II

题解

java 复制代码 
import java.io.*;
import java.util.*;
public class Main{
	static int N=150010,idx,n,m;
	static int dist[]=new int[N];
	static int h[]=new int[N],e[]=new int[N],ne[]=new int[N],w[]=new int[N];
	static boolean st[]=new boolean[N];
	static int INF=0x3f3f3f3f;
	public static void add(int a,int b, int  c) {
		e[idx]=b;
		w[idx]=c;
		ne[idx]=h[a];
		h[a]=idx++;
	}
	public static int dijkstra() {
		PriorityQueue<PIIs>queue=new PriorityQueue<>();
		Arrays.fill(dist, INF);
		dist[1]=0;
		queue.add(new PIIs(0,1));
		//第一个是距离，后一个是点。
		while(!queue.isEmpty()) {
			PIIs p= queue.poll();
			int t=p.getSecond();
			int distance=p.getFirst();
			if(st[t])continue;
			st[t]=true;
			for(int i=h[t];i!=-1;i=ne[i]) {
				int j=e[i];
				if(dist[j]>distance+w[i]) {
					dist[j]=distance+w[i];
					queue.add(new PIIs(dist[j],j));
				}
			}
		}
		if(dist[n]==INF)return -1;
		else return dist[n];
	}
	public static void main(String []args) throws IOException {
		BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
		String []str=bf.readLine().split(" ");
		n=Integer.parseInt(str[0]);
		m=Integer.parseInt(str[1]);
		Arrays.fill(h, -1);
		while(m-->0) {
			String s[]=bf.readLine().split(" ");
			int a=Integer.parseInt(s[0]);
			int b=Integer.parseInt(s[1]);
			int c=Integer.parseInt(s[2]);
			add(a,b,c);
		}
		System.out.println(dijkstra());
		
	}
}
	class PIIs implements Comparable<PIIs>{
		private int first;
		private int second;
		public int getFirst() {
			
			return this.first;
		}
		public int getSecond() {
			return this.second;
			
		}
		public PIIs(int first,int second) {
			this.first=first;
			this.second=second;
			
		}
		//按数字首位字典序排序
		public int compareTo(PIIs o) {
			return Integer.compare(first, o.first);
			
		}
	}

spfa求最短路

java 复制代码 
import java.util.*;
public class Main{
    static int N=100010,INF=0x3f3f3f3f;
    static int e[]=new int[N];
    static int ne[]=new int[N];
    static int w[]=new int[N];
    static int h[]=new int[N];
    static int dist[]=new int[N];
    static boolean st[]=new boolean[N];
    static int n,m,idx;
    public static void add(int a,int b,int c){
        e[idx]=b;
        w[idx]=c;
        ne[idx]=h[a];
        h[a]=idx;
        idx++;
    }
   public static void spfa(){
       Queue<Integer>q=new LinkedList<Integer>();
       Arrays.fill(dist,INF);
       q.offer(1);
       st[1]=true;
       dist[1]=0;
       while(!q.isEmpty()){
           int t=q.poll();
           st[t]=false;
       for(int i=h[t];i!=-1;i=ne[i]){
           int j=e[i];
           if(dist[j]>dist[t]+w[i]){
               dist[j]=dist[t]+w[i];
               if(!st[j]){
                   q.offer(j);
                   st[j]=true;
               }
           }
       }
   }
   if(dist[n]==INF)System.out.println("impossible");
   else System.out.println(dist[n]);
   }
      
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        Arrays.fill(h,-1);
        n=sc.nextInt();
        m=sc.nextInt();
        while(m-->0){
            int a=sc.nextInt();
            int b=sc.nextInt();
            int c=sc.nextInt();
            add(a,b,c);
            
        }
        spfa();
        
        
        
    }
}

✨ ✨ ✨
看到这里，不妨点个关注 💖

相关推荐
鸽鸽程序猿2 分钟前
【算法】【优选算法】宽搜（BFS）中队列的使用
算法·宽度优先·队列
Jackey_Song_Odd2 分钟前
C语言 单向链表反转问题
c语言·数据结构·算法·链表
ProtonBase5 分钟前
如何从 0 到 1 ，打造全新一代分布式数据架构
java·网络·数据库·数据仓库·分布式·云原生·架构
Watermelo6176 分钟前
详解js柯里化原理及用法，探究柯里化在Redux Selector 的场景模拟、构建复杂的数据流管道、优化深度嵌套函数中的精妙应用
开发语言·前端·javascript·算法·数据挖掘·数据分析·ecmascript
乐之者v11 分钟前
leetCode43.字符串相乘
java·数据结构·算法
小奥超人12 分钟前
RAR压缩算法的文件修复功能详解
windows·经验分享·winrar·办公技巧
A懿轩A1 小时前
C/C++ 数据结构与算法【数组】 数组详细解析【日常学习，考研必备】带图+详细代码
c语言·数据结构·c++·学习·考研·算法·数组
古希腊掌管学习的神1 小时前
[搜广推]王树森推荐系统——矩阵补充&最近邻查找
python·算法·机器学习·矩阵
云边有个稻草人1 小时前
【优选算法】—复写零（双指针算法）
笔记·算法·双指针算法
半盏茶香1 小时前
在21世纪的我用C语言探寻世界本质 ——编译和链接（编译环境和运行环境）
c语言·开发语言·c++·算法
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程