算法进修Day-26

算法进修Day-26

51. N皇后

难度:困难
题目要求
按照国际象棋的规则,皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上,并且使皇后彼此之间不能相互攻击。

给你一个整数 n ,返回所有不同的 n 皇后问题 的解决方案。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案,该方案中 'Q''.' 分别代表了皇后和空位。

示例1

输入:n = 4
输出:[[“.Q…”,“…Q”,“Q…”,“…Q.”],[“…Q.”,“Q…”,“…Q”,“.Q…”]]

示例2

输入:n = 1
输出:[[“Q”]]

题解

使用回溯法,定义列表元素 r e s res res 来接受最后的结果

步骤如下:

  • 定义一个二位数组 b o a r d board board ,大小为 n n n ,遍历每一个二维数组元素,将所有的元素的初始值都定义为".",之后进行回溯
    • 如果行 r o w row row 的值等于 b o a r d board board 的长度,那么直接将结果添加到 r e s res res
    • 如果行 r o w row row 的值小于 b o a r d board board 的长度,执行如下操作
      • 定义 n n n 为列数,对行内的每一个元素进行循环,如果当前行有"Q",那么直接跳出本次循环,如果当前元素的左上或右上有"Q",那么直接跳出本次循环
      • 对当前元素赋值为"Q",并继续进行回溯,如果最后的结果无法成立,那么回退此次操作
      • 最后将结果传入到 r e s res res 中,即可得到最终结果

想法代码

class Solution
{
    List> res;

    public static void Main(String[] args)
    {
        Solution solution = new Solution();
        int n = 4;
        IList> result = solution.SolveNQueens(n);
        foreach (var a in result)
        {
            foreach (var b in a)
            {
                Console.WriteLine("\"" + b + "\" ");
            }
            Console.WriteLine();
        }
    }

    public IList> SolveNQueens(int n)
    {
        res = new List>();
        char[][] board = new char[n][];
        for (int i = 0; i < n; ++i) board[i] = new char[n];
        foreach (char[] chars in board)
        {
            Array.Fill(chars, '.');
        }
        backTrack(board, 0);
        return res;
    }
    private void backTrack(char[][] board, int row)
    {
        if (row == board.Length)
        {
            res.Add(charToString(board));
            return;
        }
        int n = board[row].Length;
        for (int col = 0; col < n; ++col)
        {
            if (!isValid(board, row, col)) continue;
            board[row][col] = 'Q';
            backTrack(board, row + 1);
            board[row][col] = '.';
        }
    }
    private bool isValid(char[][] board, int row, int col)
    {
        int rows = board.Length;
        foreach (char[] chars in board) if (chars[col] == 'Q') return false;
        for (int i = row - 1, j = col + 1; i >= 0 && j < rows; i--, j++)
        {
            if (board[i][j] == 'Q') return false;
        }
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--)
        {
            if (board[i][j] == 'Q') return false;
        }
        return true;
    }
    private List charToString(char[][] array)
    {
        List result = new List();
        foreach (char[] chars in array) result.Add(new String(chars));
        return result;
    }
}

52. N皇后II

难度:困难
题目要求:
n 皇后问题 研究的是如何将 n 个皇后放置在 n × n 的棋盘上,并且使皇后彼此之间不能相互攻击。

给你一个整数 n ,返回 n 皇后问题 不同的解决方案的数量。

示例1

输入:n = 4
输出:2

示例2

输入:n = 1
输出:1

题解

使用回溯法,定义列表元素 i l i s t ilist ilist ,用 i l i s t . C o u n t ilist.Count ilist.Count 来接受最终结果

步骤如下:

  • 定义一个二位数组 b o a r d board board ,大小为 n n n ,遍历每一个二维数组元素,将所有的元素的初始值都定义为".",之后进行回溯
    • 如果行 r o w row row 的值等于 b o a r d board board 的长度,那么直接将结果添加到 i l i s t ilist ilist
    • 如果行 r o w row row 的值小于 b o a r d board board 的长度,执行如下操作
      • 定义 n n n 为列数,对行内的每一个元素进行循环,如果当前行有"Q",那么直接跳出本次循环,如果当前元素的左上或右上有"Q",那么直接跳出本次循环
      • 对当前元素赋值为"Q",并继续进行回溯,如果最后的结果无法成立,那么回退此次操作
      • 最后将结果传入到 i l i s t ilist ilist 中,返回 i l i s t . C o u n t ilist.Count ilist.Count 即为最终结果

想法代码

public class Solution
{
    IList> ilist = new List>();

    public static void Main(string[] args)
    {
        int n = 4;
        Solution solution = new Solution();
        int res = solution.TotalNQueens(n);
        Console.WriteLine(res);
    }
    public int TotalNQueens(int n)
    {
        char[][] board = new char[n][];
        for (int i = 0; i < n; i++)
            board[i] = new char[n];

        foreach (var ch in board)
            Array.Fill(ch, '.');

        BackTrack(n, 0, board);
        return ilist.Count;
    }

    public void BackTrack(int n, int row, char[][] board)
    {
        if (row == n)
        {
            ilist.Add(ToIList(board));
            return;
        }

        for (int col = 0; col < n; col++)
        {
            if (isValid(row, col, n, board))
            {
                board[row][col] = 'Q';
                BackTrack(n, row + 1, board);
                board[row][col] = '.';
            }
        }
    }

    public List ToIList(char[][] board)
    {
        List list = new List();
        System.Text.StringBuilder sb = new System.Text.StringBuilder();
        foreach (var chess in board)
        {
            foreach (var ch in chess)
                sb.Append(ch);
            list.Add(sb.ToString());
            sb.Clear();
        }
        return list;
    }

    public bool isValid(int row, int col, int n, char[][] board)
    {
        for (int i = 0; i < n; i++)
        {
            if (board[i][col] == 'Q')
                return false;
        }

        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--)
        {
            if (board[i][j] == 'Q')
                return false;
        }

        for (int i = row - 1, j = col + 1; i >= 0 && j <= n - 1; i--, j++)
        {
            if (board[i][j] == 'Q')
                return false;
        }
        return true;
    }
}

你可能感兴趣的:(算法进修,算法,leetcode,c#)