Recuento de torres que pueden atacarse entre sí a partir de K torres colocadas en un tablero de ajedrez N*N

Dado un par de coordenadas de torres K en un tablero de ajedrez NXN , la tarea es contar el número de torres que pueden atacarse entre sí. Nota: 1 <= K <= N*N
Ejemplos :

Entrada : K = 2, arr[][] = { {2, 2}, {2, 3} }, N = 8
Salida : 2
Explicación : Ambas torres pueden atacarse entre sí porque están en la misma fila. Por lo tanto, la cuenta de torres que pueden atacarse entre sí es 2
 

Entrada : K = 1, arr[][] = { {4, 5} }, N = 4
Salida : 0

Enfoque : la tarea se puede resolver fácilmente utilizando el hecho de que 2 torres pueden atacarse entre sí si están en la misma fila o en la misma columna , de lo contrario, no pueden atacarse entre sí.

A continuación se muestra la implementación del código anterior:

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the number of attacking rooks
int willAttack(vector<vector<int> >& arr, int k, int N)
{
    int ans = 0;
 
    for (int i = 0; i < k; i++) {
        for (int j = 0; j < k; j++) {
 
            if (i != j) {
 
                // Check if rooks are in same row
                // or same column
                if ((arr[i][0] == arr[j][0])
                    || (arr[i][1] == arr[j][1]))
                    ans++;
            }
        }
    }
 
    return ans;
}
 
// Driver Code
int main()
{
    vector<vector<int> > arr = { { 2, 2 }, { 2, 3 } };
    int K = 2, N = 8;
    cout << willAttack(arr, K, N);
    return 0;
}

import java.io.*;
import java.util.*;
 
class Solution {
  static int willAttack(int arr[][], int k, int N)
  {
    int ans = 0;
 
    for (int i = 0; i < k; i++) {
      for (int j = 0; j < k; j++) {
 
        if (i != j) {
 
          // Check if rooks are in same row
          // or same column
          if ((arr[i][0] == arr[j][0])
              || (arr[i][1] == arr[j][1]))
            ans++;
        }
      }
    }
 
    return ans;
  }
   
  // Driver code
  public static void main(String[] args)
  {
    int[][] arr = { { 2, 2 }, { 2, 3 } };
    int K = 2, N = 8;
    System.out.println(willAttack(arr, K, N));
  }
}
 
// This code is contributed by dwivediyash.

# python program for the above approach
 
# Function to count the number of attacking rooks
def willAttack(arr, k, N):
 
    ans = 0
 
    for i in range(0, k):
        for j in range(0, k):
 
            if (i != j):
 
                # Check if rooks are in same row
                # or same column
                if ((arr[i][0] == arr[j][0])
                        or (arr[i][1] == arr[j][1])):
                    ans += 1
 
    return ans
 
# Driver Code
if __name__ == "__main__":
 
    arr = [[2, 2], [2, 3]]
    K = 2
    N = 8
    print(willAttack(arr, K, N))
 
    # This code is contributed by rakeshsahni

using System;
class Solution
{
  static int willAttack(int[,] arr, int k, int N)
  {
    int ans = 0;
 
    for (int i = 0; i < k; i++)
    {
      for (int j = 0; j < k; j++)
      {
 
        if (i != j)
        {
 
          // Check if rooks are in same row
          // or same column
          if ((arr[i, 0] == arr[j, 0])
              || (arr[i, 1] == arr[j, 1]))
            ans++;
        }
      }
    }
 
    return ans;
  }
 
  // Driver code
  public static void Main()
  {
    int[,] arr = { { 2, 2 }, { 2, 3 } };
    int K = 2, N = 8;
    Console.WriteLine(willAttack(arr, K, N));
  }
}
 
// This code is contributed by gfgking

<script>
      // JavaScript code for the above approach
 
      // Function to count the number of attacking rooks
      function willAttack(arr, k, N) {
          let ans = 0;
 
          for (let i = 0; i < k; i++) {
              for (let j = 0; j < k; j++) {
 
                  if (i != j) {
 
                      // Check if rooks are in same row
                      // or same column
                      if ((arr[i][0] == arr[j][0])
                          || (arr[i][1] == arr[j][1]))
                          ans++;
                  }
              }
          }
 
          return ans;
      }
 
      // Driver Code
      let arr = [[2, 2], [2, 3]];
      let K = 2, N = 8;
      document.write(willAttack(arr, K, N));
 
// This code is contributed by Potta Lokesh
  </script>

2

Complejidad temporal : O(K*K)
Espacio auxiliar : O(1)