百度的一个笔试题

[zy416548283]

题目：在一个正整数集合S中，找出一个最大数C，使得C=A+B,其中A和B也是S种的元素。。。

我的思路：
2重遍历，将求和的结果保存在数组中，O(n^2)；
对求和结果进行排序，O(n*log2n);
从最大的元素开始查找，如果存在于集合S中，那么停止查找，O(n^2);

算下来复杂度也是O(n^2)

csdn算法专用板块么？

[evanbao]

提供一个不同的思路：先把集合排序（从小到大），时间复杂度：O(n*logn)，然后从后往前遍历，方法类似于leetcode里面的2Sum问题，最差情况下时间复杂度才为O(n*n)，且没有额外空间开销。

[SenXXX]

void findTwo(int *descArray, int len, int &num1, int &num2)
{
    int start = 1, end = len - 1, tmp, sum;
    sum = descArray[0];
    cout << sum << endl;
    while(start < end)
    {
        tmp = descArray[start] + descArray[end];
        if(sum == tmp)
        {
            num1 = descArray[start];
            num2 = descArray[end];
            return;
        }
        else if(sum > tmp)
            ++start;
        else    
            --end;
    }
}

时间复杂度由排序决定

[SenXXX]

写反了。。贴上完整的好了。。

#include <iostream>
#include <algorithm>

using namespace std;

const int maxLen = 10;

void findTwo(int *descSortedArray, int len, int &num1, int &num2)
{
    int start = 1, end = len - 1, tmp, sum;
    sum = descSortedArray[0];
    while(start < end)
    {
        tmp = descSortedArray[start] + descSortedArray[end];
        if(sum == tmp)
        {
            num1 = descSortedArray[start];
            num2 = descSortedArray[end];
            return;
        }
        else if(sum < tmp)
            ++start;
        else    
            --end;
    }
}

int cmp(int a, int b)
{
    return a > b;
}

int main()
{
    int array[maxLen] = {1, 5, 7, 8, 9, 10, 5, 20, 11, 2}, num1, num2;
    sort(array, array + maxLen, cmp); /* 时间复杂度由sort决定 */
    findTwo(array, maxLen, num1, num2);
    cout << num1 << " " << num2 << endl;
    return 0;
}

[qq_19407777]

我的思路跟qq506657335是一样的，具体看这里 http://blog.csdn.net/qq_19407777/article/details/39275289 qq506657335的代码有BUG，因为只做了第一个数，如果第一个数不等于数组中另外两个数相加，那么输出的num1和num2都是未定义的。另外，FindTwo函数未能指示查找结果成功与否，应改为bool

[Flammable_ice]

引用 3 楼 qq506657335 的回复:

写反了。。贴上完整的好了。。

#include <iostream>
#include <algorithm>

using namespace std;

const int maxLen = 10;

void findTwo(int *descSortedArray, int len, int &num1, int &num2)
{
    int start = 1, end = len - 1, tmp, sum;
    sum = descSortedArray[0];
    while(start < end)
    {
        tmp = descSortedArray[start] + descSortedArray[end];
        if(sum == tmp)
        {
            num1 = descSortedArray[start];
            num2 = descSortedArray[end];
            return;
        }
        else if(sum < tmp)
            ++start;
        else    
            --end;
    }
}

int cmp(int a, int b)
{
    return a > b;
}

int main()
{
    int array[maxLen] = {1, 5, 7, 8, 9, 10, 5, 20, 11, 2}, num1, num2;
    sort(array, array + maxLen, cmp); /* 时间复杂度由sort决定 */
    findTwo(array, maxLen, num1, num2);
    cout << num1 << " " << num2 << endl;
    return 0;
}

你试试这组数据 看看能否得到正确答案？ array[maxLen] = {6,6,19,9,16,17,14,16,12,16}

[勤奋的小游侠]

引用 5 楼 z84616995z 的回复:

[quote=引用 3 楼 qq506657335 的回复:] 写反了。。贴上完整的好了。。

#include <iostream>
#include <algorithm>

using namespace std;

const int maxLen = 10;

void findTwo(int *descSortedArray, int len, int &num1, int &num2)
{
    int start = 1, end = len - 1, tmp, sum;
    sum = descSortedArray[0];
    while(start < end)
    {
        tmp = descSortedArray[start] + descSortedArray[end];
        if(sum == tmp)
        {
            num1 = descSortedArray[start];
            num2 = descSortedArray[end];
            return;
        }
        else if(sum < tmp)
            ++start;
        else    
            --end;
    }
}

int cmp(int a, int b)
{
    return a > b;
}

int main()
{
    int array[maxLen] = {1, 5, 7, 8, 9, 10, 5, 20, 11, 2}, num1, num2;
    sort(array, array + maxLen, cmp); /* 时间复杂度由sort决定 */
    findTwo(array, maxLen, num1, num2);
    cout << num1 << " " << num2 << endl;
    return 0;
}

你试试这组数据 看看能否得到正确答案？ array[maxLen] = {6,6,19,9,16,17,14,16,12,16}[/quote] 感觉代码图样图森谱

[SenXXX]

引用 5 楼 z84616995z 的回复:

[quote=引用 3 楼 qq506657335 的回复:] 写反了。。贴上完整的好了。。

#include <iostream>
#include <algorithm>

using namespace std;

const int maxLen = 10;

void findTwo(int *descSortedArray, int len, int &num1, int &num2)
{
    int start = 1, end = len - 1, tmp, sum;
    sum = descSortedArray[0];
    while(start < end)
    {
        tmp = descSortedArray[start] + descSortedArray[end];
        if(sum == tmp)
        {
            num1 = descSortedArray[start];
            num2 = descSortedArray[end];
            return;
        }
        else if(sum < tmp)
            ++start;
        else    
            --end;
    }
}

int cmp(int a, int b)
{
    return a > b;
}

int main()
{
    int array[maxLen] = {1, 5, 7, 8, 9, 10, 5, 20, 11, 2}, num1, num2;
    sort(array, array + maxLen, cmp); /* 时间复杂度由sort决定 */
    findTwo(array, maxLen, num1, num2);
    cout << num1 << " " << num2 << endl;
    return 0;
}

你试试这组数据 看看能否得到正确答案？ array[maxLen] = {6,6,19,9,16,17,14,16,12,16}[/quote] 嗯。。跟楼上说的一样。。缺少查找成功的判断

[SenXXX]

引用 6 楼 lovesmiles 的回复:

[quote=引用 5 楼 z84616995z 的回复:] [quote=引用 3 楼 qq506657335 的回复:] 写反了。。贴上完整的好了。。

#include <iostream>
#include <algorithm>

using namespace std;

const int maxLen = 10;

void findTwo(int *descSortedArray, int len, int &num1, int &num2)
{
    int start = 1, end = len - 1, tmp, sum;
    sum = descSortedArray[0];
    while(start < end)
    {
        tmp = descSortedArray[start] + descSortedArray[end];
        if(sum == tmp)
        {
            num1 = descSortedArray[start];
            num2 = descSortedArray[end];
            return;
        }
        else if(sum < tmp)
            ++start;
        else    
            --end;
    }
}

int cmp(int a, int b)
{
    return a > b;
}

int main()
{
    int array[maxLen] = {1, 5, 7, 8, 9, 10, 5, 20, 11, 2}, num1, num2;
    sort(array, array + maxLen, cmp); /* 时间复杂度由sort决定 */
    findTwo(array, maxLen, num1, num2);
    cout << num1 << " " << num2 << endl;
    return 0;
}

你试试这组数据 看看能否得到正确答案？ array[maxLen] = {6,6,19,9,16,17,14,16,12,16}[/quote] 感觉代码图样图森谱[/quote] 说得好像好吊的样子。。

[qq120848369]

这是组合问题，避免重复计算，避免不必要的计算。 1,从小到大排序。 2,C从后往前移动。 3,对于指定C，A从小到大移动。（C-A<A则跳转步骤2） 4,对于指定C,A，在(C,A)之间做二分查找。

[zhao_test_123]

先谢谢楼上各位的解答，有空跑跑程序再来结贴

[adultmonkey2]

他是先把数组排序了的，所以的确是只算第一个，还有一个问题是数组中等于C的A+B可能不止一组

[我叫小菜菜]

引用 13 楼 adultmonkey2 的回复:

他是先把数组排序了的，所以的确是只算第一个，还有一个问题是数组中等于C的A+B可能不止一组

题目只问C，A+B只要求在S中。 如果要把A+B也找到，那么找到C和第一组A+B后，不能停止，还要在对后面的求和，是否有SUM等于C。最后停止。

[nice_cxf]

基本上11楼正解，不过为了减少重复计算，可以考虑把计算过的结果记录在另外一个数组里面，不过要额外o(n*n)的空间复杂度，不知道是否值得。。

[志起计算机编程]

先对数组进行排序，nlogn，然后从数组中最大的数（max）开始，查找是否剩下的数有两个数和为max，方法如下： “两头夹逼法”，头尾各选一个数，两个数相加与max比较，如果相等，那么找到；如果小于max，左边界数往右移一位；如果大于max，右边界数向左移一位。

[qq112141874]

我以为排序没啥必要。 说下思路，看看是否更简洁，一个3重嵌套循环解决问题。 依次选取S中的元素，循环相加 S中的元素（2重嵌套循环） 在循环中判断相加的和X，X是否在S中（第3重循环）。 X是否大于原有的X 都是是的话，则更新X值。

[lm_whales]

首先排序 O(NlogN) 得到 最大数 MAX 接着 开个 1～Max 的bool 数组表示 各数是否在数组中，O(Max) 接着两数差是否在 数组中O(N*N) 或者 O(NlogN）

[超级能量泡泡]

引用 12 楼 qq112141874 的回复:

我以为排序没啥必要。 说下思路，看看是否更简洁，一个3重嵌套循环解决问题。 依次选取S中的元素，循环相加 S中的元素（2重嵌套循环） 在循环中判断相加的和X，X是否在S中（第3重循环）。 X是否大于原有的X 都是是的话，则更新X值。

我也认为排序是不必要的 因为依序求和的时候可以比较大小，不需要所有的都排序

[lm_whales]

排序很必要，如果希望空间复杂度尽可能的小 那么，排序的数组，可以二分查找，可以有O( logX) 的查找效率，查找一个数是否在S中，否则需要O(N)的效率

[lm_whales]

引用 18 楼 lm_whales 的回复:

排序很必要，如果希望空间复杂度尽可能的小 那么，排序的数组，可以二分查找，可以有O( logX) 的查找效率，查找一个数是否在S中，否则需要O(N)的效率

如果不用计数排序中，用到的那种方法的话

[Sky丶Memory]

#include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
using namespace std;
pair<bool, int> Solution(vector<int> num)
{
    sort(num.begin(), num.end());
    for (int i = num.size() - 1; i >= 2; --i)
    {
        int low = 0, high = i -1;
        if (num[i - 1] + num[i - 2] < num[i])
            continue;
        while (low < high)
        {
            if (num[low] + num[high] == num[i])
                break;
            if (num[low] + num[high] > num[i])
                --high;
            else
                ++low;
        }
        if (low < high)
            return make_pair(true, num[i]);
    }
    return make_pair(false, -1);
}
int main()
{
    int n;
    cin >> n;
    vector<int> num(n);
    for (int i = 0; i < n; ++i)
        cin >> num[i];
    pair<bool, int> res = Solution(num);
    if (res.first)
        cout << res.second << endl;
    else
        cout << "Not found." << endl;
    return 0;
}

时间复杂度O(N^2),还有就是LZ你自己算法的时间复杂度分析错了，你将求和结果保存起来，然后排序，其时间复杂度为O(N^2lgN),