web-dev-qa-db-fra.com

Vérification de la carrée magique pour N × N matrice avec une complexité minimale

Existe-t-il un algorithme qui fonctionne mieux que O(n²) pour vérifier si une matrice carrée est une magie (par exemple, telle que la somme de toutes les lignes, cols et diagonale est égale à l'autre)?

J'ai vu quelqu'un mentionner une O(n) Time sur un site Web il y a quelques jours mais ne pouvait pas comprendre comment.

algorithmsperformancecomplexity
4
Koray

Tout dépend de ce que N est. Si vous dites que n est le nombre d'ellement par ligne que vous ne pouvez pas vérifier si la matrice est magique avec moins de O (N²). Si vous dites n est le nombre total d'ellement dans la matrice, vous pouvez facilement créer un algorithme qui a la complexité de temps de O (n).

Voici un code PSEVDO avec une complexité de temps analys

columvalue = rows[0];                    O(1)
diagonalvalue1 = rows[0][0]              O(1)
diagonalvalue2 = rows[0][-1]             O(1)
magicNumber = sum(rows[0]);              O(c)
diagonal count = 1

for r in rows:                           O(r)*(
  diagonalvalue1 += r[0+diagonalcount]         O(1)
  diagonalvalue2 += r[-1-diagonalcount]        O(1)
  diagonalcount  += 1                          0(1)
  rowsum = 0                                   O(1)
  i = 0                                        O(1)
  for n in r:                                  0(c)*(
    rowsum += n                                     O(1)
    columvalue[i] += n                              O(1)
    i += 1                                          0(1)
                                                    )
  if rowsum != magicvalue:                     O(1)
    return False                               O(1)
                                               )

for c in columvalue:                     O(c)*(
  if c != magicvalue:                          O(1)
    return False                               O(1)
                                               )

return diagonalvalue1 == magicvalue and 
       diagonalvalue2 == magicvalue       O(1)

cela nous donnera la complexité de temps de O(c) + o (R * C) là-bas C = nombre de colons et r = nombre de lignes. Depuis O (r * c)> = O(c) Nous pouvons dire que la complexité de temps est O (R * C) qui sont le nombre d'illiments dans la matrice n et cela nous donne la complexité de O (n)

4
nist