A 统计单词数
题解
注意是否是单词。
CODE
CPP
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main() {
string word, article;
getline(cin, word);
getline(cin, article);
// 转换为小写字母
transform(word.begin(), word.end(), word.begin(), ::tolower);
transform(article.begin(), article.end(), article.begin(), ::tolower);
int count = 0;
int pos = -1;
size_t start = 0;
while ((start = article.find(word, start)) != string::npos) {
// 确保找到的单词是独立的
if ((start == 0 || !isalpha(article[start - 1])) &&
(start + word.length() == article.length() || !isalpha(article[start + word.length()]))) {
count++;
if (pos == -1) {
pos = start;
}
}
start += word.length();
}
if (count > 0) {
cout << count << " " << pos << endl;
} else {
cout << -1 << endl;
}
return 0;
}
PYTHON
def find_word(word, article):
count = 0
position = -1
words = article.split()
for i in range(len(words)):
if words[i].lower() == word.lower():
count += 1
if position == -1:
position = article.index(words[i])
if count > 0:
return f"{count} {position}"
else:
return -1
word = input()
article = input()
result = find_word(word, article)
print(result)
JAVA
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String word = sc.nextLine().toLowerCase(); // 给定的单词转为小写
String article = sc.nextLine();
int count = 0; // 计数器，记录单词出现的次数
int position = -1; // 记录单词第一次出现的位置，默认为-1
int index = 0; // 当前搜索的位置
// 在文章中循环查找单词
while (index < article.length()) {
// 找到单词的第一个字符出现的位置
int start = article.toLowerCase().indexOf(word, index);
// 如果找到了单词
if (start != -1) {
// 如果该单词是一个独立的单词，即其前后字符都不是字母
if ((start == 0 || !Character.isLetter(article.charAt(start - 1))) &&
(start + word.length() == article.length() ||
!Character.isLetter(article.charAt(start + word.length())))) {
count++;
// 如果是第一次找到单词，记录位置
if (position == -1) {
position = start;
}
}
// 更新搜索的位置
index = start + word.length();
} else {
break;
}
}
// 输出结果
if (count == 0) {
System.out.println(-1);
} else {
System.out.println(count + " " + position);
}
}
}
B 单词替换
题解
注意判断是否是单词。
CODE
CPP
#include <iostream>
#include <string>
using namespace std;
string replaceWord(string s, string a, string b) {
size_t pos = s.find(a); // 找到待替换单词的位置
while (pos != string::npos) {
s.replace(pos, a.length(), b); // 替换单词
pos = s.find(a, pos + b.length());
}
return s;
}
int main() {
string s, a, b;
getline(cin, s);
getline(cin, a);
getline(cin, b);
string replacedString = replaceWord(s, a, b);
cout << replacedString << endl;
return 0;
}
PYTHON
s = input().strip()
a = input().strip()
b = input().strip()
result = s.replace(a, b)
print(result)
JAVA
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
String a = scanner.nextLine();
String b = scanner.nextLine();
String replacedString = s.replace(a, b);
System.out.println(replacedString);
}
}
C 生日相同
题解
以生日为键，保存相同生日的同学的姓名，再将姓名排序输出。
CODE
CPP
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
// 学生结构体
struct Student {
string name;
int month;
int day;
};
// 比较函数，用于sort排序
bool compare(const string& s1, const string& s2) {
if (s1.length() != s2.length()) {
return s1.length() < s2.length();
} else {
return s1 < s2;
}
}
int main() {
int n;
cin >> n;
// 使用map来存储生日相同的学生
map<pair<int, int>, vector<string>> birthdayMap;
for (int i = 0; i < n; i++) {
string name;
int month, day;
cin >> name >> month >> day;
// 将学生信息存入map中
birthdayMap[make_pair(month, day)].push_back(name);
}
// 判断是否存在生日相同的学生
int sz = birthdayMap.size();
if (sz == n) {
cout << "None" << endl;
} else {
// 遍历map输出结果
for (auto pair : birthdayMap) {
if (pair.second.size() == 1) continue;
// 输出生日相同的学生
cout << pair.first.first << " " << pair.first.second << " ";
// 对学生名字进行排序
sort(pair.second.begin(), pair.second.end(), compare);
// 输出学生名字
for (string& name : pair.second) {
cout << name << " ";
}
cout << endl;
}
}
return 0;
}
PYTHON
# 输入学生数量
n = int(input())
students = []
# 读取每个学生的信息
for _ in range(n):
name, month, day = input().split()
month, day = int(month), int(day)
students.append((name, month, day))
# 按照月份、日期、名字的长度和名字的字典顺序对学生进行排序
students.sort(key=lambda x: (x[1], x[2], len(x[0]), x[0]))
birthday_dict = {}
# 遍历排序后的学生列表
for name, month, day in students:
# 如果学生的生日还没有在字典中，就在字典中为这个生日创建一个空列表
if (month, day) not in birthday_dict:
birthday_dict[(month, day)] = []
# 将学生的名字添加到这个生日对应的列表中
birthday_dict[(month, day)].append(name)
# 按照日期的顺序遍历字典中的每个条目
for key in sorted(birthday_dict.keys()):
# 如果一个生日有多于一个的学生，就打印出这个日期和所有在这一天出生的学生的名字
if len(birthday_dict[key]) > 1:
print(key[0], key[1], *birthday_dict[key])
JAVA
import java.util.*;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
// 创建一个扫描器来读取输入
Scanner scanner = new Scanner(System.in);
// 读取学生的数量
int n = scanner.nextInt();
scanner.nextLine();
// 创建一个映射来存储每个生日的学生列表
Map<String, List<String>> birthdayMap = new TreeMap<>();
for (int i = 0; i < n; i++) {
// 读取学生的名字、出生月份和日期
String[] student = scanner.nextLine().split(" ");
String name = student[0];
String birthday = student[1] + " " + student[2];
// 如果这个生日还没有在映射中，就在映射中为这个生日创建一个空列表
if (!birthdayMap.containsKey(birthday)) {
birthdayMap.put(birthday, new ArrayList<>());
}
// 将学生的名字添加到这个生日对应的列表中
birthdayMap.get(birthday).add(name);
}
// 按照日期的顺序遍历映射中的每个条目
for (String birthday : birthdayMap.keySet()) {
// 获取这个生日的学生列表
List<String> names = birthdayMap.get(birthday);
// 如果一个生日有多于一个的学生
if (names.size() > 1) {
// 按照名字的长度和字典顺序对名字进行排序
names.sort(Comparator.comparing(String::length).thenComparing(String::compareTo));
// 打印出这个日期和所有在这一天出生的学生的名字
System.out.println(birthday + " " + String.join(" ", names));
}
}
}
}
D 编程实现进制转换
题解
二进制使用除2取余，逆序排列。八进制和十六进制使用已有的函数方法。
CODE
CPP
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// 将整数转换为二进制的函数
string toBinary(int N) {
if (N == 0) return "0";
bool neg = (N < 0 ? 1 : 0);
if (neg) {
N *= -1;
}
vector<int> binary;
while (N) {
binary.push_back(N % 2);
N /= 2;
}
reverse(binary.begin(), binary.end());
string binaryStr = "";
if (neg) {
binaryStr = "-";
}
for (int i : binary) {
binaryStr += to_string(i);
}
return binaryStr;
}
int main() {
int N;
cin >> N;
bool neg = (N < 0 ? 1 : 0);
// 输出二进制
cout << toBinary(N) << " ";
// 输出八进制
if (neg) {
cout << "-";
N *= -1;
}
cout << oct << N << " ";
// 输出十六进制
if (neg) {
cout << "-";
}
cout << hex << N << endl;
return 0;
}
PYTHON
def convert_to_bases(N):
# 转换为二进制
binary = bin(N)[2:] if N >= 0 else "-" + bin(N)[3:]
# 转换为八进制
octal = oct(N)[2:] if N >= 0 else "-" + oct(N)[3:]
# 转换为十六进制
hexadecimal = hex(N)[2:] if N >= 0 else "-" + hex(N)[3:]
return binary, octal, hexadecimal
N = int(input())
binary, octal, hexadecimal = convert_to_bases(N)
print(binary, octal, hexadecimal)
JAVA
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
// 转换为二进制
String binary = N >= 0 ? Integer.toBinaryString(N) : "-" + Integer.toBinaryString(-N);
// 转换为八进制
String octal = N >= 0 ? Integer.toOctalString(N) : "-" + Integer.toOctalString(-N);
// 转换为十六进制
String hexadecimal = N >= 0 ? Integer.toHexString(N) : "-" + Integer.toHexString(-N);
System.out.println(binary + " " + octal + " " + hexadecimal);
}
}
E Stones
题意
由于自行车的状态不对，Sempr 开始每天早上从东边走到西边，晚上再走回来。走着走着可能会有点累，所以森普尔总是在这个时候玩一些游戏。
路上有很多石头，当他遇到一块石头时，如果是单数石头，他会把它扔得越远越好，如果是双数石头，他会把它留在原地。现在给你一些关于路上石头的信息，你要告诉我 Sempr 走过之后，从起点到最远的石头的距离。请注意，如果两块或两块以上的石头停留在同一位置，你会先遇到较大的那块（如输入中描述的 Di 最小的那块）。
题解
由于单数石头被踢后后续还是会再遇到，我们需要动态取距离sempr最近的石头，可以使用堆（优先队列）来完成这种操作。
CODE
CPP
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
// 自定义比较函数，用于优先队列
struct compare {
bool operator()(pair<int, int> a, pair<int, int> b) {
if(a.first == b.first) return a.second > b.second; // 如果位置相同，投掷距离小的在前
return a.first > b.first; // 位置小的在前
}
};
int main() {
int T; // 测试用例数量
cin >> T;
while (T -- ) {
priority_queue<pair<int, int>, vector<pair<int, int>>, compare> pq; // 存储石头信息的优先队列
int n; // 石头数量
cin >> n;
for (int i = 0;i < n;i++) {
int a, b; // 石头的位置和投掷距离
cin >> a >> b;
pq.push({a,b}); // 将石头信息添加到优先队列中
}
long long ans = 0; // 最远石头的距离
int odd = 1; // 是否为奇数个石头
while (!pq.empty()) {
auto x = pq.top(); // 取出队列顶部的石头
pq.pop();
if (odd) { // 如果是奇数个石头，就投掷
pq.push({x.first + x.second, x.second}); // 投掷后的石头再放回队列中
} else { // 如果是偶数个石头，就更新最远距离
ans = max(ans, x.first*1ll);
}
odd = 1 - odd; // 更新奇偶标记
}
cout << ans << "\n"; // 输出最远石头的距离
}
return 0;
}
PYTHON
import heapq
T = int(input())
for _ in range(T):
n = int(input())
stones = []
for _ in range(n):
a, b = map(int, input().split())
stones.append((a, b))
# 使用堆来实现优先队列，堆顶元素总是最小的元素
heap = []
for stone in stones:
heapq.heappush(heap, stone)
ans = 0
odd = True
while heap:
x = heapq.heappop(heap) # 取出堆顶元素
if odd: # 如果是奇数个石头，就投掷
heapq.heappush(heap, (x[0] + x[1], x[1])) # 投掷后的石头再放回堆中
else: # 如果是偶数个石头，就更新最远距离
ans = max(ans, x[0])
odd = not odd # 更新奇偶标记
print(ans) # 输出最远石头的距离
JAVA
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); // 创建扫描器读取输入
int T = scanner.nextInt(); // 读取测试用例数量
for (int t = 0; t < T; t++) {
int n = scanner.nextInt(); // 读取每个测试用例的石头数量
// 创建优先队列，存储石头信息，先按位置排序，位置相同则按投掷距离排序
PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
for (int i = 0; i < n; i++) {
int a = scanner.nextInt(); // 读取石头的位置
int b = scanner.nextInt(); // 读取石头的投掷距离
pq.offer(new int[]{a, b}); // 将石头信息添加到优先队列中
}
long ans = 0; // 初始化最远石头的距离
boolean odd = true; // 初始化奇偶标记，true表示奇数
while (!pq.isEmpty()) {
int[] x = pq.poll(); // 从优先队列中取出队首的石头
if (odd) { // 如果是奇数个石头，就投掷
pq.offer(new int[]{x[0] + x[1], x[1]}); // 投掷后的石头再放回队列中
} else { // 如果是偶数个石头，就更新最远距离
ans = Math.max(ans, x[0]);
}
odd = !odd; // 更新奇偶标记
}
System.out.println(ans); // 输出最远石头的距离
}
scanner.close(); // 关闭扫描器
}
}
F Expedition
题解
对于当前燃料能走到的所有地方，如果没有终点，说明必须得加油，显然，最优的方案就是选择加油量最多的进行加油，然后再判断能否到达终点，再不能就还得再加油，以此类推，直到到达终点。
CODE
CPP
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
// 定义一个结构体，表示加油站
struct Station {
int distance; // 加油站到城镇的距离
int fuel; // 加油站的燃油量
};
// 比较函数，用于对加油站按照距离进行排序
bool cmp(const Station &a, const Station &b) {
return a.distance < b.distance;
}
int main() {
int N, L, P;
cin >> N; // 输入加油站的数量
vector<Station> stations(N); // 创建一个向量来存储所有的加油站
for (int i = 0; i < N; i++) {
cin >> stations[i].distance >> stations[i].fuel; // 输入每个加油站的信息
}
cin >> L >> P; // 输入卡车到城镇的距离和卡车的初始燃油量
for (int i = 0; i < N; i++) {
stations[i].distance = L - stations[i].distance; // 计算每个加油站到卡车的距离
}
sort(stations.begin(), stations.end(), cmp); // 对加油站按照距离进行排序
stations.push_back({L, 0}); // 将城镇作为一个加油站添加到向量中
priority_queue<int> pq; // 创建一个优先队列来存储可以到达的加油站的燃油量
int ans = 0, pos = 0, tank = P; // 初始化答案，当前位置和燃油箱的燃油量
for (int i = 0; i <= N; i++) {
int d = stations[i].distance - pos; // 计算到下一个加油站的距离
while (tank - d < 0) { // 如果燃油不足以到达下一个加油站
if (pq.empty()) { // 如果没有可以到达的加油站
cout << -1 << endl; // 输出-1
return 0;
}
tank += pq.top(); // 在燃油量最大的加油站加油
pq.pop(); // 从优先队列中移除这个加油站
ans++; // 增加停靠的加油站数量
}
tank -= d; // 更新燃油量
pos = stations[i].distance; // 更新当前位置
pq.push(stations[i].fuel); // 将当前加油站的燃油量添加到优先队列中
}
cout << ans << endl; // 输出最少的停靠加油站数量
return 0;
}
PYTHON
import heapq
# 定义一个类，表示加油站
class Station:
def __init__(self, distance, fuel):
self.distance = distance # 加油站到城镇的距离
self.fuel = fuel # 加油站的燃油量
N = int(input()) # 输入加油站的数量
stations = [] # 创建一个列表来存储所有的加油站
for _ in range(N):
d, f = map(int, input().split()) # 输入每个加油站的信息
stations.append(Station(d, f))
L, P = map(int, input().split()) # 输入卡车到城镇的距离和卡车的初始燃油量
for i in range(N):
stations[i].distance = L - stations[i].distance
# 将加油站按照距离进行排序
stations.sort(key=lambda s: s.distance)
# 将城镇作为一个加油站添加到列表中
stations.append(Station(L, 0))
pq = [] # 创建一个优先队列来存储可以到达的加油站的燃油量
ans = 0 # 初始化答案
pos = 0 # 初始化当前位置
tank = P # 初始化燃油箱的燃油量
for i in range(N+1):
d = stations[i].distance - pos # 计算到下一个加油站的距离
# 如果燃油不足以到达下一个加油站
while tank - d < 0:
if not pq: # 如果没有可以到达的加油站
print(-1) # 输出-1
exit(0)
tank += -heapq.heappop(pq) # 在燃油量最大的加油站加油
ans += 1 # 增加停靠的加油站数量
tank -= d # 更新燃油量
pos = stations[i].distance # 更新当前位置
heapq.heappush(pq, -stations[i].fuel) # 将当前加油站的燃油量添加到优先队列中
print(ans) # 输出最少的停靠加油站数量
JAVA
import java.util.*;
// 定义一个类，表示加油站
class Station implements Comparable<Station> {
int distance; // 加油站到城镇的距离
int fuel; // 加油站的燃油量
// 构造函数
public Station(int distance, int fuel) {
this.distance = distance;
this.fuel = fuel;
}
// 实现Comparable接口的compareTo方法，用于比较两个加油站的燃油量
public int compareTo(Station other) {
return other.fuel - this.fuel;
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt(); // 输入加油站的数量
Station[] stations = new Station[N+1]; // 创建一个数组来存储所有的加油站
for (int i = 0; i < N; i++) {
int distance = scanner.nextInt();
int fuel = scanner.nextInt();
stations[i] = new Station(distance, fuel); // 输入每个加油站的信息
}
int L = scanner.nextInt(); // 输入卡车到城镇的距离
int P = scanner.nextInt(); // 输入卡车的初始燃油量
stations[N] = new Station(L, 0); // 将城镇作为一个加油站添加到数组
for (int i = 0; i < N; i++) {
stations[i].distance = L - stations[i].distance; // 输入每个加油站的信息
}
Arrays.sort(stations, (a, b) -> a.distance - b.distance); // 对加油站按照距离进行排序
PriorityQueue<Station> pq = new PriorityQueue<>(); // 创建一个优先队列来存储可以到达的加油站
int ans = 0, pos = 0, tank = P; // 初始化答案，当前位置和燃油箱的燃油量
for (int i = 0; i <= N; i++) {
int d = stations[i].distance - pos; // 计算到下一个加油站的距离
while (tank - d < 0) { // 如果燃油不足以到达下一个加油站
if (pq.isEmpty()) { // 如果没有可以到达的加油站
System.out.println(-1); // 输出-1
return;
}
tank += pq.poll().fuel; // 在燃油量最大的加油站加油
ans++; // 增加停靠的加油站数量
}
tank -= d; // 更新燃油量
pos = stations[i].distance; // 更新当前位置
if (i < N) pq.offer(stations[i]); // 将当前加油站的燃油量添加到优先队列中
}
System.out.println(ans); // 输出最少的停靠加油站数量
}
}
G 【蓝桥杯2021初赛】货物摆放
题解
由于是乘法，考虑n的因子，对因子进行排列组合，得到所有可能的方案。
CODE
CPP
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// 找出所有因子
vector<long long> factors(long long n) {
vector<long long> f;
for (long long i = 1; i <= n / i; ++i) {
if (n % i == 0) {
f.push_back(i);
if (i * i != n) {
f.push_back(n / i);
}
}
}
return f;
}
// 计算所有可能的组合数量
long long count_combinations(const vector<long long>& f) {
long long count = 0;
for (size_t i = 0; i < f.size(); ++i) {
for (size_t j = 0; j < f.size(); ++j) {
if (binary_search(f.begin(), f.end(), f[i] * f[j])) {
++count;
}
}
}
return count;
}
int main() {
long long n = 2021041820210418;
vector<long long> f = factors(n);
sort(f.begin(), f.end());
cout << count_combinations(f) << endl;
return 0;
}
H 【蓝桥杯2021初赛】砝码称重
题解
动态规划，对于现在已经知道的能凑成的数字num，新加入一个砝码x可能会凑出新的数字，这些可能的数字是x，x+num、abs(x - num)。
CODE
CPP
#include <iostream>
#include <numeric>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> W(N);
for (int i = 0; i < N; ++i) {
cin >> W[i];
}
int sum = accumulate(W.begin(), W.end(), 0);
vector<bool> dp( sum+2,0);
for (int i = 0;i < N;i++) {
vector<bool> tdp(sum+2,0); // 加入第i个砝码后的答案数组
for (int j = 0;j <= sum;j++) {
if (W[i] == j) tdp[j] = 1; // 能凑成x
else {
tdp[j] = dp[abs(j - W[i])] | dp[j]; // 原来就能凑出或abs(x-num)
if (j + W[i] <= sum) tdp[j] = dp[j + W[i]] | tdp[j]; // x+num
}
}
dp = move(tdp); // 更新
}
cout << count(dp.begin() + 1, dp.end(), true) << endl;
return 0;
}
I 最小值-2019
题解
由于(i * j) % 2019等价于(i % 2019 * j % 2019) % 2019，因此一旦区间长度超过2019，答案就是0，不超过的话就可以遍历所有情况，找最小值。
CODE
CPP
#include <iostream>
#include <numeric>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int l, r;
cin >> l >> r; // 读取区间的左右边界
// 如果区间长度大于等于2019，那么一定可以找到两个数i和j，使得i*j mod 2019为0
if (r - l >= 2019) {
cout << 0 << "\n";
return 0;
}
// 初始化答案为2018，因为i*j mod 2019的最大值不会超过2018
int ans = 2018;
// 枚举区间内的所有数对(i, j)
for (int i = l; i <= r; i++) {
for (int j = i + 1; j <= r; j++) {
// 更新答案为当前数对和2019的模的最小值
ans = min(ans, ((i % 2019) * (j % 2019)) % 2019);
}
}
// 输出答案
cout << ans << "\n";
}
PYTHON
# 读取区间的左右边界
l, r = map(int, input().split())
# 如果区间长度大于等于2019，那么一定可以找到两个数i和j，使得i*j mod 2019为0
if r - l >= 2019:
print(0)
else:
# 初始化答案为2018，因为i*j mod 2019的最大值不会超过2018
ans = 2018
# 枚举区间内的所有数对(i, j)
for i in range(l, r+1):
for j in range(i+1, r+1):
# 更新答案为当前数对和2019的模的最小值
ans = min(ans, (i*j) % 2019)
if ans == 0: # 如果ans已经为0，那么已经找到最小值，可以提前结束循环
break
if ans == 0:
break
# 输出答案
print(ans)
JAVA
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 读取区间的左右边界
int l = scanner.nextInt();
int r = scanner.nextInt();
// 如果区间长度大于等于2019，那么一定可以找到两个数i和j，使得i*j mod 2019为0
if (r - l >= 2019) {
System.out.println(0);
return;
}
// 初始化答案为2018，因为i*j mod 2019的最大值不会超过2018
int ans = 2018;
// 枚举区间内的所有数对(i, j)
for (int i = l; i <= r; i++) {
for (int j = i + 1; j <= r; j++) {
// 更新答案为当前数对和2019的模的最小值
int aaa = i % 2019;
int bbb = j % 2019;
ans = Math.min(ans, (aaa * bbb) % 2019);
if (ans == 0) { // 如果ans已经为0，那么已经找到最小值，可以提前结束循环
System.out.println(ans);
return;
}
}
}
// 输出答案
System.out.println(ans);
}
}
L Ensemble’s heritage
题解
使用了差分数组的思想，通过对每个房间可以打开的卡片范围进行统计，然后通过遍历每张卡片，更新每张卡片可以打开的房间数量，最后统计出可以打开所有房间的卡片数量。
CODE
CPP
#include<bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m; // 读取卡片数量和房间数量
vector<int> v(n + 10,0); // 初始化一个大小为n+10的向量，所有元素都为0
for (int i = 0;i < m;i++) { // 对于每个房间
int l, r;
cin >> l >> r; // 读取可以打开这个房间的卡片范围
v[l]++, v[r+1]--; // 对应的卡片数量加一，范围外的卡片数量减一
}
int ans = 0; // 初始化答案为0
for (int i = 1;i <= n;i++) { // 对于每张卡片
v[i] += v[i - 1]; // 更新当前卡片的数量
if (v[i]==m) ans++; // 如果当前卡片的数量等于房间数量，说明这张卡片可以打开所有的房间，答案加一
}
cout << ans << "\n"; // 输出答案
return 0;
}
PYTHON
from collections import defaultdict
def main():
# 读取卡片数量和房间数量
n, m = map(int, input().split())
# 初始化一个字典，所有元素都为0
v = defaultdict(int)
for _ in range(m): # 对于每个房间
# 读取可以打开这个房间的卡片范围
l, r = map(int, input().split())
# 对应的卡片数量加一，范围外的卡片数量减一
v[l] += 1
v[r+1] -= 1
# 初始化答案为0
ans = 0
# 对于每张卡片
for i in range(1, n+1):
# 更新当前卡片的数量
v[i] += v[i - 1]
# 如果当前卡片的数量等于房间数量，说明这张卡片可以打开所有的房间，答案加一
if v[i] == m:
ans += 1
# 输出答案
print(ans)
if __name__ == "__main__":
main()
JAVA
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 读取卡片数量和房间数量
int n = scanner.nextInt();
int m = scanner.nextInt();
// 初始化一个大小为n+10的数组，所有元素都为0
int[] v = new int[n + 10];
for (int i = 0; i < m; i++) { // 对于每个房间
// 读取可以打开这个房间的卡片范围
int l = scanner.nextInt();
int r = scanner.nextInt();
// 对应的卡片数量加一，范围外的卡片数量减一
v[l]++;
v[r+1]--;
}
// 初始化答案为0
int ans = 0;
// 对于每张卡片
for (int i = 1; i <= n; i++) {
// 更新当前卡片的数量
v[i] += v[i - 1];
// 如果当前卡片的数量等于房间数量，说明这张卡片可以打开所有的房间，答案加一
if (v[i] == m) {
ans++;
}
}
// 输出答案
System.out.println(ans);
}
}