Minimum Genetic Mutation

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.

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']

Visualization

Tap to expand

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

✓ Breadth-First Search (Optimal)

⏱️ Time: O(N × 8 × 4) Space: O(N)

Since we need the minimum number of mutations, BFS is perfect as it explores mutations level by level, guaranteeing the first time we reach the target is with minimum steps. Use a queue to process genes and a set for O(1) bank lookups.

Brute Force (DFS with Backtracking)

⏱️ Time: O(4^8 * N) Space: O(8 * N)

Use depth-first search to explore every possible mutation sequence. For each gene, try changing each of the 8 positions to each of the 4 nucleotides, recursively exploring valid mutations until reaching the target.

Breadth-First Search (Optimal) — Algorithm Steps

Add startGene to queue and mark as visited
For each gene in current level, try all 32 possible mutations (8 positions × 4 nucleotides)
If mutation equals endGene, return current level + 1
If mutation is in bank and unvisited, add to next level
Continue until queue is empty or target found

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start with the initial gene in the queue

Level 1

Generate all valid single mutations and add to queue

Level 2

For each gene from level 1, generate their valid mutations

Target Found

First time we encounter target gene gives us minimum mutations

Code -

solution.c — C

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

#define GENE_LEN 8
#define MAX_BANK_SIZE 10
#define MAX_QUEUE_SIZE 100

typedef struct {
    char gene[GENE_LEN + 1];
    int mutations;
} QueueItem;

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 minMutation(char* startGene, char* endGene, char bank[][GENE_LEN+1], int bankSize) {
    if (!isInBank(endGene, bank, bankSize)) return -1;
    
    QueueItem queue[MAX_QUEUE_SIZE];
    char visited[MAX_BANK_SIZE][GENE_LEN+1];
    int front = 0, rear = 0, visitedCount = 0;
    
    strcpy(queue[rear].gene, startGene);
    queue[rear].mutations = 0;
    rear++;
    
    strcpy(visited[visitedCount], startGene);
    visitedCount++;
    
    char nucleotides[] = {'A', 'C', 'G', 'T'};
    
    while (front < rear) {
        QueueItem current = queue[front++];
        
        if (strcmp(current.gene, endGene) == 0) {
            return current.mutations;
        }
        
        for (int i = 0; i < GENE_LEN; i++) {
            for (int j = 0; j < 4; j++) {
                if (nucleotides[j] != current.gene[i]) {
                    char newGene[GENE_LEN + 1];
                    strcpy(newGene, current.gene);
                    newGene[i] = nucleotides[j];
                    
                    if (isInBank(newGene, bank, bankSize) && !isVisited(newGene, visited, visitedCount)) {
                        strcpy(visited[visitedCount], newGene);
                        visitedCount++;
                        
                        strcpy(queue[rear].gene, newGene);
                        queue[rear].mutations = current.mutations + 1;
                        rear++;
                    }
                }
            }
        }
    }
    
    return -1;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(N × 8 × 4)

Process each gene in bank once, trying 8×4=32 mutations each. N is bank size.

✓ Linear Growth

Space Complexity

O(N)

Queue and visited set can store up to N genes from the bank

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Breadth-First Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler