数独问题——Linux

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
void *column_check(void *param);
void *row_check(void *param);
void *square_check(void *parameter);


int Sudoku[9][9] = {
                   {6, 2, 4, 5, 3, 9, 1, 8, 7},
                   {5, 1, 9, 7, 2, 8, 6, 3, 4},
                   {8, 3, 7, 6, 1, 4, 2, 9, 5},
                   {1, 4, 3, 8, 6, 5, 7, 2, 9},
                   {9, 5, 8, 2, 4, 7, 3, 6, 1},
                   {7, 6, 2, 3, 9, 1, 4, 5, 8},
                   {3, 7, 1, 9, 5, 6, 8, 4, 2},
                   {4, 9, 6, 1, 8, 2, 5, 7, 3},
                   {2, 8, 5, 4, 7, 3, 9, 1, 6},
                   };

typedef struct
{
        int row;
        int column;
}parameters;

int flag = 1;//判断数独是否有效，每个子线程通过检查相应的数据设置flag是否为0

int main(void)
{
        pthread_t tid_column;
        pthread_t tid_row;
        pthread_t tid_square[3][3];

        //----------行检查
        parameters *param_row = (parameters *)malloc(sizeof(parameters));
        param_row->row = 0;
        param_row->column = 0;
        pthread_create(&tid_row,NULL,row_check,(void *)param_row);

        //-----------列检查
        parameters *param_column = (parameters *)malloc(sizeof(parameters));
        param_column->row = 0;
        param_column->column = 0;
        pthread_create(&tid_column,NULL,column_check,(void *)param_column);

        //-------------子方块检查
        parameters * param_square[3][3];
        for(int i=0;i<3;i++)  //块行
        {
                for(int j=0;j<3;j++)//块列
                {
                        param_square[i][j] = (parameters*)malloc(sizeof(parameters));
                        param_square[i][j]->row = i*3;
                        param_square[i][j]->column = j*3;
                        pthread_create(&tid_square[i][j],NULL,square_check,(void*)param_square[i][j]);
                }
        }
        pthread_join(tid_column,NULL);
        pthread_join(tid_row,NULL);
        for(int i=0;i<3;i++)
        {
                for(int j=0;j<3;j++)
                {
                        pthread_join(tid_square[i][j],NULL);
                }
        }
        if(flag == 1)
        {
                printf("Great!\n");
        }
        else
                printf("Error!\n");
        return 0;
}
void * row_check(void *param)
{
        for(int i=0;i<9;i++)
        {
                int arr[10] = {0};
                for(int j=0;j<9;j++)
                {
                        int num = Sudoku[i][j];
                        if(arr[num] == 0)
                        {
                                arr[num] = 1;
                        }
                        else
                        {
                                flag = 0;
                                pthread_exit(0);
                        }
                }
        }
        pthread_exit(0);
}
void * column_check(void *param)
{
        for(int i=0;i<9;i++)
        {
                int arr[10] = {0};
                for(int j=0;j<9;j++)
                {
                        int num = Sudoku[j][i];
                        if(arr[num] == 0)
                        {
                                arr[num] = 1;
                        }
                        else
                        {
                                flag = 0;
                                pthread_exit(0);
                        }
                }
        }
        pthread_exit(0);
}
void * square_check(void *parameter)
{
        parameters *param = (parameters*)parameter;
        int arr[10] = {0};
        for(int i=param->row;i<param->row+3;i++)
        {
                for(int j=param->column;j<param->column+3;j++)
                {
                        int num = Sudoku[i][j];
                        if(arr[num] == 0)
                        {
                                arr[num] = 1;
                        }
                        else
                        {
                                flag = 0;
                                pthread_exit(0);
                        }
                }
        }
        pthread_exit(0);
}