程序员面试金典 16.21

最新推荐文章于 2023-06-10 20:11:52 发布

原创最新推荐文章于 2023-06-10 20:11:52 发布 · 251 阅读

0 ·

CC 4.0 BY-SA版权

《程序员面试金典》专栏收录该内容

110 篇文章

订阅专栏

本文探讨了SumSwap问题的解决策略，即寻找两个数组中的元素进行交换以使数组和相等。介绍了暴力枚举方法及其时间复杂度过高的问题，并提出了使用map或set优化内层循环的解决方案，将复杂度降至O(AlogB)。此外，还讨论了当数组有序时，通过顺序遍历查找结果的更高效方法，复杂度为O(AlogA+BlogB)。

Sum Swap：给定两个数组，从每个数组中取出一个元素，使得交换这两个元素后，两数组和相等。

最简单的方法就是暴力枚举，时间复杂度为O(AB)，其中A和B分别表示数组大小。写代码之前看了下测试用例的范围，数组大小上限为100000，估计肯定会超时的，果不其然。

优化只能从内层循环入手，尝试使用map或者set代替array2的遍历，复杂度降为O(AlogB)。

class Solution {
public:
    vector<int> findSwapValues(vector<int>& array1, vector<int>& array2) {
        int sum1 = accumulate(array1.begin(), array1.end(), 0);
        int sum2 = accumulate(array2.begin(), array2.end(), 0);
        if((sum1 + sum2) % 2 != 0) return {};
        int half = (sum1 + sum2) / 2;
        set<int> set2;
        for_each(array2.begin(), array2.end(), [&set2](const int i){ set2.insert(i); });
        for(size_t i = 0; i < array1.size(); i++)
        {
            int target = half - sum1 + array1[i];
            if(set2.find(target) != set2.end()){
                return { array1[i], target };
            }
        }
        return {};
    }
};

如果两个数组都是有序的，则可以同时顺序遍历找出结果，时间复杂度为O(AlogA + BlogB)。

class Solution {
public:
    vector<int> findSwapValues(vector<int>& array1, vector<int>& array2) {
        int sum1 = accumulate(array1.begin(), array1.end(), 0);
        int sum2 = accumulate(array2.begin(), array2.end(), 0);
        if((sum1 + sum2) % 2 != 0) return {};
        int half = (sum1 + sum2) / 2;
        sort(array1.begin(), array1.end());
        sort(array2.begin(), array2.end());
        size_t i = 0, j = 0;
        while(i < array1.size() && j < array2.size()){
            int ChangedSum = sum1 - array1[i] + array2[j];
            if(ChangedSum == half){
                return { array1[i], array2[j] };
            }
            else if(ChangedSum > half){
                i++;
            }
            else{
                j++;
            }
        }
        return {};
    }
};