50分求一道ACM题SIGSEGV原因 晕了最烦这种错了

[mopishv0]

http://acm.hrbeu.edu.cn/index.php?act=problem&proid=5012&cid=0

There are two sequences A and B with N (1<=N<=10000) elements each. All of the elements are positive integers. Given C=A*B, where '*' representing Cartesian product, c = a*b, where c belonging to C, a belonging to A and b belonging to B. Your job is to find the K'th largest element in C, where K begins with 1.

Input

Input file contains multiple test cases. The first line is the number of test cases. There are three lines in each test case. The first line of each case contains two integers N and K, then the second line represents elements in A and the following line represents elements in B. All integers are positive and no more than 10000.

Output

For each case output the K'th largest number.

Sample Input

2
2 1
3 4
5 6
2 3
2 1
4 8

Sample Output

24
8

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <vector>
#include <algorithm>
#include <search.h>
using namespace std;

bool cmp ( const double a , const  double b ) 
{ 
	return b<a; 
} 

int main()
{
	int num;
	scanf("%d",&num);
	while(num--)
	{
 		int n,k;
 		scanf("%d%d",&n,&k);
 		vector<int>a;
 		for(int i=0;i<n;i++)
   		{
            double xx;
            scanf("%lf",&xx);
            a.push_back(xx);
        }
        vector<int>b;
 		for(int i=0;i<n;i++)
   		{
            double xx;
            scanf("%lf",&xx);
            b.push_back(xx);
        }
        sort(a.begin(),a.end(),cmp);
        sort(b.begin(),b.end(),cmp);
	    double max=b[0]*a[0];
     	int kth=(k+1)/3;
     	if(k==kth*3-1&&k>1)
     	    max=a[kth]*b[kth-1]>=a[kth-1]*b[kth]?a[kth]*b[kth-1]:a[kth-1]*b[kth];
     	if(k==kth*3&&k>1)
     	    max=a[kth]*b[kth-1]<a[kth-1]*b[kth]?a[kth]*b[kth-1]:a[kth-1]*b[kth];
     	if(k==kth*3+1&&k>1)
     	    max=a[kth]*b[kth];
      	printf("%.0lf\n",max);
 	}
	return 0;
}

[mopishv0]

知道哪错了 但是希望大家提供个好的不超时的方法

[星羽]

什么叫不超时？？ 你上面那个测试了是对的吗？题目好像要找出第k大的哦

[skineffect]

觉得要简化算法要用到数论的知识，比如和与积的关系等。

[ryfdizuo]

超时啊，
你能不能不用vector，这里的元素个数完全可以确定的嘛，直接申请内存，排序用qsort();

[xbt746]

呵呵,ACM上最好不要用STL东西

[hankman]

你只是取用最大的几个数据，没有必要对整个数组排序。所以可以考虑从这方面进行优化。当然，应该有一些对K的经验性判断，否则算法退化后会变成劣化。
不过，在你做优化之前，先测试一下性能瓶颈会比较好吧。

[mopishv0]

因为最大数据量是10000
所以用双层循环会导致超时
而我的算法因为少考虑了一些情况 所以是错误的

[mopishv0]

超时就是输入所有测试数据进行计算所用的时间大于规定时间

[oo]

题目说是整数，为什么要用double？

[mopishv0]

10000*10000很大的
做题时应当考虑边缘数据

[bfhtian]

楼主的程序结果应该也是错的,输入
1
4 4
9 7 5 3
8 4 2 1
正确结果应该是36,程序输出结果是28

[mopishv0]

[Quote=引用 1 楼 mopishv0 的回复:]
知道哪错了 但是希望大家提供个好的不超时的方法
[/Quote]
[Quote=引用 11 楼 fhtingtian 的回复:]
楼主的程序结果应该也是错的,输入
1
4 4
9 7 5 3
8 4 2 1
正确结果应该是36,程序输出结果是28
[/Quote]
已经知道了…………

[soyboydoy]

先计算好，用O(n)时间，用QSORT的核心函数PARTITION找出第K大的值就可以了
int findKth(int a[], int s, int e, k){
int p = partition(a, s, e, k);
if(p == k) return a[p];
if(p > k) findKth(a, s, p-1, k);
else findKth(a, p+1, e, k);
}

大致如此，我没测试过。

[fallinleave]

数组 S 包含 n 个正数，排序后分别是 x_0, x_1, ... , x_n-1，
记 P(i, j) = x_i * x_j，则 P 是一个 n*n 的矩阵，
而且每行每列分别有序（注意我们不需要真的构造矩阵 P）。

对于给定的数组元素 C，
我们判断矩阵 P 中是否存在元素 P(i, j) = C。
如果存在，则表明 x_i * x_j = C，
从大到小的考查所有可能的 C，
即可求出满足条件的最大 C。

现在问题转化成为在一个行列分别有序的 m*n 的矩阵 P 中查找元素 C。
我们用 P(a, b, c, d)
来表示左上角坐标为(a, b)、右下角坐标为 (c, d) 的 P 的子矩阵。

结论一：矩阵的最大元素在右下角，最小元素在左上角。

结论二：若 P(0, j) < C < P(0, j+1)，
则 C 一定不在子矩阵 P(0, j+1, m-1, n-1)。
(因为 P(0, j+1) 是这个子矩阵的最小元素，而 C < P(0, j+1))。

为了找到合适的 j 使得 P(0, j) < C < P(0, j+1)，
依次考查元素 P(0, n-1), P(0, n-2), ..., P(0, n-floor(lgn))，
如果我们没有找到满足条件的 j，
则对所有可能的 P(0, j) 用二分法找到合适的 j。
然后可以刨除子矩阵 P(0, j+1, m-1, n-1)，
在剩下的子矩阵 P(0, 0, j, n-1) 中找。

最坏情况下，我们用了 n - j 次比较，刨除掉了矩阵中的 n - j 列。
平均情况下，我们用了 O(lgn) 次比较，刨除掉了矩阵中的 n/2 列。

上面的方法其实就是在矩阵的第一行上找 C 的分界线，然后刨除掉矩阵的部分元素。
同样的，我们可以在矩阵的最后一行、第一列、最后一列上做类似的操作。
如果在矩阵的四边都不能刨掉元素，则 C 不在矩阵中，直接返回即可。

最坏情况下，我们需要 O(n) 次比较，判断 P 中是否存在 C。
平均情况下，我们需要 O((lgn)^2) 次比较，判断 P 中是否存在 C，

时间复杂度：
一共有 n 个可能的 C，故最坏 O(n^2)，平均 O(n*(lgn)^2)。

空间复杂度：
不需要存储矩阵 P，需要用 P(i, j) 的时候直接计算即可，
运算过程中只需要记住子矩阵的左上角、右下角坐标，
额外空间 O(1)。

[soyboydoy]

晕
看错题了
。。。

[meiZiNick]

等待牛人来答.

[dartzm]

这种错误多半是堆栈溢出之类的错误.....

[seerjk]

不知道里的问题啊