Minimum Genetic Mutation - Practice Coding Problems

Minimum Genetic Mutation - Problem

Genetic Evolution Simulator

Imagine you're a geneticist studying DNA mutations! You have a gene string represented by an 8-character sequence using only nucleotides: 'A', 'C', 'G', and 'T'.

Your mission: Transform a startGene into an endGene through the minimum number of mutations. Each mutation changes exactly one character in the gene string.

Example: "AACCGGTT" → "AACCGGTA" is one mutation (T→A)

However, there's a catch! 🧬 Not all mutations are biologically valid. You have a bank of valid gene sequences that represents all possible intermediate steps. A gene must exist in this bank to be considered a valid mutation target.

Goal: Return the minimum mutations needed, or -1 if transformation is impossible.

Note: The starting gene is always considered valid, even if not in the bank.

Input & Output

example_1.py — Basic Transformation

$ Input: startGene = "AACCGGTT", endGene = "AACCGGTA", bank = ["AACCGGTA"]

› Output: 1

💡 Note: Only one mutation needed: change the last 'T' to 'A'. The result "AACCGGTA" exists in the bank, so transformation is valid.

example_2.py — Multi-step Transformation

$ Input: startGene = "AACCGGTT", endGene = "AAACGGTA", bank = ["AACCGGTA", "AACCGCTA", "AAACGGTA"]

› Output: 2

💡 Note: Two mutations needed: AACCGGTT → AACCGGTA → AAACGGTA. Each intermediate step exists in the bank.

example_3.py — Impossible Transformation

$ Input: startGene = "AAAAACCC", endGene = "AACCCCCC", bank = ["AAAACCCC", "AAACCCCC", "AACCCCCC"]

› Output: 3

💡 Note: Three mutations needed: AAAAACCC → AAAACCCC → AAACCCCC → AACCCCCC. All steps are valid.

Visualization

Tap to expand

Understanding the Visualization

Model as Graph

Each valid gene string is a node. Edges connect genes differing by one character.

Apply BFS

Use BFS to explore from startGene, guaranteeing shortest path discovery.

Generate Neighbors

For each gene, try changing each position to each nucleotide (32 possibilities).

Validate & Queue

Only queue neighbors that exist in bank and haven't been visited.

Key Takeaway

🎯 Key Insight: Gene mutation is a shortest path problem in an unweighted graph. BFS naturally finds the minimum number of mutations by exploring paths level by level.

Time & Space Complexity

Time Complexity

⏱️

O(4^8 * N)

In worst case, we might explore 4^8 possible gene combinations, checking each against bank of size N

✓ Linear Growth

Space Complexity

O(8 * N)

Recursion stack depth up to 8*N in worst case, plus visited set

✓ Linear Space

Constraints

0 ≤ bank.length ≤ 10
startGene.length == endGene.length == bank[i].length == 8
startGene, endGene, and bank[i] consist of only the characters ['A', 'C', 'G', 'T']

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The optimal approach uses BFS (Breadth-First Search) to find the minimum genetic mutations. Since we need the shortest path in an unweighted graph, BFS guarantees we find the minimum number of mutations. Key optimizations: use a HashSet for O(1) bank lookups and track visited genes to avoid cycles. Time complexity: O(N) where N is the bank size.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS with Backtracking)	O(4^8 * N)	O(8 * N)	Try all possible mutation paths recursively
Breadth-First Search (Optimal)	O(N × 8 × 4)	O(N)	Use BFS to find shortest mutation path with level-by-level exploration

Brute Force (DFS with Backtracking) — Algorithm Steps

Start from the initial gene
For each position (0-7), try each nucleotide (A,C,G,T)
If the new gene is in the bank and not visited, recurse
Track the minimum mutations found across all paths
Use backtracking to explore all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Gene

Begin at startGene and explore all possible single mutations

Branch Out

For each valid mutation, recursively explore further mutations

Backtrack

When path ends or target found, backtrack to try other branches

Find Minimum

Keep track of shortest path found across all explorations

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#define GENE_LEN 8
#define MAX_BANK_SIZE 10

int isInBank(char* gene, char bank[][GENE_LEN+1], int bankSize) {
    for (int i = 0; i < bankSize; i++) {
        if (strcmp(gene, bank[i]) == 0) return 1;
    }
    return 0;
}

int isVisited(char* gene, char visited[][GENE_LEN+1], int visitedCount) {
    for (int i = 0; i < visitedCount; i++) {
        if (strcmp(gene, visited[i]) == 0) return 1;
    }
    return 0;
}

int dfs(char* current, char* target, int mutations, 
        char bank[][GENE_LEN+1], int bankSize,
        char visited[][GENE_LEN+1], int* visitedCount) {
    if (strcmp(current, target) == 0) return mutations;
    
    int minMutations = INT_MAX;
    char nucleotides[] = {'A', 'C', 'G', 'T'};
    
    for (int i = 0; i < GENE_LEN; i++) {
        for (int j = 0; j < 4; j++) {
            if (nucleotides[j] != current[i]) {
                char newGene[GENE_LEN+1];
                strcpy(newGene, current);
                newGene[i] = nucleotides[j];
                
                if (isInBank(newGene, bank, bankSize) && 
                    !isVisited(newGene, visited, *visitedCount)) {
                    strcpy(visited[*visitedCount], newGene);
                    (*visitedCount)++;
                    
                    int result = dfs(newGene, target, mutations + 1, bank, bankSize, visited, visitedCount);
                    if (result < minMutations) minMutations = result;
                    
                    (*visitedCount)--;
                }
            }
        }
    }
    
    return minMutations;
}

int minMutation(char* startGene, char* endGene, char bank[][GENE_LEN+1], int bankSize) {
    if (!isInBank(endGene, bank, bankSize)) return -1;
    
    char visited[MAX_BANK_SIZE][GENE_LEN+1];
    int visitedCount = 0;
    
    int result = dfs(startGene, endGene, 0, bank, bankSize, visited, &visitedCount);
    return result == INT_MAX ? -1 : result;
}

int main() {
    // Input parsing implementation
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^8 * N)

In worst case, we might explore 4^8 possible gene combinations, checking each against bank of size N

✓ Linear Growth

Space Complexity

O(8 * N)

Recursion stack depth up to 8*N in worst case, plus visited set

✓ Linear Space

Constraints

0 ≤ bank.length ≤ 10
startGene.length == endGene.length == bank[i].length == 8
startGene, endGene, and bank[i] consist of only the characters ['A', 'C', 'G', 'T']

42.8K Views

Medium-High Frequency

~18 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (DFS with Backtracking) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler