蓝桥杯知识点模板

已于 2022-05-10 19:53:57 修改
阅读量83 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
于 2022-04-06 11:50:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51108920/article/details/123985845
版权

辗转相除法：

int GCD(int a,int b)
{
    if(a%b==0) return b;
    //如果a%b==0 代表可以被整除，那么b就是最大公约数

    else return GCD(b,a%b)

    // 如果不能被整除，那么就先取余数，代码会保证左侧是大的，右侧是小的数字，所以使用时不必进行大小检查，即使a<b也会再一次递归后变成b，a在进行计算。

    //这样就能按照辗转相除法求解。（小学五年级的课程吧）
}

import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

public class Main {

    static int check(int a, int b, int c)
    {
        int flag[]=new int[11];
        for(int i=0;i<10;i++) flag[i]=0;
        flag[0]=1;
        while(a!=0)
        {
            if(flag[a%10]==1) return 0;
            else flag[a%10]=1;

            if(flag[b%10]==1) return 0;
            else flag[b%10]=1  ;


            if(flag[c%10]==1) return 0;
            else flag[c%10]=1  ;

            a=a/10;
            b=b/10;
            c=c/10;

        }
        return 1;
    }

    public static void main(String[] args) {

        int ans=0;

        for(int a=123;a<=987;a++)
            for(int b=123;b<=987-a;b++)
            {
                int c=a+b;
                if(check(a,b,c)==1)
                {
                    ans++;
                    System.out.println(a+"+"+b+"="+c);
                }

            }
        System.out.println(ans);
    }
}

栈

import java.util.Scanner;
import java.util.Stack;

public class Main {

    static Stack Mystack =new Stack();

    public static void main(String[] args)
    {
        int N;
        Scanner in=new Scanner(System.in);
        N=in.nextInt();
        for(int i=0;i<N;i++)
        {
            String op,name;
           op=in.next();
           name=in.next();
           // System.out.println(op+"  "+name);
            if(op.contains("in") )
                Mystack.push(name);

            else {
                while(!Mystack.peek().equals(name)){
                   // System.out.println(getTop());
                    Mystack.pop();
                }
                Mystack.pop();
            }
        }
        if(Mystack.empty()) System.out.println("Empty");
        else System.out.println(Mystack.peek());
    }

}

哈希表

import java.util.Scanner;
import java.util.Stack;

public class Main {

    static  final int h=999983;

    static String[] Value=new String [h];

    static String[] UpValue=new String [h];

    static int UpValueCount=0;

    static int   Hx(String s) {
        return (s.hashCode()%h+h)%h;
    }

    static boolean isAt(String s)
    {
        int n=Hx(s);
        if(Value[n]==null) return false;
        else if(Value[n].equals(s)) return true;
        else {
            for(int i=0;i<UpValueCount;i++)
                if(UpValue[i].equals(s)) return true;

            return false;
        }


    }

    static boolean in(String s)
    {
        int n=Hx(s);
        if(Value[n]==null) {
            Value[n]=s;
            return true;
        }
        else if(Value[n].equals(s)) return false;
        else {
            for(int i=0;i<UpValueCount;i++)
                if(UpValue[i].equals(s)) return false;

            UpValue[UpValueCount++]=s;
            return true;
        }
    }
    public static void main(String[] args)
    {

        int n;
        boolean flag=false;
        Scanner in=new Scanner(System.in);
        String ans="NO";
        n=in.nextInt();
        for(int i=0;i<n;i++)
        {
            String word;
            word=in.next();
            // System.out.println(Hx(word));
            if(flag) continue;

            if(isAt(word)){
                flag=true;
                ans=word;
            }
            else {
                in(word);

            }
        }
        System.out.println(ans);
    }

}

sort排序

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

public class Main {
    public static class MyComparator implements Comparator<Long> {
        @Override
        public int compare(Long a, Long b) {
            return a==b ?  0 : (a > b ? 1 : -1);
        }
    }
    public static void main(String[] args) {

        Long[] arr = new Long[500005];
        int n;
        Scanner in=new Scanner(System.in);
        n=in.nextInt();
        for(int i=0;i<n;i++)
        {
            arr[i]=in.nextLong();
        }
        Comparator<Long> cmp = new MyComparator();
        Arrays.sort(arr, 0,n,cmp); //也可以缺省cmp
        for (int i =0;i<n;i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println("");
        for (int i = n-1; i >=0; i--)
        {
            System.out.print(arr[i]+" ");
        }
    }
}

Vector

import java.util.List;
import java.util.Scanner;
import java.util.Vector;

public class Main {

  static Vector city=new Vector<String>();


  static Vector <Vector<String>> dig= new Vector <Vector<String>>();

  static int Myfind(String s)
  {

      for(int i=0;i<city.size();i++)
      {
          if(city.get(i).equals(s)) {
              return i;
          }
      }

      return -1;
  }

  public static void main(String[] args) {


      int n;
      Scanner in=new Scanner(System.in);
      n=in.nextInt();
      for(int i=0;i<n;i++)
      {
          String d,c;
          d=in.next();
          c=in.next();
          int flag=Myfind(c);
          if(flag==-1){
              city.addElement(c);


              dig.addElement(new Vector<String>());
              dig.get(city.size()-1).addElement(d);

          }
          else   dig.get(flag).addElement(d);
      }
      for(int i=0;i<city.size();i++)
      {
          System.out.println(city.get(i)+" "+dig.get(i).size());

          for(int j = 0; j< dig.get(i).size(); j++)
              System.out.println(dig.get(i).get(j));
      }
  }


}

Queue队列

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {

    static Queue<String> V=new LinkedList<String>();

    static Queue<String> N=new LinkedList<String>();

    public static void main(String[] args) {

        int M;
        Scanner in=new Scanner(System.in);
        M=in.nextInt();
        while(M>0) //
        {
            M--;
            String op,name,type;
            op=in.next();
            // System.out.println("op"+op);
            if(op.contains("IN"))
            {
                name=in.next();
                type=in.next();
                if(type.contains("V")) {
                    V.offer(name);
                }
                else {
                    N.offer(name);
                }
                // System.out.println("name:"+name+"type:"+type);

                // System.out.println(Vqueue);
            }
            else
            {
                type=in.next();
                if(type.contains("V")){
                    V.poll();
                }
                else {
                    N.poll();
                }
                // System.out.println("type"+type);
            }
        }

        while(V.size()!=0)
        {
            System.out.println(V.poll());
        }
        while(N.size()!=0)
        {
            System.out.println(N.poll());
        }
    }

}

Map映射

import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

public class Main {

  static Map mp=new TreeMap();

  public static void main(String[] args)
  {

      int n;
      boolean flag=false;
      Scanner in=new Scanner(System.in);
      String ans="NO";
      n=in.nextInt();
      for(int i=0;i<n;i++)
      {
          String word;
          word=in.next();
          // System.out.println(Hx(word));
          if(flag) continue;

          if(mp.containsKey(word)){
              flag=true;
              ans=word;
          }
          else {
              mp.put(word,true);

          }
      }
      System.out.println(ans);
  }

}

递归算法：

do(a,b,c...)
{
    //递归终止条件，即出口
    if(a==? ,b==? ,....) return 

    //递归条件
    if(条件1)
        do(参数1)

    else(条件2)
        do(参数2)

}

如本题，各子式间存在计算关系，可以化为：

do(a)
{
    if(a==0) return 0;
    if(a==1) return 1;

    return do(a-1)+do(a-2);
}

组合型枚举就是让你在 n 个中，随机选出 m 个，问你有多少种方案，而且每一种方案选择了哪 m 个，这就是组合型枚举

public class Main {

  static  int n;
  static int m;//选m个数
  static Vector<Integer> chosen = new Vector<Integer>();
  static <object> void calc(int x) {

      if (chosen.size() > m || chosen.size() + (n - x + 1) < m) //剪枝
          return;
      if (x == n + 1) { //选够了m个数输出
          String ansTem = "";

          for (int i = 0; i < chosen.size(); i++)
              System.out.print(chosen.get(i)+" ");

          System.out.println("");
          return;
      }
      calc(x + 1);
      chosen.addElement(x);
      calc(x + 1);
      chosen.remove((Object)x);
  }
  public static void main(String[] args) {
      Scanner in = new Scanner(System.in);
      n = in.nextInt();
      m = in.nextInt();
      calc(1);
  }
}

排列型枚举相对组合型枚举就简单了一点，就是 n 个的全排列，即从 n 个中选取 n 个但是关心内部的顺序。
相比较组合只关心有多少个集合，而排列是关心集合内的排列方式。即排列型枚举就是寻找 AnnA_{n}^nAnn​ 问题。

  static  int n;
  static int[] order =new int[20];
  static boolean[] chosen =new boolean[20];
  static <object> void calc(int x) {
      if (x == n + 1) { //选够了m个数输出
          String ansTem = "";
          for (int i = 1; i <=n ; i++)
              System.out.println(order[i]);
          return;
      }
      for (int i = 1; i <= n; i++) {
          if (chosen[i]) continue;
          order[x] = i;
          chosen[i] =true;
          calc(x + 1);
          chosen[i] = false;
          order[x] = 0;
      }
  }
  public static void main(String[] args) {
      Scanner in = new Scanner(System.in);
      n = in.nextInt();
      for (int i = 0; i < n; i++) {
         String s;
          s=in.next();
          name.addElement(s);
      }
      calc(1);
  }

差分算法解题的基本思路：

1、 b[1]=a[1]；
2、 从第 2 项到 n 项，利用 b[i]=a[i]−a[i−1]b[i]=a[i]-a[i-1]b[i]=a[i]−a[i−1] 差分式；
3、 对于区间端点操作加减；
4、 差分还原(前缀和)。
注意是从1开始，从0开始还有讨论i=0 的情况，使用1的话 b[1]=a[1]-a[0]=a[1]-0;
首先假设有一个数组：

a[]={1 2 3 4 5 7 2}

差分后：

b[]={1 1 1 1 1 2 -5}

一般应用场景：

让你对区间 [l,r] 加减操作 N 次

如：

从第二个元素到第五个元素每个+3
从第二个元素到第四个元素每个-2
从第一个元素到第三个元素每个+1
....

这里我们先演示前三个：

对于每个 [l,r] 区间的加减操作都转化为对端点 l,r+1 的操作

从第二个元素到第五个元素每个+3：

转化为：[l]+3 并且 [r+1]-3

那么原序列变成了：

1 1 1 1 1 2 -5
1 4 1 1 1 -1 -5

然后我们按照 b[i]=b[i]+b[i-1] 复原：

1 5 6 7 8 7 2

去掉最后一项，跟原序列对比：

1 2 3 4 5 7 2
1 5 6 7 8 7 2

确实是都加上了 3。

我们继续操作：

从第二个元素到第四个元素每个-2

转化为：[l]-2 并且 [r+1]+2

那么序列变成了： 

1 4 1 1 1 -1 -5
1 2 1 1 3 -1 -5

然后我们按照b[i]=b[i]+b[i-1] 复原

1 3 4 5 8 7 2

与上次复原后对比：

1 5 6 7 8 7 2
1 3 4 5 8 7 2 

确实是按照操作执行了。

注意 Warning：

不用每次都复原，只用最后一次复原即可，这里我是演示给大家看。

我们最后直接做三次，最后还原：

从第二个元素到第五个元素每个+3
从第二个元素到第四个元素每个-2
从第一个元素到第三个元素每个+1

a[]={1 2 3 4 5 7 2}

原序列差分后：

b[]={1 1 1 1 1 2 -5}

2 号元素 + 3 
6 号元素 - 3
2 号元素 - 2
5 号元素 + 2
1 号元素 + 1 
4 号元素 - 1

差分序列变成：

2 2 1 0 3 -1 -5

复原后：

2 4 5 5 8 7 5

与原序列对比：

1 2 3 4 5 7 2
2 4 5 5 8 7 5

所以还是非常方便快捷的。

在这里插入图片描述

首先假设有一个数组：

1 2 3 4 5 7 2

前缀和后：

0 1 3 6 10 15 22 24

一般应用场景：

让你对区间 [l,r] 求和操作N次

如：

从第二个元素到第五个元素的和
从第二个元素到第四个元素的和
从第一个元素到第三个元素的和
....

这里我们先演示前三个：

对于每个 [l,r] 区间的求和操作转化为区间端点的加减操作

sum[l,r] =[r]-[l-1]

从第二个元素到第五个元素的和：

转化为：[5]-[1]

那么Sum[2,5]=[5]-[1]=14

且 2+3+4+5=14

确实是相等的，就是这么神奇。

我们继续操作：

从第二个元素到第四个元素的和

转化为：[4]-[1]

那么Sum[2,4]=[4]-[1]=9

且 2+3+4=9

我们继续操作：

从第一个元素到第三个元素的和

转化为：[3]-[0]

那么Sum[1,3]=[3]-[0]=6

且 1+2+3=6

符合题意，验证结束，咱么做个题目看一看

二分查找：

// 在单调递增序列a中查找>=x的数中最小的一个（即x或x的后继）
while (low < high) {

  int mid = (low + high) / 2;

  if (a[mid] >= x)
      high= mid; 

  else 
      low = mid + 1;
}

// 在单调递增序列a中查找<=x的数中最大的一个（即x或x的前驱）
while (low < high) {

  int mid = (low + high + 1) / 2;

  if (a[mid] <= x) 
      low = mid;

  else 
      high = mid - 1;

}

实数二分：

//令eps 为小于题目精度一个数即可。

//比如题目说保留4位小数，0.0001 这种的。那么eps 就可以设置为五位小数的任意一个数 0.00001- 0.00009 等等都可以。一般为了保证精度我们选取精度 /100 的那个小数，即设置  eps= 0.0001/100 =1e-6。

while (l + eps < r) {
  double mid = (l + r) / 2;

  if (pd(mid)) 
      r = mid; 
  else 
      l = mid;
}

// 实数域二分，规定循环次数法

//通过循环一定次数达到精度要求，这个一般log2N< 精度即可。N为循环次数，在不超过时间复杂度的情况下，可以选择给N乘一个系数使得精度更高。

for (int i = 0; i < 100; i++) {

  double mid = (l + r) / 2;
  if (pd(mid)) 
      r = mid; 
  else 
      l = mid;
}
小刘学习ing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于枚举法及组合型、排列型枚举模板
qq_64030389的博客
03-26 2546
枚举法 枚举算法的思想： 将问题的所有可能成为答案的解一一列举，然后根据问题所给出的条件判断此解是否合适，如果合适就保留，反之舍弃。 枚举算法解题的基本思路： 确定枚举解的范围，以及判断条件 选取合适枚举方法，进行逐一枚举，此时应注意能否覆盖所有的可能的解 在枚举时使用判断条件检验，留下所有符合要求的解。 枚举算法的一般步骤： 根据题目确定枚举的范围，并选取合适的枚举方式，不能遗漏任何一个真正解，同时避免重复。 为了提高解决问题的效率，看题目是否存在优化，将可能成为解的答案范围尽可能的缩小。
蓝桥杯Python组知识点
weixin_45111135的博客
02-25 1393
用哈希表计数的时候，若当前元素不存在，则置为1；但是用defaultdict直接+1就行，不需要判断，因为创建defaultdict的时候已经规定了默认值类型。判断一个数是否为质数，可以通过暴力算法求得，而对于求（n, m）范围内，不包括m，质数的个数，可以通过埃氏筛来求取。求两个数的最大公因数可以通过math.gcd(n,m)获取，同时也可以定义辗转相除法获取。python中的堆是小顶堆，如果是二维列表，默认以每个列表的第一个元素来排序。4）heapreplace从堆中弹出最小的元素，再压入一个新元素。
蓝桥杯知识点整理
m0_51506743的博客
04-10 5023
基本输入输出、C/C++库函数以及stl模板、数据结构、算法、图论等，以及题目中涉及的知识点整理
蓝桥杯知识点(大纲)
Sunny_Deer的博客
03-24 1万+
蓝桥杯知识点(大纲) 宽度搜索 快速幂 求素数因子 最大公因数 最小公倍数 并查集 状态压缩DP 基础算法 一星：打表 枚举 倍增 离散化 差分 二星：分治法 贪心（Huffman编码） 尺取法 二分法 三分法 整体二分 ST算法 搜索 一星：基本DFS 基本BFS 二星：DFS记忆化搜索 IDA* BFS扩展（双向广搜 优先队列 双端队列）剪枝 爬山算法 随机增量法 模拟退火 三星：A* 高级数据结构 一星：并查集（带权） 分块 二星：莫队算法（树上莫队） 树状数组 线段树 可持久化线段树 二叉搜索树 t
蓝桥杯知识点汇总：基础知识和常用算法
热门推荐
GD_ONE的博客
03-18 11万+
此系列包含蓝桥杯（软件类）所考察的绝大部分知识点，算法，和写算法题必备的JAVA的基础语法,API，对想从C/C++转到JAVA组以及初学算法的同学会有帮助。
蓝桥杯知识点
m0_64592601的博客
03-27 26
蓝桥杯知识点总结
最全蓝桥杯省赛国赛知识点总结
qq_42798343的博客
06-12 1662
最全蓝桥杯省赛国赛知识点总结及其模板
蓝桥杯考纲和知识点总结
qq_45477639的博客
05-31 683
蓝桥杯前一天突击
蓝桥杯JAVA-知识点汇总复习
墨水记忆
12-13 4万+
为准备第十三届蓝桥杯大赛（软件类）省赛。 个人博客 www.tothefor.com 知识点 蓝桥杯JAVA-1.入门必知、正常输入输出和快速输入输出 蓝桥杯JAVA-2.数组操作 蓝桥杯JAVA-3.自定义类排序、进制转换、保留小数位数 蓝桥杯JAVA-4.常用数据类型 蓝桥杯JAVA-5.位运算技巧和原理 蓝桥杯JAVA-6.大数（整数、小数）处理 蓝桥杯JAVA-7.集合（容器）在竞赛中的使用 ...
14届蓝桥杯单片机国赛模板.rar
08-24
知识点： 1. **单片机编程**：单片机编程涉及汇编语言或高级语言，如C/C++，用于控制硬件执行特定任务。定时器是单片机中的重要组件，用于执行周期性操作，如定时中断。 2. **定时器状态机**：状态机是一种逻辑...
2018蓝桥杯试题范本模板.docx
11-04
蓝桥杯试题范本模板 蓝桥杯是中国大陆地区的一项信息学奥林匹克竞赛，旨在选拔优秀的信息学人才。...这些知识点对于信息学学生来说非常重要，可以帮助他们更好地理解计算机科学和技术的基本概念和算法。
2018蓝桥杯试题范本模板.pdf
11-17
【知识点详解】 1. **C语言编程基础** - 题目1“换零钞x星球”涉及C语言的基本语法和循环结构。通过两个嵌套的for循环，程序遍历所有可能的5元、2元和1元的组合，寻找满足条件的最小钞票数量。这里使用了if条件...
蓝桥杯标准模板.zip
01-22
蓝桥杯单片机标准模板.。 蓝桥杯单片机组考察数模电和单片机的知识，c语言也涉及到一点，30分的客观70分的主观。客观题部分主要由数模电c语言单片机的基础知识为主，一共十道，数模电会有5-6道，单片机有3-4道，可能...
数据结构——顺序表
m0_61965705的博客
08-27 478
例如：查找顺序表中的某个元素所在下标，就可以使用ForeachSeqList函数，搭配FindData函数传参对遍历到的数据进行操作。如果要存放字符串类型的，最好写成以下形式。空间可以不连续，访问元素方便。
Java-数据结构-包装类和认识泛型 !!!∑(ﾟДﾟノ)ノ
最新发布
2303_80388948的博客
08-27 1157
对于泛型就是：使用与许多许多类型。从代码上来说呢，就是对类型实现了参数化。对于引出泛型，我们来实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。在这里呢，我们用 Object类 来进行创建数组，Object是所有类的父类，但是呢，我们在这里呢就有一些问题，我们来看看：1、在这里呢，我们这个数组当中可以存放任何类型2、我们每次进行的到值时候呢，都要进行强转。
数据结构—链表
2301_79909332的博客
08-27 730
数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。数据量增长与程序所占用空间的比例关系称为空间复杂度。顺序表、链式表、顺序栈、链式栈、顺序队列、链式队列 、树 二叉树。使用该函数遍历顺序表内元素，符合条件的可对其进行计数和打印。使用该函数遍历顺序表内元素，符合条件的对其进行修改。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。1.空间可以不连续，访问元素不方便。3.程序 = 数据结构 + 算法。4.链表的插入和删除效率很高。
数据结构（邓俊辉）学习笔记】串 05——KMP算法：理解next[]表
weixin_44399845的博客
08-26 1336
KMP算法：理解next[]表
集合及数据结构第十三节（下）———— 枚举与Lambda表达式
2301_79418684的博客
08-27 1165
枚举与枚举的使用 1. 什么是C语言 2. 数据类型 3. 变量、常量 4. 字符串+转义字符+注释 5. 选择语句 6. 循环语句 7. 函数 8. 数组 9. 操作符 10. 常见关键字 11. define 定义常量和宏 12. 指针 13. 结构体
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值