web-dev-qa-db-fra.com

La complexité temporelle de N Queen en utilisant le backtracking?

#include<stdio.h>
#include<math.h>

void printboard(int n);
void fourQueen(int k,int n);
int place(int k,int i);
int x[100];

void NQueen(int k,int n)
{
  int i;
  for(i=1;i<=n;i++)
  {
    if(place(k,i)==1)
    {     x[k]=i;
            if(k==n)
            {
                printf("Solution\n");
                printboard(n);
            }
            else
                NQueen(k+1,n);
    }
  }
}

int place(int k,int i)
{
  int j;
  for(j=1;j<k;j++)
  {
    if((x[j]==i)||abs(x[j]-i)==abs(j-k))
        return 0;
  }
  return 1;
}

void printboard(int n)
{
  int i;
  for(i=1;i<=n;i++)
    printf("%d  ",x[i]);
}

void main()
{
    int n;
    printf("Enter Value of N:");
    scanf("%d",&n);
    NQueen(1,n);
}

Je pense que cela a une complexité temporelle: O (n ^ n), Comme la fonction NQueen appelle de manière récursive, mais existe-t-il une limite plus étroite possible pour ce programme? Qu'en est-il du meilleur et du pire cas? Je suis également confus au sujet de la fonction place () qui est O(k) et qui appelle depuis NQueen ().

calgorithmn-queens
9
tanmoy

Il y a beaucoup d'optimisations qui peuvent améliorer la complexité temporelle de l'algorithme.

Il y a plus d'informations dans ces liens:

  1. https://sites.google.com/site/nqueensolver/home/algorithm-results

  2. https://sites.google.com/site/nqueensolver/home/algorithms/2backtracking-algorithm

Snapshot

10
Juan Ramirez

Pour votre fonction T(n) = n*T(n-1) + O(n^2) qui se traduit par O(N!) complexité du temps en moyenne.

8
Vikram Bhat

COMPLEXITE TEMPORELLE DU PROBLEME DE N-REINE IS 

> O (N!)

Explication: .__ Si nous additionnons tout cela et définissons le temps d’exécution comme T (N). Alors T(N) = O(N2) + N * T (N-1). Si vous dessinez un arbre de récurrence en utilisant cette récurrence, le dernier terme sera quelque chose comme n3 + n! O (1). Selon la définition de Big O, cela peut être réduit à O (n!) Temps d'exécution.

6
Shyam Bhimani

La complexité est n ^ n et voici l'explication

Ici, n représente le nombre de reines et restera le même pour chaque appel de fonction . K est le numéro de la ligne et la fonction sera appelée fois jusqu'à ce que k atteigne le n.Si n = 8, nous avons n lignes et n reines .

T (n) = n (n + t (max de k - 1)) = n ^ max de k = n ^ n comme max de k est n.

Remarque: La fonction a deux paramètres.En boucle, n ne diminue pas. Pour chaque appel de fonction, il reste le même.Mais le nombre d'appels de la fonction est réduit, de sorte que la récursivité puisse se terminer.

2
aman_41907

O (n ^ n) est certainement une limite supérieure pour la résolution de n-reines à l’aide de retours arrière. Je suppose que vous résolvez ceci en assignant une reine colonne par colonne . Cependant, considérez ceci - lorsque vous assignez un emplacement de la reine dans la première colonne, vous avez n options, après cela, vous n'avez plus que n-1 options car vous ne pouvez pas placer la reine dans la même rangée que la première reine, puis n-2 et ainsi de suite. Ainsi, la complexité dans le cas le plus défavorable reste la borne supérieure de O (n!).

J'espère que cela répond à votre question même si j'ai presque 4 ans de retard!

1
Akshay