Strange Printer II - Practice Coding Problems

Strange Printer II - Problem

Imagine you have a magical printer that creates colorful rectangular patterns on a grid, but with some unusual restrictions! 🖨️

This strange printer has two special rules:
1. Rectangle Only: Each print operation creates a solid rectangular pattern of a single color, completely covering any existing colors in that area
2. One-Time Use: Once a color has been used for printing, it can never be used again

Given a target grid with various colors, your challenge is to determine: Is it possible to recreate this exact pattern using our strange printer?

You need to figure out if there exists a sequence of rectangular print operations that can produce the given targetGrid, where each color is used at most once.

Input & Output

example_1.py — Basic Valid Case

$ Input: targetGrid = [[1,1,1,1],[1,2,2,1],[1,2,2,1],[1,1,1,1]]

› Output: true

💡 Note: We can print color 1 first (covering the entire 4×4 area), then print color 2 in the inner 2×2 rectangle. This creates the exact target pattern.

example_2.py — Impossible Case

$ Input: targetGrid = [[1,1,1],[3,1,3]]

› Output: false

💡 Note: Color 3 appears at positions (1,0) and (1,2), forming an L-shape. Since the printer can only print rectangles, it's impossible to print color 3 without affecting other cells that should remain color 1.

example_3.py — Complex Valid Case

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

› Output: true

💡 Note: Valid printing order exists: First print 1 (entire grid), then 2 (top-left 2×2), finally 3 (bottom-right 2×2). Each step creates proper rectangular coverage.

Constraints

m == targetGrid.length
n == targetGrid[i].length
1 ≤ m, n ≤ 60
1 ≤ targetGrid[row][col] ≤ 60
Each color value represents a distinct paint color

Visualization

Tap to expand

Understanding the Visualization

🎯 Analyze Target

Look at the final artwork and identify where each color appears. Find the smallest rectangle that contains all instances of each color.

🔍 Find Dependencies

If artist A's rectangle overlaps with areas where color B is visible in the final artwork, then A must have painted before B (since B painted over A in those areas).

📊 Build Graph

Create a dependency graph where each color points to colors that must be painted after it. This captures the 'painting order' constraints.

🔄 Check Cycles

Use DFS to detect cycles in the dependency graph. A cycle means contradictory requirements (A before B, B before C, C before A), making the artwork impossible to create.

✅ Determine Result

No cycles = artwork is possible (any topological ordering works). Cycles detected = impossible to create the target artwork.

Key Takeaway

🎯 Key Insight: Transform the printing problem into a graph problem. Dependencies between colors create a directed graph, and the existence of a solution depends entirely on whether this dependency graph is acyclic. Topological sorting provides an elegant O(k² × m × n) solution.

Asked in

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

The optimal solution uses topological sorting on a dependency graph. First, find each color's bounding rectangle in the target grid. Then build dependencies: if color A appears in color B's rectangle but B is visible in the final result, then A must be printed before B. Use DFS-based cycle detection to determine if a valid printing order exists. Time complexity: O(k² × m × n) where k is the number of colors.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Orderings)	O(k! × m × n)	O(m × n)	Try every possible painting order and simulate the printing process
Topological Sort (Optimal)	O(k² × m × n)	O(k² + m × n)	Build dependency graph between colors and use topological sorting

Brute Force (Try All Orderings) — Algorithm Steps

Extract all unique colors from the target grid
Generate all possible orderings of colors
For each ordering, simulate the printing process
Find bounding rectangle for each color in the target
Paint rectangles in the given order and check if result matches target

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Colors

Find all unique colors in the target grid

Find Bounds

Calculate the bounding rectangle for each color

Generate Permutations

Create all possible orderings of colors to try

Simulate Painting

For each order, paint rectangles and check if result matches target

Code -

solution.c — C

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

bool simulate(int* order, int orderSize, int bounds[][4], int** target, int m, int n) {
    int** grid = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        grid[i] = (int*)calloc(n, sizeof(int));
    }
    
    for (int idx = 0; idx < orderSize; idx++) {
        int color = order[idx];
        for (int i = bounds[color][0]; i <= bounds[color][1]; i++) {
            for (int j = bounds[color][2]; j <= bounds[color][3]; j++) {
                grid[i][j] = color;
            }
        }
    }
    
    bool match = true;
    for (int i = 0; i < m && match; i++) {
        for (int j = 0; j < n && match; j++) {
            if (grid[i][j] != target[i][j]) {
                match = false;
            }
        }
    }
    
    for (int i = 0; i < m; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return match;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

bool tryPermutations(int* colors, int colorCount, int bounds[][4], int** target, int m, int n, int index) {
    if (index == colorCount) {
        return simulate(colors, colorCount, bounds, target, m, n);
    }
    
    for (int i = index; i < colorCount; i++) {
        swap(&colors[index], &colors[i]);
        if (tryPermutations(colors, colorCount, bounds, target, m, n, index + 1)) {
            return true;
        }
        swap(&colors[index], &colors[i]);
    }
    return false;
}

bool isPrintable(int** targetGrid, int m, int n) {
    bool colorExists[61] = {false};
    int colorCount = 0;
    int colors[61];
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (!colorExists[targetGrid[i][j]]) {
                colorExists[targetGrid[i][j]] = true;
                colors[colorCount++] = targetGrid[i][j];
            }
        }
    }
    
    int bounds[61][4];
    for (int c = 0; c < colorCount; c++) {
        int color = colors[c];
        bounds[color][0] = m; // minR
        bounds[color][1] = -1; // maxR
        bounds[color][2] = n; // minC
        bounds[color][3] = -1; // maxC
        
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (targetGrid[i][j] == color) {
                    if (i < bounds[color][0]) bounds[color][0] = i;
                    if (i > bounds[color][1]) bounds[color][1] = i;
                    if (j < bounds[color][2]) bounds[color][2] = j;
                    if (j > bounds[color][3]) bounds[color][3] = j;
                }
            }
        }
    }
    
    return tryPermutations(colors, colorCount, bounds, targetGrid, m, n, 0);
}

int main() {
    printf("Input parsing implementation needed\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k! × m × n)

k! for all permutations of k colors, m×n for simulating each grid painting

✓ Linear Growth

Space Complexity

O(m × n)

Space to store the simulated grid during painting process

⚡ Linearithmic Space

18.4K Views

Medium Frequency

~35 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Orderings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler