Minimum Number of Operations to Make All Array Elements Equal to 1

Minimum Number of Operations to Make All Array Elements Equal to 1 - Problem

You are given a 0-indexed array nums consisting of positive integers. You can do the following operation on the array any number of times:

Select an index i such that 0 <= i < n - 1 and replace either of nums[i] or nums[i+1] with their gcd value.

Return the minimum number of operations to make all elements of nums equal to 1. If it is impossible, return -1.

The gcd of two integers is the greatest common divisor of the two integers.

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,6,3,4]

› Output: 4

💡 Note: Find shortest subarray with GCD=1. [2,6,3] has GCD=1 with length 3. Operations: (3-1) to reduce subarray + (4-1) to spread = 2+3 = 5. But optimal is different - need 4 operations total.

Example 2 — Already Has 1

$ Input: nums = [2,10,6,14]

› Output: -1

💡 Note: GCD of entire array is 2 > 1, and no subarray can produce GCD=1, so impossible.

Example 3 — Contains 1

$ Input: nums = [2,1,3]

› Output: 2

💡 Note: Array already contains 1 at index 1. Need 2 operations to make other elements equal to 1.

Constraints

1 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8

The key insight is that if any subarray has GCD=1, we can reduce it to a single 1, then spread that 1 to make all elements equal to 1. Find the shortest such subarray to minimize operations. If the array already contains 1s, we just need n - (count of 1s) operations. Best approach uses subarray GCD analysis: Time O(n²), Space O(1).

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(2^n) Space: O(2^n)

Generate all possible states by trying every valid operation and track minimum steps to reach all 1s. This explores the entire search space but is extremely slow for larger arrays.

Subarray GCD Analysis

⏱️ Time: O(n²) Space: O(1)

Key insight: if any subarray has GCD=1, we can reduce it to a single 1, then spread that 1 across the entire array. Find the shortest such subarray to minimize operations.

Brute Force Simulation — Algorithm Steps

Check if already all 1s
Try all possible adjacent GCD operations
Recursively explore each new state
Return minimum operations found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original array [2,6,3,4]

Generate States

Apply all possible adjacent GCD operations

BFS Search

Continue until all elements become 1

Code -

solution.c — C

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

#define MAX_QUEUE_SIZE 100000
#define MAX_ARRAY_SIZE 100

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

typedef struct {
    int nums[MAX_ARRAY_SIZE];
    int ops;
    int n;
} State;

typedef struct {
    State states[MAX_QUEUE_SIZE];
    int front;
    int rear;
} Queue;

void initQueue(Queue* q) {
    q->front = 0;
    q->rear = 0;
}

bool isEmpty(Queue* q) {
    return q->front == q->rear;
}

void enqueue(Queue* q, State state) {
    q->states[q->rear] = state;
    q->rear++;
}

State dequeue(Queue* q) {
    State state = q->states[q->front];
    q->front++;
    return state;
}

bool allOnes(int* nums, int n) {
    for (int i = 0; i < n; i++) {
        if (nums[i] != 1) return false;
    }
    return true;
}

bool isVisited(int visited[][MAX_ARRAY_SIZE], int visitedCount, int* nums, int n) {
    for (int i = 0; i < visitedCount; i++) {
        bool match = true;
        for (int j = 0; j < n; j++) {
            if (visited[i][j] != nums[j]) {
                match = false;
                break;
            }
        }
        if (match) return true;
    }
    return false;
}

void addVisited(int visited[][MAX_ARRAY_SIZE], int* visitedCount, int* nums, int n) {
    for (int i = 0; i < n; i++) {
        visited[*visitedCount][i] = nums[i];
    }
    (*visitedCount)++;
}

int solution(int* nums, int n) {
    if (allOnes(nums, n)) return 0;
    
    // Check if impossible
    int overallGcd = nums[0];
    for (int i = 1; i < n; i++) {
        overallGcd = gcd(overallGcd, nums[i]);
    }
    if (overallGcd > 1) return -1;
    
    // BFS
    Queue queue;
    initQueue(&queue);
    
    static int visited[MAX_QUEUE_SIZE][MAX_ARRAY_SIZE];
    int visitedCount = 0;
    
    State initial;
    for (int i = 0; i < n; i++) {
        initial.nums[i] = nums[i];
    }
    initial.ops = 0;
    initial.n = n;
    
    enqueue(&queue, initial);
    addVisited(visited, &visitedCount, nums, n);
    
    while (!isEmpty(&queue)) {
        State current = dequeue(&queue);
        
        if (allOnes(current.nums, n)) {
            return current.ops;
        }
        
        // Try all possible operations
        for (int i = 0; i < n - 1; i++) {
            int gcdVal = gcd(current.nums[i], current.nums[i + 1]);
            
            // Replace nums[i] with gcd
            State newState1 = current;
            newState1.nums[i] = gcdVal;
            newState1.ops++;
            
            if (!isVisited(visited, visitedCount, newState1.nums, n)) {
                addVisited(visited, &visitedCount, newState1.nums, n);
                enqueue(&queue, newState1);
            }
            
            // Replace nums[i+1] with gcd
            State newState2 = current;
            newState2.nums[i + 1] = gcdVal;
            newState2.ops++;
            
            if (!isVisited(visited, visitedCount, newState2.nums, n)) {
                addVisited(visited, &visitedCount, newState2.nums, n);
                enqueue(&queue, newState2);
            }
        }
    }
    
    return -1;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse JSON array [a,b,c,d]
    int nums[MAX_ARRAY_SIZE];
    int n = 0;
    
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        char* endptr;
        nums[n++] = (int)strtol(p, &endptr, 10);
        p = endptr;
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each position can be modified multiple ways, creating exponential branching

⚠ Quadratic Growth

Space Complexity

O(2^n)

BFS queue or recursion stack stores exponentially many states

✓ Linear Space

8.5K Views

Medium Frequency

~25 min Avg. Time

156 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

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler