SPOJ SUMFOUR……测试用例9的TLE

SPOJ SUMFOUR.....TLE on test case 9

本文关键字：TLE 测试用例 SUMFOUR SPOJ      更新时间：2023-10-16

我正在尝试解决SPOJ问题SUMFOUR....我在测试用例9上得到了TLE http://www.spoj.com/problems/SUMFOUR/

那么，我的代码的哪一部分必须编辑，如何编辑?这里N<= 4000 

#include <iostream>
#include<string>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<map>
#include<vector>
using namespace std;

int main()
{
int a[4005][5],n;
cin>>n;
for(int i=1;i<=n;i++)
    for(int j=1;j<=4;j++)
        scanf("%d",&a[i][j]);
int k=0;
for(int i=1;i<=n;i++)
{   int p=a[i][1];
    for(int j=1;j<=n;j++)
    {   b.push_back(p+a[j][2]);
        k++;
    }
}
k=0;
for(int i=1;i<=n;i++)
{   int p=a[i][3];
    for(int j=1;j<=n;j++)
    {   c.push_back(p+a[j][4]);
        k++;
    }
}
sort(b.begin(),b.end());
int cnt=0;
for(int j=0;j<k;j++)
    if(find(b.begin(),b.end(),-c[j])!=b.end() )
        cnt=cnt+count(b.begin(),b.end(),-c[j]) ;

printf("%dn",cnt);
return 0;
}

问题就在这里:

 for(int j=0;j<k;j++)
       if(find(b.begin(),b.end(),-c[j])!=b.end() )
           cnt=cnt+count(b.begin(),b.end(),-c[j]) ;

对于n = 4000，所以b和c中有4000^2个元素，所以这个循环的时间复杂度是4000^4，因为find和count的时间复杂度是O(n)，这当然会导致你的时间限制超过。

那么，如何减少时间呢?您可以使用二进制搜索来加快计数过程，这将上述循环的时间复杂度降低到O(n^2 log n)，因为我注意到您已经排序了b。

或者，可以使用map计算并存储b和c中每个元素的频率。

map<long long, int> b;
map<long long, int> c;
for(int i=1;i<=n;i++)
{   long long p=a[i][1];
    for(int j=1;j<=n;j++)
    {   
        long long tmp =p + a[j][2];
        b[tmp] = b[tmp] + 1; 
    }
}
// Similar for c
map <long long, int>::iterator it;
long long result;
for (it = c.begin(); it != c.end(); ++it)
        result += c[it->first]*b[-(it->first)];

对于您的新更新，请更改此:

    for(int j=1;j<=n;j++)
    {   if( b.count(a[i][1]+a[j][2]) )
        {   b[a[i][1]+a[j][2]]+=1;
            c[a[i][3]+a[j][4]]+=1;
        }
        else
        {   b[a[i][1]+a[j][2]]=1;
            c[a[i][3]+a[j][4]]=1;
        } 
    }

这:

    for(int j=1;j<=n;j++)
    {   
           b[a[i][1]+a[j][2]]+=1;
           c[a[i][3]+a[j][4]]+=1;            
    }

条件检查if( b.count(a[i][1]+a[j][2]) )只适用于b，而您将其用于c，这使得c不正确。

Update:在尝试在SPOJ中接受后，结果发现映射不够快，所以我更改为二进制搜索，并被接受。

我接受的代码

请不要使用Map，因为它的最坏情况复杂度可能是O(log(n))。

所以你可以只使用两个排序数组，对于每个元素，就像

第一个数组，在第二个累积数组中查找它的-ve代理。

只需将Last lines中的find方法更改为二进制搜索(c.begin()，c.end()，key)，并使用该索引查找重复直到末尾，因为它给出了lower_bound索引。

Total Sum给出了答案，其预期复杂度为

O (n ^ 2 log (n))。

相关文章：