AI EducademyAIEducademy
🌳

AI की नींव

🌱
AI Seeds

शून्य से शुरू करें

🌿
AI Sprouts

नींव बनाएं

🌳
AI Branches

व्यवहार में लागू करें

🏕️
AI Canopy

गहराई में जाएं

🌲
AI Forest

AI में महारत हासिल करें

🔨

AI में महारत

✏️
AI Sketch

शून्य से शुरू करें

🪨
AI Chisel

नींव बनाएं

⚒️
AI Craft

व्यवहार में लागू करें

💎
AI Polish

गहराई में जाएं

🏆
AI Masterpiece

AI में महारत हासिल करें

🚀

करियर रेडी

🚀
इंटरव्यू लॉन्चपैड

अपनी यात्रा शुरू करें

🌟
व्यवहारिक इंटरव्यू में महारत

सॉफ्ट स्किल्स में महारत

💻
तकनीकी इंटरव्यू

कोडिंग राउंड में सफल हों

🤖
AI और ML इंटरव्यू

ML इंटरव्यू में महारत

🏆
ऑफर और उससे आगे

सबसे अच्छा ऑफर पाएं

सभी कार्यक्रम देखें→

लैब

7 प्रयोग लोड हुए
🧠न्यूरल नेटवर्क प्लेग्राउंड🤖AI या इंसान?💬प्रॉम्प्ट लैब🎨इमेज जनरेटर😊सेंटिमेंट एनालाइज़र💡चैटबॉट बिल्डर⚖️एथिक्स सिमुलेटर
🎯मॉक इंटरव्यूलैब में जाएँ→
nav.journeyब्लॉग
🎯
हमारे बारे में

हर जगह, हर किसी के लिए AI शिक्षा सुलभ बनाना

❓
nav.faq

Common questions answered

✉️
Contact

Get in touch with us

⭐
ओपन सोर्स

GitHub पर सार्वजनिक रूप से निर्मित

सीखना शुरू करें - यह मुफ्त है
AI EducademyAIEducademy

MIT लाइसेंस - ओपन सोर्स

सीखें

  • कार्यक्रम
  • पाठ
  • लैब

समुदाय

  • GitHub
  • योगदान करें
  • आचार संहिता
  • हमारे बारे में
  • सामान्य प्रश्न

सहायता

  • कॉफ़ी खरीदें ☕
  • footer.terms
  • footer.privacy
  • footer.contact
AI और इंजीनियरिंग प्रोग्राम›✏️ AI Sketch›पाठ›Matrix और Grid Problems
🗺️
AI Sketch • मध्यम⏱️ 19 मिनट पढ़ने का समय

Matrix और Grid Problems

2D Arrays as Grids

Matrix बस एक 2D array है, लेकिन interviews में यह अक्सर grid represent करता है - map, board, या maze। हर cell grid[r][c] एक node है, और उसके neighbours adjacent cells हैं।

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

Row r, column c, dimensions m × n। Simple - लेकिन इस पर बने patterns बहुत powerful हैं।

Directional Arrays

चार अलग if-statements लिखने की जगह direction array इस्तेमाल करो:

# 4-directional (up, down, left, right)
dirs = [(-1,0), (1,0), (0,-1), (0,1)]

# 8-directional (includes diagonals)
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:
        # process neighbour

Grid problems में यह सबसे reusable snippet है।

🤯
Direction array trick को "delta encoding" भी कहते हैं। Game development, image processing, और competitive programming में - जहाँ भी grids हों, यह दिखता है।

Grid पर BFS - Maze में Shortest Path

BFS unweighted grid में shortest path ढूँढता है। Source से शुरू करो, पहले distance 1 के सब neighbours explore करो, फिर distance 2, और आगे।

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 grid maze में level by level expand हो रहा है
BFS cells को level by level explore करता है, shortest path guarantee करता है।

Grid पर DFS - Flood Fill और Number of Islands

Flood fill (paint bucket tool जैसा): starting cell से सभी connected same-colour cells बदलो। DFS या BFS दोनों काम करते हैं।

grid scan करो; मिले तो DFS/BFS चलाकर पूरा island visited mark करो, फिर count बढ़ाओ।

पाठ 10 / 100% पूर्ण
←Greedy Algorithms

Discussion

Sign in to join the discussion

lessons.suggestEdit
Number of Islands:
1
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)  # mark island
                count += 1
    return count
🧠त्वरित जांच

'Number of Islands' में DFS के दौरान cells को visited क्यों mark करते हैं?

Rotting Oranges - Multi-Source BFS

सभी शुरू से rotten oranges sources हैं। सबको time 0 पर queue में डालो, फिर BFS। हर level एक minute। Queue खाली होने पर check करो कोई fresh orange बचा तो नहीं। Multi-source BFS कई nodes से simultaneously शुरू होता है।

🧠त्वरित जांच

'Rotting Oranges' standard BFS से कैसे अलग है?

Spiral Matrix Traversal

Matrix को spiral order में walk करो: right → down → left → up, हर pass के बाद boundaries shrink करो।

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

Matrix Rotation (90°)

N×N matrix clockwise in-place rotate: transpose (swap [r][c] with [c][r]), फिर हर row reverse।

🤔
Think about it:Anti-clockwise rotate करने के लिए पहले rows reverse करोगे फिर transpose, या transpose करके columns reverse? कागज़ पर try करो।

Sorted 2D Matrix में Search

दो common variants:

  • Rows और columns independently sorted - top-right corner से शुरू। Target छोटा हो तो left जाओ; बड़ा हो तो down। O(m + n)।
  • Fully sorted (हर row पिछली के बाद शुरू) - flat sorted array मानकर binary search। O(log(m × n))।

Grids पर Dynamic Programming

Unique Paths: top-left से bottom-right तक paths count करो, सिर्फ right या down move। dp[r][c] = dp[r-1][c] + dp[r][c-1]।

Minimum Path Sum: same idea लेकिन minimum incoming path चुनो।

🧠त्वरित जांच

Unique Paths problem में किसी भी column c के लिए dp[0][c] क्या है?

Grid Patterns Cheat Sheet

| Pattern | Technique | Key Problem | |---------|-----------|-------------| | Shortest path (unweighted) | BFS | Maze shortest path | | Connected components | DFS / BFS | Number of Islands | | Multi-source spread | Multi-source BFS | Rotting Oranges | | Traversal order | Boundary pointers | Spiral Matrix | | In-place transform | Transpose + reverse | Rotate Image | | Counting paths | DP | Unique Paths | | Sorted grid में search | Staircase / binary search | Search 2D Matrix |

🤔
Think about it:कई grid problems असल में disguised graph problems हैं। Grid पर DFS कब prefer करोगे BFS के ऊपर, और कब उल्टा?

📚 और पढ़ें

  • NeetCode - 2D Dynamic Programming - grid DP problems with visual explanations
  • Tech Interview Handbook - Matrix - common patterns और techniques
  • LeetCode Matrix tag - सैकड़ों practice problems