Welcome to Subscribe On Youtube

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

Description

You are given a 0-indexed array nums consisiting 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.

 

Example 1:

Input: nums = [2,6,3,4]
Output: 4
Explanation: We can do the following operations:
- Choose index i = 2 and replace nums[2] with gcd(3,4) = 1. Now we have nums = [2,6,1,4].
- Choose index i = 1 and replace nums[1] with gcd(6,1) = 1. Now we have nums = [2,1,1,4].
- Choose index i = 0 and replace nums[0] with gcd(2,1) = 1. Now we have nums = [1,1,1,4].
- Choose index i = 2 and replace nums[3] with gcd(1,4) = 1. Now we have nums = [1,1,1,1].

Example 2:

Input: nums = [2,10,6,14]
Output: -1
Explanation: It can be shown that it is impossible to make all the elements equal to 1.

 

Constraints:

  • 2 <= nums.length <= 50
  • 1 <= nums[i] <= 106

 

Follow-up:

The O(n) time complexity solution works, but could you find an O(1) constant time complexity solution?

Solutions

  • class Solution {
        public int minOperations(int[] nums) {
            int n = nums.length;
            int cnt = 0;
            for (int x : nums) {
                if (x == 1) {
                    ++cnt;
                }
            }
            if (cnt > 0) {
                return n - cnt;
            }
            int mi = n + 1;
            for (int i = 0; i < n; ++i) {
                int g = 0;
                for (int j = i; j < n; ++j) {
                    g = gcd(g, nums[j]);
                    if (g == 1) {
                        mi = Math.min(mi, j - i + 1);
                    }
                }
            }
            return mi > n ? -1 : n - 1 + mi - 1;
        }
    
        private int gcd(int a, int b) {
            return b == 0 ? a : gcd(b, a % b);
        }
    }
    
  • class Solution {
    public:
        int minOperations(vector<int>& nums) {
            int n = nums.size();
            int cnt = 0;
            for (int x : nums) {
                if (x == 1) {
                    ++cnt;
                }
            }
            if (cnt) {
                return n - cnt;
            }
            int mi = n + 1;
            for (int i = 0; i < n; ++i) {
                int g = 0;
                for (int j = i; j < n; ++j) {
                    g = gcd(g, nums[j]);
                    if (g == 1) {
                        mi = min(mi, j - i + 1);
                    }
                }
            }
            return mi > n ? -1 : n - 1 + mi - 1;
        }
    };
    
  • class Solution:
        def minOperations(self, nums: List[int]) -> int:
            n = len(nums)
            cnt = nums.count(1)
            if cnt:
                return n - cnt
            mi = n + 1
            for i in range(n):
                g = 0
                for j in range(i, n):
                    g = gcd(g, nums[j])
                    if g == 1:
                        mi = min(mi, j - i + 1)
            return -1 if mi > n else n - 1 + mi - 1
    
    
  • func minOperations(nums []int) int {
    	n := len(nums)
    	cnt := 0
    	for _, x := range nums {
    		if x == 1 {
    			cnt++
    		}
    	}
    	if cnt > 0 {
    		return n - cnt
    	}
    	mi := n + 1
    	for i := 0; i < n; i++ {
    		g := 0
    		for j := i; j < n; j++ {
    			g = gcd(g, nums[j])
    			if g == 1 {
    				mi = min(mi, j-i+1)
    			}
    		}
    	}
    	if mi > n {
    		return -1
    	}
    	return n - 1 + mi - 1
    }
    
    func gcd(a, b int) int {
    	if b == 0 {
    		return a
    	}
    	return gcd(b, a%b)
    }
    
    func min(a, b int) int {
    	if a < b {
    		return a
    	}
    	return b
    }
    
  • function minOperations(nums: number[]): number {
        const n = nums.length;
        let cnt = 0;
        for (const x of nums) {
            if (x === 1) {
                ++cnt;
            }
        }
        if (cnt > 0) {
            return n - cnt;
        }
        let mi = n + 1;
        for (let i = 0; i < n; ++i) {
            let g = 0;
            for (let j = i; j < n; ++j) {
                g = gcd(g, nums[j]);
                if (g === 1) {
                    mi = Math.min(mi, j - i + 1);
                }
            }
        }
        return mi > n ? -1 : n - 1 + mi - 1;
    }
    
    function gcd(a: number, b: number): number {
        return b === 0 ? a : gcd(b, a % b);
    }
    
    

All Problems

All Solutions