GESP 2024.6 三级 编程大题——讲解（全网首发！！！）(续）

上回说到，顺移字符串。

今天，让我们来看另一道大题。

        给定一个数列A:[A0,A1,A2......Ai] 要求： 遍历整个数组，找到一个可以整除所有数的一个数。 输入： 第一行输入变量T，表示有几个数列。 接下来的每个数列，先输入N，表示这个数列有N个数。 接着输入数列中的每一个数。 输出： 如果有符合上述条件的一个数，输出“YES”,反之输出‘NO’（UP错的就是这题  2.5/25）

作者在考试时做了一个流程图。

（可能有点小）

但没写出来。

回家，打开电脑，做出来了。

#include <iostream>  
#include <vector>  
using namespace std;  
  
int main() {  
    int T;  
    cin >> T;  
    while (T--) {  
        int N;  
        cin >> N;  
        vector<int> A(N);  
        for (int i = 0; i < N; ++i) {  
            cin >> A[i];  
        }  
  
        // 假设第一个数就是符合条件的数  
        int divisor = A[0];  
        bool found = true;  
  
        // 遍历数组，检查divisor是否能整除所有数  
        for (int i = 1; i < N; ++i) {  
            if (A[i] % divisor != 0) {  
                // 如果不能整除，则更新divisor为A[i]和divisor的最大公约数  
                divisor = __gcd(A[i], divisor);  
                // 再次检查更新后的divisor是否能整除前面的数  
                for (int j = 0; j < i; ++j) {  
                    if (A[j] % divisor != 0) {  
                        // 如果不能整除，则没有符合条件的数  
                        found = false;  
                        break;  
                    }  
                }  
                // 如果前面的数都能被divisor整除，则继续检查下一个数  
                if (!found) break;  
            }  
        }  
  
        // 输出结果  
        if (found && divisor > 1) { // 注意：divisor > 1是为了避免当所有数都是0时输出"YES"  
            cout << "YES" << endl;  
        } else {  
            cout << "NO" << endl;  
        }  
    }  
    return 0;  
}

注：这是不使用函数的版本

这时，老师发来消息：此题very简单，string+函数即可。

然后，改了2个小时。

有无数的BUG.

但是，成功了！

#include <iostream>  
#include <vector>  
#include <algorithm> // 用于std::gcd  
using namespace std;  
  
// 函数用于找到两个数的最大公约数  
int gcd(int a, int b) {  
    return b == 0 ? a : gcd(b, a % b);  
}  
  
// 函数用于检查是否存在一个数可以整除所有数  
bool checkDivisor(const vector<int>& A) {  
    if (A.empty()) return false; // 空数组返回false  
  
    int divisor = A[0];  
    for (int i = 1; i < A.size(); ++i) {  
        divisor = gcd(divisor, A[i]);  
        if (divisor == 1) return false; // 如果最大公约数为1，则不存在这样的数  
    }  
    return true; // 否则，divisor就是符合条件的数  
}  
  
int main() {  
    int T;  
    cin >> T;  
    while (T--) {  
        int N;  
        cin >> N;  
        vector<int> A(N);  
        for (int i = 0; i < N; ++i) {  
            cin >> A[i];  
        }  
  
        // 调用函数并输出结果  
        if (checkDivisor(A)) {  
            cout << "YES" << endl;  
        } else {  
            cout << "NO" << endl;  
        }  
    }  
    return 0;  
}

这时，一位大佬（姓名不方便透露），写了一种方法（动态分配）：

#include <iostream>  
#include <algorithm> // 用于std::gcd，如果编译器支持  
  
using namespace std;  
  
// 手动实现辗转相除法计算最大公约数  
int gcd(int a, int b) {  
    if (b == 0) return a;  
    return gcd(b, a % b);  
}  
  
// 函数用于检查是否存在一个数可以整除所有数  
bool checkDivisor(int* A, int n) {  
    if (n == 0) return false; // 空数组返回false  
  
    int divisor = A[0];  
    for (int i = 1; i < n; ++i) {  
        divisor = gcd(divisor, A[i]);  
        if (divisor == 1) return false; // 如果最大公约数为1，则不存在这样的数  
    }  
    return divisor > 1; // 否则，divisor就是符合条件的数（注意要检查是否大于1，以避免所有数都是0的情况）  
}  
  
int main() {  
    int T;  
    cin >> T;  
    while (T--) {  
        int N;  
        cin >> N;  
        int* A = new int[N]; // 动态分配数组  
        for (int i = 0; i < N; ++i) {  
            cin >> A[i];  
        }  
  
        // 调用函数并输出结果  
        if (checkDivisor(A, N)) {  
            cout << "YES" << endl;  
        } else {  
            cout << "NO" << endl;  
        }  
  
        // 释放动态分配的内存  
        delete[] A;  
    }  
    return 0;  
}

你们认为哪种好？

点赞过10，秒更！