Backtracking Concept and Decision Tree Visualization in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start the backtracking recursion with the initial empty path.

DSA Rust

fn backtrack(path: &mut Vec<i32>, result: &mut Vec<Vec<i32>>) {
    if path.len() == 3 {
        result.push(path.clone());
        return;
    }
    for num in 1..=3 {
        path.push(num);
        backtrack(path, result);
        path.pop();
    }
}

fn main() {
    let mut result = Vec::new();
    let mut path = Vec::new();
    [1];
    println!("{:?}", result);
}

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

Abacktrack(&mut result, &mut path)

Bbacktrack(&path, &result)

Cbacktrack(&mut path, &mut result)

Dbacktrack(path, result)

Attempts:

3 left

💡 Hint

Common Mistakes

Passing immutable references instead of mutable ones.

Swapping the order of arguments.

The backtracking function requires mutable references to both path and result to modify them during recursion. So we pass &mut path and &mut result.

2fill in blank

medium

Complete the code to check the base case when the path length reaches the target length.

DSA Rust

fn backtrack(path: &mut Vec<i32>, result: &mut Vec<Vec<i32>>, target_len: usize) {
    if path.len() [1] target_len {
        result.push(path.clone());
        return;
    }
    for num in 1..=3 {
        path.push(num);
        backtrack(path, result, target_len);
        path.pop();
    }
}

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

A!=

B==

C>

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using < or > which causes premature or no termination.

Using != which never matches the base case.

The base case is when the current path length equals the target length, so we use == to check equality.

3fill in blank

hard

Fix the error in the recursive call to correctly pass the mutable references.

DSA Rust

fn backtrack(path: &mut Vec<i32>, result: &mut Vec<Vec<i32>>, target_len: usize) {
    if path.len() == target_len {
        result.push(path.clone());
        return;
    }
    for num in 1..=3 {
        path.push(num);
        backtrack([1], [2], target_len);
        path.pop();
    }
}

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

A&mut path

Bpath

C&path

Dresult

Attempts:

3 left

💡 Hint

Common Mistakes

Passing immutable references or values instead of mutable references.

Swapping the order of arguments.

Inside the backtracking function, path and result are already mutable references, so pass them directly in the recursive call.

4fill in blank

hard

Fill both blanks to create a decision tree that only includes paths where the sum is less than 5.

DSA Rust

fn backtrack(path: &mut Vec<i32>, result: &mut Vec<Vec<i32>>, target_len: usize) {
    if path.len() == target_len {
        result.push(path.clone());
        return;
    }
    for num in 1..=3 {
        path.push(num);
        if path.iter().copied().sum::<i32>() [1] 5 {
            backtrack(path, result, target_len);
        }
        path.pop();
    }
}

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

A<

B>=

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using >= or == which includes unwanted paths.

Using != which does not correctly filter sums.

We want to continue exploring only if the sum of the path is less than 5, so the condition uses <.

5fill in blank

hard

Fill all three blanks to create a backtracking function that builds combinations of length 2 from numbers 1 to 3 without repetition.

DSA Rust

fn backtrack(start: i32, path: &mut Vec<i32>, result: &mut Vec<Vec<i32>>, target_len: usize) {
    if path.len() == target_len {
        result.push(path.clone());
        return;
    }
    for num in [1]..=[2] {
        path.push(num);
        backtrack(num + 1, path, result, target_len);
        path.pop();
    }
}

fn main() {
    let mut result = Vec::new();
    let mut path = Vec::new();
    backtrack([3], &mut path, &mut result, 2);
    println!("{:?}", result);
}

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

A1

B3

C0

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Starting loop at 0 which is outside the problem range.

Using wrong start value in the initial call.

The loop runs from 1 to 3 inclusive, so blanks 1 and 2 are 1 and 3. The initial start value is 1.

Practice

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

easy

A. Store data in a tree structure for quick access

B. Sort data before processing it

C. Use loops to repeat actions a fixed number of times

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

Solution

1. Step 1: Understand backtracking purpose

   Backtracking tries all options to find solutions by exploring choices step-by-step.

2. Step 2: Recognize undoing choices

   When a choice leads to no solution, backtracking reverses it to try others.

3. Final Answer:

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

4. Quick Check:

   Backtracking = Try and undo [OK]

Hint: Backtracking means try, undo if fails, then try next [OK]

Common Mistakes:

• Confusing backtracking with sorting
• Thinking backtracking only uses loops
• Believing backtracking stores data only

2. Which of the following Rust code snippets correctly starts a backtracking function signature?

easy

A. fn backtrack(path: &mut Vec<i32>, choices: &[i32]) { ... }

B. fn backtrack(path: Vec<i32>, choices: Vec<i32>) -> i32 { ... }

C. fn backtrack(path: &Vec<i32>, choices: &Vec bool { ... }

D. fn backtrack(path: Vec<i32>, choices: &[i32]) -> String { ... }

Solution

1. Step 1: Identify mutable path parameter

   Backtracking usually modifies the current path, so it needs a mutable reference.

2. Step 2: Check choices parameter type

   Choices are usually passed as a slice reference for read-only access.

3. Final Answer:

   fn backtrack(path: &mut Vec<i32>, choices: &[i32]) { ... } -> Option A

4. Quick Check:

   Mutable path + slice choices = fn backtrack(path: &mut Vec<i32>, choices: &[i32]) { ... } [OK]

Hint: Use &mut for path to change it, &[i32] for choices [OK]

Common Mistakes:

• Passing path by value instead of mutable reference
• Returning wrong types for backtracking
• Using owned Vec for choices instead of slice

3. What will be the output of the following Rust backtracking code snippet that prints all subsets of [1, 2]?

fn backtrack(path: &mut Vec<i32>, nums: &[i32], index: usize) {
    if index == nums.len() {
        println!("{:?}", path);
        return;
    }
    // Include nums[index]
    path.push(nums[index]);
    backtrack(path, nums, index + 1);
    path.pop();
    // Exclude nums[index]
    backtrack(path, nums, index + 1);
}

fn main() {
    let mut path = Vec::new();
    let nums = [1, 2];
    backtrack(&mut path, &nums, 0);
}

medium

A. [1]
[2]
[1, 2]
[]

B. [1, 2]
[1]
[2]
[]

C. []
[1]
[2]
[1, 2]

D. [1, 2]
[2]
[1]
[]

Solution

1. Step 1: Trace recursive calls including and excluding elements

   The function first includes 1, then includes 2, prints [1, 2], then excludes 2, prints [1], then excludes 1 and includes 2, prints [2], finally excludes both and prints [].

2. Step 2: Order of printed subsets

   Due to include branch first in depth-first recursion: [1, 2]\n[1]\n[2]\n[].

3. Final Answer:

   [1, 2]\n[1]\n[2]\n[] -> Option B

4. Quick Check:

   Include first: [1,2] [1] [2] [] [OK]

Hint: Include branch first: [1,2] then [1] then [2] [] [OK]

Common Mistakes:

• Mixing order of subsets printed
• Forgetting to pop after push
• Confusing include/exclude steps

4. Identify the bug in this Rust backtracking snippet that tries to generate permutations of [1, 2]:

fn backtrack(path: &mut Vec<i32>, nums: &[i32], used: &mut Vec<bool>) {
    if path.len() == nums.len() {
        println!("{:?}", path);
        return;
    }
    for i in 0..nums.len() {
        if used[i] {
            continue;
        }
        path.push(nums[i]);
        // Missing used[i] = true;
        backtrack(path, nums, used);
        path.pop();
        used[i] = false;
    }
}

fn main() {
    let mut path = Vec::new();
    let nums = [1, 2];
    let mut used = vec![false; nums.len()];
    backtrack(&mut path, &nums, &mut used);
}

medium

A. The base case condition is incorrect

B. The path vector should not be mutable

C. The line setting used[i] = true is missing before recursion

D. The loop should iterate from 1 to nums.len()

Solution

1. Step 1: Check usage of 'used' vector

   The 'used' vector tracks which elements are included. It must be set to true before recursion to avoid reuse.

2. Step 2: Identify missing assignment

   Currently, used[i] is never set to true before recursion, so the same element can be reused multiple times incorrectly.

3. Final Answer:

   The line setting used[i] = true is missing before recursion -> Option C

4. Quick Check:

   Missing used[i] = true causes reuse error [OK]

Hint: Set used[i] = true before recursion, false after [OK]

Common Mistakes:

• Not marking elements as used before recursion
• Incorrect base case length check
• Loop index off-by-one errors

5. Given a decision tree for solving the N-Queens problem with backtracking, which of the following best describes the role of pruning in the tree?

hard

A. Pruning removes branches where queens attack each other, reducing search space

B. Pruning adds more branches to explore all possibilities

C. Pruning sorts the queens by their row positions

D. Pruning duplicates nodes to increase solution count

Solution

1. Step 1: Understand pruning in backtracking

   Pruning cuts off branches in the decision tree that cannot lead to valid solutions, saving time.

2. Step 2: Apply pruning to N-Queens

   In N-Queens, pruning removes branches where queens threaten each other, so no need to explore further.

3. Final Answer:

   Pruning removes branches where queens attack each other, reducing search space -> Option A

4. Quick Check:

   Pruning = cut invalid branches [OK]

Hint: Pruning cuts invalid paths early to save time [OK]

Common Mistakes:

• Thinking pruning adds branches
• Confusing pruning with sorting
• Believing pruning duplicates nodes