Leetcode刷题模版总结

1. 双指针

双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。也可以延伸到多
个数组的多个指针。

1)滑动窗口

若两个指针指向同一数组，遍历方向相同且不会相交，则也称为滑动窗口(两个指针包围的
区域即为当前的窗口)，经常用于区间搜索。

 例题：

class Solution {
public:
    int maxVowels(string s, int k)
    {
        int ans{0};
        int count{0};
        int l{0};
        int r = k - 1;

        string vowels{"aeiou"};

        for (int i = 0; i < k; ++i) {
            if (vowels.find(s[i]) != string::npos) {
                count++;
            }
        }
        ans = count;

        while (r < s.size() - 1) {
            r++;
            l++;
            if (vowels.find(s[r]) != string::npos) {
                count++;
            }
            if (vowels.find(s[l - 1]) != string::npos) {
                count--;
            }
            ans = max(ans, count);
        }
        return ans;
    }
};

2)双指针

若两个指针指向同一数组，但是遍历方向相反，则可以用来进行搜索，待搜索的数组往往是排好序的。

例题：

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        int left = 0;
        int right = numbers.size() - 1;
        while (left < right) {
            int sum{numbers[left] + numbers[right]};
            if (sum == target) {
                break;
            }
            if (sum > target) {
                right--;
            } else {
                left++;
            }
        }        
        return vector<int> {left+1,  right+1};
    }
};

2. 二分法

采用左闭右开的写法，

• left和right最初的取值：left=0，right=numSize
• left和right索引时的偏移：left = mid + 1， right = mid
• while里的循环条件：left < right
• mid的取值：mid = left + (right - left) / 2

例题：

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> ans{-1, -1};
        if (nums.empty()) {
            return ans;
        }

        int lowerBound = binsearchLower(nums, target);
        int upperBound = max(0, binsearchUpper(nums, target) - 1);
        ans = {lowerBound, upperBound};
 
        if ((lowerBound > nums.size()) || (nums[upperBound] != target)) {
            ans = {-1, -1};
            return ans;
        }

        return ans;


    }

    int binsearchLower(const vector<int>& nums, int target) {
        int l = 0;
        int r = nums.size();
        int mid{0};
        while (l < r) {
            mid = int(l + (r - l) / 2);
            if (nums[mid] >= target) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        return l;
    }

    int binsearchUpper(const vector<int>& nums, int target) {
        int l = 0;
        int r = nums.size();
        int mid{0};
        while (l < r) {
            mid = int(l + (r - l) / 2);
            if (nums[mid] > target) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        return l;
    }

};

3. DFS深度优先搜索

一般来说，深度优先搜索类型的题可以用递归或者栈来实现，用递归写法比较好写，里面会用到主函数和辅函数，

主函数用于遍历所有的搜索位置，判断是否可以开始搜索，如果可以即在辅函数进行搜索。

辅函数则负责深度优先搜索的递归调用

例题：

class Solution {
public:
    // 辅函数
    int LandDFS(vector<vector<int>>& grid, int i, int j)
    {
        // 在矩阵尺寸范围内
        if((i < grid.size()) && (i >= 0) && (j < grid[0].size()) && (j >= 0)) {
            if (grid[i][j] == 0) { // 碰到水
                return 0;
            }
            else {
                grid[i][j] = 0;
                return 1 + LandDFS(grid, i-1, j) + LandDFS(grid, i+1, j) + LandDFS(grid, i, j-1) + LandDFS(grid, i, j+1);
            }
        }
        else {
            return 0;
        }
    }
 
    // 主函数
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int ans = 0;
        for (int i = 0; i < grid.size(); i++) {
            for (int j = 0; j < grid[0].size(); j++) {
                ans = max(ans, LandDFS(grid, i, j));  // 这里LandDFS(grid, i, j)返回的是含(i,j)的岛屿的面积
            }
        }
        return ans;
    }
};

更简洁写法：

class Solution {
public:
    int DFS(vector<vector<int>> &grid, int x, int y) {
        if (x < 0 || x >= grid.size() || y < 0 || y >= grid[0].size() || grid[x][y] == 0) {
            return 0;
        }
        grid[x][y] = 0;
        return 1+ DFS(grid, x + 1, y) + DFS(grid, x - 1, y) + DFS(grid, x, y + 1) + DFS(grid, x, y - 1);
    }

    int maxAreaOfIsland(vector<vector<int>> &grid) {
        int ans{0};
        for (int i = 0; i < grid.size(); ++i) {
            for (int j = 0; j < grid[0].size(); ++j) {
                ans = max(ans, DFS(grid, i, j));
            }
        }
        return ans;
    }
};

4. BFS广度优先搜索

搜索的题目优先用DFS，因为好写。只有碰到 1) 层序遍历，2) 最短路径 的题时才用BFS。

BFS使用队列，把每个还没有搜索到的点依次放入队列，然后再弹出队列的头部元素当做当前遍历点。BFS总共有两个模板：

模板1：如果不需要确定当前遍历到了哪一层，BFS模板如下。

 1 while queue 不空：
 2     cur = queue.pop()  // 弹出队列的头部元素当做当前遍历点
 3     for 节点 in cur的所有相邻节点：
 4         if 该节点有效且未访问过：
 5             queue.push(该节点)

模板2：如果要确定当前遍历到了哪一层，BFS模板如下。
这里增加了level表示当前遍历到二叉树中的哪一层了，也可以理解为在一个图中，现在已经走了多少步了。size表示在当前遍历层有多少个元素，也就是队列中的元素数，我们把这些元素一次性遍历完，即把当前层的所有元素都向外走了一步。

level = 0
while queue 不空：
{
    size = queue.size()    // size表示即将要遍历的那一层的元素个数。
    while (size --)   // 当size减到0时，代表这一层遍历完了
    {
        cur = queue.pop()
        for 节点 in cur的所有相邻节点：
            if 该节点有效且未被访问过：
                queue.push(该节点)
    }
    level ++;
}

上面两个是通用模板，在任何题目中都可以用，是要记住的！

例题：

LeetCode 102. Binary Tree Level Order Traversal 二叉树的层序遍历(Medium)

本题要求二叉树的层次遍历，所以同一层的节点应该放在一起，故使用模板二。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> que;
        que.push(root);

        if (root ==nullptr) {
            return res;
        }

        while (!que.empty()) {
            int size = que.size();
            vector<int> temp;
            while (size--) {
                TreeNode* cur = que.front();
                que.pop();
                temp.push_back(cur->val);
                if (cur->left) {
                    que.push(cur->left);
                }
                if (cur->right) {
                    que.push(cur->right);
                }
            }
            // 遍历完一层了
            res.push_back(temp);
        }
        return res;
    }
};

5. 回溯

回溯法(backtracking)是优先搜索的一种特殊情况，又称为试探法，常用于需要记录节点状
态的深度优先搜索。通常来说，排列、组合、选择类问题使用回溯法比较方便。

解题套路：

result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

 例题：

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> ans;
        backtrack(nums, 0, ans);
        return ans;
    }

    void backtrack(vector<int>& nums, int depth, vector<vector<int>>& ans)
    {
        if (depth == nums.size() - 1) {
            ans.push_back(nums);
            return;
        }
        for (int i = depth; i < nums.size(); ++i) {
            // 修改当前节点状态
            swap(nums[i], nums[depth]);  // 当前数字nums[i]要和后面所有的数字都要交换一遍(包括他自己)
            // 递归子节点
            backtrack(nums, depth + 1, ans); 
            // 回改当前节点状态
            swap(nums[i], nums[depth]);
        }
    }
};