＜蓝桥杯软件赛＞零基础备赛20周--第6周--数组和队列
报名明年4月蓝桥杯软件赛的同学们，如果你是大一零基础，目前懵懂中，不知该怎么办，可以看看本博客系列：备赛20周合集
20周的完整安排请点击：20周计划
每周发1个博客，共20周（读者可以按自己的进度选“正常”和“快进”两种计划）。
每周3次集中答疑，周三、周五、周日晚上，在QQ群上答疑：
文章目录
- 1. 数组的应用--高精度
-
- 1.1 Java和Python计算大数
- 1.2 C/C++高精度计算大数
-
- 1.2.1 高精度加法
- 1.2.2 高精度减法
- 1.2.3 高精度乘法
- 1.2.4 高精度除法
- 2. 队列
-
- 2.1 手写队列
-
- 2.1.1 C/C++手写队列
- 2.1.2 Java手写队列
- 2.1.3 Python手写队列
- 2.2 C++ STL队列queue
- 2.3 Java队列Queue
- 2.4 Python队列Queue和deque
- 2.5 例题
-
- 2.5.1 C/C++代码
- 2.5.2 Java代码
- 2.5.3 Python
- 3. 习题
第 6周: 高精度、队列
1. 数组的应用–高精度
高精度算法就是大数的计算方法。超过64位的大数计算，Java和Python都能直接算，而C++不能直接算，需要用数组来模拟大数的存储。
竞赛中常常用到很大的数组。强烈建议不要用动态分配，因为动态分配需要多写代码而且容易出错。定义为全局静态数组即可，而且不需要初始化为0，因为全局变量在编译时会自动初始化为全0。
#include 大数组不能定义在函数内部，这样做会导致栈溢出。因为局部变量是函数用到时才分配，大小不能超过栈，而栈不会很大。
这样写是错的：
#include 另外，注意全局变量和局部变量的初值。全局变量如果没有赋值，在编译时被自动初始化为0。在函数内部定义的局部变量，若需要初值为0，一定要初始化为0，否则可能为莫名其妙的值。
#include 1.1 Java和Python计算大数
Java和Python计算大数，理论上可以计算“无限大”的数，只要不超内存。
用下面的简单题说明Java和Python的大数计算。
【题目描述】 大数计算：输入两行表示两个整数。分别计算加、减、乘、除，分5行输出和、差、积、商、余数。
（1）Java代码。注意负数的计算，负数的加减乘都没问题，但是除法可能出错。
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
BigInteger a,b;
a=sc.nextBigInteger();
b=sc.nextBigInteger();
System.out.println(a.add(b));
System.out.println(a.subtract(b));
System.out.println(a.multiply(b));
System.out.println(a.divide(b));
System.out.println(a.mod(b)); //注意：如果b是负数，这里可能报错
}
}
（2）Python代码。注意负数的计算，加减乘都没问题，但是除法的结果可能比较奇怪。
a=int(input())
b=int(input())
print(a+b)
print(a-b)
print(a*b)
print(a // b) #注意：如果a或b是负数，除法的结果可能比较怪，例如123//(-10)得-13
print(a % b) #注意：如果a或b是负数，求余的结果可能比较怪，例如123%(-10) 得-7
1.2 C/C++高精度计算大数
C++能表示的最大整数是64位的long long，如果需要计算更大的数，需要使用“高精度”。对于加减乘除四种计算，模拟每一位的计算，并处理进位或借位。
（1）数字的读取和存储。因为整数a和b太大，无法直接赋值给C++的变量，不能按数字读入，只能按字符读入。大数a用字符串string读入，一个字符存一位数字。注意存储的顺序，读入的时候，数字的左边是高位，右边是低位，即a[0]是最高位，a[n-1]是最低位；但是计算时习惯用a[0]表示最低位，a[n-1]表示最高位，所以需要把输入的字符串倒过来。
（2）加法和减法。简单地模拟即可。
（3）乘法。模拟小学竖式乘法操作，例如34×67，计算过程：
计算结果用int a[]存储，首先算出a[0]=4×7=28，a[1]=3×7+4×6=21+24，a[2]=3×6=18，然后处理进位，得到乘积2278。
（4）除法。直接做除法有点麻烦，简单一点的方法是利用减法。例如a除以b，转化为a连续减去b，减了多少次就是商，最后不够减的是余数。
1.2.1 高精度加法
链接：大整数加法
把输入的数字存到字符串中，然后在add()中把字符转成数字，做完加法后再转回字符。
#include1.2.2 高精度减法
链接：大整数减法
#include1.2.3 高精度乘法
链接：大整数乘法
#include1.2.4 高精度除法
链接：大整数除法
#include2. 队列
队列中的数据存取方式是“先进先出”，只能往队尾插入数据、从队头移出数据。队列的原型在生活中很常见，例如食堂打饭的队伍，先到先服务，不能插队。
下图是队列的原理，队头head指向队列中的第一个元素 a 1 a_1 a1，队尾tail指向队尾最后一个元素 a n a_n an。元素只能从队头方向出去，元素只能从队尾进入队列。
2.1 手写队列
2.1.1 C/C++手写队列
队列的代码很容易实现。如果使用环境简单，最简单的手写队列代码用数组实现。
const int N = 10000; //定义队列容量，确保够用
int que[N]; //队列，用数组模拟
int head = 0; //head始终指向队头。que[head]是队头。开始时队列为空，head = 0
int tail = -1; //tail始终指向队尾。que[tail]是队尾。开始时队列为空，tail = -1
//队列长度等于tail-head+1
head++; //弹出队头元素，让head指向新队头。注意保持head <= tail
que[head]; //读队头
que[++tail] = data; //入队：先tail加1，然后数据data入队。注意tail必须小于N
这个手写代码有一个严重缺陷：如果进入队列的数据太多，使得tail超过了N，数组que[N]就会溢出，导致出错。
用下面的例子给出上述手写代码的应用。
约瑟夫问题 https://www.luogu.com.cn/problem/P1996
约瑟夫问题是一个经典问题，可以用队列、链表等数据结构实现。下面的代码用队列来模拟报数。如果不理解代码，可以模拟执行的过程。
#include 代码第3行定义了队列的容量N = 10000。本题的n最大是100，每人出圈一次，所以队列长度一定不超过100×100。如果把N设置小了，例如N=2000，提交到OJ会返回RE，即Runtime Error，说明溢出了。
如果要防止溢出，可以使用循环队列。在上面例子中，只需要设置一个N=100的循环队列即可。
手写循环队列的代码见：《算法竞赛》第8页“1.2.2 手写循环队列”。
队列是一种线性数据结构，线性数据结构的主要缺点是查找较慢。要在队列中查找某个元素，只能从头到尾一个个查找。
2.1.2 Java手写队列
下面是Java的手写队列代码，和C++代码基本一样。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int[] que = new int[10000]; // 定义队列大小，确保够用
int head = 0, tail = -1;
for (int i = 1; i <= n; i++) que[++tail] = i;
while ((tail - head + 1) != 0) {
for (int i = 1; i < m; i++) {
que[++tail] = que[head];
head++;
}
System.out.print(que[head] + " ");
head++;
}
System.out.println();
}
}
2.1.3 Python手写队列
下面是Python的手写队列代码。这个手写队列是用list实现的，进队尾用append()实现，队列自动扩展，不会有溢出问题。
n, m = map(int, input().split())
que = [i for i in range(1, n+1)]
head, tail = 0, n-1 #队头和队尾
while tail - head + 1 != 0:
for i in range(1, m):
que.append(que[head])
head += 1
tail += 1
print(que[head], end=' ')
head += 1
2.2 C++ STL队列queue
C++STL官方文档：英文主页 https://en.cppreference.com/，或中文主页https://zh.cppreference.com/
queue的文档：https://en.cppreference.com/w/cpp/container/queue
竞赛时一般不自己手写队列，而是用STL queue，而且没有溢出的问题，大大加快了做题速度。STL queue的主要操作见下表。
这里有篇博文可以参考：STL queue
下面是 约瑟夫问题 的STL queue实现。
#include 2.3 Java队列Queue
Java官方文档：https://docs.oracle.com/en/java/
Queue的文档：https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Queue.html
Java用LinkedList实现基本队列Queue。常用操作有：
这篇博文可以参考：Java队列
下面是 约瑟夫问题 的Java Queue实现。
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
Queue<Integer> q = new LinkedList<>();
for (int i = 1; i <= n; i++) q.offer(i);
while (!q.isEmpty()) {
for (int i = 1; i < m; i++) {
q.offer(q.peek());
q.poll();
}
System.out.print(q.peek() + " ");
q.poll();
}
}
}
2.4 Python队列Queue和deque
Python官方文档：https://docs.python.org/3/
deque文档：https://docs.python.org/3/library/collections.html#collections.deque
Python的队列可以用list、Queue、deque实现。
下面先用Queue实现 约瑟夫问题 。
from queue import Queue
n, m = map(int, input().split())
q = Queue()
for i in range(1, n+1): q.put(i)
while not q.empty():
for i in range(1, m): q.put(q.get())
print(q.get(), end=' ')
不过，建议算法竞赛只使用deque，不要用queue。算法竞赛的代码都是单线程的，在这种场景下，deque比Queue快很多。
deque是双向队列，队头和队尾都能插入和弹出。当成普通队列使用时，只用它的队头弹出、队尾插入功能即可。deque的常用操作有：
参考博文：Deque
下面用deque实现 约瑟夫问题 。
from collections import deque
n, m = map(int, input().split())
dq = deque(range(1, n+1))
while dq:
dq.rotate(-(m-1)) #把前m-1个数挪到队列尾部
print(dq.popleft(), end=' ') #队头是第m个数，删除并打印它。
2.5 例题
机器翻译
用一个哈希表hashtable[]模拟内存，若hashtable[x]=true，表示x在内存中，否则不在内存中。用队列queue对输入的单词排队，当内存超过M时，删除队头的单词。
2.5.1 C/C++代码
#include 2.5.2 Java代码
import java.util.*;
public class Main {
static boolean[] hashtable = new boolean[1003];
static Queue<Integer> q = new LinkedList<>(); //使用LinkedList实现队列
public static void main(String[] args) {
int m, n;
Scanner scanner = new Scanner(System.in);
m = scanner.nextInt();
n = scanner.nextInt();
int ans=0;
for (int i = 0; i < n; i++) {
int x = scanner.nextInt();
if (hashtable[x] == false) {
hashtable[x] = true;
if (q.size() < m)
q.add(x); //使用add方法添加元素到队列中
else {
//int front = ; //使用poll方法取出队列头部元素并移除
hashtable[q.poll()] = false;
q.add(x);
}
ans++;
}
}
System.out.println(ans);
}
}
2.5.3 Python
from collections import deque
hashtable = [False] * 1003 # 哈希表初始化，默认为False
m, n = map(int, input().split()) # 输入m和n
ans = 0 # 初始化答案为0
q = deque() # 初始化队列
line = list(map(int, input().split())) #读第2行
for x in line: #处理每个数
if hashtable[x] is False: # 如果x不在哈希表中
hashtable[x] = True # 将x加入哈希表
if len(q) < m: # 如果队列未满
q.append(x) # 将x加入队列
else: # 如果队列已满
hashtable[q.popleft()] = False # 将队列首元素出队并从哈希表中删除
q.append(x) # 将x加入队列
ans += 1 # 答案加1
print(ans) # 输出答案
3. 习题
https://www.lanqiao.cn/problems/3745/learning/
https://www.lanqiao.cn/problems/3746/learning/