Constraints

• 0 <= len(image_paths), len(pipelines)
• A pipeline may be empty
• All paths in `image_paths` exist in `image_store`
• The total number of operations across all pipelines is at most 2 * 10^5
• The returned list has exactly `len(image_paths) * len(pipelines)` entries, so any solution must spend at least O(m*n) time to build the output

Examples

Solution

def solution(image_paths, image_store, pipelines, output_dir):
    transforms = []
    for pipeline in pipelines:
        a, b = 1, 0
        for op in pipeline:
            name = op[0]
            if name == 'ADD':
                b += op[1]
            elif name == 'SUB':
                b -= op[1]
            elif name == 'MUL':
                factor = op[1]
                a *= factor
                b *= factor
            elif name == 'NEG':
                a = -a
                b = -b
            else:
                raise ValueError(f'Unsupported operation: {name}')
        transforms.append((a, b))

    loaded = {}
    base = output_dir.rstrip('/')
    result = []

    for i, path in enumerate(image_paths):
        if path not in loaded:
            loaded[path] = image_store[path]
        value = loaded[path]

        for j, (a, b) in enumerate(transforms):
            out_path = f'{base}/img{i}_pipe{j}.png' if base else f'img{i}_pipe{j}.png'
            result.append((out_path, a * value + b))

    return result

Time complexity: O(u + P + m*n), where `u` is the number of distinct image paths and `P` is the total number of operations across all pipelines. Space complexity: O(u + n) auxiliary space, excluding the returned output list.

Hints

1. Each supported operation keeps the form `a*x + b`. Try compressing each whole pipeline into one pair `(a, b)` before processing the images.
2. If the same path appears more than once in `image_paths`, cache its loaded value so you do not conceptually decode it multiple times.