Leetcode Top 100 Liked Questions（序号75~104）

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;
    }
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/97559.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

无涯教程-Android - Services

无涯教程-Android - Services

服务是在后台运行以执行长时间运行的操作而无需与用户交互的组件&#xff0c;并且即使应用程序被破坏&#xff0c;它也可以工作。服务实际上可以采取两种状态- Sr.No.State & Remark1 Started 当应用程序组件(如Activity)通过调用 startService()启动服务&#xff0c;启动后…
阅读更多...
[Linux]进程程序替换

[Linux]进程程序替换

[Linux]进程程序替换 文章目录 [Linux]进程程序替换进程程序替换的意义见一见进程程序替换进程程序替换的原理进程程序替换中的写时拷贝介绍进程程序替换接口 进程程序替换的意义 Linux系统下使用fork系统函数创建子进程后&#xff0c;子进程只能执行继承的部分父进程代码&…
阅读更多...
常用的css样式

常用的css样式

1&#xff1a;flex布局 .flex-between {display: flex;justify-content: space-between; }.flex-evenly {display: flex;justify-content: space-evenly; }.flex-end {display: flex;justify-content: flex-end; }.flex {display: flex; }.flex-center {display: flex;justify…
阅读更多...
JavaScript（函数，作用域和闭包）

JavaScript（函数，作用域和闭包）

目录 一&#xff0c;什么是函数1.1&#xff0c;常用系统函数1.2&#xff0c;函数声明 1.3&#xff0c;函数表达式二&#xff0c;预解析2.1&#xff0c;函数自调用 2.2&#xff0c;回调函数三&#xff0c;变量的作用域3.1&#xff0c;隐式全局变量 四&#xff0c;作用域与块级作…
阅读更多...
关于sd卡根目录在哪里

关于sd卡根目录在哪里

你说的对,一切都会过去,哪怕是回忆。 sd卡根目录在哪里 1、手机要有SD卡才会存在SD卡根目录。 2、打开文件管理并在此页面下点击所有文件。 3、点击SD卡选项进入的页面就是SD卡根目录。 4、SD存储卡是一种基于半导体快闪记忆器的新一代记忆设备&#xff0c;由于它体积小、数…
阅读更多...
[Pandas] pandas.melt

[Pandas] pandas.melt

melt是溶解 / 分解的意思&#xff0c;即拆分数据 melt()函数可以将一些列的内容进行合并&#xff0c;把宽表整合成长表 语法格式 pandas.melt(frame, id_varsNone, value_varsNone, var_nameNone, value_namevalue)参数说明 frame&#xff1a;要处理的数据集 id_vars&#…
阅读更多...
如何五分钟设计制作自己的蛋糕店小程序

如何五分钟设计制作自己的蛋糕店小程序

在现如今的互联网时代&#xff0c;小程序已成为企业推广和销售的重要利器。对于蛋糕店来说&#xff0c;搭建一个小程序可以为其带来更多的品牌曝光和销售渠道。下面&#xff0c;我们将以乔拓云平台为例&#xff0c;来教你如何从零开始搭建自己的蛋糕店小程序。 首先&#xff0c…
阅读更多...
docker 安装 Nginx

docker 安装 Nginx

1、下载 docker pull nginx:latest 2、本地创建管理目录 mkdir -p /var/docker/nginx/conf mkdir -p /var/docker/nginx/log mkdir -p /var/docker/nginx/html 3、将容器中的相应文件复制到管理目录中 /usr/docker/nginx docker run --name nginx -p 80:80 -d nginxdocke…
阅读更多...
Golang数据结构和算法

Golang数据结构和算法

Golang数据结构和算法 数据的逻辑结构和物理结构常见数据结构及其特点算法的时间复杂度和空间复杂度Golang冒泡排序Golang选择排序Golang插入排序Golang快速排序Golang归并排序Golang二分查找Golang sort包Golang链表Golang container/list标准库Golang栈stackGolang二叉搜索树…
阅读更多...
Spring Security存在认证绕过漏洞 CVE-2021-22096

Spring Security存在认证绕过漏洞 CVE-2021-22096

文章目录 0.前言1.参考文档2.基础介绍漏洞影响范围&#xff1a;官方说明&#xff1a;修复版本&#xff1a;漏洞利用步骤&#xff1a;修复方式&#xff1a; 3.解决方案 0.前言 背景&#xff1a;项目被扫到Spring Boot 的漏洞&#xff0c;严格的说应该是Spring Security 组件的漏…
阅读更多...
小程序隐私保护授权处理方式之弹窗组件

小程序隐私保护授权处理方式之弹窗组件

欢迎点击关注-前端面试进阶指南&#xff1a;前端登顶之巅-最全面的前端知识点梳理总结 *分享一个使用比较久的&#x1fa9c; 小程序隐私保护授权弹窗组件 调用wx.getUserProfile进行授权时&#xff0c;返回错误信息&#xff1a;{errMsg: “getUserProfile:fail api scope is…
阅读更多...
宿舍固定资产怎么管理

宿舍固定资产怎么管理

宿舍固定资产的管理需要做到以下几点&#xff1a; 固定资产购置&#xff1a;宿舍的固定资产包括设备、家具、厨房用品等&#xff0c;购置时需要注意质量和价格&#xff0c;并进行登记。 固定资产登记&#xff1a;将宿舍的固定资产名称、型号、规格、数量、单价、金额、…
阅读更多...
详细说明OSPF常见的LSA

详细说明OSPF常见的LSA

目录 1类LSA &#xff08;Router LSA&#xff09;介绍 总结&#xff1a;1类LSA 2类LSA &#xff08;Network LSA&#xff09;介绍 总结&#xff1a;2类LSA 3类LSA &#xff08;Summary LSA&#xff09;介绍 总结&#xff1a;3类LSA 5类LSA &#xff08;ase LSA&…
阅读更多...
layUI 中 穿梭框无法获取值的细节问题

layUI 中 穿梭框无法获取值的细节问题

初始化的时候一定要指定id&#xff0c;不然就会出现无法调用 获得右侧数据和实例重载的方法
阅读更多...
高忆管理：A股上市券商“中考”成绩放榜，最大黑马是它

高忆管理：A股上市券商“中考”成绩放榜，最大黑马是它

A股上市券商2023年半年报发表8月30日晚正式收官。全体上看&#xff0c;43家券商中有10家营收超百亿元&#xff0c;多达30家完成了营收及净利润的双增。头部券商中&#xff0c;我国银河近年来运营成绩排名稳步提高&#xff1b;区域性券商中&#xff0c;天风证券成最大黑马&#…
阅读更多...
经典文献阅读之--FastSAM(快速分割一切)

经典文献阅读之--FastSAM(快速分割一切)

0. 简介 MetaAI提出的能够“分割一切”的视觉基础大模型SAM提供了很好的分割效果&#xff0c;为探索视觉大模型提供了一个新的方向。虽然SAM的效果很好&#xff0c;但由于SAM的backbone使用了ViT&#xff0c;导致推理时显存的占用较多&#xff0c;推理速度偏慢&#xff0c;对硬…
阅读更多...
多图详解VSCode搭建Java开发环境

多图详解VSCode搭建Java开发环境

大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为CSDN博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的…
阅读更多...
LeetCode--HOT100题（46）

LeetCode--HOT100题（46）

目录 题目描述&#xff1a;114. 二叉树展开为链表&#xff08;中等&#xff09;题目接口解题思路代码 PS: 题目描述&#xff1a;114. 二叉树展开为链表&#xff08;中等&#xff09; 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链…
阅读更多...
qt day 1

qt day 1

this->setWindowIcon(QIcon("D:\\zhuomian\\wodepeizhenshi.png"));//設置窗口的iconthis->setWindowTitle("鵬哥快聊");//更改名字this->setFixedSize(500,400);//設置尺寸QLabel *qlnew QLabel(this);//創建一個標簽ql->resize(QSize(500,20…
阅读更多...
Stable Diffusion WebUI 整合包

Stable Diffusion WebUI 整合包

现在网络上出现的各种整合包只是整合了运行 Stable Diffusion WebUI&#xff08;以下简称为 SD-WebUI&#xff09;必需的 Python 和 Git 环境&#xff0c;并且预置好模型&#xff0c;有些整合包还添加了一些常用的插件&#xff0c;其实际与手动进行本地部署并没有区别。 不过&a…
阅读更多...
最新文章

Copyright @ 2022~2023