From 491d8c59a1db122b4c1520e563d2fa33f3277cf4 Mon Sep 17 00:00:00 2001
From: po79yr3at <pyh-21.24@stu.xjtu.edu.cn>
Date: Sun, 29 Oct 2023 15:12:07 +0800
Subject: [PATCH] ADD file via upload

---
 all.h | 153 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 153 insertions(+)
 create mode 100644 all.h

diff --git a/all.h b/all.h
new file mode 100644
index 0000000..337f440
--- /dev/null
+++ b/all.h
@@ -0,0 +1,153 @@
+#include<stdio.h>
+#include<stdlib.h>
+#include<time.h>
+#define range9(x) for(int x = 0; x < 9; x ++)
+
+struct Sudoku{
+    int inc[9][9];
+};
+
+#define MAXSIZE 1000
+struct Sudoku *M_PtrReg[MAXSIZE];
+int PRtp = 0;
+void ptrInit(){
+    for(int i = 0; i < MAXSIZE; i ++)
+        M_PtrReg[i] = (struct Sudoku *)malloc(sizeof(struct Sudoku));
+}
+void ptrClear(){
+    for(int i = 0; i < MAXSIZE; i ++)
+        free(M_PtrReg[i]);
+}
+struct Sudoku *ptrReg(){return M_PtrReg[PRtp++];}
+void ptrFree(){--PRtp;}
+
+void sudokuClear(struct Sudoku *a){
+    range9(i)
+        range9(j)
+            a->inc[i][j] = 0;
+}
+void sudokuCopy(struct Sudoku src, struct Sudoku *dst){
+    range9(i)
+        range9(j)
+            dst->inc[i][j] = src.inc[i][j];
+}
+void sudokufromArray(int src[9][9], struct Sudoku *dst){
+    range9(i)
+        range9(j)
+            dst->inc[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])
+                putchar('.');
+            else 
+                // putchar(a.inc[i][j] + 48);
+                printf("%d", a.inc[i][j]);
+            putchar(' ');
+        }
+        putchar('\n');
+    }
+}
+void initRandomSeed(){srand(time(NULL));}
+struct Sudoku sudokuRandomGenerate(unsigned int fill){// %
+    fill %= 101;
+    struct Sudoku *res = ptrReg();
+    range9(i)
+        range9(j)
+            if(rand()%100 <= fill)
+                res->inc[i][j] = rand() % 9 + 1;
+            else 
+                res->inc[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]){
+        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]);
+        return 1;
+    }
+    tags->inc[x][y] |= (1 << a->inc[i][j]);
+    return 0;
+}
+int tagPoint(struct Sudoku *a, int i, int j, struct Sudoku *tags){
+    range9(k)
+        if(tag(a, i, j, i, k, tags)||tag(a, i, j, k, j, tags)||tag(a, i, j, i/3*3+k/3, j/3*3+k%3, tags))
+        return 1;
+    return 0;
+}
+int tagsInit(struct Sudoku *a, struct Sudoku *tags){
+    range9(i)
+        range9(j)
+            tags->inc[i][j] |= (1 << a->inc[i][j]);
+    range9(i)
+        range9(j)
+            if(a->inc[i][j] && tagPoint(a, i, j, tags))
+                return 1;
+}
+int sudokuJudge(struct Sudoku a){
+    struct Sudoku tags;
+    sudokuClear(&tags);
+    if(tagsInit(&a, &tags)) return 1;
+    printf("True:Valid initial Sudoku matrix!\n");
+    return 0;
+}
+void tagFindLeast(struct Sudoku *a, int *x, int *y, struct Sudoku *tags){
+    int minv = 10;
+    int mini=0, minj=0;
+    range9(i)
+        range9(j)
+            if(!a->inc[i][j]){
+                int cnt = 0;
+                range9(k)
+                    cnt += (tags->inc[i][j] >> k) & 1;
+                if(cnt < minv && cnt != 0){
+                    minv = cnt;
+                    mini = i;
+                    minj = j;
+                }
+            }
+    *x = mini;
+    *y = minj;
+}
+struct Sudoku *sudokuFill__(struct Sudoku *a, int unfillednum, struct Sudoku *tags){
+    struct Sudoku *pres, *t_tags;
+    if(!unfillednum){
+        pres = ptrReg();
+        sudokuCopy(*a, pres);
+        sudokuPrint(*tags);
+        return pres;
+    }
+    int m=0, n=0;
+    tagFindLeast(a, &m, &n, tags);
+    range9(i)
+        if(!((tags->inc[m][n] >> i) & 1)){
+            a->inc[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;
+            ptrFree();
+        }
+    return NULL;
+}
+struct Sudoku *sudokuFill(struct Sudoku *a){
+    struct Sudoku tags, res, *pres;
+    sudokuClear(&tags);
+    if(tagsInit(a, &tags)) return NULL;
+    int unfillednum = 0;
+    range9(i)
+        range9(j)
+            if(!a->inc[i][j])
+                unfillednum ++;
+    printf("%d", unfillednum);
+    return sudokuFill__(a, unfillednum, &tags);
+}