0232EasyDepth-First SearchBreadth-First SearchUnion-FindGraph Theory

Coolant Reaches the Outlet

Tracked in this browser only

Trains the technique from

LeetCode 1971Find if Path Exists in Graph

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A chilled-water plant is laid out as junctions junctions, labelled 0 through junctions - 1. The plumbing is given as pipes, where pipes[i] = [a, b] is one pipe that carries coolant in either direction between junction a and junction b.

A maintenance engineer wants to know whether coolant leaving the junction intake can arrive at the junction outlet by running through a sequence of pipes, using each junction at most once along the way.

Return true if such a run of pipes exists and false otherwise. intake and outlet may refer to the same junction, in which case no pipe has to be used at all.

No pipe joins a junction to itself, and no unordered pair of junctions is listed twice, though a pair may be written in either order.

Examples

Example 1

Input: junctions = 4, pipes = [[0, 2], [2, 3]], intake = 0, outlet = 3
Output: true

Coolant can take the pipe from 0 to 2 and then the pipe from 2 to 3, arriving at the outlet.

Example 2

Input: junctions = 5, pipes = [[0, 1], [1, 2], [3, 4]], intake = 2, outlet = 4
Output: false

Every pipe out of 2 leads to 1 or 0, and no pipe is listed from 0, 1 or 2 to either 3 or 4, so the outlet is never reached.

Example 3

Input: junctions = 4, pipes = [[1, 0], [2, 1], [3, 2]], intake = 0, outlet = 3
Output: true

The pipes [1, 0], [2, 1] and [3, 2] carry coolant in either direction, so the run 0, 1, 2, 3 is available.

Constraints

1 <= junctions <= 2 * 10^5
0 <= pipes.length <= 2 * 10^5
pipes[i].length == 2
0 <= a, b <= junctions - 1
a != b
0 <= intake, outlet <= junctions - 1
No unordered pair of junctions appears in pipes more than once

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def coolant_reaches(junctions: int, pipes: list[list[int]], intake: int, outlet: int) -> bool:

Java

public boolean coolantReaches(int junctions, int[][] pipes, int intake, int outlet)

The intended approach

Time O(junctions + pipes.length)Space O(junctions + pipes.length) for the adjacency list, the seen flags and the stack

Build an adjacency list that stores each pipe under both of its endpoints, then walk outward from `intake` with an explicit stack, marking junctions as they are first reached so no junction is expanded twice. The walk stops as soon as `outlet` turns up, and the equal-endpoint case is answered before any walking starts. An explicit stack rather than recursion keeps the walk safe at the upper bound on `junctions`.

Pythonentry point: coolant_reaches

def coolant_reaches(junctions, pipes, intake, outlet):
    if intake == outlet:
        return True
    adjacency = [[] for _ in range(junctions)]
    for a, b in pipes:
        adjacency[a].append(b)
        adjacency[b].append(a)
    seen = [False] * junctions
    seen[intake] = True
    stack = [intake]
    while stack:
        node = stack.pop()
        for neighbour in adjacency[node]:
            if neighbour == outlet:
                return True
            if not seen[neighbour]:
                seen[neighbour] = True
                stack.append(neighbour)
    return False

The obvious version

Flood the network by repeatedly scanning the whole pipe list, wetting the far end of any pipe with one wet end, until a full scan changes nothing.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_coolant_reaches(junctions, pipes, intake, outlet):
    # Grow the set of wetted junctions by rescanning every pipe until a full
    # sweep adds nothing new. Obviously correct, and O(len(pipes) * junctions).
    wetted = [False] * junctions
    wetted[intake] = True
    changed = True
    while changed:
        changed = False
        for a, b in pipes:
            if wetted[a] and not wetted[b]:
                wetted[b] = True
                changed = True
            elif wetted[b] and not wetted[a]:
                wetted[a] = True
                changed = True
    return wetted[outlet]

How this problem was checked

Reference solution executed against 11 test cases — 11 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in