Related Articles
Maximum possible GCD after replacing at most one element in the given array
• Last Updated : 19 Apr, 2021

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:
Replace 7 with 2 and gcd(6, 2, 8) = 2
which is maximum possible.
Input: arr[] = {12, 18, 30}
Output:

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`

## Javascript

 ``
Output:
`2`

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up