您的位置：首页 > 其它

Two Sum

2014-01-03 05:37 323 查看
Given an array of integers, find two numbers such that they add up to a specific target number.

The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.

You may assume that each input would have exactly one solution.

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

Analysis: 

See: http://yucoding.blogspot.com/2013/03/leetcode-question-113-two-sum.html

What happens when a duplicate key is put into a HashMap? 

You may find your answer in the javadoc of Map#put(K,
V)  (which actually returns something):

public V put(K key,
V value)


Associates the specified value with the specified key in this map (optional operation). If the map previously contained a mapping for this key, the old value is replaced by the specified value. (A map 
m
 is
said to contain a mapping for a key 
k
 if
and only if 
m.containsKey(k)
  would
return 
true
.)

Parameters:
key
 -
key with which the specified value is to be associated.
value
 -
value to be associated with the specified key.

Returns:

previous value associated with specified key, or 
null
 if
there was no mapping for 
key
.
(A 
null
 return
can also indicate that the map previously associated 
null
 with
the specified 
key
,
if the implementation supports 
null
 values.)

So if you don't assign the returned value when calling 
mymap.put("1",
"a string")
, it just becomes unreferenced and thus eligible for garbage collection.
http://stackoverflow.com/questions/1669885/what-happens-when-a-duplicate-key-is-put-into-a-hashmap

Code: 

public class Solution {
public int[] twoSum(int[] numbers, int target) {
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
int first=0, second=0;
int[] res = new int[2];

b217

for(int i=0; i<=numbers.length-1; i++) {
map.put(numbers[i], i);
}

for(int j=0; j<=numbers.length-1; j++) {
if(map.containsKey(target-numbers[j]) && map.get(target-numbers[j])!=j) {   // still correct if duplicates exist !!!
if(map.get(target-numbers[j]) > j) {
res[0] = j + 1;
res[1] = map.get(target-numbers[j]) + 1;
}
else {
res[0] = map.get(target-numbers[j]) + 1;
res[1] = j + 1;
}
break;
}
}

return res;
}
}


Update: 30/01/2014

Use two pointers. However, as for this problem, since the indexes need to be returned, the first approach is much better. 

public class Solution {
public int[] twoSum(int[] numbers, int target) {
int[] original = Arrays.copyOf(numbers, numbers.length);
Arrays.sort(numbers);
int low=0, high=numbers.length-1;
int[] res = new int[2];
while(low < high) {
if(numbers[low]+numbers[high]<target) low++;
else if(numbers[low]+numbers[high]>target) high--;
else if(numbers[low]+numbers[high]==target) {
boolean first = false;
for(int i=0; i<original.length; i++) {
if(!first && original[i]==numbers[low]) {
res[0] = i+1;
first = true;
}
if(original[i]==numbers[high]) res[1]=i+1;
}
Arrays.sort(res);
break;
}
}
return res;
}
}


Update 02/08/2014: 

public class Solution {
public int[] twoSum(int[] numbers, int target) {
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
int[] res = new int[2];

for(int i=0; i<=numbers.length-1; i++) {
if(map.containsKey(target-numbers[i])) {    // find the pair
res[0] = map.get(target-numbers[i]);
res[1] = i+1;   // the current index must be the larger one
break;
}
else map.put(numbers[i], i+1);  // does not match, just store the number and index
}
return res;
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航