使给定阵列成为AP所需的最少更改次数

给定一个数组arr [] $N$整数和数字$d$ 。您可以将数组的任何元素更改为任何整数。任务是找到使给定数组成为具有共同差异的算术级数所需的最少更改次数$d$ 。

例子：

Input : N = 4, d = 2
        arr[] = {1, 2, 4, 6}
Output : 1
Explanation: change a[0]=0. 
So, new sequence is 0, 2, 4, 6 which is an AP.

Input : N = 5, d = 1
        arr[] = {1, 3, 3, 4, 6}
Output : 2
Explanation: change a[1]=2 and a[4]=5. 
So, new sequence is 1, 2, 3, 4, 5 which is an AP.

解决此问题的想法是观察AP中第n个项的公式为：

an = a0 + (n-1)*d

Where, a0 is the first term
and d is the common difference.

我们得到的价值$d$和一个_n 。因此，我们将为i的所有值找到₀的值，其中1 <= i <= n，并存储i的不同值出现₀的频率。

现在，需要更改的最小元素数是：

n - (maximum frequency of a0)

其中，最大频率为₀表示数组中AP中第一项的值相同的元素总数。

下面是上述方法的实现：

C++

// C++ program to find the minimum number
// of changes required to make the given
// array an AP with common difference d
#include 
using namespace std;
  
// Function to find the minimum number
// of changes required to make the given
// array an AP with common difference d
int minimumChanges(int arr[], int n, int d)
{
    int maxFreq = INT_MIN;
  
    // Map to store frequency of a0
    unordered_map freq;
  
    // storing frequency of a0 for all possible
    // values of a[i] and finding the maximum
    // frequency
    for (int i = 0; i < n; ++i) {
        int a0 = arr[i] - (i)*d;
  
        // increment frequency by 1
        if (freq.find(a0) != freq.end()) {
            freq[a0]++;
        }
        else
            freq.insert(make_pair(a0, 1));
  
        // finds count of most frequent number
        if (freq[a0] > maxFreq)
            maxFreq = freq[a0];
    }
  
    // minimum number of elements needed to
    // be changed is: n - (maximum frequency of a0)
    return (n - maxFreq);
}
  
// Driver Program
int main()
{
    int n = 5, d = 1;
  
    int arr[] = { 1, 3, 3, 4, 6 };
  
    cout << minimumChanges(arr, n, d);
  
    return 0;
}

Java

// Java program to find the
// minimum number of changes
// required to make the given
// array an AP with common
// difference d
import java.util.*;
  
class GFG {
  
    // Function to find the minimum
    // number of changes required
    // to make the given array an
    // AP with common difference d
    static int minimumChanges(int arr[],
                              int n, int d)
    {
        int maxFreq = -1;
  
        // Map to store frequency of a0
        HashMap
            freq = new HashMap();
  
        // storing frequency of a0 for
        // all possible values of a[i]
        // and finding the maximum
        // frequency
        for (int i = 0; i < n; ++i) {
            int a0 = arr[i] - (i)*d;
  
            // increment frequency by 1
            if (freq.containsKey(a0)) {
                freq.put(a0, freq.get(a0) + 1);
            }
            else
                freq.put(a0, 1);
  
            // finds count of most
            // frequent number
            if (freq.get(a0) > maxFreq)
                maxFreq = freq.get(a0);
        }
  
        // minimum number of elements
        // needed to be changed is:
        // n - (maximum frequency of a0)
        return (n - maxFreq);
    }
  
    // Driver Code
    public static void main(String args[])
    {
        int n = 5, d = 1;
  
        int arr[] = { 1, 3, 3, 4, 6 };
  
        System.out.println(minimumChanges(arr, n, d));
    }
}
  
// This code is contributed
// by Arnab Kundu

Python3

# Python3 program to find the minimum 
# number of changes required to make 
# the given array an AP with common 
# difference d 
  
# Function to find the minimum number 
# of changes required to make the given 
# array an AP with common difference d 
def minimumChanges(arr, n, d):
    maxFreq = -2147483648
      
    # dictionary to store 
    # frequency of a0
    freq = {}
      
    # storing frequency of a0 for 
    # all possible values of a[i] 
    # and finding the maximum'
    # frequency
    for i in range(n):
        a0 = arr[i] - i * d
          
        # increment frequency by 1
        if a0 in freq:
            freq[a0] += 1
        else:
            freq[a0] = 1
              
        # finds count of most 
        # frequent number
        if freq[a0] > maxFreq:
            maxFreq = freq[a0]
              
    # minimum number of elements 
    # needed to be changed is:
    # n - (maximum frequency of a0) 
    return (n-maxFreq)
  
# Driver Code
  
# number of terms in ap 
n = 5
  
# difference in AP
d = 1
arr = [1, 3, 3, 4, 6 ] 
ans = minimumChanges(arr, n, d)
print(ans)
  
# This code is contributed 
# by sahil shelangia

C#

// C# program to find the
// minimum number of changes
// required to make the given
// array an AP with common
// difference d
using System;
using System.Collections.Generic;
  
class GFG {
  
    // Function to find the minimum
    // number of changes required
    // to make the given array an
    // AP with common difference d
    static int minimumChanges(int[] arr,
                              int n, int d)
    {
        int maxFreq = -1;
  
        // Map to store frequency of a0
        Dictionary freq = new Dictionary();
  
        // storing frequency of a0 for
        // all possible values of a[i]
        // and finding the maximum
        // frequency
        for (int i = 0; i < n; ++i) {
            int a0 = arr[i] - (i)*d;
  
            // increment frequency by 1
            if (freq.ContainsKey(a0)) {
                var obj = freq[a0];
                freq.Remove(a0);
                freq.Add(a0, obj + 1);
            }
            else
                freq.Add(a0, 1);
  
            // finds count of most
            // frequent number
            if (freq[a0] > maxFreq)
                maxFreq = freq[a0];
        }
  
        // minimum number of elements
        // needed to be changed is:
        // n - (maximum frequency of a0)
        return (n - maxFreq);
    }
  
    // Driver Code
    public static void Main(String[] args)
    {
        int n = 5, d = 1;
  
        int[] arr = { 1, 3, 3, 4, 6 };
  
        Console.WriteLine(minimumChanges(arr, n, d));
    }
}
  
// This code contributed by Rajput-Ji

PHP

 $maxFreq)
            $maxFreq = $freq[$a0];
    }
      
    // minimum number of elements 
    // needed to be changed is:
    // $n - (maximum frequency of a0)
    return ($n - $maxFreq);
}
  
// Driver Code
$n = 5;
$d = 1;
      
$arr = array( 1, 3, 3, 4, 6 );
      
echo minimumChanges($arr, $n, $d);
      
// This code is contributed
// by ChitraNayal
?>

输出：

2