刷题(二)+基础复习

最新推荐文章于 2024-07-27 17:56:15 发布
最新推荐文章于 2024-07-27 17:56:15 发布
阅读量121 收藏
点赞数
文章标签： java 蓝桥杯 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51934288/article/details/129946487
版权

P8778 [蓝桥杯 2022 省 A] 数的拆分

真的不是黄题的难度。。。。刚开始以为就是个质因子分解的题

import java.io.*;
import java.util.*;
import java.util.concurrent.ScheduledExecutorService;

public class Main {
    static Scanner cin=new Scanner(System.in);
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    static int N=4010;static long INF=Long.MAX_VALUE/2;static long mod=1000000007;
    static long prime[]=new long[N];static int cnt=0;
    static boolean vis[]=new boolean[N];
    public static void init()
    {
        for(int i=2;i<=4000;i++){
            if(!vis[i]){
                prime[++cnt]=i;
                for(int j=i;j<=4000;j+=i){
                    vis[j]=true;
                }
            }
        }
    }
    public static boolean check(long x)
    {
        long k=(long)Math.pow(x,1.0/2);
        if(k*k==x||(k+1)*(k+1)==x)
            return true;
        k=(long)Math.pow(x,1.0/3);
        if(k*k*k==x||(k+1)*(k+1)*(k+1)==x||(k+2)*(k+2)*(k+2)==x)
            return true;
        return false;
    }
    public static void main(String[] args) throws IOException
    {
        init();
        int t=cin.nextInt();
        while(t-->0)
        {
            long x=cin.nextLong();
            if(check(x)){
                out.println("yes");
                continue;
            }
            int flag=1;
            for(int i=1;i<=cnt;i++){
                if(x%prime[i]==0) {
                    int g = 0;
                    while (x % prime[i] == 0) {
                        g++;
                        x /= prime[i];
                    }
                    if (g == 1) {
                        flag = 0;
                        break;
                    }
                }
            }
            if(flag>0 && check(x))
                out.println("yes");
            else
                out.println("no");
        }
        out.close();
    }
}

P8804 [蓝桥杯 2022 国 B] 故障

会卡精度，两个浮点数相等的条件设置到10的-9次方或者更低。

import java.io.*;
import java.util.*;

public class Main {
    static Scanner cin=new Scanner(System.in);
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    static int N=4010;static long INF=Long.MAX_VALUE/2;static long mod=1000000007;
    static int n,m,k,b[]=new int[105];
    static double a[][]=new double[105][105],p[]=new double[105],ans[]=new double[105];

    public static void main(String[] args) throws IOException
    {
        n=cin.nextInt();m=cin.nextInt();
        for(int i=1;i<=n;i++) p[i]=cin.nextDouble()*0.01;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++) a[i][j]=cin.nextDouble()*0.01;
        k=cin.nextInt();
        for(int i=1;i<=k;i++){
            int x=cin.nextInt();b[x]=1;
        }
        for(int i=1;i<=n;i++){
            ans[i]=p[i];
            for(int j=1;j<=m;j++){
                if(b[j]>0) ans[i]*=a[i][j];
                else ans[i]*=(1-a[i][j]);
            }
        }
        double sum=0;
        for(int i=1;i<=n;i++) sum+=ans[i];
        List<double[]> e=new ArrayList<>();
        for(int i=1;i<=n;i++)
            e.add(new double[]{(double) i,ans[i]/sum});
        Collections.sort(e, new Comparator<double[]>() {
            @Override
            public int compare(double[] o1, double[] o2) {
                if(Math.abs(o1[1]-o2[1])<1e-9)
                    return (int) (o1[0]-o2[0]);
                if(o1[1]>o2[1]) return -1;
                else return 1;
            }
        });
        for(double[] k:e){
            System.out.println((int)k[0]+" "+String.format("%.2f",k[1]*100).toString());
        }
        out.close();
    }
}

P8783 [蓝桥杯 2022 省 B] 统计子矩阵

80分做法，矩阵前缀和+四重循环

import java.io.*;
import java.util.*;

public class Main {
    static Scanner cin=new Scanner(System.in);
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    static int N=4010;static long INF=Long.MAX_VALUE/2;static long mod=1000000007;
    static int n,m,val,a[][]=new int[505][505],sum[][]=new int[505][505];

    public static void main(String[] args) throws IOException
    {
        n=cin.nextInt();m=cin.nextInt();val=cin.nextInt();
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++) {
                a[i][j]=cin.nextInt();
                sum[i][j]=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+a[i][j];
            }
        int ans=0,tmp=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                for(int k=0;k<i;k++)
                {
                    for(int g=0;g<j;g++)
                    {
                        tmp=sum[i][j]-sum[i][g]-sum[k][j]+sum[k][g];
                        if(tmp<=val) ans++;
                    }
                }
            }
        }
        System.out.println(ans);
        out.close();
    }
}

双指针优化一重循环，ac

import java.io.*;
import java.util.*;

public class Main {
    static Scanner cin=new Scanner(System.in);
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    static int N=4010;static long INF=Long.MAX_VALUE/2;static long mod=1000000007;
    static int n,m,val,a[][]=new int[505][505],sum[][]=new int[505][505];
    public static int sum(int x1,int y1,int x2,int y2)
    {
        return sum[x2][y2]-sum[x1-1][y2]-sum[x2][y1-1]+sum[x1-1][y1-1];
    }
    public static void main(String[] args) throws IOException
    {
        n=cin.nextInt();m=cin.nextInt();val=cin.nextInt();
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++) {
                a[i][j]=cin.nextInt();
                sum[i][j]=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+a[i][j];
            }
        long ans=0;
        int up=0,down=0,l=0,r=0;
        for(up=1;up<=n;up++)
        {
            for(down=up;down<=n;down++)
            {
                for(r=1,l=1;r<=m;r++)
                {
                    while(l<=r&&sum(up,l,down,r)>val) l++;
                    if(l<=r) ans+=r-l+1;
                }
            }
        }
        System.out.println(ans);
        out.close();
    }
}

P8808 [蓝桥杯 2022 国 C] 斐波那契数组

暴力枚举数组前两项。数组长度最大不超过30（1，1，2，3，5，8……）。
而长度受到起始2项的限制。

import java.io.*;
import java.util.*;

public class Main {
    static Scanner cin=new Scanner(System.in);
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    static int N=100010;static long INF=Long.MAX_VALUE/2;static long mod=1000000007;
    static int n,a[]=new int[N],f[]=new int[N];
    public static void main(String[] args) throws IOException
    {
        n=cin.nextInt();
        int mx=0;
        for(int i=1;i<=n;i++) {
            a[i]=cin.nextInt();
            mx=Math.max(mx,(int)Math.log(a[i]));
        }
        int ans=1000000;
        for(int i=1;i<=mx*30;i++)
        {
            int cnt=0;
            f[1]=f[2]=i;
            if(f[1]!=a[1]) cnt++;
            if(f[2]!=a[2]) cnt++;
            for(int j=3;j<=n;j++)
            {
                f[j]=f[j-1]+f[j-2];
                if(f[j]!=a[j]) {
                    cnt++;
                    if(cnt>=ans) break;
                }
            }
            ans=Math.min(ans,cnt);
        }
        out.println(ans);
        out.close();
    }
}

经典DFS

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {
    static Scanner cin=new Scanner(System.in);
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    static int N=200010;static long INF=Long.MAX_VALUE/2;static long mod=1000000007;
    public static int n,a[]=new int[N];
    public static boolean vis[]=new boolean[N];
    public static void dfs(int u)
    {
        if(u==n)
        {
            for(int i=0;i<n;i++)
                out.print(a[i]+" ");
            out.println();
            return;
        }
        for(int i=1;i<=n;i++)
        {
            if(!vis[i]){
                a[u]=i;
                vis[i]=true;
                dfs(u+1);
                vis[i]=false;
            }
        }
    }
    public static void main(String[] args) throws IOException
    {
        n=cin.nextInt();
        dfs(0);
        out.close();
    }
}

N皇后问题

法一：

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {
    static Scanner cin=new Scanner(System.in);
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    static int N=200010;static long INF=Long.MAX_VALUE/2;static long mod=1000000007;
    public static int n,ans,a[]=new int[N];
    public static char c[][]=new char[55][55];
    public static boolean col[]=new boolean[N],dg[]=new boolean[N],udg[]=new boolean[N];
    public static void dfs(int u)
    {
        if(u==n)
        {
            ans++;
            for(int i=0;i<n;i++) {
                for(int j=0;j<n;j++)
                    out.print(c[i][j]);
                out.println();
            }
            out.println("----------------------");
            return;
        }
        for(int i=0;i<n;i++)
        {
            if(!col[i]&&!dg[i+u]&&!udg[i-u+n]) {
                c[u][i]='Q';
                col[i]=dg[i+u]=udg[i-u+n]=true;
                dfs(u+1);
                c[u][i]='.';
                col[i]=dg[i+u]=udg[i-u+n]=false;
            }
        }
    }
    public static void main(String[] args) throws IOException
    {
        n=cin.nextInt();
        for(int i=0;i<n;i++) for(int j=0;j<n;j++) c[i][j]='.';
        dfs(0);
        out.println(ans);
        out.close();
    }
}

法二：枚举每一个格子

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {
    static Scanner cin=new Scanner(System.in);
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    static int N=200010;static long INF=Long.MAX_VALUE/2;static long mod=1000000007;
    public static int n,ans,a[]=new int[N];
    public static char c[][]=new char[55][55];
    public static boolean row[]=new boolean[N],col[]=new boolean[N],dg[]=new boolean[N],udg[]=new boolean[N];
    public static void dfs(int x,int y,int cnt)
    {
        if(y==n) {y=0;x++;}
        if(x==n)
        {
            if(cnt==n){
                for(int i=0;i<n;i++) {
                    for(int j=0;j<n;j++) out.print(c[i][j]);
                    out.println();
                }
                ans++;
                out.println("----------------------");
            }
            return;
        }
        //不放皇后
        dfs(x,y+1,cnt);
        // 放皇后
        if(!row[x]&&!col[y]&&!dg[x+y]&&!udg[x-y+n])
        {
            c[x][y]='Q';
            row[x]=col[y]=dg[x+y]=udg[x-y+n]=true;
            dfs(x,y+1,cnt+1);
            row[x]=col[y]=dg[x+y]=udg[x-y+n]=false;
            c[x][y]='.';
        }
    }
    public static void main(String[] args) throws IOException
    {
        n=cin.nextInt();
        for(int i=0;i<n;i++) for(int j=0;j<n;j++) c[i][j]='.';
        dfs(0,0,0);
        out.println(ans);
        out.close();
    }
}

经典BFS

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {
    static Scanner cin=new Scanner(System.in);
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    static int N=1010;static long INF=Long.MAX_VALUE/2;static long mod=1000000007;
    public static int n,m,a[][]=new int[N][N],d[][]=new int[N][N];
    public static int dx[]=new int[]{-1,1,0,0};
    public static int dy[]=new int[]{0,0,-1,1};
    public static int bfs()
    {
        Queue<int[]> q=new LinkedList<>();
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++) d[i][j]=-1;
        d[0][0]=0;
        q.add(new int[]{0,0});
        while(!q.isEmpty())
        {
            int[] tmp=q.peek();
            q.poll();
            for(int i=0;i<4;i++){
                int x=tmp[0]+dx[i],y=tmp[1]+dy[i];
                if(x>=0&&x<n&&y>=0&&y<m&&a[x][y]==0&&d[x][y]==-1){
                    d[x][y]=d[tmp[0]][tmp[1]]+1;
                    q.add(new int[]{x,y});
                }
            }
        }
        return d[n-1][m-1];
    }
    public static void main(String[] args) throws IOException
    {
        n=cin.nextInt();
        m=cin.nextInt();
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                a[i][j]=cin.nextInt();
        out.println(bfs());
        out.close();
    }
}
/*
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
 */
钟钟终
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SQL刷题系列之基础篇
weixin_45380671的博客
02-20 1978
SQL刷题系列之基础篇
PMP刷题工具+操作指引.rar
08-12
总之，这款PMP刷题工具是备考路上的重要助手，结合操作指引，考生可以系统地复习，有针对性地训练，提高通过PMP考试的成功率。在备考过程中，持续学习、深度理解和实战演练是关键，愿每位考生都能顺利取得PMP认证，...
2022蓝桥杯C/C++ B组国赛 故障
m0_63033104的博客
05-03 480
为了从故障现象反推故障原因，工程师们会总结一种叫做相关性矩阵的二维表格，来表示故障原因与故障现象之间的关系。在实际开发过程中，如果出现了故障原因，工程师就可以根据故障现象，去计算每种故障原因产生的概率，并按照概率大小对故障原因进行排查，以达到快速定位故障原因的目的。根据历史经验数据，我们统计得到了每一种故障原因出现的概率以及每一种故障原因对应的故障现象产生概率。行：按概率从高到低输出每种故障原因及其可能的概率，若出现 概率相同则优先输出编号小的故障原因。其中每行表示一种故障原因，每一列表示一种故障现象。
第十三届蓝桥杯c++b组2022年国赛决赛题解
热门推荐
hjc的博客
06-18 1万+
题目pdf下载：十三届蓝桥杯c++b组2022国赛题目pdf下载 G题没有写，J题是暴力的，其他好像都写出来，但是估计还是有错的。
2022年第十三届蓝桥杯大赛软件类决赛C/C++大学B组（国赛）题解
m0_58642116的博客
07-18 3892
蓝桥杯
2022年第十三届蓝桥杯大赛软件类国赛 C/C++ 大学B组
水深00安东尼的博客
06-28 887
试题 C: 卡牌二分法求结果 试题 D: 最大数字字符串存储，从高位到底位，判断1号操作和2号操作那种省步骤，并且是否超过A、B次。
力扣刷题中的java基础复习
LHHYWTSSB的博客
08-23 207
将数组存放到HashSet中 ： 遍历数组，并通过hashSet.add()进行添加。新建一个HashSet大小的数组，遍历HashSet中的元素，添加到数组上。在该方法中，还需要定义一个数组索引index，并赋初值为0。
java基础巩固刷题
STATICHIT静砸的博客
07-18 358
java刷题
武忠祥《660题》高效刷题包+资料分享
qq_45018803的博客
03-28 1146
660题的难度书虽然比较难，对于基础的考察比较深入，所以，有没有一种可能，！所以再继续做下去，就没有什么意义了，因为这就像是，实则在偷懒。所以，我们为什么不去把刀磨的锋利一点，再去砍树呢。。这个时候，如果你再回头重新听一遍基础，那肯定就不太现实了，因为时间有限，我们其实大部分已经掌握，只不过知识体系中有一些薄弱点需要吃透就行。在错题中成长是最快的，找到以前做错的题目，这次不是简单的看看答案就过去了，因为看答案谁都能看懂，但是下次自己做的时候说不定还是没有思路，会做错。
0基础如何复习计算机408
Graduate_Box的博客
08-25 1587
0基础如何复习计算机408
刷题&比赛&复习
CNFINITE的博客
02-07 150
今上午做了两道后缀数组的题目，依然套模版。   今下午打了场比赛，感觉比较简单，大多数是水题。   今晚上看了牛客网的图论的直播，复习了Prim算法，Kruskal算法，了解了匈牙利算法。   总之，今天还挺充实的
广东科学推理基础+刷题+生物化学地理拓展——刘文超.pdf
09-14
《广东科学推理基础+刷题+生物化学地理拓展——刘文超.pdf》是一份综合性的学习资料，旨在帮助学生和备考者深入理解科学推理中的重要概念，尤其针对广东省的考试需求进行了专门的编排。这份资料由知名B站UP主刘文超...
国家计算机二级c语言考试模拟软件，考前刷题专用
12-26
C语言，作为一种基础且强大的编程语言，是国家计算机二级考试的重要组成部分。本指南将详细阐述C语言的基础知识，结合“国家计算机二级C语言考试模拟软件”，为考生提供一套系统的备考策略。 一、C语言基础知识 ...
LeetCode刷题笔记.rar
07-05
总的来说，《LeetCode刷题笔记》不仅记录了个人在LeetCode上的学习过程，也是对数据结构和算法的系统复习。通过刷题，我们可以不断提升自己的编程思维，提高解决问题的能力，为职场竞争增添砝码。无论是初学者还是...
计算机二级java试题 刷题用 05年-10年
09-05
在复习过程中，考生不仅要刷题，还需要对错题进行分析，找出自己的知识盲点，然后针对性地学习和巩固。同时，配合使用教材和网络资源，比如Java官方文档、编程书籍、在线教程等，以增强理论知识。 此外，模拟考试...
golang 接口
m0_70982551的博客
07-24 847
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 375
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
【Java算法专场】二分查找(下）
最新发布
zhyhgx的博客
07-27 470
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
springboot之自动装配
weixin_50153914的博客
07-23 528
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
h3cse-rs+刷题软件
12-27
使用h3cse-rs刷题软件，不仅可以帮助用户系统地复习考试内容，还可以提高做题速度和准确率，为通过华三认证考试奠定坚实的基础。软件的题库内容丰富全面，覆盖了考试的所有知识点，用户可以放心使用。总之，h3cse-rs...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值