问题
I am supposed to create a O(n log(n)) algorithm that checks if sum of 2 numbers in a int[] == given number.
eg. Given [1,4,7,2,3,4] there will be a sum 8 (1+7) but not 20
The given answer suggested Binary Sort or Merge Sort, but they just gave the merge sort algorithm without the logic processing this particular requirement. Then another answer was:
Suppose x is the sum we want to check, z is the set of elements in this array: The following algorithm solves the problem:
- Sort the elements in S.
- Form the set S’ = {z : z = x − y for some y ∈ S}.
- Sort the elements in S'.
- If any value in S appears more than once, remove all but one instance. Do the same for S’.
- Merge the two sorted sets S and S’.
- There exist two elements in S whose sum is exactly x if and only if the same value appears in consecutive positions in the merged output.
To justify the claim in step 4, first observe that if any value appears twice in the merged output, it must appear in consecutive positions. Thus, we can restate the condition in step 5 as there exist two elements in S whose sum is exactly x if and only if the same value appears twice in the merged output. Suppose that some value w appears twice. Then w appeared once in S and once in S’. Because w appeared in S’, there exists some y ∈ S such that w = x − y, or x = w + y. Since w ∈ S, the elements w and y are in S and sum to x.
Conversely, suppose that there are values w, y ∈ S such that w + y = x. Then, since x − y = w, the value w appears in S’. Thus, w is in both S and S’, and so it will appear twice in the merged output.
Steps 1 and 3 require O(n log n) steps. Steps 2, 4, 5, and 6 require O(n) steps. Thus the overall running time is O(n log n).
But I don't really what they meant. In step 2, what are x and y?
But I created by own below, I wonder if its O(n log(n))?
class FindSum {
public static void main(String[] args) {
int[] arr = {6,1,2,3,7,12,10,10};
int targetSum = 20;
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
int end = arr.length - 1;
if (FindSum.binarySearchSum(arr, targetSum, 0, end, 0, end)) {
System.out.println("Found!");
} else {
System.out.println("Not Found :(");
}
}
public static boolean binarySearchSum(int[] arr, int targetSum,
int from1, int end1,
int from2, int end2) {
// idea is to use 2 "pointers" (simulating 2 arrays) to (binary) search
// for target sum
int curr1 = from1 + (end1-from1)/2;
int curr2 = from2 + (end2-from2)/2;
System.out.print(String.format("Looking between %d to %d, %d to %d: %d, %d", from1, end1, from2, end2, curr1, curr2));
int currSum = arr[curr1] + arr[curr2];
System.out.println(". Sum = " + currSum);
if (currSum == targetSum) {
// base case
return true;
} else if (currSum > targetSum) {
// currSum more than targetSum
if (from2 != end2) {
// search in lower half of 2nd "array"
return FindSum.binarySearchSum(arr, targetSum, from1, end1, from2, curr2 - 1);
} else if (from1 != end2) {
// search in lower half of 1st "array" (resetting the start2, end2 args)
return FindSum.binarySearchSum(arr, targetSum, from1, curr1 - 1, 0, arr.length - 1);
} else {
// can't find
return false;
}
} else {
// currSum < targetSum
if (from2 != end2) {
// search in upper half of 2nd "array"
return FindSum.binarySearchSum(arr, targetSum, from1, end1, curr2 + 1, end2);
} else if (from1 != end2) {
// search in upper half of 1st "array" (resetting the start2, end2 args)
return FindSum.binarySearchSum(arr, targetSum, curr1 + 1, end1, 0, arr.length - 1);
} else {
// can't find
return false;
}
}
}
}
回答1:
Similar to @user384706, however you can do this with in O(n).
What they say is the following: S=[1,4,7,2,3,4]
Add these to a HashSet, ideally TIntHashSet (but the time complexity is the same)
int total = 9;
Integer[] S = {1, 4, 7, 2, 3, 4, 6};
Set<Integer> set = new HashSet<Integer>(Arrays.asList(S));
for (int i : set)
if (set.contains(total - i))
System.out.println(i + " + " + (total - i) + " = " + total);
prints
2 + 7 = 9
3 + 6 = 9
6 + 3 = 9
7 + 2 = 9
回答2:
What they say is the following:S=[1,4,7,2,3,4]
Sort S using mergesort you get Ss=[1,2,3,4,7]. Cost is O(nlogn) - just check wiki for this.
Then you have x=8
So you form S'=[7,6,5,4,1] by subtracting x with the elements in S.
Sort S' using mergesort in O(nlogn)
Remove duplicates requires O(n).
Then you merge the Ss and S'.
You check for duplicates in consecutive positions in O(n).
Total is:O(nlogn)+O(nlogn)+O(n)+O(n)+O(n) = O(nlogn)
回答3:
What about an O(n) solution?
It's not clear from your question if you're supposed to use what you described as "another answer" [sic] or if you can come up with your own solution.
The first thing you should ask is "what are the requirements?" Because there are limitations. What's the maximum number of integers you'll receive? Two millions? Ten millions? What's the range of these integers? In your question they always seem greater than zero. What's the maximum value these integers can have? How much memory can you use?
Because there are always tradeoffs.
For example here's a non-optimized (see below) O(n) solution to your problem (I added an '8' to your input):
@Test
public void testIt() {
final int max = 10000000;
final int[] S = new int[max+1];
final int[] in = { 1, 4, 3, 2, 4, 7, 8 };
for ( final int i : in ) {
S[i]++;
}
assertFalse( containsSum(S, 1) );
assertFalse( containsSum(S, 2) );
assertTrue( containsSum(S, 3) );
assertTrue( containsSum(S, 4) );
assertTrue( containsSum(S, 5) );
assertTrue( containsSum(S, 6) );
assertTrue( containsSum(S, 7) );
assertTrue( containsSum(S, 8) );
assertTrue( containsSum(S, 9) );
assertTrue( containsSum(S, 10) );
assertTrue( containsSum(S, 11) );
assertFalse( containsSum(S, 13) );
assertFalse( containsSum(S, 14) );
assertTrue( containsSum(S, 12) );
assertTrue( containsSum(S, 15) );
assertFalse( containsSum(S, 16) );
}
private static boolean containsSum( final int[] ar, final int sum ) {
boolean found = false;
for (int i = 1; i < sum && !found; i++) {
final int b = sum - i;
found = i == b ? ar[i] > 1 : ar[i] > 0 && ar[b] > 0;
}
return found;
}
It's non optimized in that it's easy to write an O(n) working for integers from 0 to 2**31 using "only" 1 GB of memory (where you'd represent your S and your S' using bits instead of ints like I did here).
Sure, one may think "but 1GB is a lot of memory": but it all depends on the requirements. My solution above (or an optimized version of it) is O(n) and can solve an input made of, say, 100 millions integers in no time, where any other solution would fail (because you'd have OutOfMemory errors due to the overhead of Java objects).
The first thing to ask is "What are the requirements?". You need more information about the input because it's always a tradeoff.
回答4:
Your algorithm is O(n log n). Each time you either divide 1st array size by two or do a binary search on the second one. This is O((log n) ^2) worst case (ie. S = {1,2...,n} and x = 0) and hence it's absorbed by sorting.
Anyway you can do it a bit easier in O(n log n) by:
- sorting the array (O(n log n))
- iterating it's elements (O(n)) while in each iteration binary searching (O(log n)) for X-complement of the current element.
edit: In response to your first question. x is the sum you're looking for and y are the elements of the input set. So if S= {y_1, y_2, y_3,..., y_n} then S' = {x - y_1, x - y_2, x - y_3, ...x - y_n}
回答5:
It works as following :
- Sort the Input array
- create two variables front=0 [start point] rear=length of array [end point].
- It starts from both end of array calculate sum of it if it zero increment both front and rear
- if not increment the side which contains greater element.[since Array is sorted there is not chance to find element such that their sum is 0]
- stop when front >=rear.
public class TwoSumFaster {
private static int countTwoSum(int[] numbers) {
int count = 0;
int front = 0, rear = numbers.length - 1;
while (front < rear) {
if (numbers[front] + numbers[rear] == 0) {
front++;
rear--;
count++;
} else {
if (Math.abs(numbers[front]) > Math.abs(numbers[rear])) {
front++;
} else {
rear--;
}
}
}
return count;
}
public static void main(String[] args) {
int[] numbers = { 1, 3, 5, 7, 12, 16, 19, 15, 11, 8, -1, -3, -7, -8, -11, -17, -15 };
Arrays.sort(numbers);
System.out.println(countTwoSum(numbers));
}
}
来源：https://stackoverflow.com/questions/8119911/on-logn-algorithm-that-checks-if-sum-of-2-numbers-in-a-int-given-number