[Leetcode 13] 1 Two Sum

Problem:

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:

Naive iterating through the whole array will not work due to time limit. To solve n-sum problem, we need to sort the array and use two pointers start from head and tail to try the possible combination. But the problem here requires the original-index of the two elements. What we can do is using another aux array that has a copy of the original array. Then if two elements' sum equals the target, we use search algorithm in the aux to get the original index. Note that there's may be multiple same valued elements, after we get first element, we set this value to MIN_VALUE to avoid repeat. The element repeating also forbids us to use the hash method to solve ths problem -- which is more efficient. For the convenience of implementing, we use ArrayList here to serve as the aux array.

 

Code:

public class Solution {
    public int[] twoSum(int[] numbers, int target) {
        // Start typing your Java solution below
        // DO NOT write main() function
        int[] res = new int[2];
        ArrayList<Integer> aux = new ArrayList<Integer>(numbers.length);
        
        for (int i=0; i<numbers.length; i++)
            aux.add(numbers[i]);
            
        Arrays.sort(numbers);
        int i=0, j=numbers.length-1;
        while ( i < j ) {
            int sum = numbers[i] + numbers[j];
            
            if (sum == target) {
                int idx1 = aux.indexOf(numbers[i]);
                aux.set(idx1, Integer.MIN_VALUE);
                int idx2 = aux.indexOf(numbers[j]);
            
                if (idx1 < idx2) {
                    res[0] = idx1+1;
                    res[1] = idx2+1;
                } else {
                    res[0] = idx2+1;
                    res[1] = idx1+1;
                }
                
                break;
            } else if (sum > target) {
                j--;
            } else {
                i++;
            }
        }
        
        return res;
    }
}

 

Attention:

The start-end search method for 2-sum requires sort the array and thus change the corresponding relationship between element and index.

HashMap<Elem, Index> won't work here due to the redudant value.