与给定两点等距的矩阵中的像元数

给定一个由N行和M列组成的矩阵，给定矩阵上的两个点；任务是计算与给定两点等距的像元数。在水平方向或垂直方向上或在两个方向上的任何遍历都被视为有效，但对角线路径无效。
例子：

Input: 5 5 
2 4 
5 3 
Output: 5 
Explanation: 
Out of all cells, these are the points (3, 1);(3, 2);(3, 3);(4, 4);(4, 5) 
which satisfy given condition.
Input: 4 3 
2 3 
4 1 
Output: 4 
Explanation: 
Out of all cells, these are the points (1, 1);(2, 1);(3, 2);(4, 3) 
which satisfy given condition. 
 

方法：

1. 遍历矩阵的每个单元。
2. 令“ A”为当前像元与第一点之间的距离，类似地，“ B”为当前像元与第二点之间的距离。
3. 两点之间的距离是使用曼哈顿距离计算的。如果A和B相等，则计数增加。

下面是上述方法的实现：

C++

// C++ implementation of the above approach
#include 
using namespace std;
int numberOfPoints(int N, int M, int x1,
                   int y1, int x2, int y2)
{
 
    // Initializing count
    int count = 0;
 
    // Traversing through rows.
    for (int i = 1; i <= N; i++) {
 
        // Traversing through columns.
        for (int j = 1; j <= M; j++) {
 
            // By using Manhattan Distance, the distance between
            // the current point to given two points is calculated.
 
            // If distances are equal
            // the count is incremented by 1.
            if (abs(i - x1) + abs(j - y1)
                == abs(i - x2) + abs(j - y2))
                count++;
        }
    }
 
    return count;
}
 
// Driver Code
int main()
{
    int n = 5;
    int m = 5;
    int x1 = 2;
    int y1 = 4;
    int x2 = 5;
    int y2 = 3;
 
    cout << numberOfPoints(n, m, x1, y1, x2, y2);
}

Java

//Java implementation of the above approach
import java.util.*;
import java.lang.Math;
public class GFG {
    public static int numberOfPoints(int N, int M, int x1,
                                     int y1, int x2, int y2)
    {
        int count = 0, i, j;
 
        // Traversing through rows.
        for (i = 1; i <= N; i++) {
 
            // Traversing through columns.
            for (j = 1; j <= M; j++) {
 
                // By using Manhattan Distance, distance between
                // current point to given two points is calculated
 
                // If distances are equal
                // the count is incremented by 1.
                if (Math.abs(i - x1) + Math.abs(j - y1)
                    == Math.abs(i - x2) + Math.abs(j - y2))
                    count += 1;
            }
        }
        return count;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int n = 5;
        int m = 5;
        int x1 = 2;
        int y1 = 4;
        int x2 = 5;
        int y2 = 3;
 
        System.out.println(numberOfPoints(n, m, x1, y1, x2, y2));
    }
}

Python

# Python implementation of the above approach
def numberPoints(N, M, x1, y1, x2, y2):
 
    # Initializing count = 0
    count = 0
     
    # Traversing through rows.
    for i in range(1, N + 1):
     
        # Traversing through columns.
        for j in range(1, M + 1):
 
            # By using Manhattan Distance,
            # distance between current point to
            # given two points is calculated
 
            # If distances are equal the
            # count is incremented by 1.
            if (abs(i - x1)+abs(j - y1)) == (abs(i - x2)+abs(j - y2)):
                count += 1
                 
    return count
     
# Driver Code
N = 5
M = 5
x1 = 2
y1 = 4
x2 = 5
y2 = 3
print(numberPoints(N, M, x1, y1, x2, y2))

C#

// C# implementation of the above approach
using System;
 
class GFG
{
     
    static int numberOfPoints(int N, int M, int x1,
                                    int y1, int x2, int y2)
    {
        int count = 0, i, j;
 
        // Traversing through rows.
        for (i = 1; i <= N; i++)
        {
 
            // Traversing through columns.
            for (j = 1; j <= M; j++)
            {
 
                // By using Manhattan Distance, distance between
                // current point to given two points is calculated
 
                // If distances are equal
                // the count is incremented by 1.
                if (Math.Abs(i - x1) + Math.Abs(j - y1)
                    == Math.Abs(i - x2) + Math.Abs(j - y2))
                     
                    count += 1;
            }
        }
        return count;
    }
 
    // Driver Code
    public static void Main()
    {
        int n = 5;
        int m = 5;
        int x1 = 2;
        int y1 = 4;
        int x2 = 5;
        int y2 = 3;
 
        Console.WriteLine(numberOfPoints(n, m, x1, y1, x2, y2));
    }
}
 
// This code is contributed by AnkitRai01

Javascript

// javascript implementation of the above approach
 
    function numberOfPoints(N , M , x1 , y1 , x2 , y2)
    {
        var count = 0, i, j;
 
        // Traversing through rows.
        for (i = 1; i <= N; i++) {
 
            // Traversing through columns.
            for (j = 1; j <= M; j++) {
 
                // By using Manhattan Distance, distance between
                // current povar to given two points is calculated
 
                // If distances are equal
                // the count is incremented by 1.
                if (Math.abs(i - x1) + Math.abs(j - y1) == Math.abs(i - x2) + Math.abs(j - y2))
                    count += 1;
            }
        }
        return count;
    }
 
    // Driver Code
        var n = 5;
        var m = 5;
        var x1 = 2;
        var y1 = 4;
        var x2 = 5;
        var y2 = 3;
 
        document.write(numberOfPoints(n, m, x1, y1, x2, y2));
 
// This code is contributed by Rajput-Ji

输出：

5