一个"2-SUM"问题

题目要求:

Download the text file here. (Right click and save link as).

The goal of this problem is to implement a variant of the 2-SUM algorithm (covered in the Week 6 lecture on hash table applications).

The file contains 1 million integers, both positive and negative (there might be some repetitions!).This is your array of integers, with the ith row of the file specifying the ith entry of the array.

Your task is to compute the number of target values t in the interval [-10000,10000] (inclusive) such that there are distinct numbers x,y in the input file that satisfy x+y=t. (NOTE: ensuring distinctness requires a one-line addition to the algorithm from lecture.)

Write your numeric answer (an integer between 0 and 20001) in the space provided.

OPTIONAL CHALLENGE: If this problem is too easy for you, try implementing your own hash table for it. For example, you could compare performance under the chaining and open addressing approaches to resolving collisions.

大致意思是说,有一百万个数字(正负都有,且可能重复)。目标是要寻找到唯一存在的数对(x,y),使得x+y属于[-10000, 10000]的范围中,最后输出这些数对的个数。

文件中的数据差不多是这样子的:

...
-92205919974
-65150999169
-96247986144
70191728682
-59670982771
-10202710755
-72167080349
-19221613985
80341418823
-79433686277
87351713416
6084932343
40801752610
44028247959
84203784346
-28120386474
59064431376
39436465566
-89458683408
-64200776240
-42582579303
-62656888535
55650079602
62954175548
33713639217
70259349593
-97472959477
41890148139
44216212976
26864335558
...


解题思路:

起初采用了最暴力的方法,直接把这些数字塞进一个hash table中,然后遍历着去查询(这个方法很不好,所以就不详述了),结果运行了很久都没有跑出结果,遂直接放弃这种方法。

这里的问题在于如下两点:

  1. 数据量多达一百万条;
  2. 大部分数对相加的和,远超要求的范围之外。

因此针对问题的实际情况进行了些许优化,大致思路如下:

  1. 假设X为文件中的一个数字;
  2. 创建一个hash table,它的键为X/10000,值为由对应X组成的set。这样就相当于把输入的数据以10000作为一个范围对其进行划分,最后划分成若干组数据,之所以要将10000作为划分的范围,是因为题目中要求数对的和在[-10000, 10000]的范围中,这样对于我们这里的hash table,给定一个key1,我们就能知道可能有哪些key2对应集合中的数与key1集合中的数相加,是可以在要求的范围中的;
  3. 具体而言,对于一个key1,可取的key2有:{-key1-2, -key1-1, -key1}这三个。注意因为之前的X/10000是整除,其结果为向下取整,如 -14000 / 10000 = -2;
  4. 在已知了key1与key2之后,对其集合中的数进行循环遍历,如果相加的和在题目要求的范围内,那么就将计数器加一。

利用上述思路,可以避免大量的不必要的运算,另外我们还可以对其进行进一步的优化:

  1. 对key1进行遍历的时候,只取key1小于或等于零的值,这样可以进一步减少重复计算;
  2. 创建一个保存结果的set,如果找到了满足要求的数对(x, y),那么就置result[x+y] = True,最后输出result的大小。


代码实现:

有了上述的思路,利用Python对其进行了实现,代码如下:

result = {}
dic = {}
input_file = open("algo1-programming_prob-2sum.txt")

# 读入数据
for line in input_file:
    num = long(line)
    key = num/10000
    if key not in dic:
        dic[key] = {}
    # 这里记录数据出现的次数,用来判断该数是否是唯一的
    if num in dic[key]:
        dic[key][num] += 1
    else:
        dic[key][num] = 1

for key1 in dic:
    # 忽略key1 > 0的情况,减少不必要的重复计算
    if key1 > 0:
        continue
    # 根据给定的key1,可以推测出key2可取的值
    for key2 in range(-key1-2, -key1 + 1):
        if key2 in dic:
            # 对key1和key2对应集合中的数进行遍历
            for value2 in dic[key2]:
                for value1 in dic[key1]:
                    # 判断这两个数是否是唯一的
                    if dic[key1][value1] != 1 or dic[key2][value2] != 1:
                        continue
                    sum_tmp = value1+value2
                    # 判断两数之和是否在题目要求的范围内
                    if abs(sum_tmp) <= 10000 and sum_tmp not in result:
                        result[sum] = True

# 输出结果
print len(result)
input_file.close()

这段代码在我的电脑上运行仅需要大约3-4秒的时间就能跑出结果(包含读取数据的I/O操作的时间),可见该方法有效地避免了大量不必要的计算。

另外,题目中要求找到唯一存在的数对(x, y),但是如果把代码中判断唯一性的那个条件判断去除,得到的结果也是一样的,这也许和给出的数据有关。

时间: 2024-10-07 05:31:25

一个"2-SUM"问题的相关文章

给定一个整数sum, 从有N个有序元素的数组中寻找元素a,b,使得a+b的结果最接近sum

class FindClosestPairExample { public static void findAndPrintClosest(int[] arrayOne, int expectedSum) { int lenOne = arrayOne.length; //数组长度,默认全部填满. int diff = Integer.MAX_VALUE; //定义两数与期望值的差值:默认取最大整数 int resultOne = 0; //第一个元素 int resultTwo = 0; //

HDU 1241 BFS入门。。做了一个晚上,自己总算入门了。

下面上题目. Oil Deposits Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 13340    Accepted Submission(s): 7671 Problem Description The GeoSurvComp geologic survey company is responsible for detectin

hdu 3415 Max Sum of Max-K-sub-sequence(单调队列)

题目链接:hdu 3415 Max Sum of Max-K-sub-sequence 题意: 给你一串形成环的数,让你找一段长度不大于k的子段使得和最大. 题解: 我们先把头和尾拼起来,令前i个数的和为sum[i]. 然后问题变成了求一个max{sum[i]-sum[j]}(i-k<j<i) 意思就是对于每一个sum[i],我们只需要找一个满足条件的最小的sum[j],然后我们就可以用一个单调队列来维护. 1 #include<bits/stdc++.h> 2 #define F

Max Sum

Leetcode上有一个Max Sum问题,题目的描述很简单,即对于一个输入的数组,求其连续子数组的最大和.比如说,A={ 6,-1,5,4,-7},那么其连续子数组的最大和为6 + (-1) +5 + 4 = 14. 分析: 这是很简单的动态规划题,动态规划做多了,第一个想法就是用一个一维数组记录以每个元素为结尾的子序列的最大和,然后再扫描一遍这个数组,以获取最大值.但是仔细分析一下,其实不需要用一个一维数组记录每个位置的最大和,因为没有要求返回具有最大和的子序列.所以使用一个变量记住当前连续

Sum 类型题目总结

Sum类的题目一般这样: input: nums[], target output: satisfied arrays/ lists/ number 拿到题目,首先分析: 1. 是几个数的sum 2. sum是要求等于target还是小于还是大于还是closest 3. 返回的是原数组下标还是其他 对于这类题目,我们经常用双指针的方法.即排序后,左指针指向起点,右指针指向终点. 如果sum等于target,加入结果/总数目+1 如果sum大于target,右指针左移 如果sum小于target,

数字和为sum的方法数

[编程题] 数字和为sum的方法数 给定一个有n个正整数的数组A和一个整数sum,求选择数组A中部分数字和为sum的方案数. 当两种选取方案有一个数字的下标不一样,我们就认为是不同的组成方案. 输入描述: 输入为两行: 第一行为两个正整数n(1 ≤ n ≤ 1000),sum(1 ≤ sum ≤ 1000) 第二行为n个正整数A[i](32位整数),以空格隔开. 输出描述: 输出所求的方案数 输入例子: 5 15 5 5 10 2 3 输出例子: 4方法思想:动态规划思想代码: import j

LeetCode OJ 209. Minimum Size Subarray Sum

Given an array of n positive integers and a positive integer s, find the minimal length of a subarray of which the sum ≥ s. If there isn't one, return 0 instead. For example, given the array [2,3,1,2,4,3] and s = 7,the subarray [4,3] has the minimal

Binary Tree Path Sum

Question:  Given a binary tree, find all paths that sum of the nodes in the path equals to a given number target. A valid path is from root node to any of the leaf nodes. Example: Given a binary tree, and target = 5: 1 / 2 4 / 2 3 return [ [1, 2, 2],

求和函数 sum详解

sum()的参数是一个list: >>> sum([1,2,3]) 6 >>> sum(range(1,3)) 3 还有一个比较有意思的用法 a = range(1,11) b = range(1,10) c =  sum([item for item in a if item in b]) print c 输出: 45

LeetCode—**Combination Sum 利用DFS算法

Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T. The same repeated number may be chosen from C unlimited number of times. Note: All numbers (including target) will