AIUnlimited
🌳

AI-Fundamenten

🌱
AI Seeds

Begin bij nul

🌿
AI Sprouts

Bouw een fundament

🌳
AI Branches

Pas toe in de praktijk

🏕️
AI Canopy

Ga de diepte in

🌲
AI Forest

Beheers AI

🔨

AI-Meesterschap

✏️
AI Sketch

Begin bij nul

🪨
AI Chisel

Bouw een fundament

⚒️
AI Craft

Pas toe in de praktijk

💎
AI Polish

Ga de diepte in

🏆
AI Masterpiece

Beheers AI

📘

AI Praktijk

📖
Open-source modellen begrijpen

Fundamenten en bronnen voor open-source modellen

🎯
Van probleem naar modeltaak

Bedrijfsproblemen omzetten in modeltaken

⚡
Uw eerste model uitvoeren

Zie uw eerste resultaten in 30 minuten

🔧
Fijntuning en evaluatie

Modellen fijntunen en prestaties evalueren

🚀
Applicatiesystemen

Bouw echte AI-toepassingen

🎨
Generatieve AI

Verken open-source AIGC-modellen

🤖
Agents

Leer Agent-frameworks en MCP-tools

📐
Aanvullende fundamenten

LLM-basis en evaluatie

🎓

Claude Academie

🤖
Claude 101

Learn AI basics with Claude

💻
Claude Code 101

Code with Claude as your pair programmer

🤝
Introduction to Claude Cowork

Collaborate with Claude on complex projects

⚙️
Claude Platform 101

Build apps with the Claude API

Lab

7 experimenten geladen
🧬Neuraal Netwerk Sandbox🤖AI of Mens?🥋Prompt Engineering Dojo🏁Algoritme-race🧠AI-triviant🏗️Systeemontwerp Canvas
🎯Proef-sollicitatieGa naar het lab→
🚀

Carrièreontwikkeling

🚀
Interview Startplatform

Start je reis

🌟
Gedragsinterview Meesterschap

Beheers soft skills

💻
Technische Interviews

Slaag voor de codeerronde

🤖
AI- & ML-interviews

ML-interview meesterschap

🏆
Aanbod & verder

Bemachtig het beste aanbod

Begin met leren
AIUnlimited

MIT-licentie.

沪ICP备18025655号-11

Leren

  • AI-basis
  • AI Praktijk
  • Claude Academie
  • Lab
  • Carrièreontwikkeling

Community

  • Over ons
  • FAQ

Ondersteuning

  • footer.terms
  • footer.privacy
  • footer.contact
AI & Engineering Opleidingen›✏️ AI Sketch›Lessen›Matrix- en rasterproblemen
🗺️
AI Sketch • Gemiddeld⏱️ 19 min leestijd

Matrix- en rasterproblemen

2D-Arrays als Grids

Een matrix is gewoon een 2D-array, maar in interviews stelt het vaak een grid voor - een kaart, een bord of een doolhof. Elke cel grid[r][c] is een knooppunt, en de buren zijn aangrenzende cellen.

grid = [
  [1, 1, 0],
  [1, 0, 0],
  [0, 0, 1]
]

Rij r, kolom c, afmetingen m × n. Eenvoudig - maar de patronen die erop gebouwd worden zijn krachtig.

Richtingsarrays

In plaats van vier aparte if-statements, gebruik een richtingsarray:

# 4 richtingen (boven, onder, links, rechts)
dirs = [(-1,0), (1,0), (0,-1), (0,1)]

# 8 richtingen (inclusief diagonalen)
dirs = [(-1,0),(1,0),(0,-1),(0,1),
        (-1,-1),(-1,1),(1,-1),(1,1)]

for dr, dc in dirs:
    nr, nc = r + dr, c + dc
    if 0 <= nr < m and 0 <= nc < n:
        # verwerk buur

Dit is het meest herbruikbare stukje code in gridproblemen.

🤯
De richtingsarray-truc wordt soms "delta-encoding" genoemd. Het komt voor in game-ontwikkeling, beeldverwerking en competitive programming - overal waar grids worden gebruikt.

BFS op een Grid - Kortste Pad in een Doolhof

BFS vindt het kortste pad in een ongewogen grid. Begin bij de bron, verken alle buren op afstand 1, dan afstand 2, enzovoort.

from collections import deque

def shortest_path(grid, start, end):
    m, n = len(grid), len(grid[0])
    q = deque([(start[0], start[1], 0)])
    visited = {(start[0], start[1])}
    dirs = [(-1,0),(1,0),(0,-1),(0,1)]
    while q:
        r, c, dist = q.popleft()
        if (r, c) == end:
            return dist
        for dr, dc in dirs:
            nr, nc = r+dr, c+dc
            if 0<=nr<m and 0<=nc<n and (nr,nc) not in visited and grid[nr][nc]==0:
                visited.add((nr, nc))
                q.append((nr, nc, dist+1))
    return -1
BFS breidt zich laag voor laag uit over een grid-doolhof
BFS verkent cellen laag voor laag en garandeert het kortste pad.

DFS op een Grid - Flood Fill en Eilanden Tellen

Flood fill (zoals het verfemmertje): vanaf een startcel verander je alle verbonden cellen met dezelfde kleur. DFS of BFS werken beide.

Les 10 van 100% voltooid
←Greedy-algoritmen

Discussie

Inloggen deelnemen aan de discussie

Aantal Eilanden: scan het grid; als je een 1 vindt, voer DFS/BFS uit om het hele eiland als bezocht te markeren, en verhoog je teller.

def num_islands(grid):
    count = 0
    for r in range(len(grid)):
        for c in range(len(grid[0])):
            if grid[r][c] == '1':
                dfs(grid, r, c)  # markeer eiland
                count += 1
    return count
🧠Snelle check

Waarom markeren we bij 'Aantal Eilanden' cellen als bezocht tijdens DFS?

Rottende Sinaasappels - Multi-Source BFS

Alle aanvankelijk rotte sinaasappels zijn bronnen. Zet ze allemaal in de queue op tijdstip 0, dan BFS. Elk niveau is één minuut. Als de queue leeg is, controleer of er verse sinaasappels overblijven.

Minuut 0:  [2, 1, 1]    2 = rot, 1 = vers
           [1, 1, 0]
           [0, 1, 1]

Minuut 4:  [2, 2, 2]    Alle bereikbare sinaasappels rot
           [2, 2, 0]
           [0, 2, 2]

Het kernidee: multi-source BFS start vanuit meerdere knooppunten tegelijk, niet één.

🧠Snelle check

Wat maakt 'Rottende Sinaasappels' anders dan standaard BFS?

Spiraal-Matrixtraversal

Loop de matrix in spiraalvolgorde: rechts → omlaag → links → omhoog, waarbij de grenzen na elke doorgang krimpen.

def spiral(matrix):
    res = []
    top, bot = 0, len(matrix) - 1
    left, right = 0, len(matrix[0]) - 1
    while top <= bot and left <= right:
        for c in range(left, right + 1):
            res.append(matrix[top][c])
        top += 1
        for r in range(top, bot + 1):
            res.append(matrix[r][right])
        right -= 1
        if top <= bot:
            for c in range(right, left - 1, -1):
                res.append(matrix[bot][c])
            bot -= 1
        if left <= right:
            for r in range(bot, top - 1, -1):
                res.append(matrix[r][left])
            left += 1
    return res

Matrixrotatie (90°)

Draai een N×N-matrix met de klok mee in-place: transponeer (wissel [r][c] met [c][r]), dan keer elke rij om.

Origineel → Transponeer → Keer rijen om
1 2 3       1 4 7         7 4 1
4 5 6  →    2 5 8    →    8 5 2
7 8 9       3 6 9         9 6 3
🤔
Think about it:Om tegen de klok in te draaien, zou je eerst rijen omkeren en dan transponeren, of transponeren en dan kolommen omkeren? Probeer het op papier.

Zoeken in een Gesorteerde 2D-Matrix

Twee veelvoorkomende varianten:

  • Rijen en kolommen onafhankelijk gesorteerd - begin rechtsboven. Als het doel kleiner is, ga links; als groter, ga omlaag. O(m + n).
  • Volledig gesorteerd (elke rij begint waar de vorige eindigt) - behandel als platte gesorteerde array en binary search. O(log(m × n)).

Dynamic Programming op Grids

Unieke Paden: tel paden van linksboven naar rechtsonder, alleen naar rechts of omlaag. dp[r][c] = dp[r-1][c] + dp[r][c-1].

Minimale Padsom: zelfde idee, maar kies het minimum inkomende pad.

Dit zijn vaak de zachtste introductie tot 2D dynamic programming.

🧠Snelle check

In het Unieke Paden-probleem, wat is dp[0][c] voor elke kolom c?

Gridpatronen Samenvatting

| Patroon | Techniek | Kernprobleem | |---------|----------|--------------| | Kortste pad (ongewogen) | BFS | Doolhof kortste pad | | Verbonden componenten | DFS / BFS | Aantal Eilanden | | Multi-source verspreiding | Multi-source BFS | Rottende Sinaasappels | | Traversalvolgorde | Grenzen bijhouden | Spiraal Matrix | | In-place transformatie | Transponeer + omkeer | Afbeelding Draaien | | Paden tellen | DP | Unieke Paden | | Zoeken in gesorteerd grid | Trap / binary search | Zoek 2D Matrix |

🤔
Think about it:Veel gridproblemen zijn eigenlijk verkapte graafproblemen. Wanneer zou je DFS verkiezen boven BFS op een grid, en wanneer andersom?

📚 Verder Lezen

  • NeetCode - 2D Dynamic Programming - grid-DP-problemen met visuele uitleg
  • Tech Interview Handbook - Matrix - veelvoorkomende patronen en technieken
  • LeetCode Matrix tag - honderden oefenproblemen