Update all.h

all.h

@@ -4,48 +4,51 @@
 #define range9(x) for(int x = 0; x < 9; x ++)
 
 struct Sudoku{
-    int inc[9][9];
+    int v[9][9];
 };
 
 #define MAXSIZE 1000
+#define DefautTop 100
 struct Sudoku *M_PtrReg[MAXSIZE];
-int PRtp = 0;
+int PRtp = DefautTop, prtp = 0;
 void ptrInit(){
-    for(int i = 0; i < MAXSIZE; i ++)
+    for(int i = 0; i < PRtp; i ++)
-        M_PtrReg[i] = (struct Sudoku *)malloc(sizeof(struct Sudoku));
+        M_PtrReg[i] = malloc(sizeof(struct Sudoku));
 }
 void ptrClear(){
-    for(int i = 0; i < MAXSIZE; i ++)
+    for(int i = 0; i < PRtp; i ++)
         free(M_PtrReg[i]);
 }
-struct Sudoku *ptrReg(){return M_PtrReg[PRtp++];}
+struct Sudoku *ptrReg(){
-void ptrFree(){--PRtp;}
+    return prtp < PRtp ? M_PtrReg[prtp++]: (M_PtrReg[prtp++] = malloc(sizeof(struct Sudoku)));
+}
+void ptrFree(){--prtp;}
 
 void sudokuClear(struct Sudoku *a){
     range9(i)
         range9(j)
-            a->inc[i][j] = 0;
+            a->v[i][j] = 0;
 }
 void sudokuCopy(struct Sudoku src, struct Sudoku *dst){
     range9(i)
         range9(j)
-            dst->inc[i][j] = src.inc[i][j];
+            dst->v[i][j] = src.v[i][j];
 }
 void sudokufromArray(int src[9][9], struct Sudoku *dst){
     range9(i)
         range9(j)
-            dst->inc[i][j] = src[i][j];
+            dst->v[i][j] = src[i][j];
 }
 void sudokuPrint(struct Sudoku a){
     range9(i){
         if(!(i % 3)) putchar('\n');
         range9(j){
             if(!(j % 3)) putchar(' ');
-            if(!a.inc[i][j])
+            if(!a.v[i][j])
                 putchar('.');
             else 
-                // putchar(a.inc[i][j] + 48);
+                // putchar(a.v[i][j] + 48);
-                printf("%d", a.inc[i][j]);
+                printf("%d", a.v[i][j]);
             putchar(' ');
         }
         putchar('\n');
@@ -58,19 +61,19 @@ struct Sudoku sudokuRandomGenerate(unsigned int fill){// %
     range9(i)
         range9(j)
             if(rand()%100 <= fill)
-                res->inc[i][j] = rand() % 9 + 1;
+                res->v[i][j] = rand() % 9 + 1;
             else 
-                res->inc[i][j] = 0;
+                res->v[i][j] = 0;
     return *res;
 }
 struct Sudoku tags;
 int tag(struct Sudoku *a, int i, int j, int x, int y, struct Sudoku *tags){
     if(i == x && j == y) return 0;
-    if(a->inc[i][j] == a->inc[x][y]){
+    if(a->v[i][j] == a->v[x][y]){
-        printf("False:repetition found in (%d,%d) and (%d,%d) with the number {%d}\n", i+1, j+1, x+1, y+1, a->inc[x][y]);
+        printf("False:repetition found in (%d,%d) and (%d,%d) with the number {%d}\n", i+1, j+1, x+1, y+1, a->v[x][y]);
         return 1;
     }
-    tags->inc[x][y] |= (1 << a->inc[i][j]);
+    tags->v[x][y] |= (1 << a->v[i][j]);
     return 0;
 }
 int tagPoint(struct Sudoku *a, int i, int j, struct Sudoku *tags){
@@ -82,10 +85,10 @@ int tagPoint(struct Sudoku *a, int i, int j, struct Sudoku *tags){
 int tagsInit(struct Sudoku *a, struct Sudoku *tags){
     range9(i)
         range9(j)
-            tags->inc[i][j] |= (1 << a->inc[i][j]);
+            tags->v[i][j] |= (1 << a->v[i][j]);
     range9(i)
         range9(j)
-            if(a->inc[i][j] && tagPoint(a, i, j, tags))
+            if(a->v[i][j] && tagPoint(a, i, j, tags))
                 return 1;
 }
 int sudokuJudge(struct Sudoku a){
@@ -100,10 +103,10 @@ void tagFindLeast(struct Sudoku *a, int *x, int *y, struct Sudoku *tags){
     int mini=0, minj=0;
     range9(i)
         range9(j)
-            if(!a->inc[i][j]){
+            if(!a->v[i][j]){
                 int cnt = 0;
                 range9(k)
-                    cnt += (tags->inc[i][j] >> k) & 1;
+                    cnt += (tags->v[i][j] >> k) & 1;
                 if(cnt < minv && cnt != 0){
                     minv = cnt;
                     mini = i;
@@ -123,31 +126,30 @@ struct Sudoku *sudokuFill__(struct Sudoku *a, int unfillednum, struct Sudoku *ta
     }
     int m=0, n=0;
     tagFindLeast(a, &m, &n, tags);
+    printf("%d\n", unfillednum);
     range9(i)
-        if(!((tags->inc[m][n] >> i) & 1)){
+        if(!((tags->v[m][n] >> i) & 1)){
-            a->inc[m][n] = i;
+            a->v[m][n] = i;
             t_tags = ptrReg();
             sudokuCopy(*tags, t_tags);
             tagPoint(a, m, n, t_tags);
-            // sudokuPrint(*a);
-            // getchar();
             pres = sudokuFill__(a, unfillednum - 1, t_tags);
             if(pres)
                 return pres;
-            a->inc[m][n] = 0;
+            a->v[m][n] = 0;
             ptrFree();
         }
     return NULL;
 }
 struct Sudoku *sudokuFill(struct Sudoku *a){
-    struct Sudoku tags, res, *pres;
+    struct Sudoku tags;
     sudokuClear(&tags);
     if(tagsInit(a, &tags)) return NULL;
     int unfillednum = 0;
     range9(i)
         range9(j)
-            if(!a->inc[i][j])
+            if(!a->v[i][j])
                 unfillednum ++;
-    printf("%d", unfillednum);
     return sudokuFill__(a, unfillednum, &tags);
+    return NULL;
 }