probleme : resolveur de sudoku par backtracking

Bonjour j'ai fais un resolveur de sudoku en utilisant la méthode du backtracking, mais il y a un probleme ça ne resoud pas toutes les cases et je ne vois pas du tout ce qui peut clocher dans mon algo, si quelqu'un pourrait m'éclaircir...

Merci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
 
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <SDL/SDL.h>
 
 
/* Structure d'une case de sudoku */
 
struct case_sudoku{
  int temp[10];   // tableau des possibilités de la case
  int valeur_case; // valeur de la case , 0 si aucune valeur
  int base;        // 1 si valeur_case est une base
  int direction; // s'applique aux bases
};
 
typedef struct case_sudoku case_sudoku;
 
 
/*Prototypes de fonctions */
 
void init_grille(case_sudoku **tab);
void init_sdl(case_sudoku **tab,SDL_Surface **Pecran,SDL_Surface **Pgrille,SDL_Surface **Pcases);
void aff_grille(case_sudoku **tab,SDL_Surface **Pecran,SDL_Surface **Pgrille,SDL_Surface **Pcases);
void free_sdl(case_sudoku **tab,SDL_Surface **Pgrille,SDL_Surface **Pcases);
case_sudoku **allouer_tab(int,int);
void pause(case_sudoku **tab,SDL_Surface **ecran,SDL_Surface **grille,SDL_Surface **cases);
void load(case_sudoku **tab);
void save(case_sudoku **tab);
void saisir_nombre(case_sudoku **tab,int,int);
char backtrack(case_sudoku **tab,int ligne,int col);
char conflit(case_sudoku **tab,int ligne,int col,int valeur);
 
/* Fonction principale */
 
int main (void) {
 
  case_sudoku **tab=NULL;
 
  SDL_Surface **cases;
  cases=(SDL_Surface **)malloc(8*sizeof(SDL_Surface *));
 
  SDL_Surface *ecran=NULL;
  SDL_Surface *grille=NULL;
 
  tab=allouer_tab(9,9);
  init_sdl(tab,&ecran,&grille,cases);
  init_grille(tab);
  aff_grille(tab,&ecran,&grille,cases);
 
  pause(tab,&ecran,&grille,cases);
 
  free_sdl(tab,&grille,cases);
 
  return EXIT_SUCCESS; 
 
}
 
 
/* Gestion des évènements */
 
void pause(case_sudoku **tab,SDL_Surface **ecran,SDL_Surface **grille,SDL_Surface **cases) {
 
  SDL_Event event;
  int continuer=1;
 
  while(continuer) 
    {
      SDL_WaitEvent(&event);
      if(event.type==SDL_QUIT)
	continuer=0;
      if(event.type==SDL_KEYDOWN)
	{
	  switch(event.key.keysym.sym)
	    {
	    case SDLK_ESCAPE : 
	      continuer=0;
	      break;
	    case SDLK_a :
	      init_grille(tab);
	      break;
	    case SDLK_l :
	      load(tab);
	      break;
	    case SDLK_s :
	      save(tab);
	      break;
	    case SDLK_r :
	      backtrack(tab,0,0);
	      break;
	    }
	}
      if(event.type==SDL_MOUSEBUTTONUP)
	{
	  if(event.button.button==SDL_BUTTON_RIGHT)
	    saisir_nombre(tab,event.button.x,event.button.y);
	}
 
      SDL_FillRect(*ecran,NULL,SDL_MapRGB((*ecran)->format,0,0,0));
      aff_grille(tab,ecran,grille,cases);
    }
}
 
void saisir_nombre(case_sudoku **tab,int pt_x,int pt_y) {
 
  SDL_Event event;
 
  int ligne,col,continuer=1;
 
  ligne=(pt_y-120)/39;
  col=(pt_x-120)/39;
 
  while(continuer) 
    {
      SDL_WaitEvent(&event);
      if(event.type==SDL_KEYDOWN)
	{
	  switch(event.key.keysym.sym) 
	    {
	    case SDLK_KP0 :
	      tab[ligne][col].valeur_case=0;
	      tab[ligne][col].base=1;
	      continuer=0;
	      break;
	    case SDLK_KP1 :
	      tab[ligne][col].valeur_case=1;
	      tab[ligne][col].base=1;
	      continuer=0;
	      break;
	    case SDLK_KP2 :
	      tab[ligne][col].valeur_case=2;
	      tab[ligne][col].base=1;
	      continuer=0;
	      break;
	    case SDLK_KP3 :
	      tab[ligne][col].valeur_case=3;
	      tab[ligne][col].base=1;
	      continuer=0;
	      break;
	    case SDLK_KP4 :
	      tab[ligne][col].valeur_case=4;
	      tab[ligne][col].base=1;
	      continuer=0;
	      break;
	    case SDLK_KP5 :
	      tab[ligne][col].valeur_case=5;
	      tab[ligne][col].base=1;
	      continuer=0;
	      break;
	    case SDLK_KP6 :
	      tab[ligne][col].valeur_case=6;
	      tab[ligne][col].base=1;
	      continuer=0;
	      break;
	    case SDLK_KP7 :
	      tab[ligne][col].valeur_case=7;
	      tab[ligne][col].base=1;
	      continuer=0;
	      break;
	    case SDLK_KP8 :
	      tab[ligne][col].valeur_case=8;
	      tab[ligne][col].base=1;
	      continuer=0;
	      break;
	    case SDLK_KP9 :
	      tab[ligne][col].valeur_case=9;
	      tab[ligne][col].base=1;
	      continuer=0;
	      break;		
	    }
	}
    }
}
 
 
 
/* Allocation dynamique de la grille de sudoku */
 
case_sudoku **allouer_tab(int l,int c) {
 
  int i;
  case_sudoku **tab;
 
  tab=(case_sudoku **)malloc(l*sizeof(case_sudoku *));
  for(i=0;i<9;i++)
    tab[i]=(case_sudoku *)malloc(c*sizeof(case_sudoku));
  return tab;
}
 
/* Initialise SDL et charge les différentes images */
 
void init_sdl(case_sudoku **tab,SDL_Surface **Pecran,SDL_Surface **Pgrille,SDL_Surface **Pcases) {
 
   if(SDL_Init(SDL_INIT_VIDEO)!=0)
   {
     fprintf(stderr,"Erreur d'initialisation de la SDL : %s",SDL_GetError());
     exit(EXIT_FAILURE);
   }
 
   *Pecran=SDL_SetVideoMode(600,600,32,SDL_HWSURFACE);
   if(*Pecran==NULL)
     {
       fprintf(stderr,"Erreur lors du chargement video : %s",SDL_GetError());
       exit(EXIT_FAILURE);
     }
 
   SDL_WM_SetCaption("Sudoku",NULL);
 
   SDL_FillRect(*Pecran,NULL,SDL_MapRGB((*Pecran)->format,0,0,0));
   SDL_Flip(*Pecran);
   *Pgrille=SDL_LoadBMP("grille.bmp");
   Pcases[0]=SDL_LoadBMP("1.bmp");
   Pcases[1]=SDL_LoadBMP("2.bmp");
   Pcases[2]=SDL_LoadBMP("3.bmp");
   Pcases[3]=SDL_LoadBMP("4.bmp");
   Pcases[4]=SDL_LoadBMP("5.bmp");
   Pcases[5]=SDL_LoadBMP("6.bmp");
   Pcases[6]=SDL_LoadBMP("7.bmp");
   Pcases[7]=SDL_LoadBMP("8.bmp");
   Pcases[8]=SDL_LoadBMP("9.bmp");
   Pcases[9]=SDL_LoadBMP("0.bmp");
}
 
/* Libère la mémoire */
 
void free_sdl(case_sudoku **tab,SDL_Surface **Pgrille,SDL_Surface **Pcases) {
 
  char i;
 
  SDL_FreeSurface(*Pgrille);
  for(i=0;i<9;i++)
    SDL_FreeSurface(Pcases[i]);
  SDL_Quit();
 
}
 
/* Initialise la grille à vide */
 
void init_grille(case_sudoku **tab) {
 
  char i,j,k;
 
  for(i=0;i<9;i++) 
    {
      for(j=0;j<9;j++) 
	{
	  for(k=0;k<10;k++)
	    {
	      tab[i][j].valeur_case=0; 
	      tab[i][j].temp[k]=0;
	      tab[i][j].base=0;
	      tab[i][j].direction=0;
	    }
	}
    }
}
 
/* Affiche la grille de sudoku */
 
void aff_grille(case_sudoku **tab,SDL_Surface **Pecran,SDL_Surface **Pgrille,SDL_Surface **Pcases) {
 
  SDL_Rect pos_grille;
  SDL_Rect pos_nbre;
 
  int k,m,l,n;
 
  pos_grille.x=(600/2)-(359/2);
  pos_grille.y=(600/2)-(359/2);
 
  for(k=0,m=9;m<359;m+=39,k++)
    {
      pos_nbre.y=m;
      for(l=0,n=9;n<359;n+=39,l++)
	{
	  pos_nbre.x=n;
	  if((tab[k][l].valeur_case)!=0)
	    {
	      SDL_BlitSurface(Pcases[tab[k][l].valeur_case-1],NULL,*Pgrille,&pos_nbre);
	    }
	  else if((tab[k][l].valeur_case)==0)
	    {
	      SDL_BlitSurface(Pcases[9],NULL,*Pgrille,&pos_nbre);
	    }
	}
    }
 
 
 
  SDL_BlitSurface(*Pgrille,NULL,*Pecran,&pos_grille); 
  SDL_Flip(*Pecran);
}
 
/* Fonction de chargement */
 
void load(case_sudoku **tab) {
 
  char filename[20];
  FILE *fp;
  int i,j;
 
  printf("Saisissez le nom du fichier à charger :\n");
  scanf("%s",filename);
 
  fp=fopen(filename,"r");
  if(fp==NULL)
    {
      printf("Erreur lors du chargement du fichier\n");
      exit(0);
    }
 
  for(i=0;i<9;i++)
    {
      for(j=0;j<9;j++)
	{
	  fscanf(fp,"%d ",&tab[i][j].valeur_case);
	}
    }
  fclose(fp);
 
  for(i=0;i<9;i++)
    {
      for(j=0;j<9;j++)
	{
	  if(tab[i][j].valeur_case==0)
	    {
	      tab[i][j].base=0;
	    }
	  else 
	    {
	      tab[i][j].base=1;
	    }
	}
    }
}
 
/* Fonction de sauvegarde */
 
void save(case_sudoku **tab) {
 
  char filename[20];
  FILE *fp;
  int i,j;
 
  printf("Choisissez un nom de sauvegarde :\n");
  scanf("%s",filename);
 
  fp=fopen(filename,"w");
  if(fp==NULL) 
    {
      printf("Erreur de création de fichier\n");
      exit(0);
    }
  for(i=0;i<9;i++) 
    {
      for(j=0;j<9;j++)
	{
	  fprintf(fp,"%d ",tab[i][j].valeur_case);
	}
    }
  fclose(fp);
 
}
 
 
/* Fonction qui resoud une grille de sudoku par backtracking */
 
char backtrack(case_sudoku **tab,int ligne,int col) {
 
  int k=1,continuer=1,copie_col,copie_ligne,l;
 
  if(tab[ligne][col].base==0) // Si ce n'est pas une base
    {
      while(continuer)  // on avance dans le tableau temp pour trouver la premiere valeur candidate
	{
	  if(k>9) // Si aucune valeur n'est possible
	    {
	      tab[ligne][col].valeur_case=0;
	      for(l=0;l<10;l++)
		tab[ligne][col].temp[l]=0;
	      continuer=0;
	      if(col==0 && ligne==0)
		return 0;
	      if(col==0)
		backtrack(tab,ligne-1,9);
	      else
		backtrack(tab,ligne,col-1);
	    }
 
	  else if(tab[ligne][col].temp[k]==0) // Si on a trouvé une valeur candidate
	    {
	      tab[ligne][col].valeur_case=k; // On l'assigne
	      tab[ligne][col].temp[k]=9;
	      if(conflit(tab,ligne,col,k))  // S'il y a un conflit, on relance la boucle
		{
		  k++;
		  continuer=1;
		}
	      else  // S'il n'y a pas de conflit on sort de la boucle et on passe à la case suivante
		{
		  continuer=0;
		  if(col==8 && ligne==8)
		    return 1;
		  if(col==8)
		    backtrack(tab,ligne+1,0);
		  else
		    backtrack(tab,ligne,col+1);
		}
	    }
	  else if(tab[ligne][col].temp[k]!=0) // Si on n'en a pas trouvé
	    {
	      k++;
	      continuer=1;
	    }
	}
    }
  else // C'est une case base
    {
      if(col==8 && ligne==8) // Si on est à la derniere case
	return 1;
 
      if(tab[ligne][col].direction==6) // Si on avait avancé precedement avec cette case, on recule
	{
	  tab[ligne][col].direction=4;
	      if(col>0)
		backtrack(tab,ligne,col-1);
	      else if(col==0)
		backtrack(tab,ligne-1,8);
	}
 
      if(tab[ligne][col].direction==4 || tab[ligne][col].direction==0) // Sinon on avance
	    {
	      tab[ligne][col].direction=6;
	      if(col<8)
		backtrack(tab,ligne,col+1);
	      else if(col==8)
		backtrack(tab,ligne+1,0);
	    }
	}
    }
 
 
/* Fonction qui verifie si (tab[ligne][col].valeur_case==valeur) est une valeur possible ou si elle est deja présente sur la ligne, colonne ou région */		      
 
char conflit(case_sudoku **tab,int ligne,int col,int valeur) {
 
  int i,x,y;
 
  // On vérifie d'abord pour la ligne
 
  for(i=0;i<9;i++) 
    {
      if(tab[ligne][i].valeur_case!=0) 
	{
	  if(i!=col)
	    {
	      if(tab[ligne][i].valeur_case==valeur)
		return 1;
	    }
	}
    }
 
  // On verifie maintenant pour la colonne
 
  for(i=0;i<9;i++) 
    {
      if(tab[i][col].valeur_case!=0)
	{
	  if(i!=ligne)
	    {
	      if(tab[i][col].valeur_case==valeur)
		return 1;
	    }
	}
    }
 
  // On verifie maintenant la région
 
  x=(ligne/3)*3;
  y=(col/3)*3;
 
  for(i=y;i<y+3;i++)  
    {
      if(tab[x][i].valeur_case!=0)
	{
	  if(i!=col || x!=ligne)
	    {
	      if(tab[x][i].valeur_case==valeur)
		return 1;
	    }
	}
    }
 
  for(i=y;i<y+3;i++)
    {
      if(tab[x+1][i].valeur_case!=0)
	{
	  if(i!=col || x+1!=ligne)
	    {
	      if(tab[x+1][i].valeur_case==valeur)
		return 1;
	    }
	}
    }
 
  for(i=y;i<y+3;i++)
    {
      if(tab[x+2][i].valeur_case!=0)
	{
	  if(i!=col || x+2!=ligne)
	    {
	      if(tab[x+2][i].valeur_case==valeur)
		return 1;
	    }
	} 
    }
 
  return 0;
}

Bonjour,

c'est pas que l'on ne veuille pas, mais là il y a beaucoup de lignes que l'on ne connaît pas... donc c'est dur de débugger.
Pour simplifier tout cela, tu pourrais nous donner que la fonction qui pose problème :)

Sinon d'un point de vu algo, il suffit de parcourir la grille afin de trouver toutes les cases vides. Si la case est vide, tu essaies de mettre tous les chiffres possibles et vérifiant chaque fois qu'il ne violent pas une règle. D'où l'utilisation en général d'une fonction GrilleValide ou quelque chose de ce genre.
Si le chiffre ne viole pas de règle, alors tu avances à la case suivante.

Bonjour, voici la fonction qui pose problème.
Oui j'ai bien compris le principe de resolution par backtracking et je ne comprend vraiment pas qu'est ce qui ne va pas dans mon algo.

Merci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
/* Fonction qui resoud une grille de sudoku par backtracking */
 
char backtrack(case_sudoku **tab,int ligne,int col) {
 
  int k=1,continuer=1,copie_col,copie_ligne,l;
 
  if(tab[ligne][col].base==0) // Si ce n'est pas une base
    {
      while(continuer)  // on avance dans le tableau temp pour trouver la premiere valeur candidate
	{
	  if(k>9) // Si aucune valeur n'est possible
	    {
	      tab[ligne][col].valeur_case=0;
	      for(l=0;l<10;l++)
		tab[ligne][col].temp[l]=0;
	      continuer=0;
	      if(col==0 && ligne==0)
		return 0;
	      if(col==0)
		backtrack(tab,ligne-1,9);
	      else
		backtrack(tab,ligne,col-1);
	    }
 
	  else if(tab[ligne][col].temp[k]==0) // Si on a trouvé une valeur candidate
	    {
	      tab[ligne][col].valeur_case=k; // On l'assigne
	      tab[ligne][col].temp[k]=1;       // Ce n'est donc plus une valeur candidate
	      if(conflit(tab,ligne,col,k))  // S'il y a un conflit, on relance la boucle
		{
		  k++;
		  continuer=1;
		}
	      else  // S'il n'y a pas de conflit on sort de la boucle et on passe à la case suivante
		{
		  continuer=0;
		  if(col==8 && ligne==8)
		    return 1;
		  if(col==8)
		    backtrack(tab,ligne+1,0);
		  else
		    backtrack(tab,ligne,col+1);
		}
	    }
	  else if(tab[ligne][col].temp[k]!=0) // Si on n'en a pas trouvé
	    {
	      k++;
	      continuer=1;
	    }
	}
    }
  else // C'est une case base
    {
      if(col==8 && ligne==8) // Si on est à la derniere case
	return 1;
 
      if(tab[ligne][col].direction==6) // Si on avait avancé precedement avec cette case, on recule
	{
	  tab[ligne][col].direction=4;
	      if(col>0)
		backtrack(tab,ligne,col-1);
	      else if(col==0)
		backtrack(tab,ligne-1,8);
	}
 
      if(tab[ligne][col].direction==4 || tab[ligne][col].direction==0) // Sinon on avance
	    {
	      tab[ligne][col].direction=6;
	      if(col<8)
		backtrack(tab,ligne,col+1);
	      else if(col==8)
		backtrack(tab,ligne+1,0);
	    }
	}
    }

Bonjour,

il y a beaucoup de choses bizarres pour résoudre un problème aussi simple :
- qu'est ce qu'une base ?
- pourquoi utiliser une direction ?
- pourquoi avoir autant de cas ?

On a juste une grille avec des valeurs indicatives, que l'on duplique pour travailler.
On la parcours afin de trouver la première case vide.
Dans cette case vide on teste toutes les valeurs possibles avec une fonction valeurvalide (ou autre nom...) puis on appelle la fonction avec la case vide suivante.

Bonjour,

Ce que j'apelle est une base, est une valeur qu'on ne modifiera pas dans le sudoku, ce sont donc les cases initiales du sudoku qu'on ne peut pas modifier.

J'utilise une direction, car dans le cas où la case est une base, on doit soit avancer pour passer à la case suivante (vu qu'on en traite pas les bases qui sont inmodifiables) mais parfois il faut aussi reculer.
Et il y a le probleme lorsque deux cases bases se suivent, d'où ma variable direction, qui mets 6 lorsqu'on a avancé, et 4 lorsqu'on a reculé, comme ça lorsqu'on retourne sur une case base on sait déjà ce qu'on avait fait avant (avancer ou reculer) pour faire l'inverse

Bonjour,

il n'y a pas de problème pour avancer 8O...
Lorsque tu as traité une case tu avances.
Lorsque tu arrives sur une nouvelle case, si c'est une base tu ne fais rien et tu avances, sinon tu effectue le traitement.
Il est inutile de reculer, ce sera fait par le bactraking.

Si dans l'algorithme on a comme règle "si la case est une base, n'en prenez pas compte et avancer" , si ce n'est pas une base, traiter la case, si il n'y a pas de valeurs possible (que l'on aura vérifié avec une fontion), relancer la fonction avec la case d'avant en argument.

Si on fait ceci, si jamais on le cas :

CASE BASE BASE CASE

Si cette derniere case n'admet pas de valeur possible, si on suit l'algo on relance la fonction avec la case précédente et si on suit l'algo, on tombe sur une base donc on avance, ce qui ferait un aller retour infini :/

D'où mon idée de "direction".

Citation:

Envoyé par gnouz

Si dans l'algorithme on a comme règle "si la case est une base, n'en prenez pas compte et avancer" , si ce n'est pas une base, traiter la case, si il n'y a pas de valeurs possible (que l'on aura vérifié avec une fontion), relancer la fonction avec la case d'avant en argument.

Tu y es presque.

"relancer la fonction avec la case non base d'avant en argument."

Merci beaucoup ça marche maintenant