POJ - 2785 - 4 Values whose Sum is 0 - 二分折半查找

2017-08-01 21:29:14

writer:pprp

参考:http://blog.csdn.net/piaocoder/article/details/45584763

算法分析:直接暴力复杂度过高,所以要用二分的方法,分成两半复杂度就会大大降低;

题目意思:给定4个n(1<=n<=4000)元素的集合 A、B、C、D ,从4个集合中分别选取一个元素a, b,c,d。求满足 a+b+c+d=0的个数



代码如下:

//首先将前两列任意两项相加得到数组x,再将后两列任意两项相加取反得到数组y,
//再将y排序,最后依次将x中的元素在y中进行
//二分查找,看有多少个相等的数加起来即为最终的结果。

#include <iostream>
#include <cstdio>
#include <algorithm>

using namespace std;

int a[4010][4];
int x[16000001];
int y[16000001];
int ll, ans;

//search x[i] from array y[i]
void bit_search(int t)
{
    int mid,l = 0,r = ll - 1;
    while(l < r)
    {
        mid = (l+r) >> 1;
        if(y[mid] < t)
            l = mid + 1;
        else
            r = mid;
    }
    while(y[l] == t && l < ll)  //可能有找到不止一个
    {
        ans++;
        l++;
    }
}

int main()
{
    int n,i,j;

    while(cin >> n)
    {
        ans = 0,ll = 0;

        for(i = 0; i < n; i++) //record the data
            cin >> a[i][0] >> a[i][1]
                >> a[i][2] >> a[i][3];

        for(i = 0; i < n; i++) //枚举左侧
        {
            for(j = 0; j < n ; j++)
            {
                x[ll++] = a[i][0] + a[j][1];
            }
        }

        ll = 0;

        for(i = 0; i < n ; i++) //枚举右侧
        {
            for(j = 0; j < n ; j++)
            {
                y[ll++] = -(a[i][2] + a[j][3]); //这里取反 a + b + c + d = 0等价于a + b = -(c + d);
            }
        }
        sort(y,y+ll);   //先排序

        for(i = 0 ; i < ll ; i++)  //再进行二分查找,如果找到那么ans++
            bit_search(x[i]);

        cout << ans << endl;
    }
    return 0;
}
时间: 2024-12-09 22:02:17

POJ - 2785 - 4 Values whose Sum is 0 - 二分折半查找的相关文章

POJ 2785 4 Values whose Sum is 0 [二分]

传送门 13773503 njczy2010 2785 Accepted 25248K 7079MS G++ 1423B 2015-01-11 10:26:48 4 Values whose Sum is 0 Time Limit: 15000MS   Memory Limit: 228000K Total Submissions: 16102   Accepted: 4659 Case Time Limit: 5000MS Description The SUM problem can be

POJ 2785 4 Values whose Sum is 0(折半枚举)

4 Values whose Sum is 0 Time Limit: 15000MS   Memory Limit: 228000K Total Submissions: 17088   Accepted: 4998 Case Time Limit: 5000MS Description The SUM problem can be formulated as follows: given four lists A, B, C, D of integer values, compute how

poj 2785 4 Values whose Sum is 0(折半枚举(双向搜索))

Description The SUM problem can be formulated as follows: given four lists A, B, C, D of integer values, compute how many quadruplet (a, b, c, d ) ∈ A x B x C x D are such that a + b + c + d = 0 . In the following, we assume that all lists have the s

poj 2785 4 Values whose Sum is 0(sort+二分)

题意: 给你ABCD四个集合,集合中数的个数都为N(N<=4000),如果分别在ABCD四个集合中取一个数,a b c d ,求有多少种可能使得a+b+c+d=0. 当然你可以尝试枚举所有的组合,绝对可以计算出结果,大概有N^4种吧,如果你有足够的时间还是可以算出来的,哈哈. 当然我不是用上面一种方法计算的,那样算肯定超时. 我的做法是求出所有a+b 到ab数组中, 和所有 c+d到cd数组中,然后排序,枚举每个ab,用二分在cd中查找有没有可能组成0.  有个问题就是二分只能返回一个结果,所以

poj 2785 4 Values whose Sum is 0 (简单二分)

//每列选一个数相加为0的个数 # include <stdio.h> # include <algorithm> # include <string.h> using namespace std; int ab[4010*4010],cd[4010*4010]; int main() { int n,i,k,j,count,a[4010],b[4010],c[4010],d[4010]; while(~scanf("%d",&n)) { f

POJ 2785 4 Values whose Sum is 0 (对半分解 二分搜索)

4 Values whose Sum is 0 Time Limit: 15000MS   Memory Limit: 228000K Total Submissions: 17658   Accepted: 5187 Case Time Limit: 5000MS Description The SUM problem can be formulated as follows: given four lists A, B, C, D of integer values, compute how

POJ 2785 4 Values whose Sum is 0

4 Values whose Sum is 0 Time Limit: 15000MS   Memory Limit: 228000K Total Submissions: 22691   Accepted: 6869 Case Time Limit: 5000MS Description The SUM problem can be formulated as follows: given four lists A, B, C, D of integer values, compute how

poj 2785 4 Values whose Sum is 0 哈希

题意: 给4个集合ABCD,问有多少种从中各取一个数和为0的方案. 分析: 枚举前两个数建哈希表,枚举后两个数查找即可. 代码: //poj 2785 //sep9 #include <iostream> using namespace std; const int maxN=4012; const int maxM=3999972; int a[maxN],b[maxN],c[maxN],d[maxN]; int hash[maxM+10]; int e; struct Edge { int

poj 2785 4 Values whose Sum is 0 折半枚举

题目链接:http://poj.org/problem?id=2785 枚举的一般思路就是先把所有的状态枚举出来 最后一次性判断该状态合法不合法 而折半枚举的思想是 先枚举一半的状态 把他们的状态存起来 排序 然后再枚举剩下一般 用目标反推前一半的期望状态 接下来在前一半的结果数组中查找是否有相应结果 之所以能优化是因为结果数组有序 就可以用二分搜索 复杂度从O(n^2 * n^2) 降到 O(n^2 * log(n^2))即(O(n^2 * log n)) 二分搜索的一个技巧 在有序数组中用二