# Maximum possible GCD after replacing at most one element in the given array

Given an array arr[] of size N > 1. The task is to find the maximum possible GCD of the array by replacing at most one element.

Examples:

Input: arr[] = {6, 7, 8}
Output: 2
Replace 7 with 2 and gcd(6, 2, 8) = 2
which is maximum possible.

Input: arr[] = {12, 18, 30}
Output: 6

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

• Idea is to find the GCD value of all the sub-sequences of length (N – 1) and removing the element which has to be replaced in the sub-sequence as it can be replaced with any other element already in the subsequence. The maximum GCD found would be the answer.
• To find the GCD of the sub-sequences optimally, maintain a prefixGCD[] and a suffixGCD[] array using single state dynamic programming.
• The maximum value of GCD(prefixGCD[i – 1], suffixGCD[i + 1]) is the required answer. Also note that suffixGCD and prefixGCD[N – 2] also need to be compared in case the first or the last element has to be replaced.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the maximum ` `// possible gcd after replacing ` `// a single element ` `int` `MaxGCD(``int` `a[], ``int` `n) ` `{ ` ` `  `    ``// Prefix and Suffix arrays ` `    ``int` `Prefix[n + 2]; ` `    ``int` `Suffix[n + 2]; ` ` `  `    ``// Single state dynamic programming relation ` `    ``// for storing gcd of first i elements ` `    ``// from the left in Prefix[i] ` `    ``Prefix = a; ` `    ``for` `(``int` `i = 2; i <= n; i += 1) { ` `        ``Prefix[i] = __gcd(Prefix[i - 1], a[i - 1]); ` `    ``} ` ` `  `    ``// Initializing Suffix array ` `    ``Suffix[n] = a[n - 1]; ` ` `  `    ``// Single state dynamic programming relation ` `    ``// for storing gcd of all the elements having ` `    ``// index greater than or equal to i in Suffix[i] ` `    ``for` `(``int` `i = n - 1; i >= 1; i -= 1) { ` `        ``Suffix[i] = __gcd(Suffix[i + 1], a[i - 1]); ` `    ``} ` ` `  `    ``// If first or last element of ` `    ``// the array has to be replaced ` `    ``int` `ans = max(Suffix, Prefix[n - 1]); ` ` `  `    ``// If any other element is replaced ` `    ``for` `(``int` `i = 2; i < n; i += 1) { ` `        ``ans = max(ans, __gcd(Prefix[i - 1], Suffix[i + 1])); ` `    ``} ` ` `  `    ``// Return the maximized gcd ` `    ``return` `ans; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a[] = { 6, 7, 8 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a); ` ` `  `    ``cout << MaxGCD(a, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `class` `GFG  ` `{ ` ` `  `// Function to return the maximum ` `// possible gcd after replacing ` `// a single element ` `static` `int` `MaxGCD(``int` `a[], ``int` `n) ` `{ ` ` `  `    ``// Prefix and Suffix arrays ` `    ``int` `[]Prefix = ``new` `int``[n + ``2``]; ` `    ``int` `[]Suffix = ``new` `int``[n + ``2``]; ` ` `  `    ``// Single state dynamic programming relation ` `    ``// for storing gcd of first i elements ` `    ``// from the left in Prefix[i] ` `    ``Prefix[``1``] = a[``0``]; ` `    ``for` `(``int` `i = ``2``; i <= n; i += ``1``)  ` `    ``{ ` `        ``Prefix[i] = __gcd(Prefix[i - ``1``],  ` `                               ``a[i - ``1``]); ` `    ``} ` ` `  `    ``// Initializing Suffix array ` `    ``Suffix[n] = a[n - ``1``]; ` ` `  `    ``// Single state dynamic programming relation ` `    ``// for storing gcd of all the elements having ` `    ``// index greater than or equal to i in Suffix[i] ` `    ``for` `(``int` `i = n - ``1``; i >= ``1``; i -= ``1``)  ` `    ``{ ` `        ``Suffix[i] = __gcd(Suffix[i + ``1``],  ` `                               ``a[i - ``1``]); ` `    ``} ` ` `  `    ``// If first or last element of ` `    ``// the array has to be replaced ` `    ``int` `ans = Math.max(Suffix[``2``], Prefix[n - ``1``]); ` ` `  `    ``// If any other element is replaced ` `    ``for` `(``int` `i = ``2``; i < n; i += ``1``) ` `    ``{ ` `        ``ans = Math.max(ans, __gcd(Prefix[i - ``1``],  ` `                                  ``Suffix[i + ``1``])); ` `    ``} ` ` `  `    ``// Return the maximized gcd ` `    ``return` `ans; ` `} ` ` `  `static` `int` `__gcd(``int` `a, ``int` `b)  ` `{  ` `    ``return` `b == ``0` `? a : __gcd(b, a % b);      ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `a[] = { ``6``, ``7``, ``8` `}; ` `    ``int` `n = a.length; ` ` `  `    ``System.out.println(MaxGCD(a, n)); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

## Python3

 `# Python3 implementation of the approach  ` `from` `math ``import` `gcd as __gcd ` ` `  `# Function to return the maximum  ` `# possible gcd after replacing  ` `# a single element  ` `def` `MaxGCD(a, n) : ` ` `  `    ``# Prefix and Suffix arrays  ` `    ``Prefix ``=` `[``0``] ``*` `(n ``+` `2``);  ` `    ``Suffix ``=` `[``0``] ``*` `(n ``+` `2``);  ` ` `  `    ``# Single state dynamic programming relation  ` `    ``# for storing gcd of first i elements  ` `    ``# from the left in Prefix[i]  ` `    ``Prefix[``1``] ``=` `a[``0``];  ` `     `  `    ``for` `i ``in` `range``(``2``, n ``+` `1``) : ` `        ``Prefix[i] ``=` `__gcd(Prefix[i ``-` `1``], a[i ``-` `1``]);  ` ` `  `    ``# Initializing Suffix array  ` `    ``Suffix[n] ``=` `a[n ``-` `1``];  ` ` `  `    ``# Single state dynamic programming relation  ` `    ``# for storing gcd of all the elements having  ` `    ``# index greater than or equal to i in Suffix[i]  ` `    ``for` `i ``in` `range``(n ``-` `1``, ``0``, ``-``1``) : ` `        ``Suffix[i] ``=` `__gcd(Suffix[i ``+` `1``], a[i ``-` `1``]);  ` ` `  `    ``# If first or last element of  ` `    ``# the array has to be replaced  ` `    ``ans ``=` `max``(Suffix[``2``], Prefix[n ``-` `1``]);  ` ` `  `    ``# If any other element is replaced  ` `    ``for` `i ``in` `range``(``2``, n) : ` `        ``ans ``=` `max``(ans, __gcd(Prefix[i ``-` `1``],  ` `                             ``Suffix[i ``+` `1``]));  ` ` `  `    ``# Return the maximized gcd  ` `    ``return` `ans;  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``a ``=` `[ ``6``, ``7``, ``8` `];  ` `    ``n ``=` `len``(a);  ` ` `  `    ``print``(MaxGCD(a, n));  ` ` `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# implementation of the approach ` `using` `System; ` `     `  `class` `GFG  ` `{ ` ` `  `// Function to return the maximum ` `// possible gcd after replacing ` `// a single element ` `static` `int` `MaxGCD(``int` `[]a, ``int` `n) ` `{ ` ` `  `    ``// Prefix and Suffix arrays ` `    ``int` `[]Prefix = ``new` `int``[n + 2]; ` `    ``int` `[]Suffix = ``new` `int``[n + 2]; ` ` `  `    ``// Single state dynamic programming relation ` `    ``// for storing gcd of first i elements ` `    ``// from the left in Prefix[i] ` `    ``Prefix = a; ` `    ``for` `(``int` `i = 2; i <= n; i += 1)  ` `    ``{ ` `        ``Prefix[i] = __gcd(Prefix[i - 1],  ` `                            ``a[i - 1]); ` `    ``} ` ` `  `    ``// Initializing Suffix array ` `    ``Suffix[n] = a[n - 1]; ` ` `  `    ``// Single state dynamic programming relation ` `    ``// for storing gcd of all the elements having ` `    ``// index greater than or equal to i in Suffix[i] ` `    ``for` `(``int` `i = n - 1; i >= 1; i -= 1)  ` `    ``{ ` `        ``Suffix[i] = __gcd(Suffix[i + 1],  ` `                            ``a[i - 1]); ` `    ``} ` ` `  `    ``// If first or last element of ` `    ``// the array has to be replaced ` `    ``int` `ans = Math.Max(Suffix, Prefix[n - 1]); ` ` `  `    ``// If any other element is replaced ` `    ``for` `(``int` `i = 2; i < n; i += 1) ` `    ``{ ` `        ``ans = Math.Max(ans, __gcd(Prefix[i - 1],  ` `                                ``Suffix[i + 1])); ` `    ``} ` ` `  `    ``// Return the maximized gcd ` `    ``return` `ans; ` `} ` ` `  `static` `int` `__gcd(``int` `a, ``int` `b)  ` `{  ` `    ``return` `b == 0 ? a : __gcd(b, a % b);      ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args)  ` `{ ` `    ``int` `[]a = { 6, 7, 8 }; ` `    ``int` `n = a.Length; ` ` `  `    ``Console.WriteLine(MaxGCD(a, n)); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```2
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up pawanasipugmailcom

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.