Backtracking Concept and Decision Tree Visualization in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start backtracking from the first position.

DSA C#

void Backtrack(int pos) {
    if (pos == n) {
        PrintSolution();
        return;
    }
    for (int i = 0; i < choices; i++) {
        if (IsValid(pos, i)) {
            solution[pos] = i;
            Backtrack([1]);
        }
    }
}

Drag options to blanks, or click blank then click option'

A0

Bpos - 1

Cchoices

Dpos + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using pos - 1 causes infinite recursion backward.

Using 0 resets position incorrectly.

Using choices as position is out of range.

In backtracking, after choosing an option at position pos, we move to the next position pos + 1 to continue exploring.

2fill in blank

medium

Complete the code to check if the current choice is valid at position pos.

DSA C#

bool IsValid(int pos, int choice) {
    for (int i = 0; i < pos; i++) {
        if (solution[i] == [1]) {
            return false;
        }
    }
    return true;
}

Drag options to blanks, or click blank then click option'

Achoice

Bpos

Ci

Dsolution[i]

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing solution[i] with pos is incorrect.

Comparing solution[i] with i is meaningless here.

We check if the current choice conflicts with any previous choice stored in solution[i]. So we compare solution[i] with choice.

3fill in blank

hard

Fix the error in the backtracking base case to stop recursion correctly.

DSA C#

void Backtrack(int pos) {
    if (pos [1] n) {
        PrintSolution();
        return;
    }
    // rest of code
}

Drag options to blanks, or click blank then click option'

A>

B==

C<=

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using pos < n causes premature stopping.

Using pos > n is incorrect as pos never exceeds n.

Using pos <= n causes extra calls.

The base case should check if pos equals n, meaning all positions are filled, then print the solution and stop.

4fill in blank

hard

Fill both blanks to generate all subsets of a set using backtracking.

DSA C#

void GenerateSubsets(int index, List<int> current) {
    if (index == n) {
        PrintSubset(current);
        return;
    }
    // Include element
    current.Add([1]);
    GenerateSubsets(index [2] 1, current);
    current.RemoveAt(current.Count - 1);
    // Exclude element
    GenerateSubsets(index + 1, current);
}

Drag options to blanks, or click blank then click option'

Aindex

B+

C-

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Using index - 1 moves backward incorrectly.

Using n as element index causes out of range.

Not incrementing index causes infinite recursion.

To include the current element, add it using index as the element's position. Then move to next index by index + 1.

5fill in blank

hard

Fill all three blanks to implement backtracking for generating permutations.

DSA C#

void Permute(List<int> nums, int start) {
    if (start == nums.Count) {
        PrintPermutation(nums);
        return;
    }
    for (int i = [1]; i < nums.Count; i++) {
        Swap(nums, start, i);
        Permute(nums, [2]);
        Swap(nums, start, i);
    }
}

void Swap(List<int> list, int a, int b) {
    int temp = list[a];
    list[a] = list[b];
    list[b] = [3];
}

Drag options to blanks, or click blank then click option'

Astart

Bstart + 1

Ctemp

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Starting loop at 0 causes duplicate permutations.

Not incrementing start causes infinite recursion.

Swapping back incorrectly breaks the list.

The loop starts at start to swap elements. After swapping, recurse with start + 1. Swap back using temp to restore order.

Practice

1. What is the main idea behind backtracking in algorithms?

easy

A. Use loops to repeat actions

B. Sort data before processing

C. Try all possible options and undo choices when they lead to dead ends

D. Store data in a queue for processing

Solution

1. Step 1: Understand backtracking purpose

   Backtracking tries all options step-by-step and goes back if a choice fails.

2. Step 2: Compare with other options

   Sorting, looping, and queues are different concepts not related to undoing choices.

3. Final Answer:

   Try all possible options and undo choices when they lead to dead ends -> Option C

4. Quick Check:

   Backtracking = Undo and try options [OK]

Hint: Backtracking means try and undo choices to find solutions [OK]

Common Mistakes:

• Confusing backtracking with sorting or looping
• Thinking backtracking only uses loops
• Ignoring the undo step in backtracking

2. Which of the following is the correct C# syntax to start a backtracking recursive function named Backtrack with an integer parameter step?

easy

A. def Backtrack(step): ...

B. void Backtrack(int step) { ... }

C. Backtrack(int step) => { ... }

D. function Backtrack(step) { ... }

Solution

1. Step 1: Identify C# function syntax

   C# uses return type before function name and parameters in parentheses.

2. Step 2: Check options

   void Backtrack(int step) { ... } matches C# syntax. function Backtrack(step) { ... } is JavaScript style, C is invalid C# syntax, A is Python.

3. Final Answer:

   void Backtrack(int step) { ... } -> Option B

4. Quick Check:

   C# method syntax = void Name(params) [OK]

Hint: C# methods start with return type and parentheses [OK]

Common Mistakes:

• Using JavaScript or Python syntax in C#
• Omitting return type in method declaration
• Using arrow syntax incorrectly in C#

3. Consider the following C# backtracking code snippet:

void Backtrack(int step, int max) {
  if (step == max) {
    Console.WriteLine(step);
    return;
  }
  if (step > max) {
    return;
  }
  Backtrack(step + 1, max);
  Backtrack(step + 2, max);
}

Backtrack(0, 3);

What will be the printed output?

medium

A. 0
1
2
3

B. 3
4

C. 2
3

D. 3
3
3

Solution

1. Step 1: Trace recursive calls

   Starting at step=0, max=3. Calls increase step by 1 or 2 until step==3.

2. Step 2: Identify base cases printed

   Paths reaching step==3 print 3. Three paths reach 3: 0->1->2->3, 0->1->3, and 0->2->3.

3. Final Answer:

   3 3 3 -> Option D

4. Quick Check:

   Base case prints 3 three times [OK]

Hint: Follow each recursive path to base case print [OK]

Common Mistakes:

• Counting intermediate steps as output
• Missing one of the recursive paths
• Confusing step values printed

4. The following C# backtracking code is intended to print all subsets of {1, 2}, but it has an error:

void Subsets(int index, List<int> current) {
  if (index == 2) {
    Console.WriteLine(string.Join(",", current));
    return;
  }
  Subsets(index + 1, current);
  current.Add(index + 1);
  Subsets(index + 1, current);
}

What is the main problem?

medium

A. The list current is not restored after adding elements, causing incorrect subsets

B. The base case condition is wrong

C. The function should return a value

D. The index variable is not incremented

Solution

1. Step 1: Analyze list modification

   After adding element to current, it is not removed before backtracking, so subsets accumulate extra elements.

2. Step 2: Identify fix

   Need to remove last added element after recursive call to restore state.

3. Final Answer:

   The list current is not restored after adding elements, causing incorrect subsets -> Option A

4. Quick Check:

   Backtracking requires undoing changes [OK]

Hint: Always undo list changes after recursive calls [OK]

Common Mistakes:

• Forgetting to remove added elements after recursion
• Misunderstanding base case
• Expecting return value from void method

5. You want to use backtracking to find all ways to climb a staircase of 4 steps, taking either 1 or 2 steps at a time. Which decision tree correctly represents the choices at each step?

medium

A. Root at step 0, branches to step 1 and step 2, each branch continues similarly until step 4

B. Root at step 4, branches to step 3 and step 2, moving backward

C. Root at step 0, branches only to step 1 repeatedly until step 4

D. Root at step 1, branches to step 3 and step 4 directly

Solution

1. Step 1: Understand problem steps

   Starting at step 0, choices are to move 1 or 2 steps forward until reaching step 4.

2. Step 2: Match decision tree structure

   Root at step 0, branches to step 1 and step 2, each branch continues similarly until step 4 shows root at 0 with branches to 1 and 2, continuing until 4, matching the problem.

3. Final Answer:

   Root at step 0, branches to step 1 and step 2, each branch continues similarly until step 4 -> Option A

4. Quick Check:

   Decision tree = choices from start to goal [OK]

Hint: Decision tree starts at initial state, branches by choices [OK]

Common Mistakes:

• Starting decision tree at goal instead of start
• Ignoring possible step sizes
• Skipping intermediate steps in tree