0482EasyArrayMatrix

Depot Holding the Most Stock

Tracked in this browser only

Trains the technique from

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 wholesaler runs several depots and carries the same set of product lines in each of them. stock[d][p] is the number of units of product line p sitting in depot d.

A depot's holding is the number of units it has across all of its product lines added together.

Return the largest holding of any single depot.

Examples

Example 1

Input: stock = [[7, 2, 9], [4, 4, 4], [1, 1, 20]]
Output: 22

Depot 0 holds 18 units, depot 1 holds 12 and depot 2 holds 22, so the largest holding is depot 2's.

Example 2

Input: stock = [[100, 1], [50, 49]]
Output: 101

Depot 0 holds 101 units and depot 1 holds 99.

Example 3

Input: stock = [[6, 4], [5, 5]]
Output: 10

Both depots hold ten units in total, so that figure is what comes back.

Constraints

m == stock.length
n == stock[d].length
1 <= m, n <= 50
1 <= stock[d][p] <= 100

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 busiest_depot_total(stock: list[list[int]]) -> int:

Java

public int busiestDepotTotal(int[][] stock)

The intended approach

Time O(m * n)Space O(1)

Every row of the table is one depot, so add each row up as it is read and keep the largest total seen. Nothing has to be stored between rows beyond that one running best, and since every holding is at least one unit, starting the best at zero is safe.

Pythonentry point: busiest_depot_total

def busiest_depot_total(stock):
    # time O(depots * lines), space O(1)
    best = 0
    for row in stock:
        held = 0
        for count in row:
            held += count
        if held > best:
            best = held
    return best

The obvious version

Walk the table one product line at a time, adding each line's units into a running total per depot, then scan those totals for the largest. This visits the same cells as the reference and is in the same complexity class, not slower; it differs only in traversing the table by column and keeping a total for every depot.

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_busiest_depot_total(stock):
    depots = len(stock)
    lines = len(stock[0])
    running = [0] * depots
    for p in range(lines):
        for d in range(depots):
            running[d] = running[d] + stock[d][p]
    best = running[0]
    for d in range(1, depots):
        if running[d] > best:
            best = running[d]
    return best

How this problem was checked

Reference solution executed against 8 test cases — 8 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