# Divide N into K unique parts such that gcd of those parts is maximum

• Last Updated : 09 Nov, 2021

Given a positive integer N, the task is to divide it into K unique parts such that the sum of these parts is equal to the original number and the gcd of all the parts is maximum. Print the maximum gcd if such a division exists else print -1.

Examples:

Input: N = 6, K = 3
Output:
Only possible division with unique
elements are (1, 2, 3) and gcd(1, 2, 3) = 1.
Input: N = 18, K = 3
Output:

Naive approach: Find all the possible divisions of N and compute the maximum gcd of them. But this approach will take exponential time and space.
Efficient approach: Let the divisions of N be A1, A2……..AK
Now, it is known that gcd(a, b) = gcd(a, b, a + b) and hence, gcd(A1, A2….AK) = gcd(A1, A2….AK, A1 + A2…. + AK)
But A1 + A2…. + AK = N and hence, the gcd of the divisions will be one of the factors of N
Let a be the factor of N which can be the possible answer:
Since a is the gcd, all the division will be the multiples of a and hence, for K unique Bi
a * B1 + a * B2……. + a * BK = N
a * (B1 + B2…….+ BK) = N
Since all the Bi are unique,
B1 + B2…….+ BK ≥ 1 + 2 + 3 ….. + K
B1 + B2…….+ BK ≥ K * (K + 1) / 2
Hence, all the factors of N whose complementary factor is greater than or equal to K * (K + 1) / 2 can be one of the possible answers, and we have taken to the maximum of all the possible answers.

Below is the implementation of the above approach:

## CPP

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to calculate maximum GCD``int` `maxGCD(``int` `N, ``int` `K)``{` `    ``// Minimum possible sum for``    ``// K unique positive integers``    ``int` `minSum = (K * (K + 1)) / 2;` `    ``// It is not possible to divide``    ``// N into K unique parts``    ``if` `(N < minSum)``        ``return` `-1;` `    ``// All the factors greater than sqrt(N)``    ``// are complementary of the factors less``    ``// than sqrt(N)``    ``int` `i = ``sqrt``(N);``    ``int` `res = 1;``    ``while` `(i >= 1) {` `        ``// If i is a factor of N``        ``if` `(N % i == 0) {``            ``if` `(i >= minSum)``                ``res = max(res, N / i);` `            ``if` `(N / i >= minSum)``                ``res = max(res, i);``        ``}``        ``i--;``    ``}` `    ``return` `res;``}` `// Driver code``int` `main()``{``    ``int` `N = 18, K = 3;` `    ``cout << maxGCD(N, K);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.io.*;``import` `java.lang.Math;` `class` `GFG``{``    ``// Function to calculate maximum GCD``    ``static` `int` `maxGCD(``int` `N, ``int` `K)``    ``{` `        ``// Minimum possible sum for``        ``// K unique positive integers``        ``int` `minSum = (K * (K + ``1``)) / ``2``;` `        ``// It is not possible to divide``        ``// N into K unique parts``        ``if` `(N < minSum)``            ``return` `-``1``;` `        ``// All the factors greater than sqrt(N)``        ``// are complementary of the factors less``        ``// than sqrt(N)``        ``int` `i = (``int``) Math.sqrt(N);``        ``int` `res = ``1``;``        ``while` `(i >= ``1``)``        ``{` `            ``// If i is a factor of N``            ``if` `(N % i == ``0``)``            ``{``                ``if` `(i >= minSum)``                    ``res = Math.max(res, N / i);` `                ``if` `(N / i >= minSum)``                    ``res = Math.max(res, i);``            ``}``            ``i--;``        ``}` `        ``return` `res;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `N = ``18``, K = ``3``;` `        ``System.out.println(maxGCD(N, K));``    ``}``}` `// This code is contributed by ApurvaRaj`

## Python

 `# Python3 implementation of the approach``from` `math ``import` `sqrt,ceil,floor` `# Function to calculate maximum GCD``def` `maxGCD(N, K):` `    ``# Minimum possible sum for``    ``# K unique positive integers``    ``minSum ``=` `(K ``*` `(K ``+` `1``)) ``/` `2` `    ``# It is not possible to divide``    ``# N into K unique parts``    ``if` `(N < minSum):``        ``return` `-``1` `    ``# All the factors greater than sqrt(N)``    ``# are complementary of the factors less``    ``# than sqrt(N)``    ``i ``=` `ceil(sqrt(N))``    ``res ``=` `1``    ``while` `(i >``=` `1``):` `        ``# If i is a factor of N``        ``if` `(N ``%` `i ``=``=` `0``):``            ``if` `(i >``=` `minSum):``                ``res ``=` `max``(res, N ``/` `i)` `            ``if` `(N ``/` `i >``=` `minSum):``                ``res ``=` `max``(res, i)` `        ``i``-``=``1` `    ``return` `res` `# Driver code` `N ``=` `18``K ``=` `3` `print``(maxGCD(N, K))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{``    ``// Function to calculate maximum GCD``    ``static` `int` `maxGCD(``int` `N, ``int` `K)``    ``{` `        ``// Minimum possible sum for``        ``// K unique positive integers``        ``int` `minSum = (K * (K + 1)) / 2;` `        ``// It is not possible to divide``        ``// N into K unique parts``        ``if` `(N < minSum)``            ``return` `-1;` `        ``// All the factors greater than sqrt(N)``        ``// are complementary of the factors less``        ``// than sqrt(N)``        ``int` `i = (``int``) Math.Sqrt(N);``        ``int` `res = 1;``        ``while` `(i >= 1)``        ``{` `            ``// If i is a factor of N``            ``if` `(N % i == 0)``            ``{``                ``if` `(i >= minSum)``                    ``res = Math.Max(res, N / i);` `                ``if` `(N / i >= minSum)``                    ``res = Math.Max(res, i);``            ``}``            ``i--;``        ``}``        ``return` `res;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `N = 18, K = 3;` `        ``Console.WriteLine(maxGCD(N, K));``    ``}``}` `// This code is contributed by AnkitRai01`

## Javascript

 ``

Output:

`3`

Time Complexity: O(N1/2)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up