通过给定操作将数组缩减至最多一个元素

---

在这个问题中，我们将通过在每次轮换中执行给定的操作，将数组的大小缩减为 1 或 0。

我们可以在每次迭代中对数组进行排序以获得每次迭代中的最大元素。此外，我们可以使用堆数据结构来提高代码的性能。

问题陈述 - 我们给定了一个 nums[] 数组。我们需要通过执行以下操作来减少数组。

• 选择数组中的两个最大元素。

• 如果两个元素相同，则从数组中删除这两个元素。

• 如果两个元素不同，则从数组中删除这两个元素，并将 abs(第一个 - 第二个) 插入到数组中。

打印数组的最后一个元素。如果数组为空，则打印 0。

示例

输入

nums = {5, 9, 8, 3, 2, 5};

输出

0

解释 

• 在第一轮中，我们取 9 和 8 并将其差值添加到数组中。因此，数组变为 [5, 3, 2, 5, 1]。

• 在第二轮中，我们取 5 和 5。因此，数组变为 [3, 2, 1]。

• 在下一轮中，我们取 3 和 2。因此，数组变为 [1, 1]

• 在最后一轮中，我们取 1 和 1。因此，数组变为空，我们打印 0。

输入

nums = {5, 5, 5, 5, 5};

输出

5

解释 - 我们删除了两次 5 的对，并且一个 5 保留在数组中。

输入

nums = {4, 8, 7, 6};

输出

1

解释 - 首先，我们选择 8 和 7。因此，数组变为 [4, 1, 6]。之后，我们选择 4 和 6。因此，数组变为 [1, 2]。在最后一次操作中，数组变为 [1]。

方法 1

在这种方法中，我们将遍历数组，直到数组的大小变为 1 或 0。在每次迭代中，我们将对数组进行排序，并在排序数组的前两个元素上执行给定的操作。最后，我们将根据数组的大小打印输出。

算法

步骤 1 - 将数组的大小存储在“len”变量中。

步骤 2 - 使用 while 循环开始遍历数组。

步骤 3 - 在循环中使用 sort() 方法以反向顺序对数组进行排序。

步骤 4 - 取数组的第一和第二个元素。另外，取数组的第一和第二个元素之间的差值。

步骤 5 - 如果差值为 0，则删除数组的第一个元素，并将“len”减少 2。如果差值不为 0，则删除前两个元素并将“len”减少 1。

步骤 6 - 最后，如果数组的大小为 0，则返回 0。否则，返回数组的第一个元素。

示例

#include <bits/stdc++.h>
using namespace std;

int findLast(vector<int> &nums) {
    int len = nums.size();
    int p = 0;
    while (len > 1) {
        // Sort array in reverse order
        sort(nums.begin(), nums.end(), greater<int>());
        // Take the first and second elements of the array
        int a = nums[0];
        int b = nums[1];
        // Take the difference between the first and second element
        int diff = a - b;
        if (diff == 0) {
            nums.erase(nums.begin());
            nums.erase(nums.begin());
            len -= 2;
        } else {
            nums.erase(nums.begin());
            nums.erase(nums.begin());
            nums.push_back(diff);
            len -= 1;
        }
    }
    // When the size of the array is 0
    if (nums.size() == 0)
        return 0;
    return nums[0];
}
int main() {
    vector<int> nums = {5, 9, 8, 3, 2, 5};
    cout << "The last remaining element after performing the given operations is " << findLast(nums) << "\n";
    return 0;
}

输出

The last remaining element after performing the given operations is 0

时间复杂度 - O(N*NlogN)，其中 O(N) 用于遍历数组，O(NlogN) 用于在每次迭代中对数组进行排序。

空间复杂度 - O(N) 用于对数组进行排序。

方法 2

在这种方法中，我们将使用优先级队列，它实现了堆数据结构。它始终以排序的顺序存储元素。因此，我们可以轻松地删除前两个最大元素。

算法

步骤 1 - 定义名为优先级队列的“p_queue”。

步骤 2 - 将所有数组元素插入到优先级队列中。

步骤 3 - 进行迭代，直到优先级队列的大小大于 1。

步骤 4 - 依次删除优先级队列的前两个元素。

步骤 5 - 取两个元素之间的差值。

步骤 6 - 如果差值不为 0，则将其推入优先级队列。

步骤 7 - 最后，如果队列大小为 0，则返回 0。

步骤 8 - 否则，从队列中返回顶部元素。

示例

#include <bits/stdc++.h>
using namespace std;

int findLast(vector<int> &nums) {
    // Defining a priority queue
    priority_queue<int> p_queue;
    // Inserting array elements in priority queue
    for (int p = 0; p < nums.size(); ++p)
        p_queue.push(nums[p]);
    // Make iterations
    while (p_queue.size() > 1) {
        // Take the first element from queue
        int first = p_queue.top();
        p_queue.pop();
        // Get the second element from queue
        int second = p_queue.top();
        p_queue.pop();
        // Take the difference of first and second elements
        int diff = first - second;
        if (diff != 0)
            p_queue.push(diff);
    }
    // When queue is empty
    if (p_queue.size() == 0)
        return 0;
    // Return the last remaining element
    return p_queue.top();
}
int main() {
    vector<int> nums = {5, 9, 8, 3, 2, 5};
    cout << "The last remaining element after performing the given operations is " << findLast(nums) << "\n";
    return 0;
}

输出

The last remaining element after performing the given operations is 0

时间复杂度 - O(NlogN) 用于在优先级队列中插入和删除元素。

空间复杂度 - O(N) 用于在优先级队列中存储元素。

当我们需要在插入或删除任何元素后以特定顺序获取数组数据时，优先级队列数据结构始终很有用。它实现了堆数据结构，这使得插入和删除变得。