# 3Sum

The 3SUM problem is a classic algorithmic problem in the field of computer science and computational complexity theory. It asks whether, given a set of $n$ real numbers, there exists a triplet in this set that sums up to zero. More formally, given an array of numbers, does there exist indices $i$, $j$, and $k$ such that $i \neq j$, $i \neq k$, $j \neq k$, and $A[i] + A[j] + A[k] = 0$?

Understanding the 3SUM problem requires an understanding of algorithmic complexity and the concept of brute-force versus optimized solutions. Let's break down the problem and its common solutions:

### Brute-Force Solution:

1. Idea: Check every possible triplet in the array to see if their sum is zero.
2. Implementation: Use three nested loops. The outer loop picks the first element, the middle loop picks the second, and the innermost loop picks the third. For each combination, check if the sum is zero.
3. Complexity: This approach has a time complexity of $O(n^3)$ since we have three nested loops, each going through $n$ elements.

### Optimized Solution:

1. Idea: Reduce the time complexity by sorting the array first and then using a combination of iteration and two-pointer technique.
2. Implementation:
• Step 1: Sort the array. This takes $O(n \log n)$ time.
• Step 2: Iterate through the array. For each element $A[i]$, use two pointers to find if there is a pair in the remaining part of the array whose sum is $-A[i]$ (because $A[i] + A[j] + A[k] = 0$ implies $A[j] + A[k] = -A[i]$ ).
• Step 3: The two pointers start at the elements immediately after $A[i]$ and at the end of the array, moving towards each other until they meet. If their sum is too large, move the end pointer leftward. If their sum is too small, move the start pointer rightward.
3. Complexity: The sorting step is $O(n \log n)$, and the two-pointer iteration is $O(n^2)$ (since for each element, we potentially traverse the rest of the array). Thus, the overall time complexity is dominated by the $O(n^2)$ term.

### Key Points:

• Brute-Force vs. Optimized: The brute-force method is straightforward but inefficient for large $n$. The optimized method significantly reduces the time complexity.
• Applicability: 3SUM is a foundational problem that has implications in various fields like computational geometry and number theory.
• Variants: The problem has many variants, like 3SUM-closest (find a triplet whose sum is closest to a given number) or 2SUM (a simpler version where we find a pair that sums up to a given number).

This explanation is grounded in basic principles of computational complexity and algorithm design. It highlights the transition from a brute-force approach to a more nuanced and efficient algorithm, demonstrating a fundamental approach in computer science to optimize problem-solving strategies.