最大化具有给定阵列作为子序列的AP的共同差异

给定一个由N个不同元素组成的排序数组arr [] ，任务是找到算术级数的最大可能公共差，以使给定数组是该算术级数的子序列。

例子：

Input: arr[] = { 2, 4, 6, 8 } 
Output: 2 
Explanation: 
Since arr[] is a subsequence of the arithmetic progression { 2, 4, 6, 8, 10, …}, the common difference of the arithmetic progression is 2.

Input: arr[] = { 2, 5, 11, 23 } 
Output: 3 
Explanation: 
Since arr[] is a subsequence of the arithmetic progression { 2, 5, 8, 11, 14, …, 23, …}, the common difference of the arithmetic progression is 2.

天真的方法：解决此问题的最简单方法是使用变量CD (共差)遍历[[arr [N – 1] – arr [0])，1]范围，并检查该范围内的每个值给定的数组可以是算术级数的后续运算，第一个元素为arr [0] ，共同差为CD 。这可以通过简单地检查每对相邻的数组元素之间的差异是否可以被CD整除来实现。如果发现是正确的，则打印CD的值作为最大可能的答案。

时间复杂度：O(N *(MAXM – MINM))，其中MAXM和MINM分别是最后和第一阵列元素。
辅助空间： O(1)

高效的方法：可以基于以下观察来优化上述方法：

If arr[i] is X^th term and arr[0] is the first term of an arithmetic progression with common difference CD, then: 
 

arr[i] = arr[0] + (X – 1) * CD 
=> (arr[i] – arr[0]) = (X – 1) * CD

Therefore, the maximum possible common difference of the AP is the GCD of the absolute difference of each pair of adjacent array lements. 
 

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

• 初始化一个变量，例如maxCD ，以存储算术级数的最大可能公共差异，以使给定数组是该算术级数的子序列。
• 使用变量i遍历数组，并更新maxCD = GCD(maxCD，(arr [i + 1] – arr [i]))的值。
• 最后，打印maxCD的值。

下面是上述方法的实现

C++

// C++ program to implement
// the above approach
 
#include 
using namespace std;
 
// Function to find the maximum common
// difference of an AP such that arr[]
// is a subsequence of that AP
int MaxComDiffSubAP(int arr[], int N)
{
    // Stores maximum common difference
    // of an AP with given conditions
    int maxCD = 0;
 
    // Traverse the array
    for (int i = 0; i < N - 1; i++) {
 
        // Update maxCD
        maxCD = __gcd(maxCD,
                      arr[i + 1] - arr[i]);
    }
 
    return maxCD;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 3, 7, 9 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    cout << MaxComDiffSubAP(arr, N);
 
    return 0;
}

Java

// Java program to implement
// the above approach 
class GFG
{
 
  // Recursive function to return gcd of a and b
  static int gcd(int a, int b)
  {
 
    // Everything divides 0
    if (a == 0)
      return b;
    if (b == 0)
      return a;
 
    // base case
    if (a == b)
      return a;
 
    // a is greater
    if (a > b)
      return gcd(a - b, b);
 
    return gcd(a, b - a);
  }
 
  // Function to find the maximum common
  // difference of an AP such that arr[]
  // is a subsequence of that AP
  static int MaxComDiffSubAP(int arr[], int N)
  {
     
    // Stores maximum common difference
    // of an AP with given conditions
    int maxCD = 0;
 
    // Traverse the array
    for (int i = 0; i < N - 1; i++)
    {
 
      // Update maxCD
      maxCD = gcd(maxCD,
                  arr[i + 1] - arr[i]);
    }
 
    return maxCD;
  }
 
  // Driver Code
  public static void main (String[] args)
  {
    int arr[] = { 1, 3, 7, 9 };
    int N = arr.length;
 
    System.out.print(MaxComDiffSubAP(arr, N));
  }
}
 
// This code is contributed by AnkThon

Python3

# Python3 program to implement
# the above approach
from math import gcd
 
# Function to find the maximum common
# difference of an AP such that arr[]
# is a subsequence of that AP
def MaxComDiffSubAP(arr, N):
     
    # Stores maximum common difference
    # of an AP with given conditions
    maxCD = 0
 
    # Traverse the array
    for i in range(N - 1):
         
        # Update maxCD
        maxCD = gcd(maxCD, arr[i + 1] - arr[i])
 
    return maxCD
 
# Driver Code
if __name__ == '__main__':
 
    arr = [ 1, 3, 7, 9 ]
    N = len(arr)
     
    print(MaxComDiffSubAP(arr, N))
 
# This code is contributed by mohit kumar 29

C#

// C# program to implement
// the above approach 
using System;
 
class GFG{
  
// Recursive function to return
// gcd of a and b
static int gcd(int a, int b)
{
 
    // Everything divides 0
    if (a == 0)
        return b;
    if (b == 0)
        return a;
     
    // base case
    if (a == b)
        return a;
     
    // a is greater
    if (a > b)
        return gcd(a - b, b);
     
    return gcd(a, b - a);
}
 
// Function to find the maximum common
// difference of an AP such that arr[]
// is a subsequence of that AP
static int MaxComDiffSubAP(int[] arr, int N)
{
 
    // Stores maximum common difference
    // of an AP with given conditions
    int maxCD = 0;
     
    // Traverse the array
    for(int i = 0; i < N - 1; i++)
    {
         
        // Update maxCD
        maxCD = gcd(maxCD,
                    arr[i + 1] - arr[i]);
    }
    return maxCD;
}
 
// Driver Code
public static void Main ()
{
    int[] arr = { 1, 3, 7, 9 };
    int N = arr.Length;
     
    Console.WriteLine(MaxComDiffSubAP(arr, N));
}
}
 
// This code is contributed by susmitakundugoaldanga

输出：

2

时间复杂度： O(N)
辅助空间： O(1)