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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start the backtracking recursion from index 0.

DSA Javascript

function backtrack(nums, index) {
  if (index === nums.length) {
    return;
  }
  // process current index
  backtrack(nums, [1]);
}

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

Anums.length

Bindex - 1

C0

Dindex + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using index - 1 causes infinite recursion backwards.

Using 0 resets the index causing repeated calls.

Using nums.length skips all elements.

We move forward by increasing the index by 1 to explore the next element.

2fill in blank

medium

Complete the code to add the current path to results when base case is reached.

DSA Javascript

function backtrack(nums, index, path, results) {
  if (index === nums.length) {
    results.push([1]);
    return;
  }
  // continue backtracking
}

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

Anums.slice()

Bpath

Cpath.slice()

Dindex

Attempts:

3 left

💡 Hint

Common Mistakes

Pushing path directly causes all results to change together.

Pushing nums or index is incorrect for storing the path.

We push a copy of path using slice() to avoid reference issues.

3fill in blank

hard

Fix the error in the backtracking step to correctly add and remove elements.

DSA Javascript

function backtrack(nums, index, path, results) {
  if (index === nums.length) {
    results.push(path.slice());
    return;
  }
  path.push(nums[index]);
  backtrack(nums, index + 1, path, results);
  path.[1]();
}

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

Apop

Bshift

Cpush

Dsplice

Attempts:

3 left

💡 Hint

Common Mistakes

Using shift() removes wrong element.

Using push() again adds extra elements.

Using splice() without correct indices causes errors.

We use pop() to remove the last added element to backtrack correctly.

4fill in blank

hard

Fill both blanks to generate all subsets of nums using backtracking.

DSA Javascript

function subsets(nums) {
  const results = [];
  function backtrack(start, path) {
    results.push(path.slice());
    for (let i = [1]; i < nums.length; i++) {
      path.push(nums[i]);
      backtrack(i [2] 1, path);
      path.pop();
    }
  }
  backtrack(0, []);
  return results;
}

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

Astart

B1

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Starting from 1 misses the first element.

Using '-' moves backward causing infinite loops.

Start from start and move forward by adding 1 to i to explore subsets.

5fill in blank

hard

Fill all three blanks to implement backtracking for combination sum problem.

DSA Javascript

function combinationSum(candidates, target) {
  const results = [];
  function backtrack(start, path, total) {
    if (total === [1]) {
      results.push(path.slice());
      return;
    }
    if (total > target) {
      return;
    }
    for (let i = start; i < candidates.length; i++) {
      path.push(candidates[i]);
      backtrack(i, path, total [2] candidates[i]);
      path.pop();
    }
  }
  backtrack(0, [], [3]);
  return results;
}

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

Atarget

B+

C-

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' instead of '+' causes wrong totals.

Starting total at target or other values causes logic errors.

We check if total equals target, add candidates[i] to total, and start total at 0.

Practice

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

easy

A. Store data in a fixed-size array

B. Sort data before processing it

C. Use loops to repeat actions without stopping

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

Solution

1. Step 1: Understand backtracking process

   Backtracking tries options one by one and goes back if a choice fails.

2. Step 2: Compare options with backtracking idea

   Only Try all possible options and undo choices when they lead to dead ends describes trying and undoing choices, which matches backtracking.

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 choices [OK]

Hint: Backtracking means try, fail, undo, and try again [OK]

Common Mistakes:

• Confusing backtracking with sorting
• Thinking backtracking only uses loops
• Assuming backtracking stores fixed data

2. Which of the following is the correct syntax to start a backtracking function in JavaScript?

easy

A. backtrack function(options) { }

B. function backtrack(options) { }

C. function: backtrack(options) { }

D. def backtrack(options):

Solution

1. Step 1: Identify JavaScript function syntax

   JavaScript functions start with the keyword function followed by name and parameters.

2. Step 2: Check each option

   function backtrack(options) { } matches correct JavaScript syntax. Options B and C are invalid syntax. def backtrack(options): is Python syntax.

3. Final Answer:

   function backtrack(options) { } -> Option B

4. Quick Check:

   JS function syntax = function name(params) [OK]

Hint: JS functions start with 'function' keyword [OK]

Common Mistakes:

• Using Python syntax in JavaScript
• Misplacing the function keyword
• Using colons instead of braces

3. What will be the output of the following code snippet?

function backtrack(path, options) {
  if (path.length === 2) {
    console.log(path);
    return;
  }
  for (let i = 0; i < options.length; i++) {
    backtrack(path + options[i], options);
  }
}
backtrack('', ['a', 'b']);

medium

A. ['aa', 'ab', 'ba', 'bb']

B. ['a', 'b']

C. ['ab', 'ba']

D. ['a', 'aa', 'ab', 'b', 'ba', 'bb']

Solution

1. Step 1: Understand recursion and path building

   The function adds one character from options each call until path length is 2, then prints path.

2. Step 2: Trace calls and outputs

   Paths generated: 'aa', 'ab', 'ba', 'bb' as it tries both 'a' and 'b' at each step.

3. Final Answer:

   ['aa', 'ab', 'ba', 'bb'] -> Option A

4. Quick Check:

   All 2-letter combos from 'a' and 'b' = ['aa','ab','ba','bb'] [OK]

Hint: Backtracking tries all combos of length 2 here [OK]

Common Mistakes:

• Thinking only unique letters appear
• Confusing path length with options length
• Missing repeated letters in output

4. Find the error in this backtracking code that tries to generate subsets:

function subsets(nums, path = []) {
  if (nums.length === 0) {
    console.log(path);
    return;
  }
  subsets(nums.slice(1), path);
  subsets(nums.slice(1), path.push(nums[0]));
}
subsets([1, 2]);

medium

A. Console.log should be outside the function

B. Missing base case for empty path

C. Using path.push(nums[0]) modifies path and returns length, not array

D. Should use nums.pop() instead of nums.slice(1)

Solution

1. Step 1: Understand path.push behavior

   path.push(nums[0]) changes path array but returns new length, not updated array.

2. Step 2: Identify correct recursive call

   Passing path.push(nums[0]) as argument passes a number, causing wrong recursion.

3. Final Answer:

   Using path.push(nums[0]) modifies path and returns length, not array -> Option C

4. Quick Check:

   push() returns length, not array [OK]

Hint: push() returns length, not updated array [OK]

Common Mistakes:

• Assuming push returns the array
• Ignoring side effects on path array
• Confusing slice and pop usage

5. Given a decision tree for solving a maze using backtracking, which strategy helps avoid revisiting the same cell and infinite loops?

hard

A. Mark visited cells and skip them in future steps

B. Always move right before other directions

C. Use a queue instead of recursion

D. Restart the maze from the beginning after each dead end

Solution

1. Step 1: Understand infinite loops in maze backtracking

   Revisiting same cells causes loops; marking visited cells prevents this.

2. Step 2: Evaluate options for avoiding revisits

   Mark visited cells and skip them in future steps marks visited cells to skip them, stopping loops. Others do not prevent revisits effectively.

3. Final Answer:

   Mark visited cells and skip them in future steps -> Option A

4. Quick Check:

   Visited marking prevents infinite loops [OK]

Hint: Mark visited spots to avoid loops [OK]

Common Mistakes:

• Thinking direction order avoids loops
• Confusing recursion with queue usage
• Restarting maze wastes time, doesn't prevent loops