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›पाठ›Recursion और Backtracking
🧩
AI Sketch • मध्यम⏱️ 20 मिनट पढ़ने का समय

Recursion और Backtracking

Recursion Fundamentals

Recursive function खुद को problem के छोटे version के साथ call करता है जब तक base case न आ जाए जो chain रोक दे।

हर recursion को दो चीज़ें चाहिए:

  1. Base case - सबसे simple input जहाँ सीधे return करो।
  2. Recursive case - problem तोड़ो और खुद को call करो।
def factorial(n):
    if n <= 1:        # base case
        return 1
    return n * factorial(n - 1)  # recursive case

Call Stack - Visualised

हर recursive call call stack पर एक frame push करती है। Base case return होने पर frames reverse order में pop होते हैं।

factorial(4)
  → factorial(3)
    → factorial(2)
      → factorial(1) → returns 1
    ← returns 2
  ← returns 6
← returns 24

Base case न हो तो stack overflow। Python की default recursion limit 1,000 frames है।

🤯
Python की default recursion limit 1,000 intentionally conservative है। sys.setrecursionlimit() से बढ़ा सकते हो, लेकिन deep recursion के लिए iterative solutions बेहतर हैं।

Fibonacci - Classic Trap

Naïve recursive Fibonacci O(2ⁿ) है क्योंकि same sub-problems बार-बार compute होते हैं। Memoisation इसे O(n) time और space में fix करता है।

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)
Fibonacci का recursion tree जिसमें repeated sub-problems दिख रहे हैं
Memoisation बिना fib(5) 15 calls करता है। Memoisation से सिर्फ 5।

Backtracking - सब Try करो, फिर Undo करो

Backtracking recursion है एक twist के साथ: choice बनाओ, recurse करो, फिर choice undo करो और next option try करो। सोचो जैसे maze explore कर रहे हो - आगे जाओ, dead end मिला, वापस आओ, दूसरा रास्ता try करो।

Backtracking Template

def backtrack(state, choices):
    if is_solution(state):
        result.append(state.copy())
        return
    for choice in choices:
        if is_valid(choice):
            state.add(choice)       # choose
            backtrack(state, ...)   # explore
            state.remove(choice)    # un-choose

यह choose, explore, un-choose pattern लगभग हर backtracking problem की रीढ़ है।

🧠त्वरित जांच

Backtracking template में recursive call के बाद choice undo क्यों करते हैं?

पाठ 8 / 100% पूर्ण
←Binary Search Patterns

Discussion

Sign in to join the discussion

lessons.suggestEdit

Permutations

[1, 2, 3] के सभी orderings generate करो। हर level पर unused number choose करो, recurse करो, फिर un-pick करो।

         []
      /   |   \
    [1]  [2]  [3]
    / \   ...
 [1,2] [1,3]
   |      |
[1,2,3] [1,3,2]  ... (6 total)

n! permutations होते हैं, तो time complexity O(n × n!) है।

Combinations और Subsets

Combinations (n choose k): हर element पर include करो या skip करो, लेकिन duplicates से बचने के लिए सिर्फ forward recurse करो।

Subsets: same idea बिना size constraint - recursion tree का हर node valid subset है। 2ⁿ subsets होते हैं।

🤔
Think about it:Permutations n! results देते हैं जबकि subsets 2ⁿ। n=10 के लिए 3,628,800 vs 1,024 - बहुत बड़ा अंतर। क्यों?

N-Queens - Walkthrough

N×N board पर N queens रखो जो एक-दूसरे को attack न करें। N=4 के लिए:

. Q . .
. . . Q
Q . . .
. . Q .

Strategy: हर row में एक queen रखो। हर row के लिए हर column try करो। Column, main diagonal, और anti-diagonal conflicts check करो। Safe हो तो रखो और next row पर recurse करो। Stuck हो तो backtrack।

Conflicts track करो तीन sets से: cols, diag (row − col), anti_diag (row + col)।

🧠त्वरित जांच

N-Queens में diagonal conflicts efficiently कैसे check करते हैं?

Sudoku Solver - Concept

Empty cell ढूँढो, digits 1–9 try करो। हर digit के लिए row, column, और 3×3 box constraints check करो। Valid हो तो place करो और recurse करो। कोई digit काम न करे तो undo करो और backtrack। Constraints की pruning huge search space को manageable बनाती है।

Word Search in a Grid

2D board of letters और target word दिया है। हर cell से शुरू करो और DFS से four directions में एक character match करते जाओ। Recursion में cells visited mark करो और backtrack पर unmark करो।

Backtracking की Time Complexity

Cost branching factor (हर step पर choices) और depth (solution तक steps) पर depend करती है। b branches, d depth: O(bᵈ)।

| Problem | Branching | Depth | Complexity | |---------|-----------|-------|------------| | Permutations | n, n−1, … | n | O(n!) | | Subsets | 2 | n | O(2ⁿ) | | N-Queens | ~n | n | O(n!) worst case |

Pruning से Optimise करो

Pruning का मतलब ऐसी branches skip करना जो fail होंगी:

  • N-Queens: पहले से occupied columns skip करो।
  • Sudoku: constraints violate करने वाले digits skip करो।
  • Combination sum: remaining sum < 0 हो तो skip।

अच्छी pruning impractical search को fast बना सकती है।

🧠त्वरित जांच

Backtracking algorithm में pruning क्या करती है?

🤔
Think about it:कई backtracking problems dynamic programming से भी solve हो सकते हैं। दोनों approaches में key difference क्या है?

📚 और पढ़ें

  • NeetCode - Backtracking playlist - curated problems with video walkthroughs
  • Tech Interview Handbook - Recursion - patterns और common pitfalls
  • LeetCode Backtracking study plan - progressive problem set