【蓝桥杯软件赛零基础备赛20周】第5周—

文章目录

1. 数组的应用–高精度大数运算
- 1.1 Java和Python计算大数
- 1.2 C/C++高精度计算大数
- - 1.2.1 高精度加法
  - 1.2.2 高精度减法
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. 习题

1. 数组的应用–高精度大数运算

高精度算法就是大数的计算方法。超过64位的大数计算，Java和Python都能直接算，而C++不能直接算，需要用数组来模拟大数的存储。因此强烈建议大数运算使用Java或Python。

竞赛中常常用到很大的数组。强烈建议不要用动态分配，因为动态分配需要多写代码而且容易出错。定义为全局静态数组即可，而且不需要初始化为0，因为全局变量在编译时会自动初始化为全0。

#include <bits/stdc++.h>
using namespace std;
int a[10000000]; //定义一个很大的全局数组。自动初始化为0，不需要写成int a[10000000]={0};
int main(){
    cout << a[0];   //输出0
    return 0;
}

注意：C++开很大的数组时，必须放在所有函数外，不然会导致栈内存溢出！

这样写是错的：

#include <bits/stdc++.h>
using namespace std;
int main(){
    int a[10000000]={0}; //这样写是错的，大数组不能定义在函数内部
    cout << a[0];   //出错
    return 0;
}

另外，注意全局变量和局部变量的初值。全局变量如果没有赋值，在编译时被自动初始化为0。在函数内部定义的局部变量，若需要初值为0，一定要初始化为0，否则可能为莫名其妙的值。

#include <bits/stdc++.h>
using namespace std;
int a;                //全局变量自动初始化为0
int c = 999;          //赋值为999
int main(){
    int b;
    cout << a <<endl; //输出0
    cout << c <<endl; //输出999
    cout << b <<endl; //由于b没有初始化，这里输出莫名奇妙的值
    return 0;
}

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，如果需要计算更大的数，需要使用“高精度”。对于加减乘除四种计算，模拟每一位的计算，并处理进位或借位。

数字的读取和存储。因为整数a和b太大，无法直接赋值给C++的变量，不能按数字读入，只能按字符读入。大数a用字符串string读入，一个字符存一位数字。注意存储的顺序，读入的时候，数字的左边是高位，右边是低位，即a[0]是最高位，a[n-1]是最低位；但是计算时习惯用a[0]表示最低位，a[n-1]表示最高位，所以需要把输入的字符串倒过来。
加法和减法。简单地模拟即可。
乘法。模拟小学竖式乘法操作，例如34×67，计算过程：计算结果用int a[]存储，首先算出a[0]=4×7=28，a[1]=3×7+4×6=21+24，a[2]=3×6=18，然后处理进位，得到乘积2278。
除法。直接做除法有点麻烦，简单一点的方法是利用减法。例如a除以b，转化为a连续减去b，减了多少次就是商，最后不够减的是余数。

1.2.1 高精度加法

链接：大整数加法
把输入的数字存到字符串中，然后在add()中把字符转成数字，做完加法后再转回字符。

#include<bits/stdc++.h>
using namespace std;
int na[1005],nb[1005];  //加数和被加数
string add(string a,string b){
    int lena=a.size(),lenb=b.size();
    for(int i=0;i<lena;i++)
        na[lena-1-i] = a[i]-'0';  //把字符转成数字，然后翻转，使na[0]是最低位
    for(int i=0;i<lenb;i++)
        nb[lenb-1-i] = b[i]-'0';
    int lmax = lena>lenb ? lena : lenb;
    for(int i=0;i<lmax;i++) {
        na[i] += nb[i];
        na[i+1] += na[i]/10;   //处理进位
        na[i]%=10;
    }
    if(na[lmax]) lmax++;        //若最高位相加后也有进位，数字长度加1
    string ans;
    for(int i=lmax-1;i>=0;i--)  //把数字转成字符，然后翻转
        ans += na[i]+'0';
    return ans;
}
int main(){
    string a,b;
    cin >> a >> b;
    cout << add(a,b);
    return 0;
}

1.2.2 高精度减法

#include<bits/stdc++.h>
using namespace std;
int na[1005],nb[1005];             //被减数和减数
string sub(string a,string b){
    if(a == b) return "0";         //特判一下是否两数字相等
    bool neg = 0;                  //标记是否为负数
    if(a.size() < b.size() || a.size() == b.size() && a < b)
        swap(a, b), neg = 1;      //让a大于b
    int lena=a.size(),lenb=b.size();
    for(int i=0;i<lena;i++)        //把字符转成数字，然后翻转，使na[0]是最低位
        na[lena-1-i]=a[i]-'0';
    for(int i=0;i<lenb;i++)
        nb[lenb-1-i]=b[i]-'0';
    int lmax = lena;
    for(int i=0;i<lmax;i++){
        na[i] -= nb[i];
        if(na[i]<0){                //处理借位
            na[i]+=10;
            na[i+1]--;
        }
    }
    while(!na[--lmax] && lmax>0)    //找到首位为0的位置
         ;                          //什么都不做
    lmax++;
    string ans;
    for(int i=lmax-1;i>=0;i--)       //把数字转成字符，然后翻转
        ans += na[i]+'0';
    if(neg) ans = "-" + ans;          //查询一下是否为负数
    return ans;
}
int main(){
    string a,b;
    cin>>a>>b;
    cout<<sub(a,b);
    return 0;
}

1.2.3 高精度乘法

链接：大整数乘法

#include<bits/stdc++.h>
using namespace std;
int na[1005], nb[1005], nc[1000005];
string mul(string a,string b){
    if(a=="0"||b=="0")  return "0";
    int lena=a.size(),lenb=b.size();
    for(int i=0;i<lena;i++)
        na[lena-i]=a[i]-'0';
    for(int i=0;i<lenb;i++)
        nb[lenb-i]=b[i]-'0';
    for(int i=1;i<=lena;i++)
        for(int j=1;j<=lenb;j++)
            nc[i+j-1] += na[i]*nb[j];
    for(int i=1;i<=lena+lenb;i++)
        nc[i+1]+=nc[i]/10,nc[i]%=10;
    string ans;
    if(nc[lena+lenb])  ans += nc[lena+lenb]+'0';
    for(int i=lena+lenb-1;i>=1;i--) ans += nc[i]+'0';
    return ans;
}
int main(){
    string a,b;
    cin>>a>>b;
    cout<<mul(a,b);
    return 0;
}

1.2.4 高精度除法

#include<bits/stdc++.h>
using namespace std;
string sub(string a,string b){//模拟大整数减法 
    string res;
    int n=a.size(),m=b.size(),i,by=1;
    reverse(a.begin(),a.end());
    reverse(b.begin(),b.end());
    for(i=0;i<m;++i){
        int t=a[i]-b[i]+9+by;
        res+=t%10+'0';
        by=t/10;
    }
    for(;i<n;++i){
        int t=a[i]-'0'+9+by;
        res+=t%10+'0';
        by=t/10;
    }
    //消去前缀零 
    while(res[--i]=='0'&&i>0);
    res=res.substr(0,i+1);
    reverse(res.begin(),res.end());
    return res; 
}
int main(){
    string s1,s2,res,ans;
    cin>>s1>>s2;
    bool h=false;
    int n=s1.size(),m=s2.size(),t;
    //查找被除数末端非零位 
    int f=n-1;
    while(s1[f]=='0')f--;
    //模拟除法 
    for(int i=0;i<n;++i){//遍历被除数 
        ans+=s1[i];
        t=0;
        while(ans.size()>m||ans.size()==m&&ans>=s2){//具体操作 
            ans=sub(ans,s2);//用减法模拟除法 
            t++;
        } 
        if(t||h){//等待商的首位 
            h=true;
            res+=t+'0';
        }
        if(ans.empty()&&i>=f){//处理后缀零 
            while(++i<n)res+='0'; 
        }
    }
    if(res.empty())res+='0';//余数为零 
    if(ans.empty())ans+='0';//商为零 
    cout<<res<<endl<<ans;
    return 0;
}

2. 队列

队列中的数据存取方式是**“先进先出”**，只能往队尾插入数据、从队头移出数据。队列的原型在生活中很常见，例如食堂打饭的队伍，先到先服务，不能插队。

下图是队列的原理，队头head指向队列中的第一个元素 $a_1$ ，队尾tail指向队尾最后一个元素 $a_n$ 。元素只能从队头方向出去，元素只能从队尾进入队列。
在这里插入图片描述
对于栈、队列、动态数组等，竞赛中一般都用各个语言写好的类和方法，直接调用。但是为了大家更好的理解队列，需要自己先实现手写队列作为练习。

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]就会溢出，导致出错。

用下面的例子给出上述手写代码的应用：约瑟夫问题

约瑟夫问题是一个经典问题，可以用队列、链表等数据结构实现。下面的代码用队列来模拟报数。如果不理解代码，可以模拟执行的过程。

#include <bits/stdc++.h>
using namespace std;
const int N = 10000;  //定义队列大小，确保够用
int que[N];
int head=0, tail=-1;
int main(){
    int n,m;
    cin>>n>>m;
    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++;
        }
        cout << que[head] << " ";
        head++;
    }
    cout<<endl;
    return 0;
}

代码第3行定义了队列的容量N = 10000。本题的n最大是100，每人出圈一次，所以队列长度一定不超过100×100。如果把N设置小了，例如N=2000，提交到OJ会返回RE，即Runtime Error，说明溢出了。

如果要防止溢出，可以使用循环队列。在上面例子中，只需要设置一个N=100的循环队列即可。

手写循环队列的代码见：手写循环队列

队列是一种线性数据结构，线性数据结构的主要缺点是查找较慢。要在队列中查找某个元素，只能从头到尾一个个查找。

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

一个比较全的 C++ STL博客：https://wyqz.top/p/870124582.html

竞赛时一般不自己手写队列，而是用STL queue，而且没有溢出的问题，大大加快了做题速度。STL queue的主要操作见下表。

在这里插入图片描述
这里有篇博文可以参考：STL queue

下面是约瑟夫问题的STL queue实现。

#include <bits/stdc++.h>
using namespace std;
int main(){
    int n,m;
    cin>>n>>m;
    queue<int>q;
    for(int i=1;i<=n;i++)   q.push(i);
    while(!q.empty()){
        for(int i=1;i<m;i++){
            q.push(q.front());
            q.pop();
        }
        cout << q.front() << " ";
        q.pop();
    }
    cout<<endl;
    return 0;
}

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<bits/stdc++.h> 
using namespace std;
queue<int> q;
int h[1010];
int main()
{
    int n, m;
    cin >> m >> n;
    int res = 0;
    for (int i = 1; i <= n; i++) {
        int x;
        cin >> x;

        if (h[x] != 1) {
            res++;
            if (q.size() >= m) {
                h[q.front()] = 0;
                q.pop();
            }
            q.push(x);
            h[x] = 1;
        }
    }
    cout << res << endl;
    return 0;
}

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)  # 输出答案