首页 > ACM题库 > HDU-杭电 > HDU 4334-Trouble-排序-[解题报告]HOJ
2015
05-23

HDU 4334-Trouble-排序-[解题报告]HOJ

Trouble

问题描述 :

Hassan is in trouble. His mathematics teacher has given him a very difficult problem called 5-sum. Please help him.
The 5-sum problem is defined as follows: Given 5 sets S_1,…,S_5 of n integer numbers each, is there a_1 in S_1,…,a_5 in S_5 such that a_1+…+a_5=0?

输入:

First line of input contains a single integer N (1≤N≤50). N test-cases follow. First line of each test-case contains a single integer n (1<=n<=200). 5 lines follow each containing n integer numbers in range [-10^15, 1 0^15]. I-th line denotes set S_i for 1<=i<=5.

输出:

First line of input contains a single integer N (1≤N≤50). N test-cases follow. First line of each test-case contains a single integer n (1<=n<=200). 5 lines follow each containing n integer numbers in range [-10^15, 1 0^15]. I-th line denotes set S_i for 1<=i<=5.

样例输入:

2
2
1 -1
1 -1
1 -1
1 -1
1 -1
3
1 2 3
-1 -2 -3
4 5 6
-1 3 2
-4 -10 -1

样例输出:

No
Yes

 这道题目的意思就是给定5个集合,每个集合中选取一个数字,使他们的和为0.判断给定的五个集合能否找到这样的一组数据.

分析: 对于特定的序列中寻找特殊值的方法有二分查找.对于二分查找,前提就是序列有序,就可以通过log(N)的复杂度找到特定值,

二分查找的特点,一个序列,有序,特定值.

这道题用到了另外一种高效的方法.在两个有序的序列中,用O(a+b)线性时间找到一个特定值.具体的操作就是对于两个排好序的序列,设定两个游标,指向a的最大值,另外一个指向b的最小值,如果他们的和大于特定值,那么就指向最大值的游标后移,反之就最小值的那个游标前移.这样操作就可以在线性时间内完成,中间用到了一个小小的贪心思想.这个方法不知道叫什么名字.

此方法的特点.两个序列,有序,任意特定值.这种方法可以说是非常perfect .对于查找之前的排序,cpu的消耗是非常大的,如果能把排序的规模减少在效率上作用是非常显著的.

 

在这道题当中,如果应用二分查找的模式去解,就是把其中的一部分所有可能值枚举出来,排序,然后枚举另外一部分,通过二分在排好序的几何中查找.时间复杂度就是O(3*n^3*log(n)+3*n^2*log(n)) 差不多是O(n^3*log(n))   如果用贪心的方法,可以枚举前两个集合和3,4个集合,然后可以约化为3个集合,然后去枚举第三个集合,,在前两个几何当中去贪心,总的复杂度应该就是O(2*n^2*log(n)+n^3) 差不多是O(n^3)的样子.呵呵 这种方法还是很强大的. 总结一下这种方法的优势,可以分成3个集合,有效的降低了每个集合的容量,这样大大减小了排序的时间,其次在两个集合中本身的时间是线性的
非常快.

 

#include<stdio.h>
#include<stdlib.h>

int n;
__int64 que[5][210],a[41000],b[41000];

int cmp(const void*a,const void*b)
{
    if(*(__int64 *)a-*(__int64 *)b > 0)
    return 1;
    return -1;
}

void fun()
{
    int i,f,ji=0;
    for(i=0;i<n;i++)
    {
        for(f=0;f<n;f++)
        {
            a[ji]=que[0][i]+que[1][f];
            ji++;            
        }        
    }
    qsort(a,n*n,sizeof(a[0]),cmp);
    ji=0;    
    for(i=0;i<n;i++)
    {
        for(f=0;f<n;f++)
        {
            b[ji]=que[2][i]+que[3][f];
            ji++;            
        }        
    }    
    qsort(b,n*n,sizeof(b[0]),cmp);
}

int sea(__int64 x)
{
    int head=0,tail=n*n-1;
    while(1)
    {
        if(x == a[head]+b[tail])
        {
            return 1;
        }
        if(a[head]+b[tail] > x)
        {
            tail--;
            if(-1 == tail)
            {
                break;
            }
        }
        else
        {
            head++;
            if(n*n == head)
            {
                break;
            }
        }    
    }
    return 0;
}

int main()
{
    int i,num,f,g;
    scanf("%d",&num);
    for(i=0;i<num;i++)
    {
        scanf("%d",&n);
        for(f=0;f<5;f++)
        {
            for(g=0;g<n;g++)
            {
                scanf("%I64d",&que[f][g]);            
            }
        }
        
        fun();
        
        for(g=0;g<n;g++)
        {
            if(1 == sea(-que[4][g]))
            {
                printf("Yes\n");
                break;
            }
        }
        if(g == n)
        {
            printf("No\n");
        }
    }
    return 0;
}

 

版权声明:本文为博主原创文章,未经博主允许不得转载。

参考:http://blog.csdn.net/qq564690377/article/details/7824691