Introduction

This is the second part of a three-part series on *Algorithm Templates: Two Pointers*. In the first part, we delved into the first two types of the two pointers technique. Check it out if you missed it.

In this guide (Part 2), we will focus on another two common usages:

- Left and right boundary
- Pointer-1 and pointer-2 from two sequences

For each type, we will learn about it through two steps:

- Describing the concept by algorithm template and flow chart
- Providing typical examples to help you understand application scenarios and how to use it

Another common usage is putting pointers on the left-most side and right-most side. One pointer starts from the beginning, while the other pointer starts from the end. They move toward each other until they meet in the middle.

```
1# left & right boundary: left-> <-right
2def left_right_boundary(self, seq):
3 left, right = 0, len(seq) - 1
4 while left < right:
5 # left index moves when satisfy the condition
6 if self.left_condition(left):
7 left += 1
8 # right index move when satisfy the condition
9 if self.right_condition(right):
10 right -= 1
11 # process logic before or after pointers movement
12 self.process_logic(left, right)
```

Python

To better understand the theory of left and right boundary, you can refer to the following example chart.

In general, the algorithm can be used in two ways based on this technology:

- Left and right pointers form an interval to process.
- These two pointers carry information and handle the logic in each iteration.

The most classic and famous example is binary search. We find the target by shrinking the lower and upper bounds continuously. We cut off the half of the interval in each iteration. The following example is a version with both lower and upper bounds included.

```
1# [lo, hi] version, modify to [lo, hi) version as you need
2def binary_search(arr, target):
3 lo, hi = 0, len(arr) - 1
4 while lo <= hi:
5 mid = (lo + hi) // 2
6 # find the target, change to your comparison condition as you need
7 if arr[mid] == target:
8 break
9 elif arr[mid] < target:
10 lo = mid + 1
11 else:
12 hi = mid - 1
```

python

Let's take a look at a practical example with two pointers and binary search technique.

Given an array of integers that is already sorted in ascending order, find two numbers such that they add up to a specific target number.

```
1# [167] https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/
2def twoSum(numbers: 'List[int]', target: 'int') -> 'List[int]':
3 left, right = 0, len(numbers) - 1
4 while left < right:
5 if numbers[left] + numbers[right] == target:
6 return [left + 1, right + 1]
7 if numbers[left] + numbers[right] < target:
8 left += 1
9 else:
10 right -= 1
11 return [0, 0]
```

python

Let's make it a little more difficult. Upgrade the two-sum problem to four-sum.

Find all unique quadruplets in the array which gives the sum of target.

**Idea**: With the help of the above example, the solution is very clear. We can use the left and right boundary to find the solution space. We can divide the four-sum problem to three-sum, and finally to two-sum.

```
1# [18] https://leetcode.com/problems/4sum/
2def fourSum(nums: 'List[int]', target: int) -> 'List[int]':
3 result, n = [], len(nums)
4 if n < 4: return result
5 nums = sorted(nums)
6 if sum(nums[-4:]) < target:
7 return result
8
9 for i in range(n - 3):
10 # boundary checker, stop early
11 if sum(nums[i:i + 4]) > target:
12 break
13 # right boundary checker
14 if nums[i] + sum(nums[-3:]) < target:
15 continue
16 # skip same element, but keep the first one
17 if i > 0 and nums[i] == nums[i - 1]:
18 continue
19 # simplify the problem to three sum
20 target2 = target - nums[i]
21 for j in range(i + 1, n - 2):
22 if sum(nums[j:j + 3]) > target2 or sum(nums[-3:]) < target2:
23 break
24 if nums[j] + sum(nums[-2:]) < target2:
25 continue
26 if j > i + 1 and nums[j] == nums[j - 1]:
27 continue
28 # simplify the problem to two sum
29 target3 = target2 - nums[j]
30 left = j + 1
31 right = n - 1
32 while left < right:
33 if nums[left] + nums[right] == target3:
34 result.append([nums[i], nums[j], nums[left], nums[right]])
35 while left < right and nums[left] == nums[left + 1]:
36 left += 1
37 while left < right and nums[right] == nums[right - 1]:
38 right -= 1
39 left += 1
40 right -= 1
41 elif nums[left] + nums[right] < target3:
42 left += 1
43 else:
44 right -= 1
45 return result
```

python

Here is an example in which we focus on the interval.

Find two lines, which together with x-axis form a container, such that the container contains the most water possible.

**Idea**: To help you understand, I've drawn an example diagram. We calculate the water area by the interval formed by the current left and right bounds.

```
1# [11] https://leetcode.com/problems/container-with-most-water/
2def maxArea(height: 'List[int]') -> int:
3 left, right = 0, len(height) - 1
4 area_max = (right - left) * min(height[left], height[right])
5
6 while left < right:
7 # judge which side decide the area (shorter height)
8 if height[left] <= height[right]:
9 last_height = height[left]
10 # skip all the height less than current
11 while height[left] <= last_height and left < right:
12 left += 1
13 else:
14 last_height = height[right]
15 # skip all the height less than current
16 while height[right] <= last_height and left < right:
17 right -= 1
18
19 if left >= right:
20 return area_max
21 area_max = max(area_max, (right - left) * min(height[left], height[right]))
22 return area_max
```

python

In some other scenarios, we need to compare in two sequences. Each pointer represents the current logical position in the corresponding sequence.

```
1# p1 & p2 from two sequences: p1-> p2->
2def pointers_from_two_seq(self, seq1, seq2):
3 # init pointers
4 p1, p2 = 0, 0 # or seq1[0], seq2[0]
5 # or other condition
6 while p1 < len(seq1) and p2 < len(seq2):
7 # p1 index moves when satisfy the condition
8 if self.p1_condition(p1):
9 p1 += 1 # or p1 = next(seq1)
10 # p2 index move when satisfy the condition
11 if self.p2_condition(p2):
12 p2 += 1 # or p2 = next(seq2)
13 # process logic before or after pointers movement
14 self.process_logic(p1, p2)
```

python

From the following example diagram, we can see that these two pointers are relatively independent. How they move forward is determined by their own strategies.

Let's look at an example with multiple sequences.

Design a class which receives a list of

`words`

in the constructor and implements a method that takes two words,`word1`

and`word2`

, and returns the shortest distance between these two words in the list.

**Idea**: First, we create a group of index sequences, `locations`

, for each word. Every time `shortest`

function is called, we pick up the corresponding sequences `loc1`

and `loc2`

. Then we use two pointers, `l1`

and `l2`

, to calculate the shortest distance. In each iteration, the smaller pointer moves one step forward.

```
1# [244] https://leetcode.com/problems/shortest-word-distance-ii/
2class WordDistance:
3 def __init__(self, words: 'List[str]'):
4 self.locations = defaultdict(list)
5 # Prepare a mapping from a word to all it's locations (indices).
6 for i, w in enumerate(words):
7 self.locations[w].append(i)
8
9 def shortest(self, word1: str, word2: str) -> int:
10 loc1, loc2 = self.locations[word1], self.locations[word2]
11 l1, l2 = 0, 0
12 min_diff = float("inf")
13
14 # Until the shorter of the two lists is processed
15 while l1 < len(loc1) and l2 < len(loc2):
16 min_diff = min(min_diff, abs(loc1[l1] - loc2[l2]))
17 if loc1[l1] < loc2[l2]:
18 l1 += 1
19 else:
20 l2 += 1
21 return min_diff
```

python

Here is another example combined with backtracking.

Given an input string (s) and a pattern (p), implement wildcard pattern matching with support for '?' and '*'.

**Idea**: Assign one pointer `s_cur`

for the target string and another `p_cur`

for the pattern. The two pointers record the current match position. When matching '*', `match`

and `star`

are the flags that help to backtrack if matching failed in greedy.

```
1# [44] https://leetcode.com/problems/wildcard-matching/
2def isMatch(s: str, p: str) -> bool:
3 s_cur, p_cur, match, star = 0, 0, 0, -1
4
5 while s_cur < len(s):
6 # match sucess, both two pointers move forward
7 if p_cur < len(p) and (s[s_cur] == p[p_cur] or p[p_cur] == '?'):
8 s_cur += 1
9 p_cur += 1
10 # if matching star, record current state and try to match in greedy
11 elif p_cur < len(p) and p[p_cur] == '*':
12 match = s_cur
13 star = p_cur
14 p_cur += 1
15 # backtrack if match failed
16 elif star != -1:
17 p_cur = star + 1
18 match += 1
19 s_cur = match
20 else:
21 return False
22 # corner case: remove continuous star in the rest
23 while p_cur < len(p) and p[p_cur] == '*':
24 p_cur += 1
25
26 if p_cur == len(p):
27 return True
28 else:
29 return False
```

python

In this guide, we continued learning about two other types of the two pointers technique through templates and examples: *left and right boundary* and *pointer-1 and pointer-2 from two sequences*.

In the third part, we will continue to learn about other types of two pointers.

To access the complete code, you can download Algorithm Templates from Github. I hope some of them will be useful for you.

This guide is part of a series on the two pointers technique:

I hope you enjoyed it. If you have any questions, you're welcome to contact me at [email protected]