Count Artifacts That Can Be Extracted - Practice Coding Problems

Count Artifacts That Can Be Extracted - Problem

Imagine you're an archaeological explorer investigating an ancient site! You have an n × n grid representing the excavation area, and hidden beneath the earth are rectangular artifacts waiting to be discovered.

Each artifact occupies a rectangular region defined by its top-left corner (r1, c1) and bottom-right corner (r2, c2). To extract an artifact, you must completely uncover all cells that contain parts of it.

You're given:

artifacts[i] = [r1, c1, r2, c2] - coordinates of the i-th artifact
dig[i] = [r, c] - cells you will excavate

Goal: Determine how many artifacts you can fully extract after completing all your planned excavations.

Key constraint: An artifact can only be extracted if every single cell it occupies has been dug up!

Input & Output

basic_example.py — Python

$ Input: n = 2, artifacts = [[0,0,0,0],[0,1,1,1]], dig = [[0,0],[0,1]]

› Output: 1

💡 Note: Artifact 1 at (0,0) is fully excavated. Artifact 2 spans (0,1), (1,1), (1,0) but we only dug (0,1), so it cannot be extracted.

complete_extraction.py — Python

$ Input: n = 2, artifacts = [[0,0,0,0],[0,1,1,1]], dig = [[0,0],[0,1],[1,0],[1,1]]

› Output: 2

💡 Note: Both artifacts can be extracted since all their cells have been excavated.

no_extraction.py — Python

$ Input: n = 3, artifacts = [[0,0,1,1]], dig = [[1,2],[2,2]]

› Output: 0

💡 Note: The artifact spans cells (0,0), (0,1), (1,0), (1,1), but none of these cells were excavated.

Constraints

1 ≤ n ≤ 1000
1 ≤ artifacts.length, dig.length ≤ 10⁵
artifacts[i].length == 4
dig[i].length == 2
0 ≤ r1i, c1i, r2i, c2i, ri, ci ≤ n - 1
r1i ≤ r2i and c1i ≤ c2i
No two artifacts overlap
Each artifact covers at most 4 cells
All dig entries are unique

Visualization

Tap to expand

Understanding the Visualization

Mark Excavation Sites

Create a map of all locations you've dug up (hash set)

Check Each Artifact

For each treasure, verify every piece is uncovered

Fast Verification

Use the excavation map for instant lookup (O(1))

Count Treasures

Only count artifacts that are completely exposed

Key Takeaway

🎯 Key Insight: Use a hash set for O(1) cell lookup, making the solution efficient even with many artifacts and dig sites

Asked in

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

The optimal solution uses a hash set to store all excavated coordinates, allowing O(1) lookup time when checking if artifact cells are dug up. This gives us O(D + A×C) time complexity, where D is dig operations, A is artifacts, and C is cells per artifact.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Set Lookup (Optimal)	O(D + A×C)	O(D)	Store all dig sites in a hash set for O(1) lookup, then check each artifact
Brute Force (Nested Loops)	O(A × C × D)	O(1)	For each artifact, check against all dig sites to see if all cells are covered

Hash Set Lookup (Optimal) — Algorithm Steps

Create a hash set from all dig coordinates
For each artifact, generate all cells it occupies
Check if each cell exists in the hash set (O(1) lookup)
If all cells are found, increment the extractable count
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Set

Convert all dig sites to hash set O(D)

Check Artifact

Generate artifact cells

Fast Lookup

O(1) hash lookup for each cell

Count Result

Increment if all cells found

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#define MAX_CELLS 10000

struct Cell {
    int r, c;
};

bool isExcavated(struct Cell excavated[], int size, int r, int c) {
    for (int i = 0; i < size; i++) {
        if (excavated[i].r == r && excavated[i].c == c) {
            return true;
        }
    }
    return false;
}

int digArtifacts(int n, int** artifacts, int artifactsSize, int* artifactsColSize, int** dig, int digSize, int* digColSize) {
    // Store all excavated cells
    struct Cell excavated[MAX_CELLS];
    for (int i = 0; i < digSize; i++) {
        excavated[i].r = dig[i][0];
        excavated[i].c = dig[i][1];
    }
    
    int count = 0;
    
    // Check each artifact
    for (int i = 0; i < artifactsSize; i++) {
        int r1 = artifacts[i][0], c1 = artifacts[i][1];
        int r2 = artifacts[i][2], c2 = artifacts[i][3];
        bool canExtract = true;
        
        // Check if all cells of this artifact are excavated
        for (int r = r1; r <= r2 && canExtract; r++) {
            for (int c = c1; c <= c2; c++) {
                if (!isExcavated(excavated, digSize, r, c)) {
                    canExtract = false;
                    break;
                }
            }
        }
        
        if (canExtract) {
            count++;
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(D + A×C)

D dig operations to build set + A artifacts × C cells per artifact for checking

✓ Linear Growth

Space Complexity

O(D)

Hash set stores all D dig coordinates

✓ Linear Space

26.8K Views

Medium Frequency

~15 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

Hash Set Lookup (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler