[Hot 100] 221. 最大正方形 215. 数组中的第K个最大元素 208. 实现 Trie (前缀树) 207. 课程表

221. 最大正方形

用动态规划进行解决。
题目：
在一个由 ‘0’ 和 ‘1’ 组成的二维矩阵内，找到只包含 ‘1’ 的最大正方形，并返回其面积。
关键 ：找到递推公式。

这个是抄的题解上的图。
明确dp数组的含义：dp[i][j]是以matrix[i-1][j-1]为右下角的点的正方形的最大边长。
初始化：dp[0][0]为0。
循环顺序：从左往右从上到下。
递推公式:
dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1])+1（如果matrix[i-1][j-1]==1）。
0(如果matrix[i-1][j-1]==0)。
C++实现

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        int height=0, length=0;
        height = matrix.size();
        if(height>0) length = matrix[0].size();
        if(height==0 || length==0) return 0;
        int result = 0;
        vector<vector<int>> dp(height+1,vector<int>(length+1, 0));
        for(int i = 0; i < height; i++){
            for(int j=0; j < length; j++){
                if(matrix[i][j]=='1') dp[i+1][j+1] = min(dp[i][j], min(dp[i][j+1], dp[i+1][j]))+1;
                else dp[i+1][j+1] = 0;
                result = max(result, dp[i+1][j+1]);
            }
        }
        return result*result;
    }
};

215. 数组中的第K个最大元素

题目：给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

这个应该在代码随想录中有。这个是使用小顶堆。维护前k个最大值，其他的抛弃（弹出），所以使用小顶堆，一旦堆的大小大于k就弹出最小的那个，维护前K个的顺序。

一定要学会大顶堆和小顶堆的定义，以及用法。

//小顶堆定义
priority_queue<int, std::vector<int>, std::greater<int>> minHeap;
//大顶堆
priority_queue<int> maxHeap;
// 向小顶堆中添加元素
minHeap.push(nums[i]);
// 弹出小顶堆中堆顶的元素，也就是最小值
minHeap.pop();
// 获得小顶堆中的堆顶元素，也就是最小值
minHeap.top();

C++实现。

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        int size = nums.size();
        priority_queue<int, std::vector<int>, std::greater<int>> minHeap;
        for(int i = 0; i < nums.size(); i++){
            minHeap.push(nums[i]);
            while(minHeap.size() > k){
                minHeap.pop();
            }
        }
        return minHeap.top();
    }
};

208. 实现 Trie (前缀树)

B站: https://www.bilibili.com/video/BV1ZtcBewEbJ/?spm_id_from=333.337.search-card.all.click&vd_source=9e875f3cfd35b93ea904ffd5c3c157a5
作用：高效地存储和检索字符串集合。
构成：由26个子节点（存储这个节点字符的下一个字符）和一个判断是否是word地末尾的bool属性组成。
大白话就是将每个word拆成一个个char以节点的形式存储，与当前字符相连的下一个字符存储在当前节点的子节点中，如果对应的子节点为空就new一个Trie。

C++实现。

class Trie {
private:
    vector<Trie*> children;
    bool is_end_of_word;
public:
    Trie(): children(26, nullptr),is_end_of_word(false){};
    
    void insert(string word) {
        Trie* node = this;
        for(char c : word){
            if(node->children[c-'a'] == nullptr){
                node->children[c-'a'] = new Trie();
            }
            node = node->children[c-'a'];
        }   
        node->is_end_of_word = true;
    }
    
    bool search(string word) {
        Trie* node = searchPrefix(word);
        return node != nullptr && node->is_end_of_word;
    }
    
    bool startsWith(string prefix) {
        return searchPrefix(prefix) != nullptr;
    }
private:
    Trie* searchPrefix(const string& prefix){
        Trie* node = this;
        for(char c : prefix){
            if(node->children[c-'a'] == nullptr){
                return nullptr;
            }
            node = node->children[c-'a'];
        }
        return node;
    }
};

/**
 * Your Trie object will be instantiated and called as such:
 * Trie* obj = new Trie();
 * obj->insert(word);
 * bool param_2 = obj->search(word);
 * bool param_3 = obj->startsWith(prefix);
 */

207. 课程表

题目描述：你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

笨猪爆破组的题解很清晰。

把课程之间关系用图表示，当前课程连接到后续课程(也就是只有上完当前课程才能上后续这个课程)。那么入度为0的就是不需要上其他课程就可以参加的。
我们遍历入度为0的课程数组，搜寻入度为0的课程的后续课程，把这些后续课程的入度减一更新，比如：我们上了0这门课，那么3这门课是否能参加就只用考虑2这门课了，所以3入度减一。然后判断这些后续课程的入度是否为0，如果为0就添加到入度为0课程的数组中，比如：我们遍历了0，1，这两门课我们都参加了，那么3这门课我们可以参加了。
C++代码如下。

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        //入度数组，用于记录每门课程的入度
        vector<int> inDegree(numCourses, 0);
        //邻接表,存储依赖它的后序课程
        vector<vector<int>> adjList(numCourses);
        for(int i = 0; i < prerequisites.size(); i++){
            int course = prerequisites[i][0];
            int preCourse = prerequisites[i][1];
            inDegree[course] += 1;
            adjList[preCourse].push_back(course);
        }
        vector<int> queue;
        for(int i = 0; i < inDegree.size(); i++){
            if(inDegree[i]==0){
                queue.push_back(i);
            }
        }
        int count = 0;
        while(!queue.empty()){
            int curCourse = queue.back();
            queue.pop_back();
            count++;
            while(adjList[curCourse].size()){
                int nextCourse = adjList[curCourse].back();
                adjList[curCourse].pop_back();
                inDegree[nextCourse]--;
                if(inDegree[nextCourse]==0) queue.push_back(nextCourse);
            }
        }
        return count==numCourses;
    }
};