75. Sort Colors
题意：红白蓝的颜色排序，使得相同的颜色放在一起，不要用排序
我的思路
哈希
代码 Runtime 4 ms Beats 28.23% Memory 8.3 MB Beats 9.95%
class Solution {
public:
void sortColors(vector<int>& nums) {
vector<int> ans; int n=nums.size();int vis[3]={0};
for(int i=0;i<n;i++) vis[nums[i]]++;
int v=0;
for(int i=0;i<3;i++){
for(int j=0;j<vis[i];j++){
nums[v++]=i;
}
}
}
};标答
Dutch National Flag Problem荷兰国旗问题；
代码 计数排序 Runtime 0 ms Beats 100% Memory 8.3 MB Beats 41.44%
感觉和我之前做的差不多
class Solution {
public:
void sortColors(vector<int>& nums) {
int num0 = 0;
int num1 = 0;
int num2 = 0;
for (int num:nums) {
if( num==0 ) num0++;
else if (num == 1) num1++;
else if (num == 2) num2++;
}
for (int i=0; i< nums.size(); i++) {
if( num0>0 ) {
nums[i] = 0; num0--;
}
else if( num1>0 ) {
nums[i] = 1; num1--;
}
else if( num2>0 ) {
nums[i] = 2; num2--;
}
}
}
};代码 双指针 Runtime 0 ms Beats 100% Memory 8.3 MB Beats 41.44%
如果nums[mid]是0，low和mid交换，因为low负责0的部分，low++保证指针前面的都是0，low指针指到的就只有0或者1；如果nums[mid]是1，那么是正确的；如果nums[mid]是2，high指向的和mid指向的交换，high--来确保high的右边都是2，为什么mid不++？因为mid这时可能是0，所以需要循环一次在判断
class Solution {
public:
void sortColors(vector<int>& nums) {
int low = 0, mid = 0, high = nums.size()-1;
while(mid <= high){
if(nums[mid] == 0){
swap(nums[low], nums[mid]); low++; mid++;
}
else if(nums[mid] == 1) mid++;
else{
swap(nums[mid], nums[high]); high--;
}
}
}
};76. Minimum Window Substring
题意：给出两个字符串s和t，找到minimum window substring
我的思路
不会
标答
用滑动窗口，窗口的开头在s字符串的初始位置，结尾在所有t的字符都在里面；当上面的窗口有了，就可以改变头指针来缩小窗口，步骤为：
1. 如果s比t小，那么直接返回；2. 记录t中的字母数量
3. 初始化；4. 尾指针遍历s
5. 一边遍历的时候一遍计算t中的字母数量；6. 如果数量剪完了，说明窗口形成了，现在要通过移动头指针实现窗口缩小了
7. 记录下最小的窗口长度和起始位置；8. 返回答案
注意：如何在头指针移动中判断当前节点是或否是t中的？在每个end指针移动的时候会把mp中的字母--，这时候就只有在t中的字母是大于等于0的了
代码 Runtime 7 ms Beats 92.29% Memory7.9 MB Beats 79.63%
class Solution {
public:
string minWindow(string s, string t) {
if(t.size()>s.size())return "";
unordered_map<char,int>mp;
for(int i=0;i<t.size();i++)mp[t[i]]++;
int st=0,en=0,minli=99999,minst=0,coun=0;
//st是头指针，en是尾指针，minli是最短的字符串长度，minst是头指针位置，coun是t字符个数
for(;en<s.size();en++){
if(mp[s[en]]>0) coun++;//属于字符串t的字母数量
mp[s[en]]--;//无论它是不是字符串t中的字符，都要减减，这样子剪完就说明t字符都没了
//变成负数就说明它减多了
if(coun==t.size()){//字符串数量已经over了
for(;st<en && (mp[s[st]]<0);){//注意这里是小于0，如果是大于0就说明减多了
mp[s[st]]++;st++;//先加加，恢复mp原来的个数，之后st前进
}
if(en-st<minli){//看看头指针改变过后，最小字符串长度是否更新了
minst=st;minli=en-st;
}
mp[s[st]]++;st++;//更新头指针，使得目前的字符串不合法
coun--;//这时coun--，让尾指针可以接着更新
}
}
string ans="";
if (minli!=99999)
ans= s.substr(minst,minli+1);
return ans;
}
};78. Subsets
题意：给出一个数字集，输出所有的子集（包括空集）
我的思路
用递归？就像之前一样；有想过要不要用循环，但是发现用循环的话答案不对，就把循环消去了
代码 Runtime 0 ms Beats 100% Memory 7 MB Beats 78.17%
class Solution {
public:
void sol(vector<int>& nums,int nxt,vector<int>& pol,vector<vector<int>> &ans){
if(nxt==nums.size()){
ans.push_back(pol);
return ;
}
pol.push_back(nums[nxt]);//因为拿或者不拿
sol(nums,nxt+1,pol,ans);
pol.pop_back();
sol(nums,nxt+1,pol,ans);
}
vector<vector<int>> subsets(vector<int>& nums) {
vector<vector<int>> ans={}; vector<int> pol={};
sol(nums,0,pol,ans);
return ans;
}
};79. Word Search
题意：
我的思路
把所有可能性的都遍历一遍，如果是BFS的话，先把起点找到，之后环顾四周看看有没有（？
首先要准备一个队列，把（位置，第几个英文字母）找到的都放到队列里，之后bfs上下左右的看，如果在周围找不到下一个就return false，但是做到最后 超时了TLE
代码 超时代码
class Solution {
public:
struct node{
int x,y,id;
vector<vector<bool> > vis=vector(6 , vector<bool>(6,0));
};
bool exist(vector<vector<char>>& board, string word) {
queue<node>st,q;
int n=board.size(),m=board[0].size();
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(board[i][j]==word[0]){
node temp;temp.x=i;temp.y=j;temp.id=0;temp.vis[i][j]=1;
st.push(temp);
}
}
}
int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};
while(!st.empty()){
while(!q.empty())q.pop();//清空
node te=st.front();
st.pop();q.push(te);
while(!q.empty()){
node now=q.front();
int nx,ny;
if(now.id==word.size()-1)return 1;
q.pop();
for(int i=0;i<4;i++){
nx=now.x+dx[i];ny=now.y+dy[i];
if(nx>=0&&nx<n&&ny>=0&&ny<m&&!now.vis[nx][ny]){
if(board[nx][ny]==word[now.id+1]){
node ans;ans.x=nx;ans.y=ny;
ans.id=now.id+1;ans.vis=now.vis;
ans.vis[nx][ny]=1;
q.push(ans);
}
}
}
}
}
return 0;
}
};标答
首先得到n和m，遍历地图，如果地图是第一个字符，那么就可以开始递归了
代码 Runtime 774 ms Beats 47.25% Memory 7.9 MB Beats 74.74%
在递归条件中先判断是不是这个字母，然后递归下去
class Solution {
public:
bool solve(vector<vector<char>>& board,int x,int y,int c,int m,int n,string word){
if(c==word.size())return 1;
if(x<0||y<0||x>=m||y>=n)return 0;
if(board[x][y]!=word[c])return 0;
char ch=board[x][y];
board[x][y]='#';//这一手就不会来回走了！
if(solve(board,x+1,y,c+1,m,n,word)||
solve(board,x,y+1,c+1,m,n,word)||
solve(board,x-1,y,c+1,m,n,word)||
solve(board,x,y-1,c+1,m,n,word))return 1;
board[x][y]=ch;
return 0;
}
bool exist(vector<vector<char>>& board, string word) {
int m=board.size(), n=board[0].size();
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(solve(board,i,j,0,m,n,word))
return 1;
}
}
return 0;
}
};优化代码 Runtime 0 ms Beats 100% Memory8.1 MB Beats 42.63%
优化途径
1. 不要把递归放在判断if里面，这样会费时
2. 先把字符串倒过来，如果最后一个字符的数量大于第一个字符的数量，再把字符串倒转回去；也就是先把字符数量少的先递归【但是我不知道为什么】
class Solution {
public:
bool ispres(vector<vector<char>>& board, int i, int j,
const string &word,int c,int m, int n){
if(c==word.length()){
return true;
}
if(i < 0 || j < 0 || i >= m || j >= n || board[i][j]!=word[c]){
return false;
}
char ch = board[i][j];
board[i][j] = '*';
bool flag = ispres(board,i+1,j,word,c+1,m,n) ||
ispres(board,i-1,j,word,c+1,m,n) ||
ispres(board,i,j+1,word,c+1,m,n) ||
ispres(board,i,j-1,word,c+1,m,n);
board[i][j] = ch;
return flag;
}
bool exist(vector<vector<char>>& board, string word) {
int m = board.size();
int n = board[0].size();
reverse(word.begin(), word.end());
if (count(word.begin(), word.end(), word[0]) >
count(word.begin(), word.end(), word[word.size() - 1]))
reverse(word.begin(), word.end());
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
if(board[i][j]==word[0]){
if(ispres(board,i,j,word,0,m,n)){
return true;
}
}
}
}
return false;
}
};84. Largest Rectangle in Histogram
题意：
我的思路
如果是双指针的话，min（a[i],…,a[j]）*（j-i+1）
那就首先是On^2的时间复杂度，但是预处理的话二维数组会爆栈
不会做
标答
代码 单调栈 Runtime 125 ms Beats 88.36% Memory77.3 MB Beats 73.1%
st里面从小到大的放置，相等的留下，ran是最近的比当前的要大的高度，height的数组最后加上0。求面积是弹出的最大值*（当前的位置减去栈中目前的位置-1）
为什么是当前的位置减去栈中目前的位置-1？
因为设这一轮被弹出的位置为x，高位h[x]，弹出后的栈顶位置为y，因为h[y]小于等于h[x]，也就是说，（y，x]的位置之间的高都是大于h[x]；
【不然为什么（y，x]的位置之间的高要被弹出去呢】
同时（x，i)的位置之间的高也都是大于h[x]
【不然x就被弹出去了】
所以(y，i)之间，x是最小的；因此面积是h[ x ] * ( i - y - 1 )
注意：初始化ran，初始化h数组
为什么栈一开始不把-1放入？【就像32. Trapping Rain WaterLeetCode Top100 Liked 题单（序号19~33）】
因为32是栈，而这个是单调栈，需要比较站内的元素来决定是否弹出
相关:42. Trapping Rain WaterLeetCode Top100 Liked
class Solution {
public:
int largestRectangleArea(vector<int>& h) {
stack<int> st;int ans=0;
h.push_back(0); int n=h.size();
for(int i=0;i<n;i++){
while(!st.empty()&&h[st.top()]>h[i]){//找到了高的
int x=st.top(),y;st.pop();
if(st.empty()) y=-1;
else y=st.top();
ans=max(ans,h[x]*(i-y-1));
}
st.push(i);
}
return ans;
}
};代码 Runtime 86 ms Beats 99.54% Memory74.7 MB Beats 99.53%
感觉和单调栈的原理差不多，但是没有看懂
class Solution {
public:
int largestRectangleArea(const vector<int>& heights) {
int end=-1;
int n=heights.size();
int maxArea=0;
int counts[10001] = {};
int sortedIndexes[10001] = {};
for (int i=0;i<=n;++i) {
int count = 1;
while(true){
if(end<0)break;
const int index=sortedIndexes[end];
if(i!=n&&heights[index]<heights[i])break;
count+=counts[end];
int area=(counts[end]+i-index-1)*heights[index];
if(area>maxArea)maxArea=area;
--end;
}
sortedIndexes[++end] = i;
counts[end] = count;
}
return maxArea;
}
};94. Binary Tree Inorder Traversal
题意：输出二叉树中序排序
我的思路
就直接中序递归就可以了
注意：当root为空的时候要特判！！！
代码 Runtime0 ms Beats 100% Memory 8.2 MB Beats 97.70%
class Solution {
public:
void p(TreeNode* root,vector<int>& ans){
if(root->left !=NULL)
p(root->left,ans);
ans.push_back(root->val);
if(root->right!=NULL)
p(root->right,ans);
}
vector<int> inorderTraversal(TreeNode* root) {
if(root==NULL)return {};
vector<int> ans;
p(root,ans);
return ans;
}
};98. Validate Binary Search Tree
题意：判断树是不是平衡搜索树BST，左子树比中间的小，右子树比中间的大
我的思路
还是递归，就像前面的79 word search一样搜索，然后判断ans的顺序大小
注意：等于也不行！！！
注意：int&的时候不要传const int 进去
代码 Runtime13 ms Beats 42.85% Memory 21.7 MB Beats 33.33%
class Solution {
public:
bool P(TreeNode* root,long long & r){
if(root->left!=NULL){
if(!P(root->left,r))
return 0;
}
if(r>=root->val) return 0;
r=root->val;
if(root->right!=NULL){
if(!P(root->right,r))
return 0;
}
return 1;
}
bool isValidBST(TreeNode* root) {
long long ans=-2147483649;
return P(root,ans);
}
};标答
确实更加简洁快速
代码 Runtime4 ms Beats 94.78% Memory21.7 MB Beats 33.33%
class Solution {
public:
bool isValidBST(TreeNode* root,long min,long max){
if(root==NULL)
return true;
if(root->val>=max or root->val<=min)
return false;
return isValidBST(root->left,min,root->val)&&isValidBST(root->right,root->val,max);
}
bool isValidBST(TreeNode* root) {
long max=LONG_MAX;
long min=LONG_MIN;
return isValidBST(root,min,max);
}
};101. Symmetric Tree
题意：看是不是对称的
我的思路
中序序列ans，两个指针从两端向中间核对
答案不正确，因为[1,2,2,2,null,2]也会判断成正确的，所以不可以
既然是递归，那就要让左子树的左子树 和 右子树的右子树对称；左子树的右子树 和 右子树的左子树对称
但是不会写
标答
递归函数的参数是左子树指针和右子树指针，然后判断左的值和右的值是否相同
然后判断左的左和右的右 左的右和右的左
这样递归下去
代码 Runtime 0 ms Beats 100% Memory 16.2 MB Beats 91.71%
class Solution {
public:
bool p(TreeNode* l,TreeNode* r){
if(l==NULL&&r==NULL)return 1;
else if (l==NULL||r==NULL)return 0;
if(l->val!=r->val)return 0;
return p(l->left,r->right)&&p(l->right,r->left);//递归
}
bool isSymmetric(TreeNode* root) {
if(root==NULL)return 1;
return p(root->left,root->right);
}
};102. Binary Tree Level Order Traversal
题意：层序遍历
我的思路
一层的结尾放一个空指针，每次循环到空指针的时候，就在结尾放一个空指针；当循环弹出空指针同时队列为空的时候，就停止放入空指针
代码 Runtime 6 ms Beats 52.11% Memory13.3 MB Beats 92.55%
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> ans;
queue <TreeNode *>q;
if(root==NULL)return ans;
q.push(root);q.push(NULL);
vector<int> sol;
while(!q.empty()){
TreeNode * top;top=q.front();q.pop();
if(top!=NULL){
sol.push_back(top->val);
if(top->left!=NULL)q.push(top->left);
if(top->right!=NULL)q.push(top->right);
}
else{
ans.push_back(sol);sol={};
if(!q.empty())q.push(NULL);
}
}
return ans;
}
};标答
用一层的队列大小得出一层有多少个，来循环
代码 Runtime 3 ms Beats 88.93% Memory13.6 MB Beats 51.20%
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>>ans;
if(root == NULL) return ans;
queue<TreeNode*>q;
q.push(root);
while(!q.empty()){
int size = q.size();
vector<int> level;
for(int i =0;i<size;i++){
TreeNode* node=q.front();q.pop();
if(node->left!=NULL)q.push(node->left);
if(node->right!=NULL)q.push(node->right);
level.push_back(node->val);
}
ans.push_back(level);
}
return ans;
}
};104. Maximum Depth of Binary Tree
题意：求树的最大深度
我的思路
用层序遍历看看有几层或者用递归无线向下，那就先用层序遍历向下
代码 层序遍历 Runtime 0 ms Beats 100% Memory19 MB Beats 9.46%
class Solution {
public:
int maxDepth(TreeNode* root) {
queue<TreeNode*> q;
if(root==NULL)return 0;
q.push(root);
int deep=0;
while(!q.empty()){
deep++;int n=q.size();
for(int i=0;i<n;i++){
if(q.front()->left!=NULL)q.push(q.front()->left);
if(q.front()->right!=NULL)q.push(q.front()->right);
q.pop();
}
}
return deep;
}
};标答 递归
树的高度=max(左子树的高度，右子树的高度）+1
代码 递归 Runtime 8 ms Beats 61.27% Memory19 MB Beats 9.46%
class Solution {
public:
int maxDepth(TreeNode* root) {
if(root==NULL)return 0;
return max(maxDepth(root->left),maxDepth(root->right))+1;
}
};
