边数

Question

You are given a grid; having n rows; and m columns; where two cells are called to be adjacent if : they have a common side.

let two adjacent cells be a and b . Since they are adjacent; hence; you may go both from a to b ; and also from b to a .

In terms of graph theory; we may say that if the grid is modelled as a directed graph; then, there exists a directed edge from a to b ; and also a from b to; in case cells a and b are adjacent.

You are asked to find the number of directed edges in the graph.

Input Format

The first line of the input contains a single integer T ; denoting the number of test cases.

Then; t lines follow; where each line contains two space seperated integers n and m ; the dimensions of the grid respectively.

Sample Input 0

1
3 3

Sample Output 0

24

Explanation 0

Number of the directed edges is 24.

Is this approach correct? My code did passes the sample test cases but fails for others

def compute(m,n):
 arr = [[0 for x in range(n)] for y in range(m)] 
 arr[0][0]=2
 arr[n-1][m-1]=2
 arr[0][m-1]=2
 arr[n-1][0]=2
 for i in range (1,m-1):
     arr[i][0]=3
     arr[i][n-1]=3
 for j in range (1,n-1):
     arr[0][j]=3
     arr[n-1][j]=3
 for i in range (1,n-2):
     for j in range (1,m-2):
         arr[i][j]=4
 return sum(sum(arr,[])) +4 

Please explain the correct approach for this problem.Thanks in advance

Answer 1

I think you can solve this with dynamic programming.

number of edge in m*n = number of edge in (m-1)*(n) + to_be_calculated

Then you can simply find the amount of to_be_calculated by 2*n + 2*(n-1)

After you finished with columns and reached to m == 1 then you can reduce n to 1 .

def compute(n,m,sum):
  if n == 1 and m == 1:
    return sum
  elif m == 1:
    return compute(1, 1, sum + 2*(n-1))
  else:
    return compute(n, m-1, sum + 2*n + 2*(n-1) )

compute(5,5,0) # For table 5x5

Answer 2

For a grid of n rows and m columns: the number of sides in any row is m-1, the number of sides in any column is n-1. Every side has two edges in the graph of adjacent cells.

Therefore the number of edges for an n*m grid is:

def compute(n, m):
    return n * (m - 1) * 2 + m * (n - 1) * 2

Or, simplified even further:

def compute(n, m):
    return 4 * n * m - 2 * n - 2 * m

Your algorithm goes and fills in the individual edges to sum them at the end, which is far more complicated than it needs to be for this problem without additional constraints.

Answer 3

You can find a formula to compute the number of edges in the graph as follows: Suppose we have a grid with dimensions n and m . For each cell we need to count the number of neighbor cells. Then, the summation of such numbers is the number of edges.

Case 1) such a grid has 4 corner cells each with 2 neighbors ; total neighbors case 1: 4*2= 8

Case 2: such a grid has 2(n+m-2)-4 cells in its sides exclude the corners each with 3 neighbors, total neighbors case 2: (2 (n+m-2)-4) 3

Case 3) such a grid has nm-(2(n+m-2)-4)-4 inner cells each with 4 neighbors , total neighbors case 3: * (nm-(2(n+m-2)-4)-4) 4

Total number of edges = Case 1 + Case 2 + Case 3 = 8 + (2(n+m-2)-4)3 + (nm-(2(n+m-2)-4)-4)4 = 4nm - 2(n+m)

The figure below displays all the cases:

So you can use the code below to compute the number of edges:

def compute_total_edges(m,n):
    return 4*n*m-2*(n+m)

print(compute_total_edges(3,3))