POJ 2785 有多少种4个数相加等于0的方案（二分查找 or hash）

最新推荐文章于 2019-07-14 15:40:00 发布
最新推荐文章于 2019-07-14 15:40:00 发布
阅读量1.8k 收藏 1
点赞数 2
分类专栏： POJ 文章标签： 二分查找 哈希
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21201267/article/details/90047815
版权

文章目录


题目链接： http://poj.org/problem?id=2785

题目大意：给定不超过4000行4个数，每列挑出来1个，使之和为0，有多少种方案。

1.二分查找法

1.1 思路：

  • 对左边两列的所有和求出来，右边两列所有的和的求出来再取负
  • 右侧两列的值排序（进行二分查找）
  • 对左边所有的和在右边的和中进行二分查找，并查找前后都满足要求的，计数即得答案
    在这里插入图片描述

1.2 AC代码

/**
 * @description: 求四个数相加等于0的组合种数
 * @author: michael ming
 * @date: 2019/5/8 22:18
 * @modified by:
 */
#include <iostream>
#include <memory.h>
#include <algorithm>

using namespace std;
int a[4001], b[4001], c[4001], d[4001];
int ab[4000*4000+1], cd[4000*4000+1];   //存储a+b，c+d
int findSameValue(int value, int maxindex)//二分查找
{
    int low = 0, high = maxindex, mid, index, count=0;
    while(low <= high)
    {
        mid = low + (high - low)/2;
        if(value == cd[mid])    //查找前后满足要求的个数
        {
            index = mid - 1;
            while(index >= 0 && value == cd[index--])
                count++;
            index = mid + 1;
            while(index <= high && value == cd[index++])
                count++;
            return count + 1;
        }
        else if(value < cd[mid])
            high = mid - 1;
        else
            low = mid + 1;
    }
    return 0;
}
int main()
{
    int line, k=0;
    cin >> line;
    memset(ab, 0, sizeof(ab));
    memset(cd, 0, sizeof(cd));
    for(int i = 0; i < line; ++i)
    {
        cin >> a[i] >> b[i] >> c[i] >> d[i];
    }
    for(int i = 0; i < line; ++i)
    {
        for(int j = 0; j < line; ++j)
        {
            ab[k] = a[i]+b[j];
            cd[k++] = -(c[i]+d[j]);
        }
    }
    sort(cd,cd+k);  //二分查找的必要条件，有序
    int result = 0;
    for(int i = 0; i <= k-1; ++i)
        result += findSameValue(ab[i], k-1);
    cout << result << endl;
    return 0;
}

2.hash查找法

2.1 思路：

  • 对左边两列的所有和求出来，右边两列所有的和的求出来再取负
  • 对左侧两列的和存入哈希表
  • 对右边两列的和在哈希表中查找

2.2 Wrong Answer 代码

(未解决冲突，并且hash后的值可能为负，作为数组下标不行，所以错误)

/**
 * @description: 4个数和为0的方案数，哈希法
 * @author: michael ming
 * @date: 2019/5/9 22:30
 * @modified by: 
 */
#include <iostream>
#include <memory.h>
using namespace std;
int a[4001], b[4001], c[4001], d[4001];
int ab[4000*4000+1], cd[4000*4000+1];   //存储a+b，c+d
int *hasht = new int[16000057];
int offset = 1000000000;
int hashfunc(int &value)
{
    int mod = 16000057;
    return (value%mod + value/mod)%mod;
}
int main()
{
    int line, k=0, value;
    cin >> line;
    memset(hasht, 0, sizeof(hasht));
    for(int i = 0; i < line; ++i)
    {
        cin >> a[i] >> b[i] >> c[i] >> d[i];
    }
    for(int i = 0; i < line; ++i)
    {
        for(int j = 0; j < line; ++j)
        {
            ab[k] = a[i]+b[j];
            value = ab[k]+offset;
            hasht[hashfunc(value)]++;
            cd[k++] = -(c[i]+d[j]);
        }
    }
    int result = 0;
    for(int i = 0; i < k; ++i)
    {
        value = cd[i]+offset;
        if(hasht[hashfunc(value)])
            result += hasht[hashfunc(value)];
    }
    cout << result << endl;
    delete [] hasht;
    return 0;
}

2.3 Time Limit Exceeded 代码

在这里插入图片描述

/**
 * @description: 4个数和为0的方案数，哈希法
 * @author: michael ming
 * @date: 2019/5/9 22:30
 * @modified by: 
 */
#include <iostream>
#include <math.h>
using namespace std;
struct linkedNode   //链表节点
{
    pair<int, int> data;
    linkedNode *next;
    linkedNode():next(NULL), data(make_pair(0,0)){}
};
class linkedList    //链表
{
public:
    linkedNode *head;
    linkedList()
    {
        head = new linkedNode();  //表头哨兵
    }
    ~linkedList()
    {
        delete head;
    }
};
class linkedHash
{
private:
    linkedList *htList; //散列表链表数组
    int bucket;  //散列表桶个数
public:
    linkedHash(int m):bucket(m)
    {
        htList = new linkedList [bucket] ();
    }
    ~linkedHash()
    {
        for(int i = 0; i < bucket; ++i)
        {
            linkedNode *p = htList[i].head->next, *q = p;
            while(q != NULL)
            {
                p = q;
                q = q->next;
                delete p;
            }
        }
        delete [] htList;
    }
    int hash(const int &key) const
    {
        return abs(key%bucket);   //留余数法
    }
    linkedNode* find(const int &x) const
    {
        int i = hash(x);
        linkedNode *p = htList[i].head->next, *q = htList[i].head;
        while(p && p->data.first != x)
        {
            q = p;
            p = p->next;
        }
        return q;   //返回找到元素的前一个节点，或者没有找到,返回最后一个元素
    }
    linkedNode* insert(const int &x)
    {
        int i = hash(x);
        linkedNode *p = htList[i].head, *q = p;
        while(q != NULL)
        {
            p = q;
            q = q->next;
            if(q && q->data.first == x)
            {
                q->data.second++;
                return q;
            }
        }
        p->next = new linkedNode();
        p->next->data.first = x;
        p->next->data.second++;
        return p->next;
    }
};
int a[4001], b[4001], c[4001], d[4001];
int ab[4000*4000+1], cd[4000*4000+1];   //存储a+b，c+d
int main()
{
    linkedHash ht(16000057);
    int line, k=0;
    cin >> line;
    for(int i = 0; i < line; ++i)
    {
        cin >> a[i] >> b[i] >> c[i] >> d[i];
    }
    for(int i = 0; i < line; ++i)
    {
        for(int j = 0; j < line; ++j)
        {
            ab[k] = a[i]+b[j];
            ht.insert(ab[k]);
            cd[k++] = -(c[i]+d[j]);
        }
    }
    int result = 0;
    linkedNode* p;
    for(int i = 0; i < k; ++i)
    {
        p = ht.find(cd[i])->next;
        if(p && p->data.first == cd[i])
            result += p->data.second;
    }
    cout << result << endl;
    return 0;
}

2.4 偷懒失败，hash_map在poj中不存在

在这里插入图片描述

/**
 * @description: 4个数和为0的方案数，哈希法
 * @author: michael ming
 * @date: 2019/5/9 22:30
 * @modified by: 
 */
#include <iostream>
#include <hash_map>
//#include <unordered_map>
using namespace std;
int a[4001], b[4001], c[4001], d[4001];
int ab[4000*4000+1], cd[4000*4000+1];   //存储a+b，c+d
int main()
{
    __gnu_cxx::hash_map<int, int> ht;
//    std::unordered_map<int, int> ht;
    int line, k=0;
    cin >> line;
    for(int i = 0; i < line; ++i)
    {
        cin >> a[i] >> b[i] >> c[i] >> d[i];
    }
    for(int i = 0; i < line; ++i)
    {
        for(int j = 0; j < line; ++j)
        {
            ab[k] = a[i]+b[j];
            ht[ab[k]]++;
            cd[k++] = -(c[i]+d[j]);
        }
    }
    int result = 0;
    for(int i = 0; i < k; ++i)
    {
        result += ht[cd[i]];
    }
    cout << result << endl;
    return 0;
}

2.5 哈希表+二叉查找树（超时）

可能是建立二叉树插入节点new太耗时了。

/**
 * @description: 4个数和为0的方案数，哈希法
 * @author: michael ming
 * @date: 2019/5/9 22:30
 * @modified by:
 */
#include <iostream>
#include <math.h>
using namespace std;
class BSTNode
{
public:
    int data, count;
    BSTNode *left, *right;
    BSTNode():count(1), left(NULL), right(NULL){}
    BSTNode(const int& d, BSTNode *l = NULL, BSTNode *r = NULL)
    {
        data = d;   count = 1;   left = l;   right = r;
    }
};
class BST
{
private:
    BSTNode* root;
    int nodeLen;
public:
    BST():root(NULL){}
    ~BST(){}
    void clear(BSTNode* nodeP)
    {
        if(nodeP == NULL)
            return;
        clear(nodeP->left);
        clear(nodeP->right);
        delete nodeP;
    }
    BSTNode* get_root() const {  return root;    }
    bool isEmpty() const {  return root == NULL;    }
    BSTNode* search(const int& d) const
    {
        BSTNode* p = search(d, root);
        return p;
    }
    BSTNode* search(const int d, BSTNode* p) const
    {
        while(p != NULL)
        {
            if(d == p->data)
                return p;
            else if(d < p->data)
                p = p->left;
            else
                p = p->right;
        }
        return NULL;
    }
    void insert(const int d)
    {
        BSTNode *p = root, *prev = NULL;
        while(p != NULL)
        {
            prev = p;
            if(d < p->data)
                p = p->left;
            else
                p = p->right;
        }
        if(root == NULL)
            root = new BSTNode(d);
        else if(d < prev->data)
            prev->left = new BSTNode(d);
        else
            prev->right = new BSTNode(d);
    }
};

class linkedHash
{
private:
    BST* ht_bstree; //散列表二叉树数组
    int bucket;  //散列表桶个数
public:
    linkedHash(int m):bucket(m)
    {
        ht_bstree = new BST [bucket] ();
    }
    ~linkedHash()
    {
        for(int i = 0; i < bucket; ++i)
        {
            ht_bstree[i].clear(ht_bstree[i].get_root());
        }
        delete [] ht_bstree;
    }
    int hash(const int &key) const
    {
        return abs((((key+1000000000)%bucket)+1357)%bucket);   //留余数法
    }
    int find(const int &x) const
    {
        int i = hash(x);
        BSTNode *p = ht_bstree[i].search(x);
        if(p)
            return p->count;
        return 0;
    }
    void insert(const int x)
    {
        int i = hash(x);
        BSTNode *p = ht_bstree[i].search(x);
        if(p)
            p->count++;
        else
            ht_bstree[i].insert(x);
    }
};
int a[4001], b[4001], c[4001], d[4001];
int ab[4000*4000+1], cd[4000*4000+1];   //存储a+b，c+d
int main()
{
    linkedHash ht(5000);    //多次调整括号内数值，超时或者内存超限
    int line, k=0;
    cin >> line;
    for(int i = 0; i < line; ++i)
    {
        cin >> a[i] >> b[i] >> c[i] >> d[i];
    }
    for(int i = 0; i < line; ++i)
    {
        for(int j = 0; j < line; ++j)
        {
            ab[k] = a[i]+b[j];
            ht.insert(ab[k]);
            cd[k++] = -(c[i]+d[j]);
        }
    }
    int result = 0;
    for(int i = 0; i < k; ++i)
    {
        result += ht.find(cd[i]);
    }
    cout << result << endl;
    return 0;
}

2.6 AC代码（哈希+数组法）

在这里插入图片描述

/**
 * @description: poj 2785 哈希法，数组实现
 * @author: michael ming
 * @date: 2019/5/20 18:17
 * @modified by: 
 */
#include <iostream>
using namespace std;
int a[4001], b[4001], c[4001], d[4001];
const int hashtablesize = 20000001;//保证一定的富裕，装载因子0.75左右
int hasht[hashtablesize];
int count[hashtablesize];
int offset = 1000000000; // 该数 > 2^29（加上他后，就没有负数了，求模后比较方便使用下标值）
int hashfunc(int value)
{
    return value%hashtablesize;
}
int hashfunc_other(int value)
{
    return (value+3)%hashtablesize;
}
void insert(int num)
{
    int num_init = num;
    num = hashfunc(num+offset);
    while(hasht[num] != offset && hasht[num] != num_init)
    //解决冲突，不等于初始值（够不着的大数）（值改了，位子被占了），且不等于映射的值（冲突了），第一次进入循环，第一个条件肯定不满足。
    {
        num = hashfunc_other(num);//冲突了，继续寻找别的下标（换一个函数,不然相同的模在这可能无限循环）
    }
    hasht[num] = num_init;
    count[num]++;
}
int find(int num)
{
    int num_init = num;
    num = hashfunc(num+offset);
    while(hasht[num] != offset && hasht[num] != num_init)
        num = hashfunc_other(num);    //往下查找空位或者相等的值得位子
    if(hasht[num] == offset)    //找到的是空位子，则没有匹配的和等于0
        return 0;
    else    //找到了值相等的位子，把其对应的count位子里的个数返回
        return count[num];
}
int main()
{
    int line, k=0, value, i, j;
    cin >> line;
    for(i = 0; i < line; ++i)
    {
        cin >> a[i] >> b[i] >> c[i] >> d[i];
    }
    for(i = 0; i < hashtablesize; ++i)
        hasht[i] = offset;  //hash表每个元素初始化为offset
    for(i = 0; i < line; ++i)
    {
        for(j = 0; j < line; ++j)
        {
            value = a[i]+b[j];
            insert(value);
        }
    }
    int result = 0;
    for(i = 0; i < line; ++i)
    {
        for(j = 0; j < line; ++j)
        {
            value = (-c[i]-d[j]);
            result += find(value);
        }
    }
    cout << result << endl;
    return 0;
}
Michael阿明
关注
专栏目录
POJ2785 和为0的组合数（数的哈希）
Shuyu Fang
12-01 1044
给定4个组合A，B，C，D，这四个组合里面的元素数目相等。要求找出所有的序列（a, b, c, d），四个数分别来自A，B，C，D四个组合，使得a + b + c + d = 0，输出这样的序列的总数。若两个满足条件的序列是完全相同的，它们也算是不同的序列，因为A，B，C，D中可能含有相同的元素。 解题思路很简单，取所有的(a, b)序列进行哈希，以a+b作为键，分别映射到非负数和负数两个哈希表
POJ2785 （折半枚举）
Since_natural_ran
12-28 1071
题意： 给出四组数字，各拿出一个相加之和为0，求出有几种方法。 思路： 相对来说还是很好想通，问题数据很复杂， 为了快速的查找，肯定要用优化， 关键是如何与查找联系，这里给出折半的方法，把问题分成两半解决，先枚举 出一半的情况，再二分查找。 不过还是要说明一下STL中的两个函数 函数upper_bound()返回的在前闭后开区间查找的关键字的上界，如一个数组number
poj2785
weixin_30298497的博客
07-14 228
1．链接地址 https://vjudge.net/problem/POJ-2785 2．问题描述 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 ...
POJ 2785 4 Values whose Sum is 0
源代码
03-21 634
题目大意： 开放地址Hash： 注释代码： 无注释代码： 二分搜索： 注释代码： 无注释代码： 单词解释：
poj 2785 求4个数相加和为0 的个数 hash 或者二分
hnust_xiehonghao的专栏
07-15 3002
4 Values whose Sum is 0 Time Limit: 15000MS   Memory Limit: 228000K Total Submissions: 12654   Accepted: 3559 Case Time Limit: 5000MS Description The SUM problem can b
POJ 2785: four values sum is zero
a130737的专栏
03-08 890
问题描述： 给定四个长度为n的数组A， B， C， D。 要求从每个数组中取一个数， 这样得到四个数， 并且这四个数的之和为0. 求这样组合的个数。 限制条件： 1 例如， 输入： 6 -45 -41 -36 -36 26 -32 22 -27 53 30 -38 -54 42 56 -37 -75 -10 -6 -16 30 77 -46 62 45格式是：  数组大小        
poj 2785 测试数据
03-01
poj 2785 4 Values whose Sum is 0 测试数据 解题报告: http://blog.csdn.net/qq7366020/article/details/8623208
poj模拟题(二分查找)
07-22
二分查找是一种高效的查找算法，其基本思想是将待查区间分成两个子区间，根据目标值与区间中间值的大小关系来决定继续查找左子区间还是右子区间，从而逐步缩小查找范围，直到找到目标值或者区间无法继续分割为止。二...
poj算法题目实现.zip_algorithm_arrangement4hv_conditionyis_poj problems
09-15
通过建立一个二维数组来表示问题的约束，然后使用回溯法逐步构造解。 4. poj1201 "Sieve"（筛法） 题目要求计算一定范围内的素数。这可以通过埃拉托斯特尼筛法（Sieve of Eratosthenes）高效地解决，先将所有数字...
POJ3277.rar_3277 poj_poj3277_多个面积_线段树
09-24
标题中的“POJ3277.rar_3277 poj_poj3277_多个面积_线段树”是指一个与编程竞赛相关的压缩文件，特别提到了POJ（Problemset Online Judge）的第3277号问题。POJ是一个著名的在线编程竞赛平台，参与者需要解决各种...
POJ2785——4 Values whose Sum is 0（二分查找的应用）
Asher
05-17 254
题目来源：http://poj.org/problem?id=2785 题目大意：给定长度相等的四列数，要求从每列中选择一个数，求出4个数加和为0的所有组合。 解题思路：如果选用暴力的方法，时间复杂度为O(n^4)，最终肯定会超时。为了降低时间复杂度可以选用二分法，先将前两列数的所有组合结果求出存放在一个数组中，再进行排序，然后利用二分查找去有序的数组中查找后两列组合结果的相反数。该方法的时间...
POJ - 2785 4 Values whose Sum is 0（折半枚举+二分）
辞树
04-14 251
题目大意：给出一个整数n，接下来有n组数，每组数包含四个数 a、b、c、d求有多少中组合方式使得 a+b+c+d = 0 题目数据范围 n <= 4000，强行枚举的话，一共有4000^4种方式。这是必不可行的。 我们来引入一下折半枚举的思想： 当枚举的集合过大导致无法简单实现，同时刚好只需要他们的和或其他可以处理出的东西，就可以一半一半的枚举搜索。 在本题当中： a +...
POJ2785——4 Values whose Sum is 0
piaocoder
05-08 477
题目链接：http://poj.org/problem?id=2785 4 Values whose Sum is 0 题目大意：给你n行4列数，让你在每一列中取一个数，然后相加，问有多少种组合（相加之和为0）？ 解题思路：虽然给了15秒，但是直接暴力还是会超时的。接下来讲讲我的做法：首先将前两列任意两项相加得到数组x，再将后两列任意两项相加取反得到数组y，再将y排序，最后依次将x中的元
POJ 2785（4 Values whose Sum is 0）
weixin_30657999的博客
08-05 86
【题意描述】 对于给定的四个序列，从每个序列中选出一个数，并让四个数相加，输出所有相加和为0的情况数目。 【解题思路】 我们可以考虑前两列的数字相加之和一定与后两列相加和互为相反数，那么我们可以枚举出前两列数字之和，并且，枚举出后两列数据之和的相反数，并对之排序，然后利用二分法进行查找即可。 【AC代码】 #include<iostream> #include<a...
POJ 2785:4 Values whose Sum is 0
BootStar
04-25 626
http://poj.org/problem?id=2785 这道题目意思很简单，但是数据量很庞大，就需要设计比较好的算法。 方法一：利用二分搜索算法。根据题意，我们将数据分为左右两个部分，然后将左侧的两列之和加起来，然后排序，在对右侧的两列加起来，二分搜索相应的解的上下限。这里需要注意对一个数出现的上下界的寻找办法，代码要注意，也可以通过STL中的lower_bound与upperbound
[折半枚举] poj 2785 4 Values whose Sum is 0
童凌的技术博客
08-03 529
Values whose Sum is 0 Time Limit: 15000MS Memory Limit: 228000K Total Submissions: 17715 Accepted: 5209 Case Time Limit: 5000MS DescriptionThe SUM problem can be formulated as follows: g
POJ2785-4 Values whose Sum is 0
Collider
08-10 237
如题，有四个数组，分别从四个数组中挑选一个数字使得四个数字之和为0，问有多少种这样的组合。 四个数组总共有n^4种情况，但是如果使用用折半枚举的方法，只需枚举出数组A与数组B中n^2中情况，将这些情况排序后就可以用二分搜索将算法的复杂度降低到n^2logn.#include <cstdio> #include <algorithm>using namespace std;const int max
POJ2785 -- 4 Values whose Sum is 0（折半枚举）
qq_38230420的博客
08-03 243
问题描述: 给定4个数组ABCD从每个数组中选出1个数abcd,使得a+b+c+d=0 每个数组中相同的数组看做不同的情况，因此本题不需要进行剪枝。 思路:如果对每个数组的数字进行枚举，那么时间复杂度为n^4，但虽然本题的时长可以为15000ms，也会导致超时。 但如果折半来看，枚举2个数组的复杂度为n^2，剩下的2个数组使用二分法来进行计算 那么时间复杂度就为n^2logn 就可以接
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Michael阿明

如果可以，请点赞留言支持我哦！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值