Check if Array has at least M non-overlapping Subarray with gcd G

Given an array A[] and M, the task is to check whether there exist M non-overlapping subarrays(non-empty) of A for which the average of the GCD of those subarrays equals G where G denotes the gcd of all the numbers in the array A.

Examples:

Input: A[] =  {1, 2, 3, 4, 5}, M = 3
Output: Yes
?Explanation: Here, G = gcd(1, 2, 3, 4, 5) = 1. 
We can choose 3 non overlapping subarrays {[1], [2, 3], [4, 5]} where 
gcd(1) = 1, gcd(2, 3) = 1, and gcd(4, 5) = 1. 
Thus, the average = (1 + 1 + 1)/3 = 1. Hence, we can have 3 such subarrays.

Input: A[] =  {6, 12, 18, 24} 
Output: No

Approach: The problem can be solved based on the following observation:

Observations:

Note that the gcd of any subarray of A[] will certainly be at least G, since G divides every element of A[]. So, each g_i (gcd of subarray) ? G, which means the only way their average can equal G is if each g_i itself equals G.

So, we need to find if  at least M disjoint subarrays in A[] have gcd G.

• Since G divides every element of A[], if we have a subarray whose gcd is G, extending this subarray to the right or left will still leave its gcd as G.
• In particular, if a solution exists, then there will always exist a solution that covers the full array.
• This gives us a simple algorithm to check:
  • While the array is not empty, find the smallest prefix of the array with gcd G. If no such prefix exists, stop.
  • This prefix (if found) will form one subarray in the answer. Remove this prefix and do the same to the remaining array.
• The number of times we successfully performed the operation equals the maximum number of disjoint subarrays with gcd G that can be obtained. 

If number is ? M then print ‘Yes’, otherwise print ‘No’.

Follow the below steps to solve the problem:

• Find the GCD(G)of all the elements in array A[].
• Keep a variable denoting the current gcd, say g. Initially, g = 0.
• For each i from 1 to N:
  • Set g = gcd(g, A_i)
  • If g > G, continue on
  • If g = G, increase the count by 1 and reset g to 0.
• If the count of GCD is greater than or equal to M, print “Yes” else “No”

Below is the implementation of the above approach.

C++

// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;

// Function to find gcd of two numbers
int gcd(int a, int b)
{
    if (b == 0)
    {
        return a;
    }
    return gcd(b, a % b);
}

// Function to find check whether
// non-overlapping subarray exists
string find(int arr[], int n, int m)
{
    int G = 0;
    int g = 0;
    int count = 0;
    for (int i = 0; i < n; i++)
    {
        G = gcd(G, arr[i]);
    }
    for (int i = 0; i < n; i++)
    {

        // arr[i] = sc.nextInt();
        g = gcd(g, arr[i]);
        if (g == G)
        {
            count++;
            g = 0;
        }
    }
    if (count >= m)
        return "Yes";
    return "No";
}

// Driver code
int main()
{
    int A[] = {1, 2, 3, 4, 5};
    int N = sizeof(A) / sizeof(A[0]);
    int K = 3;

    // Function call
    cout << (find(A, N, K));
}

// This code is contributed by Potta Lokesh

Java

// Java code to implement the approach

import java.io.*;
import java.util.*;

public class GFG {

    // Function to find gcd of two numbers
    public static int gcd(int a, int b)
    {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    // Function to find check whether
    // non-overlapping subarray exists
    static String find(int arr[], int n, int m)
    {
        int G = 0;
        int g = 0;
        int count = 0;
        for (int i = 0; i < n; i++) {
            G = gcd(G, arr[i]);
        }
        for (int i = 0; i < n; i++) {

            // arr[i] = sc.nextInt();
            g = gcd(g, arr[i]);
            if (g == G) {
                count++;
                g = 0;
            }
        }
        if (count >= m)
            return "Yes";
        return "No";
    }

    // Driver code
    public static void main(String[] args)
    {
        int A[] = { 1, 2, 3, 4, 5 };
        int N = A.length;
        int K = 3;

        // Function call
        System.out.println(find(A, N, K));
    }
}

Python3

# Python code to implement the approach

# Function to find gcd of two numbers
def gcd(a, b):
    if (b == 0):
        return a
    return gcd(b, a % b)

# Function to find check whether
# non-overlapping subarray exists
def find(arr, n, m):
    G = 0
    g = 0
    count = 0
    for i in range(n):
        G = gcd(G, arr[i])

    for i in range(n):
        g = gcd(g, arr[i])
        if (g == G):
            count += 1
            g = 0

    if (count >= m):
        return "Yes"
    return "No"

# Driver code
if __name__ == "__main__":
    A = [1, 2, 3, 4, 5]
    N = 5
    K = 3

    # Function call
    print(find(A, N, K))

# This code is contributed by Rohit Pradhan

C#

// C# code to implement the approach

using System;

public class GFG {

    // Function to find gcd of two numbers
    public static int gcd(int a, int b)
    {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    // Function to find check whether
    // non-overlapping subarray exists
    static String find(int[] arr, int n, int m)
    {
        int G = 0;
        int g = 0;
        int count = 0;
        for (int i = 0; i < n; i++) {
            G = gcd(G, arr[i]);
        }
        for (int i = 0; i < n; i++) {

            // arr[i] = sc.nextInt();
            g = gcd(g, arr[i]);
            if (g == G) {
                count++;
                g = 0;
            }
        }
        if (count >= m)
            return "Yes";
        return "No";
    }

    static public void Main()
    {

        // Code
        int[] A = { 1, 2, 3, 4, 5 };
        int N = A.Length;
        int K = 3;

        // Function call
        Console.WriteLine(find(A, N, K));
    }
}

// This code is contributed by lokeshmvs21.

Javascript

// Javascript code to implement the approach

// Function to find gcd of two numbers

function gcd(a, b){

  // Everything divides 0
  if(b == 0){
    return a;
  }

  return gcd(b, a % b);
}

// Function to find check whether
// non-overlapping subarray exists
function find(arr, n, m)
{
        let G = 0;
        let g = 0;
        let count = 0;
        for (let i = 0; i < n; i++) {
            G = gcd(G, arr[i]);
        }
        for (let i = 0; i < n; i++) {


            g = gcd(g, arr[i]);
            if (g == G) {
                count++;
                g = 0;
            }
        }
        if (count >= m)
            return "Yes";
        return "No";
   }
// Driver code
let A = [ 1, 2, 3, 4, 5 ];
let N = A.length;
let K = 3;

 // Function call
console.log(find(A, N, K));

// This code is contributed by aarohirai2616.

Output

Yes

Time Complexity: O(N * log(K)) where K is the maximum element of A[]
Auxiliary Space: O(log(min(a,b))