蓝桥杯上岸必背模板 (纯享版）

大家好 我是寸铁

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

日更3000里，蓝桥眷顾你

暴力出奇迹，打表过样例

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

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

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

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

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

日更3000里，蓝桥眷顾你

暴力出奇迹，打表过样例

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

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

考点秘籍

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

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

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

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

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

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

蓝桥杯必背第一期

蓝桥杯必背第二期

往期精彩回顾

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

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

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

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

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

蓝桥杯上岸每日N题 第四期(最少刷题数)！！！

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

蓝桥杯上岸每日N题 第六期(求阶乘)！！！

蓝桥杯上岸每日N题 第七期(小猫爬山)！！！

蓝桥杯上岸每日N题 第八期 (全球变暖)！！！

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

LeetCode Hot100 刷题(第三期)

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

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

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

填空题

竞赛干货

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

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

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

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

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

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

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

蓝桥杯上岸必背！！！(第八期 简单数论)

蓝桥杯上岸必刷！！！(进制、数位专题)

蓝桥杯上岸考点清单 (冲刺版）！！！

祝大家蓝桥杯上岸 ✌️

暴力出奇迹，打表过样例！

日更3000里，省一眷顾你！

不开Long Long见祖宗，多多模拟必成功！

---

二分

import java.util.*;
public class Main{
    public static void main(String []args){
        Scanner in  = new Scanner(System.in);
        int n = in.nextInt();
        int q=in.nextInt();
        int a[]=new int[100010];
        for(int i=0;i<n;i++)a[i]=in.nextInt();
        while(q-->0){
            int x=in.nextInt();
            int l=0,r=n-1;
            while(l<r){
                int mid=l+r>>1;
                if(a[mid]>=x){
                    r=mid;
                }
                else{
                    l=mid+1;
                }
            }
                if(a[l]!=x){
                    System.out.println("-1 -1");
            }
            else{
                System.out.print(l+" ");
                l=0;r=n-1;
                while(l<r){
                int mid=l+r+1>>1;
                if(a[mid]<=x)l=mid;
                else r=mid-1;
                }
                System.out.println(l);
            }
            
        }
        
        
    }
      
}

---

双指针

//对一段序列用两个指针实现同步的移动

import java.util.*;
public class Main{
    static int N=100010;;
    static int a[]=new int [N];
    static int s[]=new int [N];
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int res=0;
        for(int i=0;i<n;i++)a[i]=sc.nextInt();
        for(int i=0,j=0;i<n;i++){
            s[a[i]]++;
            while(j<=i&&s[a[i]]>1){
                s[a[j]]--;
                j++;
            }
            res=Math.max(res,i-j+1);
            
        }
        System.out.println(res);
        
        
    }

}

---

前缀和:

模板1

import java.util.*;
public class Main{
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int s[]=new int[n+10];
        int a[]=new int[n+10];
        for(int i=1;i<=n;i++){
            a[i]=sc.nextInt();
        }
        for(int i=1;i<=n;i++){
            s[i]+=s[i-1]+a[i];
        }
        while(m-->0){
            int l=sc.nextInt();
            int r=sc.nextInt();
            System.out.println(s[r]-s[l-1]);
        }
    }
}

模板2

import java.util.*;
public class Main{
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        //int a[]=new int[n+10];
        int s[]=new int[n+10];
        for(int i=1;i<=n;i++){
            s[i]=sc.nextInt();
        }
        for(int i=1;i<=n;i++){
            s[i]+=s[i-1];
        }
        while(m-->0){
            int l=sc.nextInt();
            int r=sc.nextInt();
            System.out.println(s[r]-s[l-1]);
        }
    }
}

---

子矩阵的和：

对于每个询问输出子矩阵中所有数(值)的和

import java.util.*;
public class Main{
        static int N=1010;
        static int a[][]=new int[N][N];
        static int s[][]=new int[N][N];
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int q=sc.nextInt();
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                a[i][j]=sc.nextInt();
            }
        }
        //预处理前缀和
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+a[i][j];
            }
        }
        while(q-->0){
            int x1=sc.nextInt();
            int y1=sc.nextInt();
            int x2=sc.nextInt();
            int y2=sc.nextInt();
            System.out.println(s[x2][y2]-s[x2][y1-1]-s[x1-1][y2]+s[x1-1][y1-1]);
        }
    }
}

---

差分模板

import java.util.*;
public class Main{
    static int N=100010;
    static int b[]=new int[N];
    static int a[]=new int[N];
    public static void main(String []args){
        Scanner in = new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        for(int i=1;i<=n;i++)
        {
         a[i]=in.nextInt();
         insert(i,i,a[i]);
        }
        while(m-->0){
            int l= in.nextInt();
            int r=in.nextInt();
            int c=in.nextInt();
            insert(l,r,c);
        }
        for(int i=1;i<=n;i++){
            a[i]=a[i-1]+b[i];
            System.out.print(a[i]+" ");
        }
    }
    public static void insert(int l,int r,int c){
        b[l]+=c;
        b[r+1]-=c;
    }
}

---

差分矩阵 矩阵内数字加上C

import java.util.*;
public class Main{
    static int N=1010;
    static int b[][]=new int[N][N];
    static int a[][]=new int[N][N];
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int q=sc.nextInt();
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                a[i][j]=sc.nextInt();
                insert(i,j,i,j,a[i][j]);
            }
        }
        while(q-->0){
            int x1=sc.nextInt();
            int y1=sc.nextInt();
            int x2=sc.nextInt();
            int y2=sc.nextInt();
            int c=sc.nextInt();
            insert(x1,y1,x2,y2,c);
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                a[i][j]=a[i-1][j]+a[i][j-1]-a[i-1][j-1]+b[i][j];
                System.out.print(a[i][j]+" ");
            }
            System.out.println();
        }
        
        
    }
    public static void insert(int x1,int y1,int x2,int y2,int c){
        b[x1][y1]+=c;
        b[x1][y2+1]-=c;
        b[x2+1][y1]-=c;
        b[x2+1][y2+1]+=c;
    }
}

---

归并排序：

import java.util.*;
public class Main{
    public static void main(String []args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int q[] = new int [n];
        for(int i=0;i<n;i++){
            q[i]=in.nextInt();
        }
        mergeSort(q,0,n-1);
        for(int i=0;i<n;i++){
            System.out.print(q[i]+" ");
        }
    }
    public static void mergeSort(int q[],int l,int r ){
        if(l>=r)return;
        int mid = (l+r)/2;
        mergeSort(q,l,mid);
        mergeSort(q,mid+1,r);
        int temp[] = new int[r-l+1];
        int k=0,i=l,j=mid+1;
        while(i<=mid&&j<=r)
        if(q[i]<=q[j]&&j<=r)
        temp[k++]=q[i++];
        else
        temp[k++]=q[j++];
        while(i<=mid)
        temp[k++]=q[i++];
        while(j<=r)
        temp[k++]=q[j++];
        for(int a=l,b=0;a<=r;a++,b++){
            q[a]=temp[b];
        }
    }
}

---

二进制中1的个数

import java.util.*;
public class Main{
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        while(n-->0){
            int x=sc.nextInt();
            int sum=0;
            while(x!=0){
                x-=lowbit(x);
                sum++;
            }
            System.out.print(sum+" ");
        }
    }
    public static int lowbit(int x){
        return x&-x;
    }
}

----------------------------------------、

并查集

import java.util.*;
public class Main{
    static int N=100010;
    static int p[]=new int[N];
    public static int find(int x){
        if(x!=p[x])p[x]=find(p[x]);
        return p[x];
        
    }
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        for(int i=1;i<=n;i++)p[i]=i;
        while(m-->0){
            String s=sc.next();
            if(s.equals("M")){
                int a=sc.nextInt();
                int b=sc.nextInt();
                if(find(a)!=find(b)){
                    p[find(a)]=find(b);
                }
            }
            else{
                int a=sc.nextInt();
                int b=sc.nextInt();
                if(find(a)==find(b))System.out.println("Yes");
                else System.out.println("No");
            }
        }
    }
}

---

0-1背包

import java.util.*;
public class Main{
    static int N=1010;
    static int w[]=new int[N];
    static int V[]=new int[N];
    static int f[][]=new int[N][N];
    public static void main(String []args){
        Scanner in = new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        for(int i=1;i<=n;i++){
            V[i]=in.nextInt();
            w[i]=in.nextInt();
        }
        for(int i=1;i<=n;i++){
            for(int j=0;j<=m;j++){
                f[i][j]=f[i-1][j];
                if(j>=V[i])f[i][j]=Math.max(f[i][j],f[i-1][j-V[i]]+w[i]);
            }
        }
        System.out.println(f[n][m]);
        
    }
}

---

完全背包问题

import java.util.*;
public class Main{
    static int N=1010;
    static int f[][]=new int [N][N];
    static int v[]=new int[N];
    static int w[]=new int[N];
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        for(int i=1;i<=n;i++){
            v[i]=sc.nextInt();
            w[i]=sc.nextInt();
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                f[i][j]=f[i-1][j];
                if(j>=v[i])f[i][j]=Math.max(f[i][j],f[i][j-v[i]]+w[i]);
            }
        }
        System.out.println(f[n][m]);
    }
}

---

多重背包

//一件物品选k次
//最多选s[i]次，体积不超过j

import java.util.*;
public class Main{
    static int N=110;
    static int f[][]=new int[N][N];
    static int v[]=new int[N];
    static int w[]=new int[N];
    static int s[]=new int[N];
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        for(int i=1;i<=n;i++){
            v[i]=sc.nextInt();
            w[i]=sc.nextInt();
            s[i]=sc.nextInt();
        }
        for(int i=1;i<=n;i++){
            for(int j=0;j<=m;j++){
                for(int k=0;k<=s[i]&&k*v[i]<=j;k++){
                    f[i][j]=Math.max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
                }
            }
        }
    System.out.println(f[n][m]);    
    }
}

---

分组背包

import java.util.*;
public class Main{
    static int N=1010;
    static int s[]=new int[N];
    static int f[][]=new int[N][N];
    static int w[][]=new int[N][N];
    static int v[][]=new int[N][N];
    public static  void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        for(int i=1;i<=n;i++){
            s[i]=sc.nextInt();
            for(int j=1;j<=s[i];j++){
                v[i][j]=sc.nextInt();
                w[i][j]=sc.nextInt();
            }
        }
        for(int i=1;i<=n;i++){
            for(int j=0;j<=m;j++){
                f[i][j]=f[i-1][j];
                for(int k=1;k<=s[i];k++){
                    if(j>=v[i][k])f[i][j]=Math.max(f[i][j],f[i-1][j-v[i][k]]+w[i][k]);
                }
            }
        }
        System.out.println(f[n][m]);
        
    }
}

---

线性DP: 数字三角形

import java.util.*;
public class Main{
    static int N=510;
    static int a[][]=new int[N][N];
    static int f[][]=new int[N][N];
    static int INF=0x3f3f3f3f;
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        for(int i=1;i<=n;i++){
            for(int j=1;j<=i;j++){
                a[i][j]=sc.nextInt();
            }
        }
        //0和i+1都会被走到需要初始化
        for(int i=0;i<=n;i++){
            for(int j=0;j<=i+1;j++){
                f[i][j]=-INF;
                
            }
        }
        f[1][1]=a[1][1];
        //第1层已初始化
        //遍历第2层到第n层的三角形的所有点
        //直至最后一层遍历完毕
        for(int i=2;i<=n;i++){
            for(int j=1;j<=i;j++){
                f[i][j]=Math.max(f[i-1][j-1]+a[i][j],f[i-1][j]+a[i][j]);
            }
        }
        long res=f[n][1];
        //先定义为最大，比他大的可以被筛出
        //没有比他大的，则它最大
        for(int i=1;i<=n;i++){
            res=Math.max(f[n][i],res);
        }
        
        System.out.println(res);
    }
}

---

线性DP: 最长上升子序列

import java.util.*;
public class Main{
    static int N=1010;
    static int a[]=new int[N];
    static int q[]=new int[N];
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        for(int i=0;i<n;i++)a[i]=sc.nextInt();
        int len=0;
        for(int i=0;i<n;i++){
        int l=0,r=len;
        while(l<r){
            int mid=l+r+1>>1;
            if(q[mid]<a[i])l=mid;
            else r=mid-1;
        }
        len=Math.max(len,r+1);
        q[r+1]=a[i];
        }
        System.out.println(len);
    }
}

---

区间DP

import java.util.*;
public class Main{
    static int N=310;
    static int f[][]=new int[N][N];
    static int s[]=new int[N];
    public static void main(String []args){
        Scanner in = new Scanner(System.in);
        int n=in.nextInt();
        for(int i=1;i<=n;i++)s[i]=in.nextInt();
        for(int i=1;i<=n;i++)s[i]+=s[i-1];
        for(int len=2;len<=n;len++){
            for(int i=1;i+len-1<=n;i++){
            int l=i,r=i+len-1;
            f[l][r]=0x3f3f3f3f;
            for(int k=l;k<r;k++){
                f[l][r]=Math.min(f[l][r],f[l][k]+f[k+1][r]+s[r]-s[l-1]);
            }
        }
        }
        System.out.println(f[1][n]);
    }
}

---

排列数字DFS

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;
            }
        }
    }
}

---

BFS 走迷宫

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;
    }
}

---

全球变暖 BFS

import java.util.*;
public class Main{
    static int N=1010;
    static boolean st[][]=new boolean[N][N];
    static char g[][]=new char[N][N];
    static int n;
    static int dx[]={0,1,0,-1};
    static int dy[]={1,0,-1,0};
    public static boolean bfs(int x,int y){
        Queue<PII>q=new LinkedList<PII>();
        q.add(new PII(x,y));
        st[x][y]=true;
        int cnt=0;
        int bound=0;
        while(!q.isEmpty()){
            PII t=q.poll();
            cnt++;
            boolean isbound=false;
            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>=n)continue;
                if(st[a][b])continue;
                if(!st[a][b]&&g[a][b]=='.'){
                    isbound=true;
                    continue;
                }
                q.add(new PII(a,b));
                st[a][b]=true;
                    
            }
            if(isbound)bound++;
        }
        return bound==cnt;
    }
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        for(int i=0;i<n;i++){
            char a[]=sc.next().toCharArray();
            for(int j=0;j<a.length;j++){
                g[i][j]=a[j];
            }
        }
        int res=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(!st[i][j]&&g[i][j]=='#'){
                    if(bfs(i,j))res++;
                }
            }
        }
    System.out.println(res);
    }
}
class PII{
    int x;
    int y;
    public PII(int x,int y)
    {
        this.x=x;
        this.y=y;
        
    }
}

---

spfa求最短路

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();
    }
}

---

dijkstra I

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

---

dijkstra II（堆优化版排序）

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);
			
		}
	}

---

最大公约数gcd

import java.util.*;
public class Main{
    public static int gcd(int a,int b){
        while(b!=0){
            int c=a%b;
            a=b;
            b=c;
        }
        return a;
    }
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        while(n-->0){
        int a=sc.nextInt();
        int b=sc.nextInt();
        System.out.println(gcd(a,b));
    }
}
}

---

筛质数

import java.util.*;
public class Main{
    static int N=1000010;
    static int primes[]=new int[N];
    static boolean st[]=new boolean[N];
    static int cnt;
    public static int get_primes(int x){
        for(int i=2;i<=x;i++){
            if(!st[i]){
                primes[cnt++]=i;
            for(int j=i;j<=x;j+=i){
                st[j]=true;
            }
        }
    }
    return cnt;
    }

    public static void main(String []args)
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        System.out.println(get_primes(n));
    }
}