two pointers 双指针
给定一个递增的正整数序列和一个正整数M，求序列中的两个不同位置的数a和b，使得它们的和恰好为M，输出所有满足条件的方案。例如给定序列{1,2,3,4,5,6}和正整数M = 8，就存在2+6=8和3+5=8成立。
容易想到：使用二重循环枚举序列中的整数a和b，判断它们的和是否为M，如果是，输出方案，如果不是，则继续枚举。
代码如下，时间复杂度为O（n^2）。
for(int i=0;i<n;i++){
for(int j=i+1;i<n;i++)
{
if(a[i]+a[j]==M){
printf("%d %d\n",a[i],a[j]);
}
}
}优化算法如下：该算法的时间复杂度为O（n）。
#include <cstdio>
#include <iostream>
using namespace std;
const int N = 1e5+10;
int a[N];
int main(){
int n,k;
int cnt = 0;
cin>>n>>k;
int i = 0,j = n-1;
for(int i=0;i<n;i++) cin>>a[i];
while(i<j){
if(a[i]+a[j]==k){
cnt++;
i++;
j--;
}else if(a[i]+a[j]<k){
i++;
}else {
j--;
}
}
cout<<cnt;
return 0;
}#include <cstdio>
#include <iostream>
using namespace std;
// 定义常量 N，用于确定数组的最大长度
const int N = 1e5 + 10;
// 定义三个数组 a、b、c，分别用于存储两个待合并的有序数组和合并后的有序数组
int a[N], b[N], c[N];
// 合并函数，将两个有序数组合并为一个有序数组
int merge(int a[], int b[], int c[], int n, int m) {
// i 指向数组 a 的起始位置，j 指向数组 b 的起始位置，index 指向数组 c 的起始位置
int i = 0, j = 0, index = 0;
// 当数组 a 和数组 b 都还有元素未处理时
while (i < n && j < m) {
// 如果 a[i] 小于等于 b[j]，将 a[i] 放入数组 c 中，并将 i 和 index 指针后移
if (a[i] <= b[j]) c[index++] = a[i++];
// 否则将 b[j] 放入数组 c 中，并将 j 和 index 指针后移
else c[index++] = b[j++];
}
// 如果数组 a 还有剩余元素，将其依次放入数组 c 中
while (i < n) c[index++] = a[i++];
// 如果数组 b 还有剩余元素，将其依次放入数组 c 中
while (j < m) c[index++] = b[j++];
// 返回合并后数组 c 的长度
return index;
}
int main() {
int n, m;
// 读取数组 a 的长度 n 和数组 b 的长度 m
scanf("%d%d",&n,&m);
// 读取数组 a 的 n 个元素
for (int i = 0; i < n; i++) scanf("%d",&a[i]);
// 读取数组 b 的 m 个元素
for (int i = 0; i < m; i++) scanf("%d",&b[i]);
// 调用 merge 函数合并数组 a 和数组 b 到数组 c 中，并获取合并后数组 c 的长度
int res = merge(a, b, c, n, m);
// 输出合并后数组 c 的元素
for (int i = 0; i < res; i++) {
printf("%d", c[i]);
// 除了最后一个元素，每个元素后面输出一个空格
if (i < res - 1) cout << " ";
}
return 0;
}递归写法
#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 1010;
int a[maxn];
//将数组A的[L1,R1]与[L2,r2]区间合并为有序区间(此处L2即为r1+1)
void merge(int a[], int l1, int r1, int l2, int r2) {
int i = l1, j = l2; //i指向a[l1],j指向a[l2]
int temp[maxn], index = 0; //temp临时存放合并后的数组，index为其下标
while (i <= r1 && j <= r2) {
if (a[i] <= a[j]) { //如果a[i]<=a[j]
temp[index++] = a[i++]; //将a[i]加入序列temp
} else {
temp[index++] = a[j++];
}
}
while (i <= r1) temp[index++] = a[i++];
while (j <= r2) temp[index++] = a[j++];
for (i = 0; i < index; i++) {
a[l1 + i] = temp[i]; //将合并后的序列赋值给数组a
}
}
//将array数组当前区间[left,right]进行归并排序
void mergeSort(int a[], int left, int right) {
if (left < right) { //只要left小于right
int mid = (left + right) / 2; //取[left,right]的中点
mergeSort(a, left, mid); //递归，将左子区间[left,mid]归并排序
mergeSort(a, mid + 1, right); //递归，将右子区间[mid+1,right]归并排序
merge(a, left, mid, mid + 1, right); //将左子区间和右子区间合并
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
// 调用归并排序函数对数组进行排序
mergeSort(a, 0, n - 1);
// 输出排序后的数组
for (int i = 0; i < n; i++) {
cout << a[i];
if (i < n - 1) cout << " ";
}
return 0;
} 非递归写法
/*1. 外层循环 for(int step = 2; step/2 <= n; step *= 2)
step 的含义：step 表示当前每组元素的个数。在归并排序的非递归实现中，我们从最小的有序子数组开始合并，初始时每组有 2 个元素（即 step = 2），然后每次将 step 乘以 2，逐渐扩大每组的元素个数。
循环条件 step/2 <= n：当 step/2 大于数组的长度 n 时，说明已经完成了所有的合并操作，因为此时分组已经包含了整个数组，所以循环结束。
step *= 2：每次循环结束后，将 step 乘以 2，这样就可以将相邻的两个有序子数组合并成一个更大的有序数组。
2. 内层循环 for(int i = 1; i <= n; i += step)
i 的含义：i 表示当前组的起始位置。每次循环将 i 增加 step，这样就可以依次处理数组中的每一组元素。
循环条件 i <= n：确保 i 不会超出数组的范围。
3. int mid = i + step/2 - 1
mid 的含义：mid 表示当前组中左子区间的最后一个元素的下标。因为左子区间的元素个数为 step/2，所以 mid 的值为 i + step/2 - 1。
4. if(mid + 1 <= n)
判断右子区间是否存在元素：如果 mid + 1 大于数组的长度 n，说明右子区间不存在元素，不需要进行合并操作；否则，需要将左子区间 [i, mid] 和右子区间 [mid + 1, min(i + step - 1, n)] 进行合并。
5. merge(a, i, mid, mid + 1, min(i + step - 1, n))
调用 merge 函数进行合并：merge 函数的作用是将两个有序子数组合并成一个更大的有序数组。这里的左子区间为 [i, mid]，右子区间为 [mid + 1, min(i + step - 1, n)]。使用 min(i + step - 1, n) 是为了防止右子区间的下标超出数组的范围。
注意事项
代码中数组的下标是从 1 开始的，而在 C++ 中数组的下标通常是从 0 开始的。如果要在实际代码中使用，需要根据具体情况进行调整。
代码中使用了变量 n，但在提供的代码片段中并没有对 n 进行定义，在实际使用时需要确保 n 是数组的长度*/
void mergeSort(int a[]){
// step为组内元素个数，step/2为左子区间元素个数，注意等号可以不取
for(int step = 2; step/2 <= n; step *= 2){
// 每step个元素一组，组内前step/2和后step/2个元素进行合并
for(int i = 1; i <= n; i += step){ // 对每一组
int mid = i + step/2 - 1; // 左子区间元素个数为step/2
if(mid + 1 <= n){ // 右子区间存在元素则合并
// 左子区间为[i, mid], 右子区间为[mid + 1, min(i + step - 1, n)]
merge(a, i, mid, mid + 1, min(i + step - 1, n));
}
}
}
}快速排序的交换方式：
//对区间[left,right]进行划分
int partition(int a[],int left,int right){
int temp = a[left];//将a[left]存放至临时变量temp
while(left<right){//只要left与right
while(left<right&&a[right]>temp) right--;//反复左移right
a[left] = a[right];//将a[right]挪到a[left]
while(left<right&&a[left]<=temp) left++;//反复右移left
a[right] = a[left];//将a[left]挪到a[right]
}
a[left] = temp;//把temp放到left与right相遇的地方
return left;//返回相遇的下标
} 快速排序的递归实现如下：
//快速排序，left 与right初值为序列首尾下标（如1,与n）
void quicksort(int a[],int left,int right){
if(left<right){//当前区间的长度不超过1
//将[left,right]按a[left]一分为二
int pos = partition(a,left,right);
quicksort(a,left,pos-1);//对左子区间递归进行快速排序
quicksort(a,pos+1,right); //对右子区间递归进行快速排序
}
}#include <cstdio>
#include <iostream>
using namespace std;
const int maxn = 1010;
int a[maxn];
//对区间[left,right]进行划分
int partition(int a[],int left,int right){
int temp = a[left];//将a[left]存放至临时变量temp
while(left<right){//只要left与right不相遇
while(left<right&&a[right]>temp) right--;//反复左移right
a[left] = a[right];//将a[right]挪到a[left]
while(left<right&&a[left]<=temp) left++;//反复右移left
a[right] = a[left];//将a[left]挪到a[right]
}
a[left] = temp;//把temp放到left与right相遇的地方
return left;//返回相遇的下标
}
//快速排序，left 与right初值为序列首尾下标（如1,与n）
void quicksort(int a[],int left,int right){
if(left<right){//当前区间的长度不超过1
//将[left,right]按a[left]一分为二
int pos = partition(a,left,right);
quicksort(a,left,pos-1);//对左子区间递归进行快速排序
quicksort(a,pos+1,right); //对右子区间递归进行快速排序
}
}
int main(){
int n;cin>>n;
for(int i=0;i<n;i++) cin>>a[i];
quicksort(a,0,n-1);
for(int i=0;i<n;i++){
cout<<a[i];
if(i<n-1) cout<<" ";
}
return 0;
}#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int mod = 1e9 + 7;
int leftnump[maxn] = {0}; // 每一位左边（含）p的个数
int main() {
string str;
getline(cin, str);
int len = str.size();
for (int i = 0; i < len; i++) { // 从左到右遍历字符串
if (i > 0) { // 如果不是0号位
leftnump[i] = leftnump[i - 1]; // 继承上一位的结果
}
if (str[i] == 'P') { // 当前为是P
leftnump[i]++; // 令leftnump[i]加1
}
}
int ans = 0, rightnumt = 0; // ans为答案，rightnumt记录右边t的个数
for (int i = len - 1; i >= 0; i--) {
if (str[i] == 'T') {
rightnumt++;
} else if (str[i] == 'A') {
ans = (ans + leftnump[i] * rightnumt) % mod; // 累计乘积
}
}
cout << ans << endl;
return 0;
} #include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
bool cmp(int a,int b){ //递减排序
return a>b;
}
void to_array(int n,int num[]){//将n的每一位存到num数组中
for(int i=0;i<4;i++){
num[i] = n%10;
n/=10;
}
}
int to_number(int num[]){//将num数组转换为数字
int sum = 0;
for(int i=0;i<4;i++){
sum = sum*10+num[i];
}
return sum;
}
int main(){
int n;cin>>n;
int min,max;
int num[5];
while(1){
to_array(n,num);//将n转换为数组
sort(num,num+4);//对num数组中元素从小到大排序
min = to_number(num);//获取最小值
sort(num,num+4,cmp);//获取最大值
max = to_number(num);
n = max-min;//得到下一个数
printf("%04d - %04d = %04d\n",max,min,n);
if(n==0||n==6174) break;
}
return 0;
}#include <cstdio>
#include <iostream>
using namespace std;
// 定义一个函数 gcd，用于计算两个整数 a 和 b 的最大公约数
// 该函数使用欧几里得算法（辗转相除法）来实现
int gcd(int a, int b) {
// 当 b 为 0 时，a 就是最大公约数，直接返回 a
if (b == 0) return a;
// 若 b 不为 0，则递归调用 gcd 函数，将 b 和 a 除以 b 的余数作为新的参数
// 这是根据欧几里得算法的原理：gcd(a, b) = gcd(b, a % b)
else return gcd(b, a % b);
}
int main() {
int m, n;
// 使用 while 循环和 scanf 函数不断从标准输入读取两个整数 m 和 n
// scanf 函数返回成功匹配并赋值的输入项数量，当输入结束（遇到文件结束符 EOF）时，scanf 返回 EOF
// 所以这里的条件是当 scanf 成功读取两个整数时，循环继续执行
while (scanf("%d%d", &m, &n) != EOF) {
// 调用 gcd 函数计算 m 和 n 的最大公约数
// 并使用 printf 函数将结果输出到标准输出，每个结果占一行
printf("%d\n", gcd(m, n));
}
return 0;
} #include <cstdio>
#include <iostream>
using namespace std;
// 定义函数gcd，用于计算两个整数a和b的最大公约数
// 采用欧几里得算法（辗转相除法），即两个整数的最大公约数等于较小数和两数相除余数的最大公约数
// 当b为0时，a就是最大公约数，返回a
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
int m, n;
// 从标准输入读取两个整数m和n
// 使用cin输入流，它是C++中用于从标准输入设备（通常是键盘）读取数据的对象
cin >> m >> n;
// 计算并输出m和n的最小公倍数
// 根据最小公倍数的计算方法：两个数的最小公倍数等于这两个数的乘积除以它们的最大公约数
// 先调用gcd函数计算m和n的最大公约数，然后通过公式m/gcd(m,n)*n计算最小公倍数并输出
// 使用cout输出流，它是C++中用于向标准输出设备（通常是显示器）输出数据的对象
cout << m / gcd(m, n) * n;
return 0;
}#include <cstdio> // 包含标准输入输出函数的头文件，如 scanf 和 printf
#include <cstring> // 包含字符串处理函数的头文件，这里主要使用 memset 函数
#include <vector> // 包含 vector 容器相关的头文件，用于存储素数
using namespace std;
const int MAXN = 1000000 + 1; // 定义一个常量，表示数组的最大长度，用于标记每个数是否为素数
bool isPrime[MAXN]; // 定义一个布尔类型的数组，用于标记每个数是否为素数，初始假设所有数都是素数
vector<int> primes; // 定义一个 vector 容器，用于存储筛选出的素数
// 函数功能：使用埃拉托斯特尼筛法筛选出小于等于 n 的所有素数
void getPrimes(int n) {
// 将 isPrime 数组的所有元素初始化为 true，表示所有数都假设为素数
memset(isPrime, true, sizeof(isPrime));
// 从 2 开始遍历到 n
for (int i = 2; i <= n; i++) {
// 如果 isPrime[i] 为 true，说明 i 是素数
if (isPrime[i]) {
// 将素数 i 添加到 primes 容器中
primes.push_back(i);
// 从 i 的 2 倍开始，以 i 为步长，将所有 i 的倍数标记为非素数
for (int j = i + i; j <= n; j += i) {
isPrime[j] = false;
}
}
}
}
int main() {
int n;
// 从标准输入读取一个整数 n，n 表示要筛选小于等于 n 的素数
scanf("%d", &n);
// 调用 getPrimes 函数筛选出小于等于 n 的所有素数
getPrimes(n);
// 遍历 primes 容器，将其中存储的素数依次输出，每个素数占一行
for (int i = 0; i < primes.size(); i++) {
printf("%d\n", primes[i]);
}
return 0;
}#include <cstdio>
#include <iostream>
using namespace std;
// 定义一个常量，表示数组的最大长度，用于标记数是否为素数的数组大小
const int maxn = 1e6 + 10;
// 布尔类型数组，用于标记每个数是否为素数，初始值都设为false（0表示false）
bool p[maxn] = {0};
// 用于存储素数的数组
int prime[maxn];
// 记录素数的数量，初始值为0
int pnum = 0;
// 用于接收用户输入的整数n
int n;
// 函数功能：筛选出小于等于n的所有素数
void findprime() {
// 从2开始遍历到n，因为1不是素数
for (int i = 2; i <= n; i++) {
// 如果p[i]为false，说明当前数i还未被标记为合数，即i是素数
if (p[i] == false) {
// 将素数i存入prime数组中，并更新素数数量pnum
prime[pnum++] = i;
// 从i的2倍开始，将i的所有倍数标记为合数（即p[j]设为true）
for (int j = i + i; j < maxn; j += i) {
p[j] = true;
}
}
}
}
int main() {
// 从标准输入读取一个整数n
cin >> n;
// 调用findprime函数筛选小于等于n的素数
findprime();
// 遍历prime数组，输出所有找到的素数
for (int i = 0; i < pnum; i++) {
printf("%d\n", prime[i]);
}
return 0;
}#include <cstdio>
#include <iostream>
using namespace std;
// 定义一个常量，表示数组的最大长度，这里设置为 1e6 + 10，用于存储素数和标记数组
const int maxn = 1e6+10;
// 用于存储素数的数组，下标从 0 开始
int prime[maxn],num = 0;
// 用于标记数组，p[i] 为 true 表示 i 不是素数，为 false 表示 i 可能是素数
bool p[maxn] = {0};
// 函数功能：筛选出前 n 个素数并存储在 prime 数组中
void findprime(int n){
// 从 2 开始遍历到 maxn - 1（因为数组下标从 0 开始，最大到 maxn - 1）
for(int i=2;i<maxn;i++){
// 如果 p[i] 为 false，说明 i 还未被标记为合数，即 i 是素数
if(p[i]==false){
// 将素数 i 存入 prime 数组中，并更新素数的数量 num
prime[num++] = i;
// 如果已经找到了 n 个素数，就退出循环，不需要再继续找了
if(num>=n) break;
// 从 i 的 2 倍开始，将 i 的所有倍数标记为合数（即 p[j] 设为 true）
for(int j=i+i;j<maxn;j+=i) {
p[j] = true;
}
}
}
}
int main(){
int m,n,count = 0;
// 从标准输入读取两个整数 m 和 n，m 表示要输出的素数的起始位置（从 1 开始计数），n 表示结束位置
cin>>m>>n;
// 调用 findprime 函数，筛选出前 n 个素数
findprime(n);
// 遍历从 m 到 n 的素数，并按照规定格式输出
for(int i=m;i<=n;i++){
// prime 数组的下标从 0 开始，所以输出 prime[i - 1]
printf("%d",prime[i-1]);
// 记录已经输出的素数的个数
count++;
// 如果 count 不是 10 的倍数且还未输出到最后一个素数（i < n），则输出一个空格分隔
if(count%10!=0&&i<n) cout<<" ";
// 否则换行
else cout<<"\n";
}
return 0;
}#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
// 从标准输入读取一个整数 n
cin >> n;
// 输出格式：先输出 "n="
printf("%d=", n);
// 如果 n 等于 1，直接输出 "1" 并换行
if (n == 1) puts("1");
else
{
// 用于标记是否是第一次输出质因数，初始为 true
bool first = true;
// 遍历从 2 到 n 的平方根的数（因为一个数的质因数不会超过它的平方根）
for (int i = 2; i <= n / i; i++)
// 判断 n 是否能被 i 整除，如果能整除，说明 i 是 n 的一个质因数
if (n % i == 0)
{
// 计算 n 能被质因数 i 整除的次数，即质因数 i 的幂次
int k = 0;
while (n % i == 0) n /= i, k++;
// 如果不是第一次输出质因数，先输出乘号 "*"
if (!first) cout << "*";
else first = false;
// 输出质因数 i
cout << i;
// 如果质因数 i 的幂次大于 1，输出幂次，格式为 "^k"
if (k > 1) cout << "^" << k;
}
// 如果经过前面的循环后，n 仍然大于 1，说明 n 本身就是一个大于其平方根的质因数
if (n > 1)
{
// 如果不是第一次输出质因数，先输出乘号 "*"
if (!first) cout << "*";
// 输出剩余的质因数 n
cout << n;
}
}
return 0;
}#include <cstdio>
#include <iostream>
#include <cmath>
#include <vector>
using namespace std;
// 定义一个常量，用于表示数组的最大大小，这里用于存储素数相关信息
const int maxn = 100010;
// 布尔类型数组，用于标记每个数是否为素数，初始值都设为false（0表示false）
// 后续会通过埃拉托斯特尼筛法来更新这些标记
bool isprime[maxn] = {0};
// 用于存储素数的数组
int prime[maxn];
// 记录素数的数量，初始值为0
int pnum = 0;
// 函数功能：使用埃拉托斯特尼筛法生成小于maxn的素数表
void findprime() {
// 初始化isprime数组，将所有大于等于2的数标记为可能是素数（设为true）
for (int i = 2; i < maxn; i++) {
isprime[i] = true;
}
// 遍历从2到maxn - 1的数
for (int i = 2; i < maxn; i++) {
// 如果当前数i被标记为素数
if (isprime[i]) {
// 将素数i存入prime数组中，并更新素数的数量pnum
prime[pnum++] = i;
// 将i的所有倍数标记为非素数（设为false）
for (int j = i + i; j < maxn; j += i) {
isprime[j] = false;
}
}
}
}
// 定义结构体factor，用于存储质因数及其个数
struct factor {
int x, cnt; // x表示质因子，cnt表示个数
};
int main() {
// 调用findprime函数生成素数表
findprime();
int n;
// 使用scanf函数从标准输入读取一个整数n，提高输入效率
scanf("%d", &n);
// 如果n等于1，按照题目要求输出"1=1"并换行
if (n == 1) {
printf("1=1\n");
} else {
// 按照题目要求，先输出n和等号，如："n="
printf("%d=", n);
// 计算n的平方根，用于后续确定质因数的查找范围
int sqr = (int)sqrt(1.0 * n);
// 使用vector动态数组fac来存储质因数及其个数
vector<factor> fac;
// 遍历素数表prime，查找n的质因数
for (int i = 0; i < pnum && prime[i] <= sqr; i++) {
// 如果当前素数prime[i]是n的质因数（n能被prime[i]整除）
if (n % prime[i] == 0) {
factor temp;
// 记录当前质因数
temp.x = prime[i];
// 初始化当前质因数的个数为0
temp.cnt = 0;
// 计算当前质因数的个数，即n能被prime[i]整除的次数
while (n % prime[i] == 0) {
temp.cnt++;
n /= prime[i];
}
// 将当前质因数及其个数存入fac数组中
fac.push_back(temp);
}
// 如果n已经被分解为1，说明质因数分解完成，退出循环
if (n == 1) break;
}
// 如果经过上述循环后，n仍然大于1，说明n本身就是一个大于其平方根的质因数
if (n != 1) {
factor temp;
temp.x = n;
temp.cnt = 1;
fac.push_back(temp);
}
// 遍历fac数组，按照题目要求的格式输出质因数分解的结果
for (size_t i = 0; i < fac.size(); i++) {
// 如果不是第一个质因数，先输出乘号"*"
if (i > 0) printf("*");
// 输出当前质因数
printf("%d", fac[i].x);
// 如果当前质因数的个数大于1，输出其指数，格式为"^个数"
if (fac[i].cnt > 1) {
printf("^%d", fac[i].cnt);
}
}
// 输出结束后换行
printf("\n");
}
return 0;
}#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;
// 定义一个常量，用于表示数组的最大大小，这里用于存储素数相关信息
const int maxn = 100010;
// 布尔类型数组，用于标记每个数是否为素数，初始值都设为false（0表示false）
// 后续会通过埃拉托斯特尼筛法来更新这些标记
bool isprime[maxn] = {0};
// 用于存储素数的数组
int prime[maxn];
// 记录素数的数量，初始值为0
int pnum = 0;
// 函数功能：使用埃拉托斯特尼筛法生成小于maxn的素数表
void findprime() {
// 初始化isprime数组，将所有大于等于2的数标记为可能是素数（设为true）
for (int i = 2; i < maxn; i++) {
isprime[i] = true;
}
// 遍历从2到maxn - 1的数
for (int i = 2; i < maxn; i++) {
// 如果当前数i被标记为素数
if (isprime[i]) {
// 将素数i存入prime数组中，并更新素数的数量pnum
prime[pnum++] = i;
// 将i的所有倍数标记为非素数（设为false）
for (int j = i + i; j < maxn; j += i) {
isprime[j] = false;
}
}
}
}
// 定义结构体factor，用于存储质因数及其个数
struct factor {
int x, cnt; // x表示质因子，cnt表示个数
} fac[maxn]; // 定义一个足够大的数组来存储质因数及其个数
int main() {
// 调用findprime函数生成素数表
findprime();
int n;
// 使用scanf函数从标准输入读取一个整数n，提高输入效率
scanf("%d", &n);
// 如果n等于1，按照题目要求输出"1=1"并换行
if (n == 1) {
printf("1=1\n");
} else {
// 按照题目要求，先输出n和等号，如："n="
printf("%d=", n);
// 计算n的平方根，用于后续确定质因数的查找范围
int sqr = (int)sqrt(1.0 * n);
int num = 0; // 用于记录质因数的个数
// 遍历素数表prime，查找n的质因数
for (int i = 0; i < pnum && prime[i] <= sqr; i++) {//如果当前素数prime[i]是n的质因数（n能被prime[i]整除）
if (n % prime[i] == 0) {
fac[num].x = prime[i];
fac[num].cnt = 0;
// 计算当前质因数的个数，即n能被prime[i]整除的次数
while (n % prime[i] == 0) {
fac[num].cnt++;
n /= prime[i];
}
num++;
}
// 如果n已经被分解为1，说明质因数分解完成，退出循环
if (n == 1) break;
}
// 如果经过上述循环后，n仍然大于1，说明n本身就是一个大于其平方根的质因数
if (n != 1) {
fac[num].x = n;
fac[num].cnt = 1;
num++;
}
// 遍历fac数组，按照题目要求的格式输出质因数分解的结果
for (int i = 0; i < num; i++) {
// 如果不是第一个质因数，先输出乘号"*"
if (i > 0) printf("*");
// 输出当前质因数
printf("%d", fac[i].x);
// 如果当前质因数的个数大于1，输出其指数，格式为"^个数"
if (fac[i].cnt > 1) {
printf("^%d", fac[i].cnt);
}
}
// 输出结束后换行
printf("\n");
}
return 0;
}#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;
// 增大数组大小以适应更大范围的素数，定义一个常量表示数组的最大长度，用于素数表和质因数存储数组的大小
const int maxn = 100010;
// 判断n是否为素数的函数，参数n为长整型
bool isprime(long long n) {
// 如果n等于1，根据素数定义，1不是素数，直接返回false
if (n == 1) return false;
// 计算n的平方根，并转换为长整型，用于后续循环判断的上限
long long sqr = (long long)sqrt(1.0 * n);
// 从2到n的平方根遍历，检查是否存在能整除n的数
for (long long i = 2; i <= sqr; i++) {
// 如果存在能整除n的数，则n不是素数，返回false
if (n % i == 0) return false;
}
// 如果遍历完都没有找到能整除n的数，则n是素数，返回true
return true;
}
// 用于存储素数的数组，数组元素为长整型，以适应较大的素数
long long prime[maxn];
// 记录素数在prime数组中的数量
int pnum = 0;
// 求素数表的函数，即找出一定范围内的所有素数并存入prime数组
void findprime() {
// 从2开始遍历到maxn - 1
for (long long i = 2; i < maxn; i++) {
// 如果当前数i是素数
if (isprime(i)) {
// 将素数i存入prime数组，并更新素数数量pnum
prime[pnum++] = i;
}
}
}
// 定义结构体factor，用于存储质因数及其个数
struct factor {
long long x; // 存储质因数，为长整型以适应较大的质因数
int cnt; // 存储质因数的个数
} fac[maxn];
int main() {
// 调用findprime函数生成素数表
findprime();
long long n;
// 使用scanf函数从标准输入读取一个长整型整数n，提高输入效率
scanf("%lld", &n);
// 如果n等于1，按照题目要求输出"1=1"并换行
if (n == 1) {
printf("1=1\n");
} else {
// 按照题目要求，先输出n和等号，如："n="
printf("%lld=", n);
// 计算n的平方根，并转换为长整型，用于后续质因数查找的范围判断
long long sqr = (long long)sqrt(1.0 * n);
int num = 0; // 用于记录质因数的个数
// 遍历素数表prime，查找n的质因数
for (int i = 0; i < pnum && prime[i] <= sqr; i++) {
// 如果当前素数prime[i]是n的质因数（即n能被prime[i]整除）
if (n % prime[i] == 0) {
fac[num].x = prime[i]; // 记录当前质因数
fac[num].cnt = 0; // 初始化当前质因数的个数为0
// 计算当前质因数的个数，即n能被prime[i]整除的次数
while (n % prime[i] == 0) {
fac[num].cnt++;
n /= prime[i];
}
num++; // 质因数个数加1
}
// 如果n已经被分解为1，说明质因数分解完成，退出循环
if (n == 1) break;
}
// 如果经过上述循环后，n仍然大于1，说明n本身就是一个大于其平方根的质因数
if (n != 1) {
fac[num].x = n; // 记录这个质因数
fac[num].cnt = 1; // 这个质因数的个数为1
num++;
}
// 遍历fac数组，按照题目要求的格式输出质因数分解的结果
for (int i = 0; i < num; i++) {
// 如果不是第一个质因数，先输出乘号"*"
if (i > 0) printf("*");
// 输出当前质因数
printf("%lld", fac[i].x);
// 如果当前质因数的个数大于1，输出其指数，格式为"^个数"
if (fac[i].cnt > 1) {
printf("^%d", fac[i].cnt);
}
}
// 输出结束后换行
printf("\n");
}
return 0;
}#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
// 定义大整数结构体bign
struct bign{
int d[1000]; // 用于存储大整数的每一位数字，数组长度为1000
int len; // 记录大整数的位数
bign(){
// 初始化函数，将数组d的所有元素置为0
memset(d,0,sizeof(d));
len = 0; // 初始化大整数的位数为0
}
};
// 将字符数组表示的数转换为bign结构体表示的大整数
bign change(char str[]){
bign a;
a.len = strlen(str); // 获取字符数组的长度，即大整数的位数
for(int i=0;i<a.len;i++){
// 将字符数组中的字符转换为对应的数字，并逆序存储到bign结构体的数组d中
a.d[i] = str[a.len-i-1] - '0';
}
return a; // 返回转换后的大整数
}
// 实现两个大整数相加的函数
bign add(bign a,bign b){
bign c;
int carry = 0; // 进位变量，初始值为0
// 遍历两个大整数的每一位，直到两个大整数的所有位都处理完毕
for(int i=0;i<a.len||i<b.len;i++){
// 计算当前位的和，包括两个大整数对应位的数字以及进位
int temp = a.d[i] + b.d[i] + carry;
c.d[c.len++] = temp % 10; // 将当前位的和的个位数存入结果大整数c的数组d中，并更新位数
carry = temp / 10; // 更新进位
}
// 如果最后还有进位，将进位存入结果大整数c的数组d中，并更新位数
if(carry!=0){
c.d[c.len++] = carry;
}
return c; // 返回相加后的大整数
}
// 用于输出大整数的函数
void print(bign a){
// 从大整数的最高位开始，依次输出每一位数字
for(int i=a.len-1;i>=0;i--){
printf("%d",a.d[i]);
}
}
int main(){
char str1[1000],str2[1000];
// 从标准输入读取两个字符数组，用于表示两个大整数
scanf("%s%s",str1,str2);
bign a = change(str1); // 将字符数组str1转换为大整数a
bign b = change(str2); // 将字符数组str2转换为大整数b
print(add(a,b)); // 计算大整数a和b的和，并输出结果
return 0;
}#include <iostream>
#include <cstdio>
using namespace std;
int cal(int n){
int ans = 0;
while(n){
ans += n/2;
n/=2;
}
return ans;
}
int main(){
int n;cin>>n;
int ans = cal(n);
cout<<ans;
return 0;
}递归版本：
//计算n!中有多少个质因子p
int cal(int n,int p){
if(n<p) return 0;//n<p时1-n中不可能有质因子p
return n/p+cal(n/p,p);
} #include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int main(){
// 定义一个整型变量 n，用于存储要输入的整数的数量
int n;
// 从标准输入读取一个整数赋值给 n
cin >> n;
// 定义一个整型变量 x，用于临时存储每次输入的整数
int x;
// 定义一个整型向量 vi，用于存储输入的多个整数
vector<int> vi;
// 循环 n 次，依次读取 n 个整数
for(int i = 1; i <= n; i++){
// 从标准输入读取一个整数赋值给 x
cin >> x;
// 将读取到的整数 x 添加到向量 vi 的末尾
vi.push_back(x);
}
// 遍历向量 vi 中的每一个元素
for(int i = 0; i < (int)vi.size(); i++){
// 以整数形式输出向量 vi 中的第 i 个元素
printf("%d", vi[i]);
// 如果当前输出的元素不是向量中的最后一个元素
if(i < (int)vi.size() - 1)
// 输出一个空格，用于分隔元素
cout << " ";
}
return 0;
}#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
// 定义常量 maxn，用于表示数组的最大长度，这里设为 10010
const int maxn = 1e4 + 10;
// 定义常量 mod，用于取模运算，避免结果溢出，这里取 10007
const int mod = 10007;
// 定义 dp 数组，用于存储中间结果，实现记忆化搜索
int dp[maxn];
// 递归函数 f，用于计算满足斐波那契数列递推关系的第 n 项的值
int f(int n) {
// 递归终止条件：当 n 为 1 或者 2 时，函数返回 1
if (n == 1 || n == 2) return 1;
// 检查 dp[n] 是否已经计算过，如果不等于 -1，说明已经计算过，直接返回存储的值
if (dp[n] != -1) return dp[n];
else {
// 若 dp[n] 未计算过，则根据递推公式 f(n) = f(n - 1) + f(n - 2) 计算
// 同时对结果进行取模操作，避免结果过大
dp[n] = (f(n - 1) + f(n - 2)) % mod;
// 返回计算得到的 dp[n] 的值
return dp[n];
}
}
int main() {
int n;
// 从标准输入读取一个整数 n，表示要计算的项数
cin >> n;
// 使用 memset 函数将 dp 数组的所有元素初始化为 -1
// -1 表示该位置的结果还未被计算过
memset(dp, -1, sizeof(dp));
// 调用函数 f 计算第 n 项的值，并将结果存储在 ans 中
int ans = f(n);
// 输出计算得到的第 n 项的值
cout << ans;
// 程序正常结束，返回 0
return 0;
}#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
// 定义常量 maxn，代表数组的最大尺寸
const int maxn = 1000;
// 定义二维数组 f，用于存储数字三角形中每个位置的数值
// f[i][j] 表示数字三角形中第 i 行第 j 列的数值
int f[maxn][maxn], dp[maxn][maxn];
int main() {
int n;
// 从标准输入读取数字三角形的行数 n
cin >> n;
// 读取数字三角形中每个位置的数值
// 外层循环遍历每一行
for (int i = 1; i <= n; i++) {
// 内层循环遍历当前行的每一列
for (int j = 1; j <= i; j++) {
// 读取第 i 行第 j 列的数值，并存储到 f[i][j] 中
cin >> f[i][j];
}
}
// 初始化 dp 数组的最后一行
// dp 数组用于记录从某个位置到底部的最大路径和
// 最后一行每个位置到底部的最大路径和就是该位置本身的值
for (int j = 1; j <= n; j++) {
dp[n][j] = f[n][j];
}
// 从倒数第二行开始，向上递推计算每个位置到底部的最大路径和
for (int i = n - 1; i >= 1; i--) {
// 遍历当前行的每一列
for (int j = 1; j <= i; j++) {
// 状态转移方程：当前位置到底部的最大路径和等于
// 下一行相邻两个位置到底部的最大路径和中的较大值加上当前位置的值
dp[i][j] = max(dp[i + 1][j], dp[i + 1][j + 1]) + f[i][j];
}
}
// 输出从数字三角形顶部（即 dp[1][1]）到底部的最大路径和
cout << dp[1][1];
// 程序正常结束，返回 0
return 0;
}#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
// 定义常量 maxn，作为数组的最大长度，这里设置为 10010
const int maxn = 1e4 + 10;
// 定义数组 a 和 dp
// a[i] 用于存放输入的序列元素
// dp[i] 用于存放以 a[i] 结尾的连续序列的最大和
int a[maxn], dp[maxn];
int main() {
int n;
// 从标准输入读取序列的长度 n
cin >> n;
// 循环读取序列中的每个元素，并存储到数组 a 中
for (int i = 0; i < n; i++) {
cin >> a[i];
}
// 初始化 dp 数组的第一个元素
// 以 a[0] 结尾的连续序列的最大和就是 a[0] 本身
dp[0] = a[0];
// 从第二个元素开始，递推计算以每个元素结尾的连续序列的最大和
for (int i = 1; i < n; i++) {
// 状态转移方程：
// 以 a[i] 结尾的连续序列的最大和要么是 a[i] 单独构成一个序列，
// 要么是将 a[i] 加入到以 a[i-1] 结尾的连续序列中
// 取两者中的最大值
dp[i] = max(a[i], dp[i - 1] + a[i]);
}
// 初始化 k 为 0，用于记录 dp 数组中最大值的下标
int k = 0;
// 遍历 dp 数组，找出其中的最大值
for (int i = 1; i < n; i++) {
// 如果当前 dp[i] 的值大于之前记录的最大值 dp[k]
if (dp[i] > dp[k]) {
// 更新 k 为当前下标 i
k = i;
}
}
// 输出 dp 数组中的最大值，也就是整个序列中连续子序列的最大和
cout << dp[k];
// 程序正常结束，返回 0
return 0;
}#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
// 定义常量 maxn，作为数组的最大长度，这里设置为 10010
const int maxn = 1e4 + 10;
// 定义数组 a、dp 和 start
// a[i] 用于存放输入的序列元素
// dp[i] 用于存放以 a[i] 结尾的连续序列的最大和
// start[i] 用于存放以 a[i] 结尾的最大和连续序列的起始下标
int a[maxn], dp[maxn], start[maxn];
int main() {
int n;
// 从标准输入读取序列的长度 n
cin >> n;
// 循环读取序列中的每个元素，并存储到数组 a 中
for (int i = 0; i < n; i++) {
cin >> a[i];
}
// 初始化 dp 数组的第一个元素
// 以 a[0] 结尾的连续序列的最大和就是 a[0] 本身
dp[0] = a[0];
// 以 a[0] 结尾的最大和连续序列的起始下标就是 0
start[0] = 0;
// 从第二个元素开始，递推计算以每个元素结尾的连续序列的最大和
for (int i = 1; i < n; i++) {
// 状态转移方程：
// 以 a[i] 结尾的连续序列的最大和要么是 a[i] 单独构成一个序列，
// 要么是将 a[i] 加入到以 a[i - 1] 结尾的连续序列中
// 取两者中的最大值
if (a[i] > dp[i - 1] + a[i]) {
// 如果 a[i] 单独构成序列的和更大
dp[i] = a[i];
// 那么以 a[i] 结尾的最大和连续序列的起始下标就是 i
start[i] = i;
} else {
// 否则将 a[i] 加入到以 a[i - 1] 结尾的连续序列中
dp[i] = dp[i - 1] + a[i];
// 以 a[i] 结尾的最大和连续序列的起始下标和以 a[i - 1] 结尾的相同
start[i] = start[i - 1];
}
}
// 初始化 k 为 0，用于记录 dp 数组中最大值的下标
int k = 0;
// 遍历 dp 数组，找出其中的最大值
for (int i = 1; i < n; i++) {
// 如果当前 dp[i] 的值大于之前记录的最大值 dp[k]
if (dp[i] > dp[k]) {
// 更新 k 为当前下标 i
k = i;
}
}
// 输出 dp 数组中的最大值，也就是整个序列中连续子序列的最大和
// 同时输出最大和连续子序列的起始位置和结束位置（下标从 1 开始）
cout << dp[k] << " " << start[k] + 1 << " " << k + 1;
// 程序正常结束，返回 0
return 0;
}#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
// 定义常量 maxn，代表数组的最大长度
const int maxn = 100;
// 定义数组 a 用于存储输入的序列
// 定义数组 dp 用于存储以每个元素结尾的最长不下降子序列的长度
int a[maxn], dp[maxn];
int main() {
int n;
// 从标准输入读取序列的长度 n
cin >> n;
// 循环读取序列中的每个元素，并存储到数组 a 中
// 注意：这里下标从 1 开始
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
// 初始化 ans 为 -1，用于记录最大的 dp[i] 值，即最长不下降子序列的长度
int ans = -1;
// 按顺序计算出 dp[i] 的值，dp[i] 表示以 a[i] 结尾的最长不下降子序列的长度
for (int i = 1; i <= n; i++) {
// 边界初始条件：先假设每个元素自成一个子序列，所以长度为 1
dp[i] = 1;
// 遍历 i 之前的所有元素
for (int j = 1; j < i; j++) {
// 若 a[i] 不小于 a[j]，说明可以将 a[i] 接在以 a[j] 结尾的不下降子序列后面
// 并且如果接上之后子序列的长度（dp[j] + 1）大于当前 dp[i] 的值
if (a[i] >= a[j] && dp[j] + 1 > dp[i]) {
// 则更新 dp[i] 的值，这就是状态转移方程
dp[i] = dp[j] + 1;
}
}
// 更新 ans 的值，取当前 ans 和 dp[i] 中的较大值
ans = max(ans, dp[i]);
}
// 输出最长不下降子序列的长度
cout << ans;
// 程序正常结束，返回 0
return 0;
}#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
// 定义常量 MAXN，用于确定二维数组 dp 的最大尺寸
// 这里设定为 101，考虑到字符串长度最大为 100，且为了方便处理下标从 1 开始
const int MAXN = 100 + 1;
// 定义二维数组 dp，dp[i][j] 表示字符串 s1 的前 i 个字符和字符串 s2 的前 j 个字符的最长公共子序列的长度
int dp[MAXN][MAXN];
int main() {
string s1, s2;
// 从标准输入读取两个字符串 s1 和 s2
cin >> s1 >> s2;
// 外层循环遍历字符串 s1 的每个字符
for (int i = 1; i <= s1.length(); i++) {
// 内层循环遍历字符串 s2 的每个字符
for (int j = 1; j <= s2.length(); j++) {
// 由于字符串下标从 0 开始，s1[i - 1] 和 s2[j - 1] 分别表示当前正在比较的字符
// 如果当前字符相等，说明可以将这个相同字符加入到之前的最长公共子序列中
if (s1[i - 1] == s2[j - 1]) {
// 则当前的最长公共子序列长度等于两个字符串各自去掉当前字符后的最长公共子序列长度加 1
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
// 如果当前字符不相等，最长公共子序列长度取两种情况的最大值
// 情况一：字符串 s1 的前 i 个字符和字符串 s2 的前 j - 1 个字符的最长公共子序列长度
// 情况二：字符串 s1 的前 i - 1 个字符和字符串 s2 的前 j 个字符的最长公共子序列长度
dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
}
}
}
// 输出字符串 s1 和字符串 s2 的最长公共子序列的长度
// dp[s1.length()][s2.length()] 存储了两个完整字符串的最长公共子序列长度
printf("%d", dp[s1.length()][s2.length()]);
// 程序正常结束，返回 0
return 0;
}#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
// 定义常量 maxn，用于确定数组的最大长度，这里设定为 101
const int maxn = 100 + 1;
// 定义二维数组 dp，dp[i][j] 表示字符串 a 的前 i 个字符和字符串 b 的前 j 个字符的最长公共子序列的长度
int dp[maxn][maxn];
int main() {
string a, b;
// 从标准输入读取两个字符串 a 和 b
cin >> a >> b;
// 获取字符串 a 的实际长度
int lena = a.size();
// 获取字符串 b 的实际长度
int lenb = b.size();
// 边界条件：
// 当字符串 b 的长度为 0 时，字符串 a 的前 i 个字符和空字符串的最长公共子序列长度为 0
for (int i = 0; i <= lena; i++) {
dp[i][0] = 0;
}
// 当字符串 a 的长度为 0 时，字符串 b 的前 j 个字符和空字符串的最长公共子序列长度为 0
for (int j = 0; j <= lenb; j++) {
dp[0][j] = 0;
}
// 状态转移方程部分：
// 遍历字符串 a 的每个字符
for (int i = 1; i <= lena; i++) {
// 遍历字符串 b 的每个字符
for (int j = 1; j <= lenb; j++) {
// 注意字符串下标应从 0 开始，所以使用 a[i - 1] 和 b[j - 1]
if (a[i - 1] == b[j - 1]) {
// 如果当前字符相等，那么最长公共子序列长度等于两个字符串各自去掉当前字符后的最长公共子序列长度加 1
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
// 如果当前字符不相等，那么最长公共子序列长度取两种情况的最大值：
// 1. 字符串 a 的前 i - 1 个字符和字符串 b 的前 j 个字符的最长公共子序列长度
// 2. 字符串 a 的前 i 个字符和字符串 b 的前 j - 1 个字符的最长公共子序列长度
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
// 输出字符串 a 和字符串 b 的最长公共子序列的长度
cout << dp[lena][lenb];
// 程序正常结束，返回 0
return 0;
} #include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
// 定义常量 maxn，作为数组的最大长度，这里设置为 1010
const int maxn = 1010;
// 定义二维数组 dp，dp[i][j] 表示字符串 s 中从下标 i 到下标 j 的子串是否为回文子串
// dp[i][j] = 1 表示是回文子串，dp[i][j] = 0 表示不是回文子串
int dp[maxn][maxn];
int main() {
string s;
// 从标准输入读取一个字符串 s
cin >> s;
// 获取字符串 s 的长度
int len = s.size();
// 初始化最长回文子串的长度为 1，因为单个字符一定是回文子串
int ans = 1;
// 使用 memset 函数将 dp 数组所有元素初始化为 0
memset(dp, 0, sizeof(dp));
// 边界条件处理
for (int i = 0; i < len; i++) {
// 单个字符的子串一定是回文子串，所以 dp[i][i] = 1
dp[i][i] = 1;
// 检查相邻两个字符的子串是否为回文子串
if (i < len - 1) {
if (s[i] == s[i + 1]) {
// 如果相邻两个字符相等，则它们组成的子串是回文子串
dp[i][i + 1] = 1;
// 更新最长回文子串的长度为 2
ans = 2;
}
}
}
// 状态转移方程部分
// 枚举子串的长度，从 3 开始，因为长度为 1 和 2 的情况已经在边界条件中处理
for (int l = 3; l <= len; l++) {
// 枚举子串的起始端点 i
for (int i = 0; i + l - 1 < len; i++) {
// 计算子串的右端点 j
int j = i + l - 1;
// 如果子串的两端字符相等，并且去掉两端字符后的子串也是回文子串
if (s[i] == s[j] && dp[i + 1][j - 1] == 1) {
// 则该子串是回文子串
dp[i][j] = 1;
// 更新最长回文子串的长度为当前子串的长度 l
ans = l;
}
}
}
// 输出最长回文子串的长度
cout << ans;
// 程序正常结束，返回 0
return 0;
}#include <cstdio>
// 定义迷宫的最大行数和列数
const int MAXN = 5;
// n 表示迷宫的行数，m 表示迷宫的列数
int n, m, maze[MAXN][MAXN];
// 用于标记某个位置是否已经被访问过
bool visited[MAXN][MAXN] = {false};
// 记录从起点到终点的路径数量
int counter = 0;
// 表示可以移动的方向数量
const int MAXD = 4;
// 分别表示向右、向左、向下、向上移动时 x 坐标的变化量
int dx[MAXD] = {0, 0, 1, -1};
// 分别表示向右、向左、向下、向上移动时 y 坐标的变化量
int dy[MAXD] = {1, -1, 0, 0};
// 判断某个位置是否合法
bool isValid(int x, int y) {
// 位置要在迷宫范围内，且该位置的值为 0 （表示通路），并且该位置未被访问过
return x >= 0 && x < n && y >= 0 && y < m && maze[x][y] == 0 && !visited[x][y];
}
// 深度优先搜索函数，用于寻找从起点到终点的路径
void DFS(int x, int y) {
// 如果到达了迷宫的终点
if (x == n - 1 && y == m - 1) {
// 路径数量加 1
counter++;
return;
}
// 标记当前位置为已访问
visited[x][y] = true;
// 尝试向四个方向移动
for (int i = 0; i < MAXD; i++) {
// 计算下一个位置的 x 坐标
int nextX = x + dx[i];
// 计算下一个位置的 y 坐标
int nextY = y + dy[i];
// 如果下一个位置合法
if (isValid(nextX, nextY)) {
// 递归调用 DFS 函数，继续搜索
DFS(nextX, nextY);
}
}
// 回溯，将当前位置标记为未访问
visited[x][y] = false;
}
int main() {
// 输入迷宫的行数和列数
scanf("%d%d", &n, &m);
// 输入迷宫的布局
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &maze[i][j]);
}
}
// 从起点 (0, 0) 开始进行深度优先搜索
DFS(0, 0);
// 输出从起点到终点的路径数量
printf("%d", counter);
return 0;
}#include <cstdio>
#include <queue>
#include <utility>
using namespace std;
// 使用 typedef 为 pair<int, int> 定义一个别名 Position，方便后续使用
// Position 用来表示矩阵中的一个位置，其中 first 表示行，second 表示列
typedef pair<int, int> Position;
// 定义矩阵的最大行数和列数
const int MAXN = 100;
// n 表示矩阵的实际行数，m 表示矩阵的实际列数
// matrix 是一个二维数组，用于存储矩阵中的元素
int n, m, matrix[MAXN][MAXN];
// inQueue 是一个二维布尔数组，用于标记矩阵中的某个位置是否已经在队列中
// 初始化为 false，表示所有位置都不在队列中
bool inQueue[MAXN][MAXN] = {false};
// 表示可以移动的方向数量，这里是上下左右四个方向
const int MAXD = 4;
// dx 和 dy 数组分别表示在 x 轴和 y 轴上的移动偏移量
// 结合起来表示向右、向左、向下、向上四个方向的移动
int dx[MAXD] = {0, 0, 1, -1};
int dy[MAXD] = {1, -1, 0, 0};
// 判断某个位置是否可以访问
bool canVisit(int x, int y) {
// 位置要在矩阵范围内（行和列都不能越界）
// 该位置的值必须为 1
// 并且该位置还没有被加入队列
return x >= 0 && x < n && y >= 0 && y < m && matrix[x][y] == 1 && !inQueue[x][y];
}
// 广度优先搜索函数，从给定的位置 (x, y) 开始进行搜索
void BFS(int x, int y) {
// 定义一个队列 q，用于存储待访问的位置
queue<Position> q;
// 将起始位置加入队列
q.push(Position(x, y));
// 标记起始位置已经在队列中
inQueue[x][y] = true;
// 当队列不为空时，继续搜索
while (!q.empty()) {
// 获取队列头部的位置
Position front = q.front();
// 从队列中移除头部位置
q.pop();
// 尝试向四个方向移动
for (int i = 0; i < MAXD; i++) {
// 计算下一个位置的行坐标
int nextX = front.first + dx[i];
// 计算下一个位置的列坐标
int nextY = front.second + dy[i];
// 如果下一个位置可以访问
if (canVisit(nextX, nextY)) {
// 标记下一个位置已经在队列中
inQueue[nextX][nextY] = true;
// 将下一个位置加入队列
q.push(Position(nextX, nextY));
}
}
}
}
int main() {
// 从标准输入读取矩阵的行数和列数
scanf("%d%d", &n, &m);
// 从标准输入读取矩阵中的每个元素
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &matrix[i][j]);
}
}
// 用于记录矩阵中值为 1 的连通块的数量
int counter = 0;
// 遍历矩阵中的每个位置
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// 如果该位置的值为 1 且还没有被访问过
if (matrix[i][j] == 1 && !inQueue[i][j]) {
// 从该位置开始进行广度优先搜索
BFS(i, j);
// 连通块数量加 1
counter++;
}
}
}
// 输出矩阵中值为 1 的连通块的数量
printf("%d", counter);
return 0;
}#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
// 定义矩阵的最大尺寸，可根据实际需求调整
const int maxn = 110;
// 定义一个结构体 node 来表示矩阵中的一个位置
// 结构体包含两个整型成员 x 和 y，分别代表位置的行和列
struct node {
int x, y; // 位置 (x, y)
} Node;
// 定义变量 n 和 m 来表示矩阵的行数和列数
int n, m; // 矩阵大小为 n * m
// 定义一个二维数组 matrix 来存储矩阵中的元素
int matrix[maxn][maxn];
// 定义一个二维布尔数组 inq 来标记矩阵中的每个位置是否已经被访问过
// 初始值都为 false，表示所有位置都未被访问
bool inq[maxn][maxn] = { false };
// 方向数组，分别表示右、左、下、上四个方向
// dx 和 dy 数组配合使用，用于计算当前位置向四个方向移动后的新位置
int dx[4] = { 0, 0, 1, -1 };
int dy[4] = { 1, -1, 0, 0 };
// 判断坐标 (x, y) 是否合法且可以访问
bool judge(int x, int y) {
// 检查坐标是否越界，如果越界则返回 false
if (x < 0 || x >= n || y < 0 || y >= m) return false;
// 检查该位置的值是否为 0 或者该位置是否已经被访问过
// 如果满足其中一个条件则返回 false
if (matrix[x][y] == 0 || inq[x][y]) return false;
// 如果上述条件都不满足，则表示该位置合法且可以访问，返回 true
return true;
}
// 广度优先搜索函数，用于从起始位置 (x, y) 开始遍历连通区域
void bfs(int x, int y) {
// 定义一个队列 q 来存储待访问的位置
queue<node> q;
// 将起始位置赋值给结构体 Node
Node.x = x, Node.y = y;
// 将起始位置加入队列
q.push(Node);
// 标记起始位置已经被访问
inq[x][y] = true;
// 当队列不为空时，继续进行遍历
while (!q.empty()) {
// 获取队列头部的位置
node top = q.front();
// 将队列头部的位置出队
q.pop();
// 尝试向四个方向移动
for (int i = 0; i < 4; i++) {
// 计算向第 i 个方向移动后的新位置的行坐标
int newx = top.x + dx[i];
// 计算向第 i 个方向移动后的新位置的列坐标
int newy = top.y + dy[i];
// 判断新位置是否合法且可以访问
if (judge(newx, newy)) {
// 将新位置赋值给结构体 Node
Node.x = newx, Node.y = newy;
// 将新位置加入队列
q.push(Node);
// 标记新位置已经被访问
inq[newx][newy] = true;
}
}
}
}
int main() {
// 从标准输入读取矩阵的行数和列数
cin >> n >> m;
// 从标准输入读取矩阵中的每个元素
for (int x = 0; x < n; x++) {
for (int y = 0; y < m; y++) {
cin >> matrix[x][y];
}
}
// 用于记录矩阵中值为 1 的连通区域的数量
int ans = 0;
// 遍历矩阵中的每个位置
for (int x = 0; x < n; x++) {
for (int y = 0; y < m; y++) {
// 如果该位置的值为 1 且还未被访问过
if (matrix[x][y] == 1 && !inq[x][y]) {
// 连通区域数量加 1
ans++;
// 从该位置开始进行广度优先搜索，标记该连通区域内的所有位置为已访问
bfs(x, y);
}
}
}
// 输出矩阵中值为 1 的连通区域的数量
cout << ans;
return 0;
}#include <cstdio>
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
// 定义最大的迷宫尺寸，可根据实际情况调整
const int maxn = 100;
// 定义一个结构体 node 来表示迷宫中的一个位置
// x 和 y 表示该位置的坐标，step 表示从起点到达该位置的最少步数
struct node {
int x, y; // 位置 (x, y)
int step; // step 为从起点 S 到达该位置的最少步数
} S, T, Node;
// n 表示迷宫的行数，m 表示迷宫的列数
int n, m;
// maze 二维数组用于存储迷宫的布局，其中 '*' 表示墙壁，'.' 表示平地，'S' 表示起点，'T' 表示终点
char maze[maxn][maxn];
// inq 二维布尔数组用于标记某个位置是否已经被访问过，初始都为 false
bool inq[maxn][maxn] = { false };
// 方向数组，用于表示上下左右四个方向的偏移量
// dx 和 dy 配合使用，分别表示在 x 轴和 y 轴上的移动距离
int dx[4] = { 0, 0, 1, -1 };
int dy[4] = { 1, -1, 0, 0 };
// 判断坐标 (x, y) 是否合法且可以访问
bool test(int x, int y) {
// 检查坐标是否越界，如果越界则返回 false
if (x < 0 || x >= n || y < 0 || y >= m) return false;
// 检查该位置是否为障碍物（墙壁），如果是则返回 false
if (maze[x][y] == '*') return false;
// 检查该位置是否已经被访问过，如果是则返回 false
if (inq[x][y]) return false;
// 如果上述条件都不满足，则该位置合法且可访问，返回 true
return true;
}
// 广度优先搜索函数，计算从起点 S 到终点 T 的最短路径步数
int bfs() {
// 定义一个队列 q 用于存储待访问的位置
queue<node> q;
// 将起点加入队列
q.push(S);
// 标记起点已访问
inq[S.x][S.y] = true;
// 当队列不为空时，继续进行搜索
while (!q.empty()) {
// 获取队列头部的元素
node top = q.front();
// 将队列头部元素出队
q.pop();
// 如果当前位置是终点，返回从起点到该位置的步数
if (top.x == T.x && top.y == T.y) {
return top.step;
}
// 尝试向四个方向移动
for (int i = 0; i < 4; i++) {
// 计算向第 i 个方向移动后的新位置的 x 坐标
int newx = top.x + dx[i];
// 计算向第 i 个方向移动后的新位置的 y 坐标
int newy = top.y + dy[i];
// 判断新位置是否合法且可以访问
if (test(newx, newy)) {
// 更新新位置的坐标
Node.x = newx;
Node.y = newy;
// 新位置的步数为当前位置的步数加 1
Node.step = top.step + 1;
// 将新位置加入队列
q.push(Node);
// 标记新位置已访问
inq[newx][newy] = true;
}
}
}
// 如果队列为空仍未找到终点，说明无法到达，返回 -1
return -1;
}
int main() {
// 从标准输入读取迷宫的行数和列数
cin >> n >> m;
// 逐行读取迷宫的布局
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// 读取迷宫中每个位置的字符
cin >> maze[i][j];
// 如果当前位置是起点，记录起点的坐标和初始步数
if (maze[i][j] == 'S') {
S.x = i;
S.y = j;
S.step = 0;
}
// 如果当前位置是终点，记录终点的坐标
else if (maze[i][j] == 'T') {
T.x = i;
T.y = j;
}
}
}
// 调用 bfs 函数计算从起点到终点的最短步数并输出结果
cout << bfs() << endl;
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
