Maximum Number of Intersections on the Chart

Maximum Number of Intersections on the Chart - Problem

Array Hash Table Math Binary Indexed Tree Geometry Line Sweep Sorting Hard

Maximum Number of Intersections on the Chart

Imagine you have a line chart plotting stock prices over time. The chart consists of n points connected by line segments, where the k-th point has coordinates (k, y[k]). No two consecutive points share the same y-coordinate (no horizontal segments).

Your task is to find the maximum number of intersection points that can be achieved by drawing a single infinitely long horizontal line across this chart.

🎯 Goal: Return the maximum number of times a horizontal line can intersect with the line segments of the chart.

Input: A 1-indexed integer array y representing y-coordinates
Output: Maximum number of intersections possible with one horizontal line

Input & Output

example_1.py — Basic Case

$ Input: [1, 3, 2, 4]

› Output: 2

💡 Note: The chart has segments (1,1)→(2,3), (2,3)→(3,2), (3,2)→(4,4). A horizontal line at height 2.5 intersects the first and third segments, giving maximum 2 intersections.

example_2.py — All Increasing

$ Input: [1, 2, 3, 4, 5]

› Output: 0

💡 Note: All segments are increasing, so no horizontal line can intersect any segment (intersections require line to pass between endpoints, not at endpoints).

example_3.py — Zigzag Pattern

$ Input: [2, 1, 3, 1, 2]

› Output: 3

💡 Note: With segments going up and down, a horizontal line at height 1.5 can intersect multiple segments simultaneously.

Visualization

Tap to expand

Understanding the Visualization

Plot the Chart

Connect consecutive points with line segments

Identify Critical Heights

Find y-values between consecutive points where intersections change

Count Intersections

For each critical height, count how many segments it crosses

Find Maximum

Return the height with the most intersections

Key Takeaway

🎯 Key Insight: Intersections only occur at specific y-values between consecutive points - we don't need to check every possible height!

Time & Space Complexity

Time Complexity

⏱️

O(R × n)

Where R is the range of y-values (max - min), and n is array length. For each of R positions, we check n-1 segments

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters and variables

✓ Linear Space

Constraints

1 ≤ y.length ≤ 10⁵
1 ≤ y[i] ≤ 10⁹
No two consecutive points have the same y-coordinate
Array is 1-indexed in the problem description but 0-indexed in implementation

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal approach uses coordinate compression to identify only the critical y-values where intersection counts can change. Instead of checking every possible height, we focus on values between consecutive points. This reduces the search space significantly while guaranteeing we find the maximum intersections.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Y-Values)	O(R × n)	O(1)	Check every possible y-coordinate between min and max values
Coordinate Compression + Line Sweep	O(n² log n)	O(n)	Use coordinate compression to find all critical y-values efficiently

Brute Force (Try All Y-Values) — Algorithm Steps

Find minimum and maximum y-values in the array
For each integer y-coordinate from min to max
Count segments where y is strictly between consecutive points
Track maximum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Range

Find min and max y-values to define search range

Try Each Height

For each integer height, draw horizontal line

Count Intersections

Check each segment to see if line passes through it

Track Maximum

Keep track of the best count found so far

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int maxIntersections(int* y, int n) {
    if (n <= 1) return 0;
    
    int minY = y[0], maxY = y[0];
    for (int i = 1; i < n; i++) {
        if (y[i] < minY) minY = y[i];
        if (y[i] > maxY) maxY = y[i];
    }
    
    int maxIntersections = 0;
    
    // Try each possible y-coordinate
    for (int h = minY; h <= maxY; h++) {
        int intersections = 0;
        // Check each line segment
        for (int i = 0; i < n - 1; i++) {
            int y1 = y[i], y2 = y[i + 1];
            int minVal = (y1 < y2) ? y1 : y2;
            int maxVal = (y1 > y2) ? y1 : y2;
            // Check if horizontal line at height h intersects segment
            if (minVal < h && h < maxVal) {
                intersections++;
            }
        }
        if (intersections > maxIntersections) {
            maxIntersections = intersections;
        }
    }
    
    return maxIntersections;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse array input
    int y[100];
    int n = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        y[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", maxIntersections(y, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(R × n)

Where R is the range of y-values (max - min), and n is array length. For each of R positions, we check n-1 segments

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters and variables

✓ Linear Space

Constraints

1 ≤ y.length ≤ 10⁵
1 ≤ y[i] ≤ 10⁹
No two consecutive points have the same y-coordinate
Array is 1-indexed in the problem description but 0-indexed in implementation

26.8K Views

Medium Frequency

~35 min Avg. Time

856 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Y-Values) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler