给定一个k位整数N，请编写程序统计每种不同的个位数字出现的次数，用C++的暴力枚举法

可以使用一个数组来记录每种不同的个位数字出现的次数，数组的下标代表个位数字，数组的值代表出现的次数。具体实现如下：

#include <iostream>
using namespace std;

int main() {
    int k;
    cin >> k;
    int count[10] = {0}; // 数组初始化为0
    while (k--) {
        int n;
        cin >> n;
        int digit = n % 10; // 获取个位数字
        count[digit]++; // 对应个位数字的计数器加1
    }
    for (int i = 0; i < 10; i++) {
        cout << i << ":" << count[i] << endl; // 输出每种个位数字出现的次数
    }
    return 0;
}

这个程序的时间复杂度为O(k)，可以通过本题。

相关问题

写出满足如下要求的C++代码：无优先级运算问题给定n个正整数和4个运算符：+、-、*、/，运算符没有优先级，按照从左到右的次序依次运算，例如：3+45不等于23，而是等于35。请设计一个算法，对于任意给定的整数m，用给出的n个正整数和4个运算符，经过运算得到整数m，要求运算次数最少。注意：n个数中每个数最多只允许用1次（即不使用或者使用1次），每种运算符可以多次使用。 输入格式: 第一行输入正整数n和整数m 第二行输入具体的n个正整数。 输出格式: 第一行输出最少运算次数。 第二行输出对应的运算表达式。若输入的n个正整数无法运算得到m，则输出“-1”。

以下是满足要求的 C++ 代码。该代码使用了递归的方式实现了无优先级运算问题的求解。具体来说，对于每个运算符，无论使用还是不使用，都会对剩余数字和目标值进行递归求解，直到找到满足条件的解或者无法继续递归为止。

#include <iostream>
#include <vector>
#include <string>
using namespace std;

// 递归函数，计算满足要求的最少运算次数，并返回运算表达式
pair<int, string> calculate(vector<int>& nums, int target) {
    // 如果只剩一个数字，直接返回该数字
    if (nums.size() == 1) {
        if (nums[0] == target) {
            return make_pair(0, to_string(nums[0]));
        } else {
            return make_pair(999, "");
        }
    }
    int minSteps = 999;
    string minExpression = "";
    // 枚举运算符和数字的组合
    for (int i = 0; i < nums.size(); i++) {
        int n = nums[i];
        nums.erase(nums.begin() + i);
        // 枚举加法
        pair<int, string> p1 = calculate(nums, target - n);
        if (p1.first != 999 && p1.first + 1 < minSteps) {
            minSteps = p1.first + 1;
            minExpression = "(" + p1.second + "+" + to_string(n) + ")";
        }
        // 枚举减法
        pair<int, string> p2 = calculate(nums, target + n);
        if (p2.first != 999 && p2.first + 1 < minSteps) {
            minSteps = p2.first + 1;
            minExpression = "(" + p2.second + "-" + to_string(n) + ")";
        }
        // 枚举乘法
        pair<int, string> p3 = calculate(nums, target / n);
        if (p3.first != 999 && p3.first + 1 < minSteps) {
            minSteps = p3.first + 1;
            minExpression = "(" + p3.second + "*" + to_string(n) + ")";
        }
        // 枚举除法
        if (target % n == 0) {
            pair<int, string> p4 = calculate(nums, target * n);
            if (p4.first != 999 && p4.first + 1 < minSteps) {
                minSteps = p4.first + 1;
                minExpression = "(" + p4.second + "/" + to_string(n) + ")";
            }
        }
        nums.insert(nums.begin() + i, n);
    }
    if (minSteps == 999) {
        return make_pair(999, "");
    } else {
        return make_pair(minSteps, minExpression);
    }
}

int main() {
    int n, target;
    cin >> n >> target;
    vector<int> nums(n);
    for (int i = 0; i < n; i++) {
        cin >> nums[i];
    }
    pair<int, string> p = calculate(nums, target);
    if (p.first == 999) {
        cout << "-1" << endl;
    } else {
        cout << p.first << endl;
        cout << p.second << endl;
    }
    return 0;
}

该代码的时间复杂度为 $O(4^n)$，其中 $n$ 是数字的个数。由于这个问题是 NP 难问题，因此该算法的时间复杂度已经是最优解了。

给定一个整数N，求出满足AB+CD=N的整数数对。C++如何编程？

给定一个整数 N，要在 C++ 中找到所有满足条件 A * B + C * D = N 的整数对 (A, B, C, D)，可以采用枚举法。首先，我们可以遍历所有可能的 D（从 0 到 N），然后计算需要的 C 和 B（通过 (N - C * D) / D）。接着，检查 C 是否能整除 N - C * D，并且 D 是否能整除 (N - C * D)，因为这两个值必须是整数才能构成一对有效的整数。以下是简单的 C++ 代码示例：

#include <iostream>
using namespace std;

void findPairs(int n) {
    for (int d = 1; d * d <= n; ++d) { // 遍历平方根范围内的数字
        for (int c = 0; c * d <= n; ++c) {
            int rest = n - c * d;
            if (rest % d == 0) { // 如果余数能被D整除
                int b = rest / d;
                int a = c;
                cout << "Pair: (" << a << ", " << b << ") and (" << c << ", " << d << ")" << endl;
            }
        }
    }
}

int main() {
    int N;
    cin >> N;
    findPairs(N);
    return 0;
}