C++1.找和为K的两个元素 在一个长度为n(n < 1000)的整数序列中，判断是否存在某两个元素之和为k。 时间限制：1000 内存限制：65536 输入 第一行输入序列的长度n和k，用空格分开。 第二行输入序列中的n个整数，用空格分开。 输出 如果存在某两个元素的和为k，则输出yes，否则输出no。 样例输入 9 10 1 2 3 4 5 6 7 8 9 样例输出 yes

好的，根据您的要求，这里给出 C++ 的实现代码，供您参考：

#include <iostream>
#include <unordered_set>
using namespace std;

int main() {
    int n, k;
    cin >> n >> k;
    unordered_set<int> nums;
    for (int i = 0; i < n; i++) {
        int num;
        cin >> num;
        if (nums.count(k - num)) {
            cout << "yes" << endl;
            return 0;
        }
        nums.insert(num);
    }
    cout << "no" << endl;
    return 0;
}

使用 unordered_set 来实现哈希表的功能，当找到满足条件的两个数时，直接输出 "yes"，退出程序。如果遍历完整个序列仍没有找到满足条件的两个数，则输出 "no"。希望可以帮助到您！

相关问题

2、长度为n的整数序列，试设计一个尽可能高效的算法，返回序列中第k小的元素。用c++写出代码

好的，我会记住您的要求。以下是使用快速选择算法的 C 代码，可在 O(n) 时间内找到序列中第 k 小的元素：

#include <stdio.h>
#include <stdlib.h>

int partition(int* nums, int left, int right) {
    int pivot = nums[right];
    int i = left - 1;
    for (int j = left; j <= right - 1; j++) {
        if (nums[j] < pivot) {
            i++;
            int temp = nums[i];
            nums[i] = nums[j];
            nums[j] = temp;
        }
    }
    int temp = nums[i + 1];
    nums[i + 1] = nums[right];
    nums[right] = temp;
    return i + 1;
}

int select(int* nums, int left, int right, int k) {
    if (left == right) {
        return nums[left];
    }
    int pivot_index = partition(nums, left, right);
    int length = pivot_index - left + 1;
    if (length == k) {
        return nums[pivot_index];
    } else if (length > k) {
        return select(nums, left, pivot_index - 1, k);
    } else {
        return select(nums, pivot_index + 1, right, k - length);
    }
}

int main() {
    int n, k;
    printf("请输入序列长度n和要求第k小的元素：\n");
    scanf("%d %d", &n, &k);
    int* nums = (int*)malloc(n * sizeof(int));
    printf("请输入序列中的%d个整数：\n", n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    int kth_smallest = select(nums, 0, n - 1, k);
    printf("第%d小的元素是：%d\n", k, kth_smallest);
    free(nums);
    return 0;
}

这个算法的基本思想是利用快速排序中的划分操作，每次选一个枢轴元素，将序列分为比枢轴元素小和比枢轴元素大两部分，然后根据 pivot_index 和 k 的大小关系递归在左半部分或右半部分中查找第 k 小的元素，直到找到它为止。由于每次只需要处理一半的元素，所以时间复杂度为 O(n)。

c++给定一个长度为n(0< n< =100000)的序列，保证每一个序列中的数字a[i]是正整数 ，编程要求求出整个序列中第k大的数字减去第k小的数字的值m，并判断m是否为质数。(0< k< =n)

好的，下面是C++代码实现：

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
using namespace std;

// 快速选择算法
int quickSelect(vector<int>& nums, int left, int right, int k) {
    if (left == right) {  // 只有一个元素，直接返回
        return nums[left];
    }

    // 随机选择一个枢轴元素
    int pivotIndex = left + rand() % (right - left + 1);
    int pivot = nums[pivotIndex];

    // 将序列分为两部分
    swap(nums[pivotIndex], nums[right]);  // 将枢轴元素放到最右边
    int i = left, j = right;
    while (i < j) {
        while (i < j && nums[i] < pivot) {
            i++;
        }
        while (i < j && nums[j] >= pivot) {
            j--;
        }
        swap(nums[i], nums[j]);
    }
    swap(nums[i], nums[right]);  // 将枢轴元素放到正确的位置

    // 判断枢轴元素的下标
    int rank = i - left + 1;
    if (k == rank) {
        return pivot;  // 第k大/小的数就是pivot
    } else if (k < rank) {
        return quickSelect(nums, left, i - 1, k);  // 第k小的数在左半部分
    } else {
        return quickSelect(nums, i + 1, right, k - rank);  // 第k小的数在右半部分
    }
}

// 判断一个数是否为质数
bool isPrime(int num) {
    if (num < 2) {
        return false;
    }
    for (int i = 2; i * i <= num; i++) {
        if (num % i == 0) {
            return false;
        }
    }
    return true;
}

int main() {
    int n, k;
    cin >> n >> k;

    vector<int> nums(n);
    for (int i = 0; i < n; i++) {
        cin >> nums[i];
    }

    // 求第k大的数和第k小的数
    int kthSmallest = quickSelect(nums, 0, n - 1, k);
    int kthLargest = quickSelect(nums, 0, n - 1, n - k + 1);

    // 计算差值m
    int m = kthLargest - kthSmallest;

    // 判断m是否为质数
    if (isPrime(m)) {
        cout << "Yes" << endl;
    } else {
        cout << "No" << endl;
    }

    return 0;
}