Container With Most Water in DSA C - Execution Trace

Concept Flow - Container With Most Water

Start with two pointers

↓

Calculate area between pointers

↓

Update max area if larger

↓

Move pointer at smaller height inward

↓

Pointers meet?

No→Repeat calculation

Yes↓

Return max area

We use two pointers at the ends, calculate area, move the smaller pointer inward, and repeat until pointers meet.

Execution Sample

DSA C

int maxArea(int* height, int heightSize) {
    int left = 0, right = heightSize - 1;
    int max_area = 0;
    while (left < right) {
        int area = (right - left) * (height[left] < height[right] ? height[left] : height[right]);
        if (area > max_area) max_area = area;
        if (height[left] < height[right]) left++; else right--;
    }
    return max_area;
}

Calculates the maximum water container area by moving two pointers inward based on height comparison.

Execution Table

Step	Operation	Left Pointer	Right Pointer	Height[left]	Height[right]	Area Calculated	Max Area	Pointer Moved	Visual State
1	Initialize pointers	0	8	1	3	min(1,3)*8=8	8	Move left (height[left]<height[right])	[1,8,6,2,5,4,8,7,3]
2	Calculate area	1	8	8	3	min(8,3)*7=21	21	Move right (height[left]>=height[right])	[1,8,6,2,5,4,8,7,3]
3	Calculate area	1	7	8	7	min(8,7)*6=36	36	Move right (height[left]>=height[right])	[1,8,6,2,5,4,8,7,3]
4	Calculate area	1	6	8	8	min(8,8)*5=40	40	Move right (height[left]>=height[right])	[1,8,6,2,5,4,8,7,3]
5	Calculate area	1	5	8	4	min(8,4)*4=16	40	Move right (height[left]>=height[right])	[1,8,6,2,5,4,8,7,3]
6	Calculate area	1	4	8	5	min(8,5)*3=15	40	Move right (height[left]>=height[right])	[1,8,6,2,5,4,8,7,3]
7	Calculate area	1	3	8	2	min(8,2)*2=4	40	Move right (height[left]>=height[right])	[1,8,6,2,5,4,8,7,3]
8	Calculate area	1	2	8	6	min(8,6)*1=6	40	Move right (height[left]>=height[right])	[1,8,6,2,5,4,8,7,3]
9	Pointers meet	1	1	8	8	-	40	Stop	[1,8,6,2,5,4,8,7,3]

💡 Pointers meet at index 1, loop ends with max area 40

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	After Step 8	Final
left	0	1	1	1	1	1	1	1	1	1
right	8	8	7	6	5	4	3	2	1	1
max_area	0	8	21	36	40	40	40	40	40	40

Key Moments - 3 Insights

Why do we move the pointer at the smaller height instead of the larger one?

Because the area is limited by the smaller height, moving the smaller pointer inward may find a taller line and potentially increase area, as shown in steps 1-8 in the execution_table.

Why does the loop stop when left equals right?

When left equals right, the pointers meet, meaning no width remains between them, so no container can be formed. This is shown in step 9 of the execution_table.

How is the area calculated at each step?

Area is calculated as the width between pointers times the smaller height of the two pointers, as detailed in the 'Area Calculated' column of the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the area calculated?

A 36

B 21

C 35

D 8

💡 Hint

Check the 'Area Calculated' column at step 3 in the execution_table.

At which step does the max area first update to 40?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Max Area' column in the execution_table to see when it changes to 40.

If the height at index 0 was 10 instead of 1, what would happen at step 1?

A Area would be larger than 8

B Area would be smaller than 8

C Area would remain 8

D Pointer moved would be right instead of left

💡 Hint

Area is width times smaller height; increasing height[0] from 1 to 10 increases the smaller height at step 1.

Concept Snapshot

Container With Most Water:
- Use two pointers at array ends
- Calculate area = width * min(height[left], height[right])
- Move pointer at smaller height inward
- Update max area if current area is larger
- Stop when pointers meet
- Returns max water container area

Full Transcript

This concept uses two pointers starting at the ends of the height array. At each step, it calculates the area formed by the lines at these pointers, which is the width between pointers times the smaller height. It updates the maximum area found so far. Then, it moves the pointer at the smaller height inward to try to find a taller line that could increase the area. This repeats until the pointers meet, meaning no more containers can be formed. The maximum area found is returned. The execution table shows each step's pointers, heights, area calculation, and pointer movement. The variable tracker follows the pointers and max area changes. Key moments clarify why the smaller pointer moves and why the loop stops. The visual quiz tests understanding of these steps.