Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Largest integer that can be placed at center of given square Matrix to maximise arithmetic progressions

  • Last Updated : 29 Apr, 2022

Given a N x N matrix, such that the element at the index [N/2, N/2] is missing, the task is to find the maximum integer that can be placed at index [N/2, N/2] such that the count of arithmetic progressions over all rows, columns, and diagonals is maximized.

Example:

Input: mat[][]={{3, 4, 11}, {10, ?, 9}, {-1, 6, 7}}
Output: 5
Explanation: The maximum integer that can be placed 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

 

Approach: The given problem can be solved by finding all the possible numbers that can be placed on the index [N/2, N/2] such that it forms an Arithmetic progression over any row, column, or diagonal of the given matrix and keeping track of the largest integer out of them which forms the maximum AP’s.

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.

The same approach can be applied to N*N matrix.

Below is the implementation of the above approach:

C++




// C++ code for the above approach
#include <bits/stdc++.h>
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<vector<int> >& mat)
{
    int N = mat.size();
 
    // Stores the occurrence of each
    // possible integer value
    unordered_map<int, int> 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<vector<int> > 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 occurrence of each
    // possible integer value
    HashMap<Integer, Integer> mp = new HashMap<Integer, Integer>();
 
    // 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<Integer, Integer> 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 occurrence 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 occurrence of each
    // possible integer value
    Dictionary<int, int> mp =
           new Dictionary<int, int>();
 
    // 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<int, int> 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



<script>
        // 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 occurrence 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
    </script>
 
 
Output
5
 
Time Complexity: O(1)
Auxiliary Space: O(1)
 

My Personal Notes
arrow_drop_up
Previous
Top 7 Artificial Intelligence and Machine Learning Trends For 2022
Next

Geeky Year
Recommended Articles
Page :
Find an integer that is common in the maximum number of given arithmetic progressions
15, Jan 20
Distance of chord from center when distance between center and another equal length chord is given
28, May 19
K-th term from given N merged Arithmetic Progressions
03, Jul 20
Introduction to Arithmetic Progressions | Class 10 Maths
07, Nov 20
Count Arithmetic Progressions having sum S and common difference equal to D
03, Mar 21
Count Arithmetic Progressions having sum N and common difference equal to 1
02, Mar 21
Maximise matrix sum by following the given Path
28, May 19
Digital Root (repeated digital sum) of square of an integer using Digital root of the given integer
01, Oct 20
Maximise K that can be reduced from Array to make all elements equal
19, Jan 22
Count tiles of dimensions 2 * 1 that can be placed in an M * N rectangular board that satisfies the given conditions
15, Feb 21
Check if all disks can be placed at a single rod based on given conditions
03, Feb 21
Largest integer upto N having greatest prime factor greater than its square root
05, Oct 21
Check if matrix can be converted to another matrix by transposing square sub-matrices
12, Mar 19
Maximum number of plates that can be placed from top to bottom in increasing order of size
05, May 21
Maximum bishops that can be placed on N*N chessboard
12, Jan 19
Find the number of rectangles of size 2*1 which can be placed inside a rectangle of size n*m
26, Oct 18
Maximum non-attacking Rooks that can be placed on an N*N Chessboard
01, Sep 20
Check if all objects of type A and B can be placed on N shelves
29, Jun 20
Find position of non-attacking Rooks in lexicographic order that can be placed on N*N chessboard
18, Jul 20
Count of smaller rectangles that can be placed inside a bigger rectangle
09, Sep 20
Count of rooks that can attack each other out of K rooks placed on a N*N chessboard
21, Dec 21
Check if all enemies are killed with bombs placed in a matrix
17, Jan 19
Check if all rows of a Binary Matrix have all ones placed adjacently or not
23, Feb 21
Maximise distance by rearranging all duplicates at same distance in given Array
16, Feb 22
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
kritirikhi
@kritirikhi
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!