洛谷算法1-3 暴力枚举

已于 2025-02-09 16:04:54 修改
阅读量702 收藏 23
点赞数 11
文章标签： 算法 java
于 2025-02-09 16:04:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_78895231/article/details/145533301
版权

目录

1 P2241统计方形

 2 三连击

 3 选数

4  P1088 [NOIP2004 普及组] 火星人

 5 P3799 小 Y 拼木棒 排列组合

 6 P2392 kkksc03考前临时抱佛脚

 7 P2036 [COCI2008-2009 #2] PERKET

1 P2241统计方形

思路：

  • 本题中，矩阵数量=正方形数量+长方形数量，得出正方形个数和矩阵个数即可求出长方形个数
  • 求正方形个数：正方形右下角i，j，取min（i，j）即为到这个点可能的正方形个数
  • 求矩阵个数，i*j
public static void main(String[] args) {
    Scanner scanner=new Scanner(System.in);
    int n = scanner.nextInt();
    int m= scanner.nextInt();
    // 1*1正方形
    long countZheng=0;
    long countJu=0;
    for (int i = 1; i <=n ; i++) {
        for (int j = 1; j <=m ; j++) {
           countZheng+=Math.min(i,j);
           countJu+= (long) i *j;
        }
    }
    System.out.print(countZheng+" ");
    System.out.println(countJu-countZheng);
}

 2 三连击

思路：

  • 将9个数分成三个三位数，要找到成比例的一组数，枚举出所有可能的数
  • 采用深度搜索，使用boolean数组判断该数是否被使用
  • 要记录三个三位数，因为题目中直接输出即可，不是先输出组数，所以不需要保存该组数据，使用一个number数组，前3位为第一个三位数，中间三位为第二个三位数，后三位为第三个三位数
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Scanner;

public class P1618 {
    static Scanner scanner=new Scanner(System.in);
    static int A = scanner.nextInt();
    static int B = scanner.nextInt();
    static int C = scanner.nextInt();
    static boolean flags=false;

    public static void main(String[] args) {
        int[]number=new int[10];
        boolean[]flag=new boolean[10];
        // 深度搜索枚举所有情况
        digui(1,number,flag);
        if (!flags){
            System.out.println("No!!!");
        }
    }

    public static int judge(int m,int[] number){
        int sum=0;
        for (int i = 3*m-2; i <=3*m ; i++) {
                int ele=number[i];
                sum=sum*10+ele;
        }
        return sum;
    }


    public static void digui(int index,int[]number, boolean[]flag){
        if (index>=10){
            // 9位数全部使用完了 判断比例关系
            int one=judge(1,number);
            int two=judge(2,number);
            int three=judge(3,number);
           if (one*B==two*A && one*C==three*A && two*C==three*B){
               System.out.print(one+" ");
               System.out.print(two+" ");
               System.out.print(three);
               System.out.println();
               flags=true;
           }
            return;
        }
        for (int i = 1; i <= 9; i++) {
            if (!flag[i]){
                // 拼接这个数
                number[index]=i;
                flag[i]=true;
                digui(index+1,number,flag);
                // 回溯
                flag[i]=false;
            }
        }
    }
}

 3 选数

思路：

  • 组合，从一些数中选取一部分(子集)，判断是否是素数
  • 递归深度搜索，深度为子集的个数
  • 该题中组合不可以重复，使用start来标记从哪里开始
import java.util.Scanner;

public class P1036 {
    static int count=0;
    public static void main(String[] args) {
       Scanner scanner=new Scanner(System.in);
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        int[] array=new int[n];
        int sum=0;
        boolean[] flags=new boolean[n];
        for (int i = 0; i < n; i++) {
            array[i]=scanner.nextInt();
        }
        digui(1,array,k,sum,flags,0);
        System.out.println(count);

    }
    public static void digui(int index,int[]array,int k,int sum,boolean[] flags,int start){
        if (index>k){
            // 已经选择够数量 判断sum是否是素数
            if (isPrime(sum)){
                count++;
            }
            return;
        }
        for (int i = start; i < array.length; i++) {
            if (!flags[i]){
                sum+=array[i];
                flags[i]=true;
                // 这里start是i+1而不是start+1 因为i指向的是当前数 i+1是之后的数 
                // start是第一次进入该循环开始的数 之后循环继续而start不变 会造成重复
                digui(index+1,array,k,sum,flags,i+1);
                flags[i]=false;
                sum-=array[i];
            }
        }
    }

    private static boolean isPrime(int sum) {
        for (int i = 2; i <= sum/i; i++) {
            if (sum%i==0){
                // 不是素数
                return false;
            }
        }
        return true;
    }
}

4  P1088 [NOIP2004 普及组] 火星人

思路：

  • 题目给出一个手指数，将其转换为数字，加上给定数之后，找到对应的排列数输出
  • 直接定位题目给定排列， i=array[index-1];
    • array是程序给定的一个排列数数组，array[index-1];是当前层数的值
    • 我们需要找到初始时给定的排列数，我们把i值赋给 num[index-1]
    • 在深度达到层数后，第一次找到的排列数即为给定排列数
  • System.exit(0);直接结束程序，return只能结束方法，在递归深度很深时，程序依然需要很长时间
import java.util.Arrays;
import java.util.Scanner;

public class P1088 {
    static int count=0;
    static int[]array;
    static int M;
    static int target;
    static boolean flag=false;

    public static void main(String[] args) {
        new Thread(null, () -> {
            Scanner scanner=new Scanner(System.in);
            int N = scanner.nextInt();
            M = scanner.nextInt();
            // array是火星人的手指
            array=new int[N];
            for (int i = 0; i < N; i++) {
                array[i]=scanner.nextInt();
            }
            // 1.将手指转为所代表的数字
            boolean[] flags=new boolean[N+1];
            int[]num=new int[N];
            // 2.加上小整数
            // 3.转为手指数
            digui(1,flags,N,num);
            scanner.close();
        },"t",2<<24).start();
        // 2<<24 是stackSize 测试样例第二个爆栈，改一下虚拟机栈内存大小
    }

    /**
     * 全排列
     * @return
     */
    public static void digui(int index,boolean[]flags,int N,int[]num)  {
        if (index>N){
            count++;
            if (count==1){
                // 第一次找到的排列数 皆为输入的数
                // 计算目标值
                target=count+M;
            }
            if (count==target){
                for (int ele : num) {
                    System.out.print(ele+" ");
                }
                flag=true;
            }
            return;
        }
        for (int i = 1; i <= N; i++) {
            if (count==0){
                // count==0 还没有找到第一个排列的数
                // array是给定的数组 1 2 3 4 5 多次递归之后 直接到达给定的位置
                i=array[index-1];
            }
            if (!flags[i]){
                num[index-1]=i;
                flags[i]=true;
                digui(index+1,flags,N,num);
                flags[i]=false;
                if (flag){
                    // 结束
                    System.exit(0);
                }
            }
        }
    }
}

 5 P3799 小 Y 拼木棒 排列组合

思路：

  • n根木棒中挑出4根组成正三角形(3条边都相等，则有两根木棒长度相等，另外两根木棒相加为前两根木棒的长度
  • 纯暴力解法会TLE，采用数学中组合的方式，
    • 首先统计每个长度出现的次数
    • 外层循环，挑选2个长度相等的木棒，注意：木棒长度需要大于2，否则两根木棒相加之和大于此木棒，在数量为n的木棒中，挑选两个a=C(counts[i],2) n*(n-1)/2
    • 内层循环，一根木棒长度为j，另一根木棒长度为i-j，如果j=i-j,则需要在长度为j的木棒中挑选两根，c=C(count[j],2),注意该长度为j的木棒个数需要>=2个;如果j!=i-j,则需要在长度为j的木棒中挑选一根，长度为i-j的木棒中挑选一根，c=C(counts[j],1)*C(counts[i-j],1);
    • 则 count+=a*c;注意需要每次都取模，以免超出范围

细节：运算的优先顺序

  • count += a * c;
  • 首先计算 a * c 的结果，然后将这个结果加到 count 上。
  • 接着对 count 进行取模运算，即 count %= (int) mod;，这会确保 count 的值不会超过 mod。
  • count += a * c % mod;
  • 首先计算 a * c 的结果，然后对这个结果进行取模运算，得到 (a * c) % mod。
  • 然后将这个取模结果加到 count 上。
import java.util.Scanner;

public class P3799 {
    static double mod = Math.pow(10, 9) + 7;
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int n = scanner.nextInt();
        int[]array=new int[n];
        int[]counts=new int[n];
        // 记录最大长度
        int maxLength=0;
        int menLength=Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            array[i]=scanner.nextInt();
            counts[array[i]]++;
            maxLength=Math.max(maxLength,array[i]);
            menLength=Math.min(menLength,array[i]);
        }
        int count=0;
        // 外层循环 拿到两个长度为i值木棒 i和j是长度 counts.length是有多少种长度不同的元素 无法代表最长长度
        for (int i = menLength+1; i <= maxLength; i++) {
            // 排列组合的方式 在长度等于i的木棒中挑两个
            if (counts[i]<2){
                continue;
            }
            int a=C(counts[i],2);
            // 内层循环 拿到两根长度和为i的木棒
            for (int j = menLength; j <= i/2; j++) {
                int c;
                // 两根木棒相等 则总长度为j的木棒中挑2个
                if (j==i-j){
                    if (counts[j]<2){
                        continue;
                    }
                    c=C(counts[j],2);
                }else{
                    // 两根木棒长度相等 则总长度为j的木棒中挑1个 i-j的木棒中挑一个
                    c=C(counts[j],1)*C(counts[i-j],1);
                }
                // 注意每次计算完都要取模
                count+=a*c;
                count %= (int) mod;
            }
        }
        System.out.println(count);;
    }

    public static int C(int  n,int k){
        if (k==2){
            // 从n个数中取2个数
            return n*(n-1)/2;
        }else{
            return n;
        }
    }
}

排列公式：

  • A 有顺序

组合公式：

  • C 无顺序
  • C35=5*4*3/1*2*3
  • C62=6*5/1*2

 6 P2392 kkksc03考前临时抱佛脚

思路：

  • 每次选择让时间加到较小值的思想不成立
  • 每个科目独立，则进行多次循环，算出每个科目需要的最短时间
  • 左右脑同时学习，则本道题要不左脑，要不右脑，两种情况可以类比为背包问题，在左右脑的时间都接近t/2时，所用时间最短效率最高，则背包容量为t/2，每道题为所放物品，求怎样放时长最接近t/2
  • 每个科目所需的时间为Math.max(v,t-v);
  • v为背包所求时间，t-v为剩余题目的时间

细节：背包容量设置为sumTime / 2 + 1，这样可以避免0容量

import java.util.Arrays;
import java.util.Scanner;

public class P2392 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int[] array=new int[4];
        for (int i = 0; i < 4; i++) {
            array[i]=scanner.nextInt();
        }
        int sum=0;
        for (int value : array) {
            // 将时间比作价值
            int[] values = new int[value];
            // 总时间
            int sumTime = 0;
            for (int j = 0; j < values.length; j++) {
                values[j] = scanner.nextInt();
                sumTime += values[j];
            }
            // 比作01背包问题 当左右脑时间最接近t/2时 效率高
            int[][] dp = new int[value][sumTime / 2 + 1];
            for (int j = 0; j < sumTime / 2+1; j++) {
                if (j >= values[0]) {
                    dp[0][j] = values[0];
                }
            }
            for (int j = 1; j < value; j++) {
                for (int k = 0; k < sumTime / 2 + 1; k++) {
                    if (k < values[j]) {
                        dp[j][k] = dp[j - 1][k];
                    } else {
                        dp[j][k] = Math.max(dp[j - 1][k], dp[j - 1][k - values[j]] + values[j]);
                    }
                }
            }
            sum += Math.max(dp[value - 1][sumTime / 2], sumTime - dp[value - 1][sumTime / 2]);
        }
        System.out.println(sum);
    }
}

 7 P2036 [COCI2008-2009 #2] PERKET

思路

  • 本题中说至少使用一种配料，即可能使用一种，两种...n种，我们要找到酸度和苦读绝对差最小的组合，采用dfs深度搜索
  • 注意：因为配料数目不同，可以多次深度搜索，通过层数来决定每次搜索的组合数
import javax.sound.midi.SysexMessage;
import java.util.Scanner;

public class P2036 {
    static int result=Integer.MAX_VALUE;
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int n = scanner.nextInt();
        int[][] array=new int[n][2];
        for (int i = 0; i < n; i++) {
            array[i][0] = scanner.nextInt();
            array[i][1] = scanner.nextInt();
        }
        int s=1;
        int b=0;
        boolean[]flags=new boolean[n];
        // n次深度搜索 每次深度不同
        for (int i = 1; i <= n; i++) {
            dfs(i,1,array,0,flags,s,b);
        }
        System.out.println(result);
    }
// num是本次深度搜索的层数（组合数）  index是当前递归的层数
    public static void dfs(int num,int index,int[][]array,int start,boolean[]flags,int s,int b){
        if (index>num){
            int abs = Math.abs(s - b);
            if (abs<result){
                result=abs;
            }
            return ;
        }
        for (int i = start; i <array.length ; i++) {
            if (!flags[i]){
                s*=array[i][0];
                b+=array[i][1];
                flags[i]=true;
                dfs(num,index+1,array,i+1,flags,s,b);
                flags[i]=false;
                s/=array[i][0];
                b-=array[i][1];
            }
        }
    }
}

_殊途
关注
蓝桥杯练习||洛谷【算法1-3】暴力枚举
优快云_kada的博客
02-13 1026
P2241 统计方形（数据加强版） P1036 [NOIP2002 普及组] 选数 P1157 组合的输出 P3392 涂国旗 P1217 [USACO1.5] 回文质数 Prime Palindromes P1149 [NOIP2008 提高组] 火柴棒等式 P3799 妖梦拼木棒（组合数、暴力） P2392 kkksc03考前临时抱佛脚（动态规划、01背包）
【算法1-3】暴力枚举——PERKET
qq_43034907的博客
10-28 356
洛谷题单： 【算法1-3】暴力枚举——PERKET
P3654 First Step (ファーストステップ)【暴力枚举】
zbin01的博客
07-20 596
这道题也是一道暴力枚举的题目，思路比较清晰，直接将横向，纵向两个方向进行遍历，即可得出结果，不过要考虑特殊情况，即在K=1时，横向和纵向是同一种情况，只要遍历一种情况即可。我们 Aqours 现在已经一共有 K 个队员了，要歌唱舞蹈起来的话，我们得排成一条 1×K 的直线，一个接一个地站在篮球场的空地上呢 (横竖均可)。对于所有数据，1≤𝑅,𝐶≤1001≤R,C≤100，1≤𝑘≤min⁡(𝑅,𝐶)1≤k≤min(R,C)。Aqours 的真正的粉丝的你，能帮我们算算吗？里面堆满了学校的各种杂物呢……
【洛谷算法1-3】暴力枚举
bettle_king的博客
04-27 964
目录P2089 烤鸡 P2089 烤鸡 https://www.luogu.com.cn/problem/P2089 #include<cstdio> #include<iostream> #include<cmath> using namespace std; int n; int a[10]; int b[60005][10]; int ans=0; void dfs(int index) { if(index==10) { int sum=0; for
洛谷题单算法1-3暴力枚举
Cloud_Ivy37的博客
08-06 677
洛谷题单算法1-3暴力枚举
洛谷题单心得-算法1-3【暴力枚举】深度搜索
qq_39530733的博客
10-01 221
基本思路：以初状态为节点，一直向更深处探索，直到遇到死路才返回上一个节点，更换路线探索。就像走迷宫，在一个路口先往a路走，a路不通再走b路，都不行再往更以前返回。暴力枚举实在是太暴力啦，所以也要学习学习温柔的搜索（深度搜索DFS，广度搜索BFS），DFS主要依靠递归，BFS听说过但是还没见过。背包好像是一个大类的问题，dfs好像只能解决第1阶的背包，只了解到一点点，所以我就名正言顺的咕咕咕啦~dfs函数一般带着①限制参数②迭代参数③位置参数，并且需注意终止条件。就目前本蒟蒻的水平，只见到两类DFS。
洛谷刷题记录---------暴力枚举
jinxdtaiy的博客
07-26 533
对于一个 n*m 的矩形，他所含的所有矩形的数量为n∗m，矩形数=正方形数 + 长方形数，对于正方形，我们枚举每个顶点作为右下方的顶点，数量为minij，然后长方形的数量就等于总数减去正方形的数量。
洛谷题单 算法1-3 暴力枚举
付某人的博客
07-24 776
1 First Step (ファーストステップ) 题目背景 知らないことばかりなにもかもが（どうしたらいいの？） 一切的一切 尽是充满了未知数（该如何是好） それでも期待で足が軽いよ（ジャンプだ！） 但我仍因满怀期待而步伐轻盈（起跳吧！） 温度差なんていつか消しちゃえってね 冷若冰霜的态度 有朝一日将会消失得无影无踪 元気だよ元気をだしていくよ 拿出活力 打起精神向前迈进吧 我们Aqours，要第一次举办演唱会啦！ 虽然学生会长看上去不怎么支持我们的样子，可是有了理事长的支持，我们还是被允许在校内的篮球场
洛谷题单：【算法1-3】暴力枚举
qq_43751506的博客
03-22 1004
（1）P2241 统计方形（数据加强版） 这道题经过数据加强后，只能通过两个循环解决，那么我们肯定是枚举长和宽的长度，然后找规律发现，在确定了长度和宽度后，能横向平移，或者纵向平移的次数是：（大矩阵的长度-当前矩阵的长度+1），宽度也是同理，那么我们可以知道，长和宽移动的次数相乘便是这个形状的小矩形的个数。然后枚举所有小矩形的形状即可。 import java.io.BufferedReader;...
洛谷-算法1-3暴力枚举题单 题解
行码棋
04-05 184
P2089烤鸡（）
8.7 洛谷1-3暴力枚举+div3
m0_69367351的博客
08-09 119
8.7日刷题记录（洛谷1-3+div3）
洛谷--暴力枚举法的4道题【1、四位完全平方数 2、验证子串 3、珠心算测验 4、火柴棒等式】
m0_74044018的博客
09-22 289
洛谷--暴力枚举法的4道题【1、四位完全平方数 2、验证子串 3、珠心算测验 4、火柴棒等式】
【算法1-3】暴力枚举——统计方形
qq_43034907的博客
10-27 237
洛谷题单： 【算法1-3】暴力枚举——方形统计
算法 - 暴力枚举
qq_61386381的博客
02-19 3970
枚举的基本条件： 　　（1）时间条件： 首先是时间条件。一般来说主流的OJ当中，1000ms的时间限制下可以运行操作数为10^7以内的运算（通常10^6以内较为保险），所以在采用枚举方法之前最好看一下数据范围，确保整个程序的执行操作数不会超过10^6-10^7这个量级，如果超过了就尝试更换枚举的维度或者使用其他算法吧。 　　（2）编程上的实现条件： 其次是编程上的实现条件。在编程实现上，一般来说暴力枚举需要两个条件，一是枚举的范围一般需要连续，如果枚举范围是离散的，那么一般很难使用for循环枚举出所
【漫话机器学习系列】275.GrabCut 算法——用于去除图片背景（Grabcut For Removing Image Backgrounds）
IT古董
05-24 775
GrabCut 是由微软剑桥实验室于 2004 年提出的一种交互式图像前景分割算法。相比传统的图像分割方法，它的亮点是：支持用户轻松交互，只需简单画个矩形；基于高斯混合模型（GMM）与图割（Graph Cut）优化；分割效果细腻，适用于复杂背景下的图像处理。GrabCut 是一项结合图割与 GMM 的强大图像分割算法；通过手动圈定目标区域，就能自动判断前景与背景；适合中等难度的抠图任务，是 OpenCV 实战中的常用技能之一。
016搜索之广度优先BFS——算法备赛
最新发布
2401_82484471的博客
05-27 668
广度优先搜索是一种逐层遍历的方式，是图论，树论的基本搜索方式，在决策类问题上也有应用。 算法的关键是准备一个`节点队列`，每遍历一个节点将其所有未访问的子节点(或所有的邻接节点)入队，遍历完一个节点后及时从队列中出队。当队列为空遍历结束。 BFS作为基础搜索算法，其逐层扩散的特点在很多高级算法有着广泛的应用，如`Djstra`算法就是用优先队列实现的`BFS`。
题目 3341: 蓝桥杯2025年第十六届省赛真题-抽奖
m0_75262437的博客
05-27 1047
题目 3341: 蓝桥杯2025年第十六届省赛真题-抽奖时间限制: 2s 内存限制: 192MB 提交: 415 解决: 105题目描述LQ 商场为了回馈广大用户，为在此消费的用户提供了抽奖机会：抽奖机有三个转轮，每个转轮上都分布有 n 个数字图案，标号为 1 ∼ n ，按照从 1 到 n 顺序转动，当转到第 n 个图案时会从第一个继续开始。奖项如下：1）三个相同的图案，积分 +200；2）两个相同的图案，积分 +100；
DeepSeek 赋能智能安防：从算法革新到场景落地的全解析
邓邓子的博客
05-27 850
随着人工智能技术的快速发展，智能安防系统迎来了新的变革机遇。本文聚焦 DeepSeek 在智能安防系统中的应用，深入剖析其基于 Transformer 架构与混合专家架构的核心技术原理。详细阐述 DeepSeek 在智能监控预警、门禁身份识别、智能分析决策及系统运维优化等场景中的实践应用，结合智慧社区、智慧监狱等实际案例，展现其高精度识别、高效决策优势。同时，客观分析DeepSeek应用过程中面临的数据安全、算法优化等挑战，并对其与物联网、大数据融合的未来发展方向进行展望，为智能安防领域技术创新提供参考。
java 代码查重（五）比较余弦算法、Jaccard相似度、欧式距离、编辑距离等在计算相似度的差异
我的E家
05-24 1261
为了实现更准确对比2个Java代码的相似度(用于Java课程作业查重场景)， 可以将Java源码原封不动保存到.java文件中，可以得到更准确结果，且不同相似度算法下计算的相似度差异一致。比较源文件和目标文件都是标准的Java代码(.java代码)，唯一区别在于目标文件含有注释，源文件没有注释。初步结论： 相同的Java代码复制到文本文件中(.txt文件)，不同算法检查的相似度差异较大。比较源文件和目标文件都是标准的Java代码，唯一区别在于目标文件含有注释，源文件没有注释。
暴力枚举洛谷例题c++算法
01-08
### 关于洛谷平台上的C++暴力枚举算法例题解法 #### 暴力枚举的概念及其应用 暴力枚举作为一种基础而重要的编程技巧，在解决特定类型的题目时非常有效。这种方法通过构建循环结构来遍历所有潜在的可能性，并利用条件判断语句`if`筛选出满足需求的情况[^1]。 对于洛谷平台上的一些经典问题，采用暴力枚举策略能够帮助理解如何处理数据以及实现逻辑控制。下面给出一个具体的例子——求解两个日期之间相隔天数的问题： 假设给定起始年份`startYear`, 结束年月日分别为 `endYear`,`endMonth`,`endDate`. 需要计算这两个时间点之间的总天数差值。可以通过逐个累加每个月的日历来完成这一目标: ```cpp #include <iostream> using namespace std; bool isLeap(int year){ return (year%4==0 && year%100!=0)||(year%400==0); } int monthDays[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; // 计算某一年某一月份有多少天 int getDayOfMonth(int y,int m){ int days=monthDays[m-1]; if(m==2&&isLeap(y))days++; return days; } long long countDaysBetweenDates(int startYear, int endYear, int endMonth, int endDate) { long long total_days = 0; // 处理非同年的部分 for (int i=startYear;i<endYear;++i){ bool leap=isLeap(i); total_days+=leap?366:365; } // 同年内剩余的时间 for (int j=1;j<=endMonth-1;++j){ total_days +=getDayOfMonth(endYear,j); } // 加上最后一个月的具体日子 total_days+=endDate; return total_days-(startYear>endYear)?total_days-getDayOfYear(startYear):total_days; } ``` 这段代码展示了如何运用多层循环和简单的数学运算来进行暴力枚举操作，从而得出正确的结果[^3]。 需要注意的是，虽然上述方法能解决问题，但在某些情况下可能存在效率较低的问题。因此，在实际比赛中应当考虑更高效的替代方案，比如使用预处理数组加速查询过程或是引入其他高级的数据结构与算法优化性能表现[^2]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值