任何元素左侧可整除的最大元素数

给定一个包含N 个元素的数组arr[] 。元素 arr[i] 的好值是有效索引 j例子：

Input: arr[] = {9, 6, 2, 3} 
Output: 2 
9 doesn’t has any element on its left. 
6 doesn’t divide any element on its left. 
2 divides 6. 
3 divides 6 and 9.
Input: arr[] = {8, 1, 28, 4, 2, 6, 7} 
Output: 3 
 

朴素的方法：对于每个元素，在其左侧找到可被它整除的数字的数量并打印这些值的最大值。
下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to return the maximum count
// of required elements
int findMax(int arr[], int n)
{
    int res = 0;
    int i, j;
     
    // For every element in the array starting
    // from the second element
    for(i = 0; i < n ; i++)
    {
         
        // Check all the elements on the left
        // of current element which are divisible
        // by the current element
        int count = 0;
        for(j = 0; j < i; j++)
        {
            if (arr[j] % arr[i] == 0)
                count += 1;
        }
        res = max(count, res);
    }
    return res;
}
 
// Driver code
int main()
{
    int arr[] = { 8, 1, 28, 4, 2, 6, 7 };
    int n = sizeof(arr) / sizeof(int);
 
    cout << findMax(arr, n);
 
    return 0;
}
 
// This code is contributed by Rajput-Ji

Java

// Java implementation of the approach
class GFG
{
 
// Function to return the maximum count
// of required elements
static int findMax(int arr[], int n)
{
    int res = 0;
    int i, j;
     
    // For every element in the array starting
    // from the second element
    for(i = 0; i < n ; i++)
    {
         
        // Check all the elements on the left
        // of current element which are divisible
        // by the current element
        int count = 0;
        for(j = 0; j < i; j++)
        {
            if (arr[j] % arr[i] == 0)
                count += 1;
        }
        res = Math.max(count, res);
    }
    return res;
}
 
// Driver Code
public static void main (String[] args)
{
    int arr[] = {8, 1, 28, 4, 2, 6, 7};
    int n = arr.length;
    System.out.println(findMax(arr, n));
}
}
 
// This code is contributed by AnkitRai01

Python3

# Python3 implementation of the approach
 
# Function to return the maximum count
# of required elements
def findMax(arr, n):
    res = 0
     
    # For every element in the array starting
    # from the second element
    for i in range(1, n):
         
        # Check all the elements on the left
        # of current element which are divisible
        # by the current element
        count = 0
        for j in range(0, i):
            if arr[j] % arr[i] == 0:
                count += 1
        res = max(count, res)
    return res
 
# Driver code
arr = [8, 1, 28, 4, 2, 6, 7]
n = len(arr)
print(findMax(arr, n))

C#

// C# implementation of the above approach
using System;
     
class GFG
{
 
// Function to return the maximum count
// of required elements
static int findMax(int []arr, int n)
{
    int res = 0;
    int i, j;
     
    // For every element in the array 
    // starting from the second element
    for(i = 0; i < n ; i++)
    {
         
        // Check all the elements on the left
        // of current element which are divisible
        // by the current element
        int count = 0;
        for(j = 0; j < i; j++)
        {
            if (arr[j] % arr[i] == 0)
                count += 1;
        }
        res = Math.Max(count, res);
    }
    return res;
}
 
// Driver Code
public static void Main (String[] args)
{
    int []arr = {8, 1, 28, 4, 2, 6, 7};
    int n = arr.Length;
    Console.WriteLine(findMax(arr, n));
}
}
 
// This code is contributed by PrinciRaj1992

Javascript

 
// JavaScript implementation of the approach
 
// Function to return the maximum count
// of required elements
function findMax(arr, n)
{
    var res = 0;
    var i, j;
     
    // For every element in the array starting
    // from the second element
    for(i = 0; i < n ; i++)
    {
         
        // Check all the elements on the left
        // of current element which are divisible
        // by the current element
        var count = 0;
        for(j = 0; j < i; j++)
        {
            if (arr[j] % arr[i] == 0)
                count += 1;
        }
        res = Math.max(count, res);
    }
    return res;
}
 
// Driver code
var arr = [8, 1, 28, 4, 2, 6, 7];
var n = arr.length;
document.write( findMax(arr, n));
 

输出：

3

时间复杂度： O(N ² )
有效的方法：可以观察到，对于任何元素对(arr[i], arr[j]) ，其中i < j和(arr[i] % arr[j]) = 0 ，如果元素的数量可以被arr整除[i]在它的左边是X那么它左边的可被arr[j]整除的元素的数量肯定会大于X因为所有可被arr[i]整除的元素也将被arr[j]整除。因此，对于每个可被其右侧的任何其他元素整除的元素，不需要计算其左侧可被其整除的元素数，这将提高整个程序的时间复杂度，但应注意对于没有元素可以被任何其他元素整除的输入(例如，当所有元素都是素数时)，最坏情况的时间复杂度仍然是O(N ² ) 。
下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to return the maximum count
// of required elements
int findMax(int arr[], int n)
{
 
    // divisible[i] will store true
    // if arr[i] is divisible by
    // any element on its right
    bool divisible[n] = { false };
 
    // To store the maximum required count
    int res = 0;
 
    // For every element of the array
    for (int i = n - 1; i > 0; i--) {
 
        // If the current element is
        // divisible by any element
        // on its right
        if (divisible[i])
            continue;
 
        // Find the count of element
        // on the left which are divisible
        // by the current element
        int cnt = 0;
        for (int j = 0; j < i; j++) {
 
            // If arr[j] is divisible then
            // set divisible[j] to true
            if ((arr[j] % arr[i]) == 0) {
                divisible[j] = true;
                cnt++;
            }
        }
 
        // Update the maximum required count
        res = max(res, cnt);
    }
 
    return res;
}
 
// Driver code
int main()
{
    int arr[] = { 8, 1, 28, 4, 2, 6, 7 };
    int n = sizeof(arr) / sizeof(int);
 
    cout << findMax(arr, n);
 
    return 0;
}

Java

// Java implementation of the approach
class GFG
{
 
// Function to return the maximum count
// of required elements
static int findMax(int arr[], int n)
{
 
    // divisible[i] will store true
    // if arr[i] is divisible by
    // any element on its right
    boolean []divisible = new boolean[n];
 
    // To store the maximum required count
    int res = 0;
 
    // For every element of the array
    for (int i = n - 1; i > 0; i--)
    {
 
        // If the current element is
        // divisible by any element
        // on its right
        if (divisible[i])
            continue;
 
        // Find the count of element
        // on the left which are divisible
        // by the current element
        int cnt = 0;
        for (int j = 0; j < i; j++)
        {
 
            // If arr[j] is divisible then
            // set divisible[j] to true
            if ((arr[j] % arr[i]) == 0)
            {
                divisible[j] = true;
                cnt++;
            }
        }
 
        // Update the maximum required count
        res = Math.max(res, cnt);
    }
    return res;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 8, 1, 28, 4, 2, 6, 7 };
    int n = arr.length;
 
    System.out.println(findMax(arr, n));
}
}
 
// This code is contributed by Rajput-Ji

蟒蛇3

# Python3 implementation of the approach
 
# Function to return the maximum count
# of required elements
def findMax(arr, n) :
 
    # divisible[i] will store true
    # if arr[i] is divisible by
    # any element on its right
    divisible = [ False ] * n;
 
    # To store the maximum required count
    res = 0;
 
    # For every element of the array
    for i in range(n - 1, -1, -1) :
 
        # If the current element is
        # divisible by any element
        # on its right
        if (divisible[i]) :
            continue;
 
        # Find the count of element
        # on the left which are divisible
        # by the current element
        cnt = 0;
        for j in range(i) :
 
            # If arr[j] is divisible then
            # set divisible[j] to true
            if ((arr[j] % arr[i]) == 0) :
                divisible[j] = True;
                cnt += 1;
 
        # Update the maximum required count
        res = max(res, cnt);
 
    return res;
 
# Driver code
if __name__ == "__main__" :
 
    arr = [ 8, 1, 28, 4, 2, 6, 7 ];
    n = len(arr);
 
    print(findMax(arr, n));
 
# This code is contributed by kanugargng

C＃

// C# implementation of the approach
using System;
 
class GFG
{
 
// Function to return the maximum count
// of required elements
static int findMax(int []arr, int n)
{
 
    // divisible[i] will store true
    // if arr[i] is divisible by
    // any element on its right
    bool []divisible = new bool[n];
 
    // To store the maximum required count
    int res = 0;
 
    // For every element of the array
    for (int i = n - 1; i > 0; i--)
    {
 
        // If the current element is
        // divisible by any element
        // on its right
        if (divisible[i])
            continue;
 
        // Find the count of element
        // on the left which are divisible
        // by the current element
        int cnt = 0;
        for (int j = 0; j < i; j++)
        {
 
            // If arr[j] is divisible then
            // set divisible[j] to true
            if ((arr[j] % arr[i]) == 0)
            {
                divisible[j] = true;
                cnt++;
            }
        }
 
        // Update the maximum required count
        res = Math.Max(res, cnt);
    }
    return res;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 8, 1, 28, 4, 2, 6, 7 };
    int n = arr.Length;
 
    Console.WriteLine(findMax(arr, n));
}
}
 
// This code is contributed by Rajput-Ji

Javascript

 
// JavaScript implementation of the approach
 
// Function to return the maximum count
// of required elements
function findMax(arr, n)
{
 
    // divisible[i] will store true
    // if arr[i] is divisible by
    // any element on its right
    var divisible = Array(n).fill(false);
 
    // To store the maximum required count
    var res = 0;
 
    // For every element of the array
    for (var i = n - 1; i > 0; i--) {
 
        // If the current element is
        // divisible by any element
        // on its right
        if (divisible[i])
            continue;
 
        // Find the count of element
        // on the left which are divisible
        // by the current element
        var cnt = 0;
        for (var j = 0; j < i; j++) {
 
            // If arr[j] is divisible then
            // set divisible[j] to true
            if ((arr[j] % arr[i]) == 0) {
                divisible[j] = true;
                cnt++;
            }
        }
 
        // Update the maximum required count
        res = Math.max(res, cnt);
    }
 
    return res;
}
 
// Driver code
var arr = [8, 1, 28, 4, 2, 6, 7];
var n = arr.length;
document.write( findMax(arr, n));
 

输出：

3