通过删除一个元素和一个步骤中的所有倍数来最小化减少 Array 的步骤

给定一个大小为N的数组arr[] ，任务是通过在一次操作中从数组中删除一个元素及其所有倍数来找到减少数组的最小操作数。

例子：

Input: N = 5, arr[] = {5, 2, 3, 8, 7}
Output: 4
Explanation: Removing 2, will make it remove 8 (as it is a multiple of 2),  
then 3, 5, 7 would be removed in one operation each,  
Thus, total count = 1 + 3 = 4 (Required Answer)

Input: N = 7, arr[] = {12, 10, 2, 3, 5, 6, 27}
Output: 3
Explanation: Removing 2 and its multiples 10, 12, 6 in one operation. So count = 1.
Then, remove 3 and 27 (multiple of 3) in one operation. So total count = 1+1 = 2. 
Last element left would be 5 which will again take one operation. 
Thus, total count = 2 + 1 = 3 (Required Answer)

方法：解决方案的方法基于以下思想：

Sort the array and then start iterating from the start.
For each element group all its multiples together if it already is not part of any group.
The total number of group is the required answer.

请按照以下步骤解决问题：

• 按升序对数组进行排序。
• 从i = 0 迭代到 N-1并且：
  • 该元素是否属于任何组。
  • 如果不是，则将此元素及其所有倍数组合在一起。
  • 否则，跳过此并继续迭代。
• 返回组总数的计数。

下面是上述方法的实现：

C++

// C++ code for the above approach
 
#include 
using namespace std;
 
// Function to do required operation
void solve(int n, vector& v)
{
    int M = INT_MIN;
    for (int i = 0; i < n; i++)
        M = max(M, v[i]);
 
    // Initializing a visited array
    // of max size of N and marking
    // each element as 0(false)
    vector vis(M + 1, 0);
 
    // Sorting the given array
    // such that each element
    // appear in increasing order
    sort(v.begin(), v.end());
 
    // Special case for 1
    for (int i = 0; i < v.size(); i++) {
        if (v[i] == 1) {
            cout << 1 << "\n";
            return;
        }
    }
 
    // Initializing final count answer
    int count = 0;
 
    // Traverse in the given array
    for (int i = 0; i < v.size(); i++) {
 
        // Check if element is
        // not visited yet
        if (vis[v[i]] == 0) {
 
            // Mark it as visited
            vis[v[i]] = 1;
 
            // Store that element for
            // further traversing through
            // its multiples
            int temp = v[i];
 
            // Then, traverse from N
            // min to max range and
            // mark all the multiples of
            // stored element as visited
            for (int i = 1; i <= M; i++) {
                if (i * temp <= M) {
                    vis[i * temp] = 1;
                }
            }
 
            // Increase count by 1 for
            // each iteration
            count++;
        }
    }
 
    // Print the final count answer
    cout << count << "\n";
}
 
// Driver Code
int main()
{
 
    // Taking input
    int N = 5;
    vector arr = { 5, 2, 3, 8, 7 };
 
    // Function call
    solve(N, arr);
    return 0;
}

Java

// Java code for the above approach
import java.util.*;
public class GFG {
 
  // Function to do required operation
  static void solve(int n, int[] v)
  {
    int M = Integer.MIN_VALUE;
    for (int i = 0; i < n; i++)
      M = Math.max(M, v[i]);
 
    // Initializing a visited array
    // of max size of N and marking
    // each element as 0(false)
    int[] vis = new int[M + 1];
    for (int i = 0; i < M + 1; i++) {
      vis[i] = 0;
    }
 
    // Sorting the given array
    // such that each element
    // appear in increasing order
    Arrays.sort(v);
 
    // Special case for 1
    for (int i = 0; i < v.length; i++) {
      if (v[i] == 1) {
        System.out.println(1);
        return;
      }
    }
 
    // Initialiazing final count answer
    int count = 0;
 
    // Traverse in the given array
    for (int i = 0; i < v.length; i++) {
 
      // Check if element is
      // not visited yet
      if (vis[v[i]] == 0) {
 
        // Mark it as visited
        vis[v[i]] = 1;
 
        // Store that element for
        // further traversing through
        // its multiples
        int temp = v[i];
 
        // Then, traverse from N
        // min to max range and
        // mark all the multiples of
        // stored element as visited
        for (int j = 1; j <= M; j++) {
          if (j * temp <= M) {
            vis[j * temp] = 1;
          }
        }
 
        // Increase count by 1 for
        // each iteration
        count++;
      }
    }
 
    // Print the final count answer
    System.out.println(count);
  }
 
  // Driver Code
  public static void main(String args[])
  {
 
    // Taking input
    int N = 5;
    int[] arr = { 5, 2, 3, 8, 7 };
 
    // Function call
    solve(N, arr);
  }
}
 
// This code is contributed by Samim Hossain Mondal.

Python3

# Python3 code for the above approach
INT_MIN = -2147483647 - 1
 
# Function to do required operation
def solve(n, v):
   M = INT_MIN
   for i in range(n):
      M = max(M, v[i])
 
   # Initializing a visited array
   # of max size of N and marking
   # each element as 0(false)
   vis = [0]*(M+1)
 
   # Sorting the given array
   # such that each element
   # appear in increasing order
   v.sort()
 
   # Special case for 1
   for i in range(len(v)):
      if (v[i] == 1):
         print(1)
         return
 
   # Initialiazing final count answer
   count = 0
 
   # Traverse in the given array
   for i in range(len(v)):
 
      # Check if element is
      # not visited yet
      if (vis[v[i]] == 0):
 
         # Mark it as visited
         vis[v[i]] = 1
 
         # Store that element for
         # further traversing through
         # its multiples
         temp = v[i]
 
         # Then, traverse from N
         # min to max range and
         # mark all the multiples of
         # stored element as visited
         for i in range(1,M+1):
            if (i * temp <= M):
               vis[i * temp] = 1
 
               # Increase count by 1 for
               # each iteration
         count += 1
 
      # Print the final count answer
   print(count)
 
# Driver Code
# Taking input
N = 5
arr = [5, 2, 3, 8, 7]
 
# Function call
solve(N, arr)
 
# This code is contributed by shinjanpatra

C#

// C# code for the above approach
using System;
class GFG {
 
  // Function to do required operation
  static void solve(int n, int[] v)
  {
    int M = Int32.MinValue;
    for (int i = 0; i < n; i++)
      M = Math.Max(M, v[i]);
 
    // Initializing a visited array
    // of max size of N and marking
    // each element as 0(false)
    int[] vis = new int[M + 1];
    for (int i = 0; i < M + 1; i++) {
      vis[i] = 0;
    }
 
    // Sorting the given array
    // such that each element
    // appear in increasing order
    Array.Sort(v);
 
    // Special case for 1
    for (int i = 0; i < v.Length; i++) {
      if (v[i] == 1) {
        Console.WriteLine(1);
        return;
      }
    }
 
    // Initializing final count answer
    int count = 0;
 
    // Traverse in the given array
    for (int i = 0; i < v.Length; i++) {
 
      // Check if element is
      // not visited yet
      if (vis[v[i]] == 0) {
 
        // Mark it as visited
        vis[v[i]] = 1;
 
        // Store that element for
        // further traversing through
        // its multiples
        int temp = v[i];
 
        // Then, traverse from N
        // min to max range and
        // mark all the multiples of
        // stored element as visited
        for (int j = 1; j <= M; j++) {
          if (j * temp <= M) {
            vis[j * temp] = 1;
          }
        }
 
        // Increase count by 1 for
        // each iteration
        count++;
      }
    }
 
    // Print the final count answer
    Console.WriteLine(count);
  }
 
  // Driver Code
  public static void Main()
  {
 
    // Taking input
    int N = 5;
    int[] arr = { 5, 2, 3, 8, 7 };
 
    // Function call
    solve(N, arr);
  }
}
 
// This code is contributed by Samim Hossain Mondal.

Javascript

    // JavaScript code for the above approach
 
    const INT_MIN = -2147483647 - 1;
 
    // Function to do required operation
    const solve = (n, v) => {
        let M = INT_MIN;
        for (let i = 0; i < n; i++)
            M = Math.max(M, v[i]);
 
        // Initializing a visited array
        // of max size of N and marking
        // each element as 0(false)
        let vis = new Array(M + 1).fill(0);
 
        // Sorting the given array
        // such that each element
        // appear in increasing order
        v.sort();
 
        // Special case for 1
        for (let i = 0; i < v.length; i++) {
            if (v[i] == 1) {
                document.write("1<br/>");
                return;
            }
        }
 
        // Initializing final count answer
        let count = 0;
 
        // Traverse in the given array
        for (let i = 0; i < v.length; i++) {
 
            // Check if element is
            // not visited yet
            if (vis[v[i]] == 0) {
 
                // Mark it as visited
                vis[v[i]] = 1;
 
                // Store that element for
                // further traversing through
                // its multiples
                let temp = v[i];
 
                // Then, traverse from N
                // min to max range and
                // mark all the multiples of
                // stored element as visited
                for (let i = 1; i <= M; i++) {
                    if (i * temp <= M) {
                        vis[i * temp] = 1;
                    }
                }
 
                // Increase count by 1 for
                // each iteration
                count++;
            }
        }
 
        // Print the final count answer
        document.write(`${count}<br/>`);
    }
 
    // Driver Code
 
 
    // Taking input
    let N = 5;
    let arr = [5, 2, 3, 8, 7];
 
    // Function call
    solve(N, arr);
 
// This code is contributed by rakeshsahni
 

输出

4

时间复杂度： O(N*M) 其中 M 是数组的最大元素
辅助空间： O(M)