改进了嵌套循环的优化

Improving optimization of nested loop

本文关键字：优化 嵌套循环      更新时间：2023-10-16

我正在制作一个简单的程序来计算数组中可被 3 个数组长度整除的对数，并且值由用户确定。

现在我的代码完全没问题。但是，我只想检查是否有一种更快的方法来计算它，从而减少编译时间？

由于数组的长度为 10^4 或更小，编译器需要不到 100 毫秒的时间。但是，当它增加到 10^5 时，它会飙升到 1000 毫秒，那么这是为什么呢？以及如何提高速度？

#include <iostream>
using namespace std;
int main()
{
    int N, i, b;
    b = 0;
    cin >> N;
    unsigned int j = 0;
    std::vector<unsigned int> a(N);
    for (j = 0; j < N; j++) {
        cin >> a[j];
        if (j == 0) {
        }
        else {
            for (i = j - 1; i >= 0; i = i - 1) {
                if ((a[j] + a[i]) % 3 == 0) {
                    b++;
                }
            }
        }
    }
    cout << b;
    return 0;
}

您的算法具有O(N^2)复杂性。有一种更快的方法。

(a[i] + a[j]) % 3 == ((a[i] % 3) + (a[j] % 3)) % 3
因此，您

不需要知道确切的数字，您只需要知道它们的除以三的余数。总和的零余数可以用两个余数为零的数字接收(0 + 0)，两个余数为 1 和 2 (1 + 2) 的数字接收。

结果将等于 r[1]*r[2] + r[0]*(r[0]-1)/2其中r[i]是余数等于 i 的数字的数量。 

int r[3] = {};
for (int i : a) {
    r[i % 3]++; 
}
std::cout << r[1]*r[2] + (r[0]*(r[0]-1)) / 2;

该算法的复杂性是O(N)。

我以前遇到过这个问题，虽然我没有找到我的特定解决方案，但您可以通过哈希来缩短运行时间。

代码如下所示：

// A C++ program to check if arr[0..n-1] can be divided
// in pairs such that every pair is divisible by k.
#include <bits/stdc++.h>
using namespace std;
// Returns true if arr[0..n-1] can be divided into pairs
// with sum divisible by k.
bool canPairs(int arr[], int n, int k)
{
    // An odd length array cannot be divided into pairs
    if (n & 1)
         return false;
    // Create a frequency array to count occurrences
    // of all remainders when divided by k.
    map<int, int> freq;
    // Count occurrences of all remainders
    for (int i = 0; i < n; i++)
        freq[arr[i] % k]++;
    // Traverse input array and use freq[] to decide
    // if given array can be divided in pairs
    for (int i = 0; i < n; i++)
    {
        // Remainder of current element
        int rem = arr[i] % k;
        // If remainder with current element divides
        // k into two halves.
        if  (2*rem == k)
        {
            // Then there must be even occurrences of
            // such remainder
            if (freq[rem] % 2 != 0)
                return false;
        }
        // If remainder is 0, then there must be two 
        // elements with 0 remainder
        else if (rem == 0)
        {
           if (freq[rem] & 1)           
               return false;
        }        
        // Else number of occurrences of remainder
        // must be equal to number of occurrences of
        // k - remainder
        else if (freq[rem] != freq[k - rem])
            return false;
    }
    return true;
}
/* Driver program to test above function */
int main()
{
    int arr[] =  {92, 75, 65, 48, 45, 35};
    int k = 10;
    int n = sizeof(arr)/sizeof(arr[0]);
    canPairs(arr, n, k)? cout << "True": cout << "False";
    return 0;
}

这适用于 k（在您的情况下为 3）但话又说回来，这不是我的代码，而是您可以在以下链接中找到的代码。有适当的解释。我不只是粘贴链接，因为我认为这是不好的做法。

相关文章：