本章内容包括

1、掌握基础结构的写法：
- 自定义数据类型的快排
- 自定义数据类型的优先队列
- 普通数据类型的优先队列
- 归并排序
- - 什么时候使用归并排序？
  - 归并排序+自定义数据类型+自定义排序的综合性问题（DNA序列）
- HashMap
- 二分查找
2、掌握基础知识：
- 基本数据类型的范围
- 递归什么时候越界
- 中学基本知识——数学公式
- 字符串类型的灵活运用
掌握经典题型：
- Balanced lineup
- 走马日
- 最长公共子序列
- 输出前k大的数
- 排列的逆序数
- 背包问题

1、掌握基础结构的写法：

自定义数据类型的快排

解析：基本数据类型的快排使用：Arrays.sort()方法，譬如电影节这样的问题，程序需要对每部电影的结束时间进行从小到大进行排序。就需要自己在自定义类改写“compareTo（）”方法

package summarizeMyWork;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;//此类结构常常出现在贪心算法中，接下来的程序是以“电影节”这个问题为原型展开的：
/*描述
大学生电影节在北大举办! 这天，在北大各地放了多部电影，给定每部电影的放映时间区间，区间重叠的电影不可能同时看（端点可以重合），问李雷最多可以看多少部电影。输入
多组数据。每组数据开头是n(n<=100)，表示共n场电影。
接下来n行，每行两个整数(0到1000之间)，表示一场电影的放映区间
n=0则数据结束
输出
对每组数据输出最多能看几部电影
样例输入
8
3 4
0 7
3 8
15 19
15 20
10 15
8 18
6 12
0
样例输出
3
*/
public class 自定义数据类型的快排 {static class movie implements Comparable<movie>{//这里容易忘记写后面的“implements Comparable<movie>”！int start;int end;public movie(int s,int e) {this.start=s;this.end=e;}@Overridepublic String toString() {return "电影开始时间："+this.start+"电影结束时间："+this.end;}@Overridepublic int compareTo(movie next) {return this.end-next.end;//返回结果为负，即为升序}}public static void main(String[] args) {movie[] m=new movie[10];m[0]=new movie(2, 9);m[1]=new movie(21, 29);m[2]=new movie(2, 93);m[3]=new movie(5, 3);m[4]=new movie(2, 0);m[5]=new movie(0, 7);m[6]=new movie(2, 6);m[7]=new movie(44, 3);m[8]=new movie(47, 88);m[9]=new movie(3, 38);List<movie> list=new ArrayList<movie>(Arrays.asList(m));//对于List这个类，eclips会自动引包，指向awt，需要删掉改成util包！Collections.sort(list);//遍历for(movie e:list) {System.out.println(e.toString());}//排序结果重新赋给数组int c=0;for(movie e:list) {m[c++]=e;}//获取链表中的某个对象System.out.println("获取到的对象  "+list.get(6));}}

自定义数据类型的优先队列

package summarizeMyWork;import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;//此类结构常常出现在贪心算法中，接下来的程序是以“畜栏保留问题”这个问题为原型展开的：
/** 描述
农场有N头牛，每头牛会在一个特定的时间区间[A, B]（包括A和B）在畜栏里挤奶，且一个畜栏里同时只能有一头牛在挤奶。现在农场主希望知道最少几个畜栏能满足上述要求，并要求给出每头牛被安排的方案。对于多种可行方案，主要输出一种即可。输入
输入的第一行包含一个整数N(1 ≤ N ≤ 50, 000)，表示有N牛头；接下来N行每行包含两个数，分别表示这头牛的挤奶时间[Ai, Bi](1 ≤ A≤ B ≤ 1, 000, 000)。
输出
输出的第一行包含一个整数，表示最少需要的畜栏数；接下来N行，第i+1行描述了第i头牛所被分配的畜栏编号（从1开始）。
样例输入
5
1 10
2 4
3 6
5 8
4 7
样例输出
4
1
2
3
2
4
*/
//分析：譬如畜栏保留这样的问题，程序需要设置一个优先队列，按照挤奶时间结束时间早晚存放畜栏。则需要写一个“ new Comparator<>”对象，用于优先队列
public class 自定义数据类型的优先队列 {static class corral {int code;int lasttime;public corral(int c,int l) {this.code=c;this.lasttime=l;}@Overridepublic String toString() {return "畜栏编码"+this.code+"畜栏结束时间"+this.lasttime;}}static Comparator<corral> comparator=new Comparator<corral>() {public int compare(corral c1,corral c2) {return c1.lasttime-c2.lasttime;}};public static void main(String[] args) {corral[] c=new corral[5];c[0]=new corral(1, 9);c[1]=new corral(2, 29);c[2]=new corral(3, 96);c[3]=new corral(4, 21);c[4]=new corral(5, 1);Queue<corral> queue=new PriorityQueue<corral>(comparator);for(int i=0;i<5;i++) {queue.add(c[i]);//对于队列而言，只能通过add操作将数据存入队列，才会进行排序}//返回队首元素,基本上常用的就是代码里面使用到的这四个方法System.out.println(queue.peek());//与链表不同的是，队列必须采用以下方法进行遍历：System.out.println(queue.size());while(!queue.isEmpty()) {System.out.println(queue.poll());}
//      for(int i=0;i<queue.size();i++) {//，采用这个方法只打印了3个结果，是因为队列的size是动态在变化的
//          System.out.println(queue.poll());
//      }}}

普通数据类型的优先队列

package summarizeMyWork;import java.util.PriorityQueue;
import java.util.Queue;public class 普通数据类型的优先队列 {public static void main(String[] args) {Queue<Integer> queue=new PriorityQueue<Integer>();queue.offer(1);queue.offer(0);queue.offer(-1);System.out.println(queue.element());//返回队首元素while(!queue.isEmpty()) {System.out.println(queue.poll());}}}

归并排序

package summarizeMyWork;public class 归并排序 {//存储归并排序所需的数据必须在全局变量之下static int[] array=new int[100];static int[] b=new int[100];public static void main(String[] args) {int c=2039;for(int i=0;i<100;i++) {array[i]=c--;}MergeSort(array,0,99);//与String.substring方法不同的是：归并排序传入的值应当是（start_index,end_index）for(int i=0;i<100;i++) {System.out.println(array[i]);}}static void MergeSort(int[] a,int s,int e) {if(s<e) {int mid=s+(e-s)/2;MergeSort(a, s, mid);MergeSort(a, mid+1, e);Judge(a,s,mid,e);}}static void Judge(int[] a,int s,int mid,int e) {int p1=s,p2=mid+1;int pb=0;while(p1<=mid&&p2<=e) {if(a[p1]>=a[p2]) {b[pb++]=a[p2++];}else {b[pb++]=a[p1++];//像排列的逆序数这样的问题，只是在这里加了一个ans=mid-p1+1；}}while(p1<=mid){//粗心大意，这些界限容易写错b[pb++]=a[p1++];}while(p2<=e) {b[pb++]=a[p2++];}for(int i=0;i<e-s+1;i++) {a[s+i]=b[i];}}}

什么时候使用归并排序？

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
归并排序最优时间复杂度是O(nlog2n) ,最坏的时间复杂度是O(nlog2n) ，它是稳定性很好的一个排序算法。
在大多数情况下，快速排序的效率都要比归并排序高，那归并排序的优势是什么呢？在我们的快排中！我们的一切操作都是在原有的列表之上进行操作的，并没有生成新的列表。但是我们的归并排序的时候，我们需要先切分，这时候我们切分之后会形成新的列表，然后是对新的列表进行操作的！这就是区别。在算法中往往不仅仅是对数组进行排序，归并排序运用分治的思想，譬如“排列的逆序数”这样的问题，需要用到分治解决问题时，归并排序就有了天然的优势。

归并排序+自定义数据类型+自定义排序的综合性问题（DNA序列）

题目是：


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;//3:DNA排序
//查看 提交 统计 提问
//总时间限制: 1000ms 内存限制: 65536kB
//描述
//现在有一些长度相等的DNA串（只由ACGT四个字母组成），请将它们按照逆序对的数量多少排序。
//逆序对指的是字符串A中的两个字符A[i]、A[j]，具有i < j 且 A[i] > A[j] 的性质。如字符串”ATCG“中，T和C是一个逆序对，T和G是另一个逆序对，这个字符串的逆序对数为2。
//输入
//第1行：两个整数n和m，n(0<n<=50)表示字符串长度，m(0<m<=100)表示字符串数量
//第2至m+1行：每行是一个长度为n的字符串
//输出
//按逆序对数从少到多输出字符串，逆序对数一样多的字符串按照输入的顺序输出。
//样例输入
//10 6
//AACATGAAGG
//TTTTGGCCAA
//TTTGGCCAAA
//GATCAGATTT
//CCCGGGGGGA
//ATCGATGCAT
//样例输出
//CCCGGGGGGA
//AACATGAAGG
//GATCAGATTT
//ATCGATGCAT
//TTTTGGCCAA
//TTTGGCCAAA
/** 这道题知识点是分治归并排序+自定义数据类型+自定义排序* 描述
现在有一些长度相等的DNA串（只由ACGT四个字母组成），请将它们按照逆序对的数量多少排序。
逆序对指的是字符串A中的两个字符A[i]、A[j]，具有i < j 且 A[i] > A[j] 的性质。如字符串”ATCG“中，T和C是一个逆序对，T和G是另一个逆序对，这个字符串的逆序对数为2。
输入
第1行：两个整数n和m，n(0<n<=50)表示字符串长度，m(0<m<=100)表示字符串数量
第2至m+1行：每行是一个长度为n的字符串
输出
按逆序对数从少到多输出字符串，逆序对数一样多的字符串按照输入的顺序输出。*/
public class DNA排序的分治 {static numm[] num;static char[] b;static class numm implements Comparable<numm>{int code;int count;public numm(int c,int co) {this.code=c;this.count=co;}@Overridepublic int compareTo(numm next) {return this.count-next.count;}@Override public String toString () {return "编号"+code+"序列数"+count;}}public static void main(String[] args) {Scanner reader=new Scanner(System.in);int m=reader.nextInt();//认真读题！比如这道题就是先给你列，再给你行int n=reader.nextInt();String[] string=new String[n];char[] a=new char[m];b=new char[m];num=new numm[n];for(int i=0;i<n;i++) {string[i]=reader.next();num[i]=new numm(i,0);for(int j=0;j<m;j++)a[j]=string[i].charAt(j);
//          for(int j=0;j<m-1;j++) {//              for(int k=j+1;k<m;k++) {//                  if(string[i].charAt(j)>string[i].charAt(k)) {//                      count++;
//                      num[i].count=count;//注意必须在上面new 对象，在这里new就会出现多个。
//                  }
//              }
//          }MergeSort(a,i,0,m-1);
//          System.out.println(num[i].count);}List<numm> nList=new ArrayList<numm>(Arrays.asList(num));Collections.sort(nList);for(numm e:nList) {//          System.out.print(e.toString()+"  ");System.out.println(string[e.code]);}}static void MergeSort(char[] a,int i,int s,int e) {if(s<e) {int mid=s+(e-s)/2;MergeSort(a,i, s, mid);MergeSort(a,i, mid+1, e);Judge(a, i,s,mid, e);}}static void Judge(char[] a,int i,int s,int mid,int e) {int p1=s,p2=mid+1;//错过，写成p2=eint pb=0;while(p1<=mid&&p2<=e) {if(a[p1]>a[p2]) {num[i].count+=mid-p1+1;b[pb++]=a[p2++];}else {b[pb++]=a[p1++];}}while(p1<=mid)b[pb++]=a[p1++];while(p2<=e)b[pb++]=a[p2++];for(int k=0;k<e-s+1;k++) {a[s+k]=b[k];}}
}

HashMap

package summarizeMyWork;import java.util.HashMap;public class hashMap {public static void main(String[] args) {// TODO Auto-generated method stubHashMap<String,String> map=new HashMap<>();map.put("账号", "密码");String string1="cqust";System.out.println(map.containsKey(string1));System.out.println(map.get("账号"));}}

二分查找

package summarizeMyWork;public class 二分查找 {public static void main(String[] args) {// TODO Auto-generated method stubint[] array=new int[100];for(int i=0;i<100;i++) {array[i]=i;}//数组是排序好了的。System.out.println(BinarySort(array,0,99));}static int BinarySort(int[] a,int s,int e) {int left=s,right=e,max=0;int mid=left+(right-left)/2;while(left<=right) {if(mid<87) {//查找小于87的最大的数，具体问题具体分析max=mid;left=mid+1;}else {right=mid-1;}mid=left+(right-left)/2;}return max;}}

2、掌握基础知识：

基本数据类型的范围

int型（2 * 10^9）
long型（9 * 10^18）

递归什么时候越界

溢出的意思就是越界，操作系统会给每个进程分配一个最大上限的堆栈空间，操作系统分配给一个进程的栈空间是2M，堆空间在32位机器上是4G。
撇如“数字三角形”这样的问题，如果使用递归求解，算法的时间复杂度是在2^100 左右。这样的程序不存在计算机可以在一个人的有生之年之内算出来。

中学基本知识——数学公式

0、a%1000007的含义是a/1000007的余数是多少。
1、欧几里得定理（也叫辗转相除法）gcd（a,b）=gcd(a,a%b);
像下面这道题如果还是暴力求解一定会出现越界的情况，如果使用数学公式就很简单gcd（f（2020），f(520)）=f(gcd(2020,520));

2、大整数取模：（这个如果想要掌握就需要反复记忆）
（a+b）%n=(a%n+b%n)%n;
(a-b)%n=((a%n-b%n)+n)%n;
(ab)%n=(a%b)(b%n)%n
对于一个大的只能用数组存储的数来说：
因为数字有个规律1234=((1*10+2）*10+3)*10+4
for（int i=0;i<a.lenght;i++）{
long ans=(int )(ans 10+a[i]-‘0’)%n;
}
3、奇数，偶数，质数，合数，众数，平均
（1）奇数，又称单数，整数中，能被2整除的数是偶数，不能被2整除的数是奇数，奇数的个位为1，3，5，7，9。
（2）偶数，整数中,能够被2整除的数,叫做偶数,正的偶数又称双数。偶数包括正偶数、负偶数和0。
（3）质数，又称素数，有无限个。质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数。
（4）合数,是指自然数中除能被1和本数整除外,还能被其他的数整除的数。
（5）众数(Mode)众数是指一组数据中出现次数最多的那个数据,一组数据可以有多个众数,也可以没有众数。众数是统计学名词，在统计分布上具有明显集中趋势点的数值，代表数据的一般水平（众数可以不存在或多于一个）。
（6）平均数是指在一组数据中所有数据之和再除以数据的个数。平均数是表示一组数据集中趋势的量数，它是反映数据集中趋势的一项指标。
（7）方差计算公式：s^2 =(1/n)[(x1-x0)^2 + (x2-x0)^2 +…+ (xn-x0)^2]
（8）极差计算公式：x=xmax-xmin
（9）标准差=方差的算术平方根
4、正三角、平行四边形、2个菱形、2个梯形、圆形、圆周长、2个弧长、2个扇形、圆柱圆锥侧面积和全面积公式
弧长：l = n（圆心角）× π（圆周率）× r（半径）/180=α(圆心角弧度数)× r（半径）
扇形面积：

圆锥侧面积：圆锥的侧面展开图是扇形，该扇形的半径是母线长L(注意，此处L是圆锥母线的长，不是弧长)，扇形的弧长是圆锥底面圆的周长2πr，其中r是底面圆的半径。套用第二条扇形面积公式得
S圆锥侧=L(2πr)/2=πrL。
5、其他偶尔需要用到的就请各位道友务必自行百度。

字符串类型的灵活运用

String类型是Java组算法经常使用的数据类型，对于它的运用也非常得灵活，需要熟练掌握
StringBuilder 、BigInteger、BigDecimal、Integer等类的常用方法。

package summarizeMyWork;public class 字符串API {public static void main(String[] args) {//1、将int转换成string类型String  s=String.valueOf(122*111);System.out.println(s);//2、判断字符串是不是以参数指定内容结束boolean s2=s.endsWith("00");//3、判断字符串是不是以参数指定内容开始boolean s3=s.startsWith("1");System.out.println(s2+" "+s3);//4、获取子串，常用于校验+隐藏,含头不含尾String s4=s.substring(0,3);System.out.println(s4);//5、！字符串！转换成Int型int s5=Integer.valueOf(s);//6、！字符！转换成Int型，也可以用于将字符串转换成整型int s6=Integer.parseInt(String.valueOf(s.charAt(4)));System.out.println(s5+" "+s6);//7、去除开头结尾空格和tabString s7=s.trim();//8、将字符串按照给定正则表达式的分割成子串String[] s8=s.split(" ");//9、统一转换大小写String s9=s.toLowerCase();String s10=s.toUpperCase();//10、将子一个字符串变为字符数组char[] c=s.toCharArray();//将字符数组变为字符串String s11=new String(c);//将部分字符串变为stringString s12=new String(c,0,3);//将整型（整型数组）转成字符串String s13=" ";s13+=Integer.toString(c[0]);//11、按字典顺序比较两个字符串（区分大小写与不区分大小写）if(s9.compareTo(s10)>0)System.out.println("区分大小写");if(s9.compareToIgnoreCase(s10)==0)System.out.println("不区分大小写");//12、判断此字符串第一次/最后一次出现指定字符处的索引int s14=s.indexOf('1',0);int s15=s.lastIndexOf('1',0);//13、替换字符/字符串,不能用字符串替换字符，也不能用字符替换字符串String s16=s.replace('1', '9');System.out.println(s16);//14、对一个字符串进行修改StringBuilder s17=new StringBuilder();s17.append("zxcvbnm");s17.insert(3, "asdf");s17.setCharAt(0, 'Z');String s18=s17.toString();System.out.println(s18);//15、以二进制返回一个整数的字符串表示形式String  s19=Integer.toBinaryString(10);String s20=Integer.toHexString(10);String s21=Integer.toOctalString(10);}}

掌握经典题型：

Balanced lineup

走马日

最长公共子序列

输出前k大的数

排列的逆序数

背包问题

第十二届蓝桥杯Java B组——前期知识汇总梳理相关推荐

2021年第十二届蓝桥杯 Java B 组省赛填空题解析
第十二届蓝桥杯 Java B 组省赛填空题解析第一题 [问题描述] 已知大写字母 AAA 的 ASCIIASCIIASCII 码值为 656565, 那么大写字母 LLL 的 ASCIIASCIIA ...
第十二届蓝桥杯青少年python组第1-3题 C++实现
蓝桥杯STEMA测评--Python真题讲解1 蓝桥杯STEMA测评--Python真题讲解1_哔哩哔哩_bilibili 蓝桥杯STEMA测评--Python真题讲解2 蓝桥杯STEMA测评--Py ...
第十二届蓝桥杯青少年C++组 10月比赛第1题
/* 第十二届蓝桥杯青少年C++组 10月比赛第1题王曙翰 2022.1.18 */ #include <bits/stdc++.h> using namespace std; i ...
第十二届蓝桥杯青少年 C++组 10月比赛第2题统计字符
/* 第十二届蓝桥杯青少年C++组 10月比赛第2题统计字符王曙翰 2022.1.18 */ #include<bits/stdc++.h> #include<string.h ...
Java C++ 实现第十二届蓝桥杯 C++ B组省赛真题（希望能和各位佬能一起讨论算法题：讨论群：99979568）
山水有相逢来日皆可期告辞虽然是C++组的,但是和Java组的差不了两道题,大家都可以看一看如有错误,还请佬评论或私信指出(写的稍些急) 等后面在补充补充解题思路,在补一套C++实现(已完成, ...
2019第十届蓝桥杯JAVA G组题解
蓝桥杯历年真题及解析. 试题 A: 立方和本题总分:5 分 [问题描述] 小明对数位中含有 2.0.1.9 的数字很感兴趣,在 1 到 40 中这样的数包括 1.2.9.10 至 32.39 和 ...
2019 第十届蓝桥杯 Java B组赛后总结
我是大三第一次参加蓝桥杯,也是最后一次参加了(大四应该没时间了).我参加的是java b组,总体来说赛程挺顺利的,第一次参赛觉得四个小时有点不够哈哈哈.不过蓝桥杯这个比赛我是带着试一下的心态去参加的. ...
第十二届蓝桥杯c++b组个人题解
又是一年一度的蓝桥杯了,本届蓝桥杯的题型分布有所改变,如果没记错的话往常都是3-5道填空题,今年一反往常只有2道填空题了,相对于之前的"暴力破解杯"和"dp杯" ...
第十二届蓝桥杯C++B组国赛
总体评价国赛跟省赛差距感觉还是蛮大的叭.所以说,还是要好好准备的如果想拿国一的话.我觉得重点还是要准备DP,它每年都会至少两道题,所以说准备DP的话受益还是很大的.不聊啦~补题去惹试题 A: 带宽 ...

第十二届蓝桥杯Java B组——前期知识汇总梳理