可以放置在给定方阵中心以最大化算术级数的最大整数

给定一个N x N矩阵，使得索引[N/2, N/2]处的元素丢失，任务是找到可以放在索引[N/2, N/2]处的最大整数，例如使所有行、列和对角线上的算术级数数最大化。

例子：

Input: mat[][]={{3, 4, 11}, {10, ?, 9}, {-1, 6, 7}}
Output: 5
Explanation: The maximum integer that can be palced on [1, 1] is 5. Hence, the AP’s formed is are:

1. Top left diagonal: 3, 5, 7.
2. Top right diagonal: −1, 5, 1.
3. Middle column: 4, 5, 6.
4. Right column: 11, 9, 7.

Therefore, the number of AP formed is 4 which is the maximum possible.

Input: mat[][]={{2, 2, 11}, {1, ?, 7}, {-1, 6, 6}}
Output: 4

方法：给定的问题可以通过找到可以放在索引[N/2, N/2]上的所有可能的数字来解决，使得它在给定矩阵的任何行、列或对角线上形成算术级数，并且跟踪其中最大的整数，形成最大的 AP 。

Let’s suppose the matrix is of 3*3 size. 

Now, the missing element is (1, 1). 
So, for each row, column and diagonal, three numbers are present. Say, these three numbers are A, B, C and B is missing. 

So, it can be observed that for integers A, B, and C to form and an AP,  
B must be equal to [A + (C – A)]/2. 

Hence, for any value of A and C, B can be calculated using the above-discussed formula. Also, if (C – A) is odd then no integer value exists for B.

So, apply this formula to over row, column and diagonal and find the maximum element which will form the maximum element.

相同的方法可以应用于N*N矩阵。

下面是上述方法的实现：

C++

// C++ code for the above approach
#include 
using namespace std;
 
// Function to find the maximum value
// of the missing integer such that the
// count of AP's formed is maximized
int findMissing(vector >& mat)
{
    int N = mat.size();
 
    // Stores the occurence of each
    // possible integer value
    unordered_map mp;
 
    // For 1st Row
    int t = abs(mat[N / 2][N / 2 + 1]
                - mat[N / 2][N / 2 - 1]);
    int A
        = min(mat[N / 2][N / 2 + 1],
              mat[N / 2][N / 2 - 1]);
 
    if (t % 2 == 0) {
        mp[A + t / 2] += 1;
    }
 
    // For 1st Col
    t = abs(mat[N / 2 + 1][N / 2]
            - mat[N / 2][N / 2]);
    A = min(mat[N / 2 + 1][N / 2],
            mat[N / 2][N / 2]);
 
    if (t % 2 == 0) {
        mp[A + t / 2] += 1;
    }
 
    // For Left Diagonal
    t = abs(mat[N / 2 + 1][N / 2 + 1]
            - mat[N / 2 - 1][N / 2 - 1]);
    A = min(mat[N / 2 + 1][N / 2 + 1],
            mat[N / 2 - 1][N / 2 - 1]);
 
    if (t % 2 == 0) {
        mp[A + t / 2] += 1;
    }
 
    // For Right Diagonal
    t = abs(mat[N / 2 - 1][N / 2 + 1]
            - mat[N / 2 + 1][N / 2 - 1]);
    A = min(mat[N / 2 - 1][N / 2 + 1],
            mat[N / 2 + 1][N / 2 - 1]);
 
    if (t % 2 == 0) {
        mp[A + t / 2] += 1;
    }
 
    int ans = -1, occur = 0;
 
    // Loop to find the largest integer
    // with maximum count
    for (auto x : mp) {
        if (occur < x.second) {
            ans = x.first;
        }
        if (occur == x.second) {
            ans = max(ans, x.first);
        }
    }
 
    // Return Answer
    return ans;
}
 
// Driver Code
int main()
{
    vector > mat
        = { { 3, 4, 11 },
            { 10, INT_MAX, 9 },
            { -1, 6, 7 } };
    cout << findMissing(mat);
}

Java

// Java code for the above approach
import java.util.*;
class GFG
{
 
  // Function to find the maximum value
  // of the missing integer such that the
  // count of AP's formed is maximized
  static int findMissing(int[][] mat) {
    int N = mat.length;
 
    // Stores the occurence of each
    // possible integer value
    HashMap mp = new HashMap();
 
    // For 1st Row
    int t = Math.abs(mat[N / 2][N / 2 + 1] - mat[N / 2][N / 2 - 1]);
    int A = Math.min(mat[N / 2][N / 2 + 1], mat[N / 2][N / 2 - 1]);
 
    if (t % 2 == 0) {
      if (mp.containsKey(A + t / 2)) {
        mp.put(A + t / 2, mp.get(A + t / 2) + 1);
      } else {
        mp.put(A + t / 2, 1);
      }
    }
 
    // For 1st Col
    t = Math.abs(mat[N / 2 + 1][N / 2] - mat[N / 2][N / 2]);
    A = Math.min(mat[N / 2 + 1][N / 2], mat[N / 2][N / 2]);
 
    if (t % 2 == 0) {
      if (mp.containsKey(A + t / 2)) {
        mp.put(A + t / 2, mp.get(A + t / 2) + 1);
      } else {
        mp.put(A + t / 2, 1);
      }
    }
 
    // For Left Diagonal
    t = Math.abs(mat[N / 2 + 1][N / 2 + 1] - mat[N / 2 - 1][N / 2 - 1]);
    A = Math.min(mat[N / 2 + 1][N / 2 + 1], mat[N / 2 - 1][N / 2 - 1]);
 
    if (t % 2 == 0) {
      if (mp.containsKey(A + t / 2)) {
        mp.put(A + t / 2, mp.get(A + t / 2) + 1);
      } else {
        mp.put(A + t / 2, 1);
      }
    }
 
    // For Right Diagonal
    t = Math.abs(mat[N / 2 - 1][N / 2 + 1] - mat[N / 2 + 1][N / 2 - 1]);
    A = Math.min(mat[N / 2 - 1][N / 2 + 1], mat[N / 2 + 1][N / 2 - 1]);
 
    if (t % 2 == 0) {
      if (mp.containsKey(A + t / 2)) {
        mp.put(A + t / 2, mp.get(A + t / 2) + 1);
      } else {
        mp.put(A + t / 2, 1);
      }
    }
 
    int ans = -1, occur = 0;
 
    // Loop to find the largest integer
    // with maximum count
    for (Map.Entry x : mp.entrySet()) {
      if (occur < x.getValue()) {
        ans = x.getKey();
      }
      if (occur == x.getValue()) {
        ans = Math.max(ans, x.getKey());
      }
    }
 
    // Return Answer
    return ans;
  }
 
  // Driver Code
  public static void main(String[] args) {
    int[][] mat = { { 3, 4, 11 }, { 10, Integer.MAX_VALUE, 9 }, { -1, 6, 7 } };
    System.out.print(findMissing(mat));
  }
}
 
// This code is contributed by shikhasingrajput

Python3

# Python 3 code for the above approach
from collections import defaultdict
import sys
 
# Function to find the maximum value
# of the missing integer such that the
# count of AP's formed is maximized
def findMissing(mat):
    N = len(mat)
     
    # Stores the occurence of each
    # possible integer value
    mp = defaultdict(int)
 
    # For 1st Row
    t = abs(mat[N // 2][N // 2 + 1]
            - mat[N // 2][N // 2 - 1])
    A = min(mat[N // 2][N // 2 + 1],
            mat[N // 2][N // 2 - 1])
 
    if (t % 2 == 0):
        mp[A + t // 2] += 1
 
    # For 1st Col
    t = abs(mat[N // 2 + 1][N // 2]
            - mat[N // 2][N // 2])
    A = min(mat[N // 2 + 1][N // 2],
            mat[N // 2][N // 2])
 
    if (t % 2 == 0):
        mp[A + t // 2] += 1
 
    # For Left Diagonal
    t = abs(mat[N // 2 + 1][N // 2 + 1]
            - mat[N // 2 - 1][N // 2 - 1])
    A = min(mat[N // 2 + 1][N // 2 + 1],
            mat[N // 2 - 1][N // 2 - 1])
 
    if (t % 2 == 0):
        mp[A + t // 2] += 1
 
    # For Right Diagonal
    t = abs(mat[N // 2 - 1][N // 2 + 1]
            - mat[N // 2 + 1][N // 2 - 1])
    A = min(mat[N // 2 - 1][N // 2 + 1],
            mat[N // 2 + 1][N // 2 - 1])
 
    if (t % 2 == 0):
        mp[A + t // 2] += 1
 
    ans = -1
    occur = 0
 
    # Loop to find the largest integer
    # with maximum count
    for x in mp:
        if (occur < mp[x]):
            ans = x
 
        if (occur == mp[x]):
            ans = max(ans, x)
 
    # Return Answer
    return ans
 
# Driver Code
if __name__ == "__main__":
    mat = [[3, 4, 11],
           [10, sys.maxsize, 9],
           [-1, 6, 7]]
    print(findMissing(mat))
 
    # This code is contributed by ukasp.

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG
{
     
static int INT_MAX = 2147483647;
 
// Function to find the maximum value
// of the missing integer such that the
// count of AP's formed is maximized
static int findMissing(int [,]mat)
{
    int N = mat.GetLength(0);
 
    // Stores the occurence of each
    // possible integer value
    Dictionary mp =
           new Dictionary();
 
    // For 1st Row
    int t = Math.Abs(mat[N / 2, N / 2 + 1]
                - mat[N / 2, N / 2 - 1]);
    int A
        = Math.Min(mat[N / 2, N / 2 + 1],
              mat[N / 2, N / 2 - 1]);
 
    if (t % 2 == 0) {
        if (mp.ContainsKey(A + t / 2))
        {
            mp[A + t / 2] = mp[A + t / 2] + 1;
        }
        else
        {
            mp.Add(A + t / 2, 1);
        }
    }
 
    // For 1st Col
    t = Math.Abs(mat[N / 2 + 1, N / 2]
            - mat[N / 2, N / 2]);
    A = Math.Min(mat[N / 2 + 1, N / 2],
            mat[N / 2, N / 2]);
 
    if (t % 2 == 0) {
        if (mp.ContainsKey(A + t / 2))
        {
            mp[A + t / 2] = mp[A + t / 2] + 1;
        }
        else
        {
            mp.Add(A + t / 2, 1);
        }
    }
 
    // For Left Diagonal
    t = Math.Abs(mat[N / 2 + 1, N / 2 + 1]
            - mat[N / 2 - 1, N / 2 - 1]);
    A = Math.Min(mat[N / 2 + 1, N / 2 + 1],
            mat[N / 2 - 1, N / 2 - 1]);
 
    if (t % 2 == 0) {
        if (mp.ContainsKey(A + t / 2))
        {
            mp[A + t / 2] = mp[A + t / 2] + 1;
        }
        else
        {
            mp.Add(A + t / 2, 1);
        }
    }
 
    // For Right Diagonal
    t = Math.Abs(mat[N / 2 - 1, N / 2 + 1]
            - mat[N / 2 + 1, N / 2 - 1]);
    A = Math.Min(mat[N / 2 - 1, N / 2 + 1],
            mat[N / 2 + 1, N / 2 - 1]);
 
    if (t % 2 == 0) {
        if (mp.ContainsKey(A + t / 2))
        {
            mp[A + t / 2] = mp[A + t / 2] + 1;
        }
        else
        {
            mp.Add(A + t / 2, 1);
        }
    }
 
    int ans = -1, occur = 0;
 
    // Loop to find the largest integer
    // with maximum count
    foreach(KeyValuePair x in mp)
        {
        if (occur < x.Value) {
            ans = x.Key;
        }
        if (occur == x.Value) {
            ans = Math.Max(ans, x.Value);
        }
    }
 
    // Return Answer
    return ans;
}
 
// Driver Code
public static void Main()
{
    int [,]mat
        = { { 3, 4, 11 },
            { 10, INT_MAX, 9 },
            { -1, 6, 7 } };
             
    Console.Write(findMissing(mat));
}
}
 
// This code is contributed by Samim Hossain Mondal.

Javascript

        // JavaScript code for the above approach
 
        // Function to find the maximum value
        // of the missing integer such that the
        // count of AP's formed is maximized
        function findMissing(mat)
        {
            let N = mat.length;
 
            // Stores the occurence of each
            // possible integer value
            let mp = new Map();
 
            // For 1st Row
            let t = Math.abs(mat[Math.floor(N / 2)][Math.floor(N / 2) + 1]
                - mat[Math.floor(N / 2)][Math.floor(N / 2) - 1]);
            let A
                = Math.min(mat[Math.floor(N / 2)][Math.floor(N / 2) + 1],
                    mat[Math.floor(N / 2)][Math.floor(N / 2) - 1]);
 
            if (t % 2 == 0) {
                if (mp.has(A + Math.floor(t / 2)))
                    mp.set(A + Math.floor(t / 2), mp.get(A + Math.floor(t / 2)) + 1);
                else
                    mp.set(A + Math.floor(t / 2), 1);
            }
 
            // For 1st Col
            t = Math.abs(mat[Math.floor(N / 2) + 1][Math.floor(N / 2)]
                - mat[Math.floor(N / 2)][Math.floor(N / 2)]);
            A = Math.min(mat[Math.floor(N / 2) + 1][Math.floor(N / 2)],
                mat[Math.floor(N / 2)][Math.floor(N / 2)]);
 
            if (t % 2 == 0) {
                if (mp.has(A + Math.floor(t / 2)))
                    mp.set(A + Math.floor(t / 2), mp.get(A + Math.floor(t / 2)) + 1);
                else
                    mp.set(A + Math.floor(t / 2), 1);
            }
 
 
            // For Left Diagonal
            t = Math.abs(mat[Math.floor(N / 2) + 1][Math.floor(N / 2) + 1]
                - mat[Math.floor(N / 2) - 1][Math.floor(N / 2) - 1]);
            A = Math.min(mat[Math.floor(N / 2) + 1][Math.floor(N / 2) + 1],
                mat[Math.floor(N / 2) - 1][Math.floor(N / 2) - 1]);
 
            if (t % 2 == 0) {
                if (mp.has(A + Math.floor(t / 2)))
                    mp.set(A + Math.floor(t / 2), mp.get(A + Math.floor(t / 2)) + 1);
                else
                    mp.set(A + Math.floor(t / 2), 1);
            }
 
 
            // For Right Diagonal
            t = Math.abs(mat[Math.floor(N / 2) - 1][Math.floor(N / 2) + 1]
                - mat[Math.floor(N / 2) + 1][Math.floor(N / 2) - 1]);
            A = Math.min(mat[Math.floor(N / 2) - 1][Math.floor(N / 2) + 1],
                mat[Math.floor(N / 2) + 1][Math.floor(N / 2) - 1]);
 
            if (t % 2 == 0) {
                if (mp.has(A + Math.floor(t / 2)))
                    mp.set(A + Math.floor(t / 2), mp.get(A + Math.floor(t / 2)) + 1);
                else
                    mp.set(A + Math.floor(t / 2), 1);
            }
 
 
            let ans = -1, occur = 0;
 
            // Loop to find the largest integer
            // with maximum count
            for (let [key, val] of mp) {
                if (occur < val) {
                    ans = key;
                }
                if (occur == val) {
                    ans = Math.max(ans, key);
                }
            }
 
            // Return Answer
            return ans;
        }
 
        // Driver Code
        let mat = [[3, 4, 11],
            [10, Number.MAX_VALUE, 9],
            [-1, 6, 7]];
        document.write(findMissing(mat))
 
  // This code is contributed by Potta Lokesh
    

输出

5

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