 GeeksforGeeks App
Open App Browser
Continue

# Minimize steps to reduce Array by deleting an element and all multiples in a step

Given an array arr[] of size N, the task is to find the minimum number of operations to reduce the array by deleting an element and all its multiples from the array in one operation.

Examples:

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)

Approach: The approach to the solution is based on the following idea:

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.

Follow the steps to solve the problem:

• Sort the array in increasing order.
• Iterate from the i = 0 to N-1 and:
• If this element is part of any group or not.
• If not then group this element and all its multiples together.
• Otherwise, skip this and continue iteration.
• Return the count of the total number of groups.

Below is the implementation of the above approach:

## C++

 `// C++ code for the above approach` `#include ``using` `namespace` `std;` `// Function to do required operation``void` `solve(``int` `n, vector<``int``>& 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<``int``> 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<``int``> 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``;``      ``}``    ``}` `    ``// 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``    ``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` `   ``# Initializing 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

 ``

Output

`4`

Time Complexity: O(N*M) where M is the maximum element of the array
Auxiliary Space: O(M)

My Personal Notes arrow_drop_up