[leetcode]Two Sum

本来以为是一道水题，结果居然能从n^2, n*log(n)一直优化到n。感慨啊~

O(n^2): 暴力

public class Solution {
public int[] twoSum(int[] numbers, int target) {
// Start typing your Java solution below
// DO NOT write main() function
int[] r = new int[2];
for (int i = 0; i < numbers.length; i++)
{
for (int j = i+1; j < numbers.length; j++)
{
if (numbers[i] + numbers[j] == target)
{
r[0] = i+1;
r[1] = j+1;
break;
}
}
}
return r;
}
}

O(n*log(n)): 排序。用了O(n)的空间记录原来的数组，然后开始和最后O(n)的扫一遍，不过不改变总体复杂度。当然有的人用数据结构记录原来的和后来的联系，那也就是另外O(n)的空间省最后扫一遍而已。解题过程中一开始忘了记录原来的数组，后来忘了排序后的第一第二和排序后的也可能不同。

import java.util.Arrays;

public class Solution {
public int[] twoSum(int[] numbers, int target) {
// Start typing your Java solution below
// DO NOT write main() function
int[] result = new int[2];
int[] tmp = new int[numbers.length];
for (int i = 0; i < numbers.length; i++)
{
tmp[i] = numbers[i];
}
Arrays.sort(tmp);
int l = 0;
int r = tmp.length - 1;
int sum = tmp[l] + tmp[r];
while( sum != target && r > l)
{
if (sum > target)
{
r--;
}
else
{
l++;
}
sum = tmp[l] + tmp[r];
}
int index = 0;
for (int i = 0; i < numbers.length; i++)
{
if (tmp[l] == numbers[i] || tmp[r] == numbers[i])
{
result[index] = i + 1;
index++;
if (index > 1) break;
}
}

return result;
}
}

　O(n): 果然无耻的用了Hash，那么也就不神奇了。所以真实的复杂度考虑到Hash的实现，会比O(n)要大些。

import java.util.HashMap;

public class Solution {
public int[] twoSum(int[] numbers, int target) {
// Start typing your Java solution below
// DO NOT write main() function
int[] result = new int[2];
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int i = 0; i < numbers.length; i++)
{
if (map.containsKey(target - numbers[i]))
{
result[0] = map.get(target-numbers[i]) + 1;
result[1] = i + 1;
break;
}
else
{
map.put(numbers[i], i);
}
}

return result;
}
}