LeetCode 实践练习51-55

LeetCode—51（N皇后问题）

方法：经典的N皇后问题，基本所有的算法书都会包含的问题，经典的解法为回溯递归，一层层的向下扫描，需要用到一个pos数组，其中pos[i]表示第i行皇后的位置，初始化为-1，然后从第0开始递归，每一行都一次遍历各列，判断如果在该位置皇后会不会有冲突，依次类推，当到最后一个皇后放好后，一种解法就生成了，将其存入结果res中，再继续。
C++代码：

class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        vector<vector<string>> res;
        vector<int> pos(n,-1);
        solveNQueenDFS(pos,0,res);
        return res;
    }
    void solveNQueenDFS(vector<int> &pos,int row,vector<vector<string>> &res){
        int n = pos.size();
        //若row等于n，则所有皇后都填充完成，将结果加入res
        if (row == n) {
            vector<string> out(n,string(n,'.'));//生成n*n的全是'.'的结果
            for(int i = 0;i < n;i++){
                out[i][pos[i]] = 'Q';//将皇后赋值到指定位置
            }
            res.push_back(out);
        }else{
            for (int col = 0;col < n;col++){
                if (isValid(pos,row,col)){
                    pos[row] = col;
                    solveNQueenDFS(pos,row+1,res);
                    pos[row] = -1;//关键操作，必须保证每次选皇后时，当前行列的值为空，不能影响下一个列的有效判断
                    //将上面一步注释，没有报错，反而变得更加快了 快乐50ms
                }
            }
        }
    }
    bool isValid(vector<int>& pos,int row,int col){
        for(int i =0;i < row;i++){
            if(col == pos[i] || abs(row - i) == abs(col - pos[i])){//对角线的性质|行-当前数的行数| = |列-当前数的列数|
                return false;//逐行判断，目前的皇后问题是否有效
            }
        }
        return true;
    }
};

LeetCode—52(N皇后问题)

与上面一题，题目一样。但是需要的结果不是解法，只需要给出解法的数量即可。

LeetCode—53(最大子序和)

方法：用当前数与子序列和比较

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int res = INT_MIN,cursum = 0;
        for (int num:nums){
            cursum = max(cursum+num,num);
            res = max(res,cursum);
        }
        return res;
    }
};

另一个方法：$O(nlgn)$(待了解)

LeetCode—54(螺旋矩阵)

方法：对于这种螺旋遍历的方法，重要的是要确定上下左右四条边的位置，那么初始化的时候，上边up就是0，下边down就是m-1，左边left是0，右边right是n-1。然后我们进行while循环，先遍历上边，将所有元素加入结果res，然后上边下移一位，如果此时上边大于下边，说明此时已经遍历完成了，直接break。同理对于下边，左边，右边，依次进行相对应的操作，这样就会使得坐标很有规律，并且不易出错。(理解代码)

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if (matrix.empty() || matrix[0].empty()) return {};
        int m = matrix.size(), n = matrix[0].size();
        vector<int> res;
        int up = 0, down = m - 1, left = 0, right = n - 1;
        while (true) {
            for (int j = left; j <= right; ++j) res.push_back(matrix[up][j]);
            if (++up > down) break;
            for (int i = up; i <= down; ++i) res.push_back(matrix[i][right]);
            if (--right < left) break;
            for (int j = right; j >= left; --j) res.push_back(matrix[down][j]);
            if (--down < up) break;
            for (int i = down; i >= up; --i) res.push_back(matrix[i][left]);
            if (++left > right) break;
        }
        return res;
    }
};

LeetCode—55(跳跃游戏)

方法：首先题目的意思是每个元素代表你在该位置可以跳跃的最大长度。贪婪算法Greedy Algorithm，因为我们并不是很关心每一个位置上的剩余步数，我们只希望知道能否到达末尾，也就是说我们只对最远能到达的位置感兴趣，所以我们维护一个变量reach，表示最远能到达的位置，初始化为0。遍历数组中每一个数字，如果当前坐标大于reach或者reach已经抵达最后一个位置则跳出循环，否则就更新reach的值为其和i + nums[i]中的较大值，其中i + nums[i]表示当前位置能到达的最大位置。
C++代码：

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int reach = 0,n = nums.size();
        for(int i = 0;i < n;i++){
            if(reach >= n-1 || i > reach) break;
            reach = max(reach,i + nums[i]);
        }
        return reach >= n-1;
    }
};