记录一个问题_char**和 char[][]

ubuntu 20.04

不能用 使用 char** ,

$ gcc --version
gcc (Ubuntu 10.3.0-1ubuntu1~20.04) 10.3.0
Copyright (C) 2020 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef int bool;
#define false (0)
#define true (1)

bool isValid(int row, int col, char val, char (*board)[9])
{
    // 判断行里是否重复
    for (int i = 0; i < 9; i++)
    {
        if (board[row][i] == val)
        {
            return false;
        }
    }

    // 判断列里是否重复
    for (int j = 0; j < 9; j++)
    {
        if (board[j][col] == val)
        {
            return false;
        }
    }

    // 判断9方格里是否重复
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++)
    {
        for (int j = startCol; j < startCol + 3; j++)
        {
            if (board[i][j] == val)
            {
                return false;
            }
        }
    }
    return true;
}

bool backtracking(char board[][9], int rowSize, int colSize)
{
    // char (*bd)[9] = (char (*)[9])board;
    // 遍历行
    for (int i = 0; i < rowSize; i++)
    {
        // 遍历列
        for (int j = 0; j < colSize; j++)
        {
            if (board[i][j] != '.')
                continue;

            // (i, j) 这个位置放k是否合适
            for (char k = '1'; k <= '9'; k++)
            {
                if (isValid(i, j, k, board))
                {
                    board[i][j] = k; // 放置k
                    if (backtracking(board, rowSize, colSize))
                        return true;   // 如果找到合适一组立刻返回
                    board[i][j] = '.'; // 回溯，撤销k
                }
            }
            return false; // 9个数都试完了，都不行，那么就返回false
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}


void solveSudoku(char (*board)[9], int boardRowSize, int *boardColSize)
{
    backtracking(board, 9, 9);
}

int test()
{
    {
        char board[][9] = {
            {'5', '3', '.', '.', '7', '.', '.', '.', '.'},
            {'6', '.', '.', '1', '9', '5', '.', '.', '.'},
            {'.', '9', '8', '.', '.', '.', '.', '6', '.'},
            {'8', '.', '.', '.', '6', '.', '.', '.', '3'},
            {'4', '.', '.', '8', '.', '3', '.', '.', '1'},
            {'7', '.', '.', '.', '2', '.', '.', '.', '6'},
            {'.', '6', '.', '.', '.', '.', '2', '8', '.'},
            {'.', '.', '.', '4', '1', '9', '.', '.', '5'},
            {'.', '.', '.', '.', '8', '.', '.', '7', '9'}};

        char expected[][9] = {
            {'5', '3', '4', '6', '7', '8', '9', '1', '2'},
            {'6', '7', '2', '1', '9', '5', '3', '4', '8'},
            {'1', '9', '8', '3', '4', '2', '5', '6', '7'},
            {'8', '5', '9', '7', '6', '1', '4', '2', '3'},
            {'4', '2', '6', '8', '5', '3', '7', '9', '1'},
            {'7', '1', '3', '9', '2', '4', '8', '5', '6'},
            {'9', '6', '1', '5', '3', '7', '2', '8', '4'},
            {'2', '8', '7', '4', '1', '9', '6', '3', '5'},
            {'3', '4', '5', '2', '8', '6', '1', '7', '9'}};

        int rowSize = 9, colSize = 9;
        solveSudoku(board, rowSize, &colSize);
        if (0 != memcmp(board, expected, rowSize * colSize))
        {
            printf("error 1\n");
            return 0;
        }
    }
    return 0;
}

int main()
{
    return test();
}

leetcode 上必须这样才行, 而 在ubuntu20.04 上此段代码段错误 , 原因是:

board[i][j] 定位的地址完全不对!

bool isValid(int row, int col, char val, char **board)
{
    // 判断行里是否重复
    for (int i = 0; i < 9; i++)
    {
        if (board[row][i] == val)
        {
            return false;
        }
    }

    // 判断列里是否重复
    for (int j = 0; j < 9; j++)
    {
        if (board[j][col] == val)
        {
            return false;
        }
    }

    // 判断9方格里是否重复
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++)
    {
        for (int j = startCol; j < startCol + 3; j++)
        {
            if (board[i][j] == val)
            {
                return false;
            }
        }
    }
    return true;
}

bool backtracking(char **board, int rowSize, int colSize)
{
    // char (*bd)[9] = (char (*)[9])board;
    // 遍历行
    for (int i = 0; i < rowSize; i++)
    {
        // 遍历列
        for (int j = 0; j < colSize; j++)
        {
            if (board[i][j] != '.')
                continue;

            // (i, j) 这个位置放k是否合适
            for (char k = '1'; k <= '9'; k++)
            {
                if (isValid(i, j, k, board))
                {
                    board[i][j] = k; // 放置k
                    if (backtracking(board, rowSize, colSize))
                        return true;   // 如果找到合适一组立刻返回
                    board[i][j] = '.'; // 回溯，撤销k
                }
            }
            return false; // 9个数都试完了，都不行，那么就返回false
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}


void solveSudoku(char **board, int boardRowSize, int *boardColSize)
{
    backtracking(board, 9, 9);
}

这个问题很奇怪, 正常逻辑 char** 可以使用char[i][j] 代替 p + i*j进行偏移, 而在ubuntu20.04 , gcc10中, 就连board + i * j 这种写法也不行.

暂时未找到原因!

---

修改后的代码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef int bool;
#define false (0)
#define true (1)

bool isValid(int row, int col, char val, char **board)
{
    // 判断行里是否重复
    for (int i = 0; i < 9; i++)
    {
        if (board[row][i] == val)
        {
            return false;
        }
    }

    // 判断列里是否重复
    for (int j = 0; j < 9; j++)
    {
        if (board[j][col] == val)
        {
            return false;
        }
    }

    // 判断9方格里是否重复
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++)
    {
        for (int j = startCol; j < startCol + 3; j++)
        {
            if (board[i][j] == val)
            {
                return false;
            }
        }
    }
    return true;
}

bool backtracking(char **board, int rowSize, int colSize)
{
    // char (*bd)[9] = (char (*)[9])board;
    // 遍历行
    for (int i = 0; i < rowSize; i++)
    {
        // 遍历列
        for (int j = 0; j < colSize; j++)
        {
            if (board[i][j] != '.')
                continue;

            // (i, j) 这个位置放k是否合适
            for (char k = '1'; k <= '9'; k++)
            {
                if (isValid(i, j, k, board))
                {
                    board[i][j] = k; // 放置k
                    if (backtracking(board, rowSize, colSize))
                        return true;   // 如果找到合适一组立刻返回
                    board[i][j] = '.'; // 回溯，撤销k
                }
            }
            return false; // 9个数都试完了，都不行，那么就返回false
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}

// void solveSudoku(char (*board)[9], int boardRowSize, int *boardColSize)
void solveSudoku(char **board, int boardRowSize, int *boardColSize)
{
    backtracking(board, 9, 9);
}


int test()
{
    {
        char *constBoard[] = {
            "53..7....",
            "6..195...",
            ".98....6.",
            "8...6...3",
            "4..8.3..1",
            "7...2...6",
            ".6....28.",
            "...419..5",
            "....8..79"};

        char *expected[] = {
            "534678912",
            "672195348",
            "198342567",
            "859761423",
            "426853791",
            "713924856",
            "961537284",
            "287419635",
            "345286179"};

        int rowSize = 9, colSize = 9;

        // 将字符串从 .text区(不可修改), 拷贝到内存(可修改)
        char **board = (char **)calloc(rowSize, sizeof(char *));
        for(int i = 0; i < rowSize; i++)
        {
            board[i] = (char *)calloc(strlen(constBoard[i]), 1);
            memcpy(board[i], constBoard[i], strlen(constBoard[i]));
        }

        solveSudoku(board, rowSize, &colSize);
        for(int i = 0; i < rowSize; i++)
        {
            if (0 != memcmp(board[i], expected[i], strlen(expected[i])) )
            {
                printf("error 1\n");
                return 0;
            }
        }

        //  释放内存
        for(int i = 0; i < rowSize; i++)
        {
            free(board[i]);
        }
        free(board);
    }

    {
        char *constBoard[] = {
            "..9748...",
            "7........",
            ".2.1.9...",
            "..7...24.",
            ".64.1.59.",
            ".98...3..",
            "...8.3.2.",
            "........6",
            "...2759.."};

        char *expected[] = {
            "519748632",
            "783652419",
            "426139875",
            "357986241",
            "264317598",
            "198524367",
            "975863124",
            "832491756",
            "641275983"};

         int rowSize = 9, colSize = 9;

        // 将字符串从 文字常量区(不可修改), 拷贝到内存(可修改)
        char **board = (char **)calloc(rowSize, sizeof(char *));
        for(int i = 0; i < rowSize; i++)
        {
            board[i] = (char *)calloc(strlen(constBoard[i]), 1);
            memcpy(board[i], constBoard[i], strlen(constBoard[i]));
        }

        solveSudoku(board, rowSize, &colSize);
        for(int i = 0; i < rowSize; i++)
        {
            if (0 != memcmp(board[i], expected[i], strlen(expected[i])) )
            {
                printf("error 1\n");
                return 0;
            }
        }

        //  释放内存
        for(int i = 0; i < rowSize; i++)
        {
            free(board[i]);
        }
        free(board);
    }
    return 0;
}

int main()
{
    return test();
}