LeetCode Top100 Liked 题单（序号34~51）

​34. Find First and Last Position of Element in Sorted Array ​

题意：找到非递减序列中目标的开头和结尾

我的思路

用二分法把每一个数字都找到，最后返回首尾两个数

代码 Runtime12 ms Beats 33.23% Memory14 MB Beats 5.16%

class Solution {
public:void bins(int l,int r,int tar,vector<int>& nums,vector<int>& ans){while(l<=r){int mid=l+(r-l)/2;if(nums[mid]>tar) r=mid-1;else if(nums[mid]<tar)l=mid+1;else{ans.push_back(mid);bins(l,mid-1,tar,nums,ans);bins(mid+1,r,tar,nums,ans);return ;}}}vector<int> searchRange(vector<int>& nums, int target) {int n=nums.size();vector<int> ans;bins(0,n-1,target,nums,ans);if (ans.empty())return {-1,-1};else  sort(ans.begin(),ans.end());return {ans[0],ans[ans.size()-1]};}
};

标答

可以直接找到序列的头部数字，和数字加一的序列的头部数字

代码 Runtime 3 ms Beats 96.59% Memory13.7 MB Beats 11.32%

class Solution {
public:pair<int,int> bins(vector<int>& nums,int tar,int l,int r){int ans=-1;while(l<=r){int mid=(l+r)/2;if(tar>nums[mid]) l=mid+1;else if(tar<nums[mid]) r=mid-1;else{//如果等于的话ans=mid;r=mid-1;}}if(ans==-1)return {l,0};return {ans,1};}vector<int> searchRange(vector<int>& nums, int target) {int n=(int)nums.size()-1;pair<int,int> st;   pair<int,int> en;st =bins(nums,target,0,n);en =bins(nums,target+1,0,n);if(!st.second) return {-1,-1};return {st.first,en.first-1};}
};

35. Search Insert Position

题意：给定一个有序数组和一个元素，找到给序号，没找到返回他应该插在哪里

我的思路

二分查找，我记得二分查找应该是有upper_bound和lower_bound直接用的

注意：lower_bound函数是返回指针，用于在指定区域内查找不小于目标值的第一个元素，也就是说[1,2,3,5]数组中，target为4的情况下返回的是序号为3；[1,2,3,4]数组中，target为4的情况下返回的是序号为3

upper_bound为大于目标元素的第一个数/位置，[1,2,3,5]数组中，target为4的情况下返回的是序号为3；[1,2,3,4]数组中，target为4的情况下返回的是序号为4

代码 3ms Beats 88.42% 9.63mb Beats 47.66%

class Solution {
public:int searchInsert(vector<int>& nums, int target) {return lower_bound(nums.begin(), nums.end(), target) - nums.begin();}
};

39. Combination Sum

题意：给定一个不同整数数组和一个目标，返回一个单独的集合，使得集合内部和等于target；同一个数字可以用多次；

我的思路

好像是动态规划做的？和背包问题差不多，但是我忘记了orz

标答 动态规划

首先创建一个dp的vector，每个dp的内容是答案的格式，也就是vector<vector<int>>，dp表示的是从第一个数开始到target的每个数为target时的答案

状态转移方程为 dp[j]=dp[j-i]+i (这里的+时集合加入的意思)

代码 Runtime 18 ms Beats 34.7% Memory14.3 MB Beats 40.40%

class Solution {
public:vector<vector<int>> combinationSum(vector<int>& candidates, int target) {vector <vector <vector<int>>> dp(target+1);//首先要开辟空间，不然会runtime errordp[0]={{}}; //初始化for(int &i:candidates){//对于每一个在候选名单里的for(int j=i;j<=target;j++){//对于每个在数组里的ifor(auto v:dp[j-i]){//v是每一个答案中的集合v.push_back(i);dp[j].push_back(v);//要把更新的集合放回dp[j]中}}}return dp[target];}
};

标答 递归

递归的方法好像速度更快，首先将数组排序，之后递归，递归的引入参数为num；next是nums的索引，也就是遍历了nums的每一个数字；psol是每一个集合，表示拿或者不拿的可能性；target是目标；result是最后的答案

注意：在一开始要排序，这么做是为了剪枝操作

因为 if(target<0)return; 这一操作同样可以退出递归，但是如果target-candidates[next]<0 的时候推出递归，那么可以剪枝，大大提升速度；如果要达成这target-candidates[next]<0退出的操作，那么就必须要nums排序，这一才能加快速度

注意：psol传入时要引用，不然会拖慢时间

代码 Runtime2 ms Beats 91.39% Memory10.7 MB Beats 84.74%

class Solution {
public:void search(vector<int>& candidates, int next, int target, vector<int>& pol, vector<vector<int>> &result){if(target==0){//说明结束了result.push_back(pol);return;}if(next==candidates.size()||target-candidates[next]<0) return;pol.push_back(candidates[next]);//这是拿了,注意拿了还可以接着拿search(candidates,next,target-candidates[next],pol,result);pol.pop_back();search(candidates,next+1,target,pol,result);//这是没拿，没拿就走了}vector<vector<int>> combinationSum(vector<int>& candidates, int target) {sort(candidates.begin(),candidates.end());vector<int> pol;vector<vector<int>> result;//初始化search(candidates,0,target,pol,result);return result;}
};

41. First Missing Positive 

题意：给出未排序的nums，返回未在这些数字中的正整数

我的思路

好像博弈论中有这个算法，还涉及位运算？但是忘记了【好吧，答案中没有位运算】

num的长度只有1e5，所以只能写一个O n的算法了

代码 Runtime 38 ms Beats 98.63% Memory41.3 MB Beats 34.99%

class Solution {
public:int firstMissingPositive(vector<int>& nums) {bool vis[100005]={0};int n=nums.size();for(int i=0;i<n;i++){if(nums[i]>100000||nums[i]<=0)continue;vis[nums[i]]=1;}for(int i=1;i<=100001;i++){if(vis[i]==0)return i;}return 0;}
};

另一道题 涉及位运算

给定一个包含 0, 1, 2, ..., n 中 n 个数的序列，找出 0 .. n 中没有出现在序列中的那个数。

输入: [3,0,1]
输出: 2

输入: [9,6,4,2,3,5,7,0,1]
输出: 8

运用位运算来完成，思路为temp ^ nums[ i ] ^ (i + 1),这里的temp值从0开始，因为nums 的值是从0开始，而（i + 1）则是为了取到自然数1,2,3,4,5...等。运算规则如下：假如目标数组nums 值 为 0，1，2，4 自然数对应为1,2,3,4

0 ^ 1 ^ 0 = 1

1 ^ 2 ^ 1 = 2

2 ^ 3 ^ 2 = 3

3 ^ 4 ^ 4 = 3

返回值为3 缺失的数字即为3

class Solution {
public:int firstMissingPositive(vector<int>& nums) {int temp = 0;for(int i = 0;i < nums.size();i++){temp = temp ^ (i + 1) ^ (nums[i]);}return temp;}
};


42. Trapping Rain Water

题意：给一组正整数数组，表示宽度为1的砖块的高度，问能存多少水

我的思路

费案1

单调栈，同时要记录下每个砖块的距离，所以栈里面存的是序号，一层一层的扫描？首先是y等于1之间的砖块，之后是y=2之间的砖块

假设是9 6 2 0 3 0 2 5 ，就是先9和6和3和0放入栈中；【如果一开始是0，就不放进去了】

height【i】=3来了把0弹出来，那么就直接弹出，之后栈顶是2，在计算0的那一个步骤，ans加上min(目前栈顶=2，height【i】=3)的数值，ans+=2；

目前栈顶是2，发现小于等于height【i】=3，那么就直接弹出，之后栈顶是6，在计算2的那一个步骤，ans+=id的差=2 * (height【i】=3 - 上一个弹出的数=2)的数值，ans+=2；当前栈为9 6 3

height【i】=0，不弹出；

height【i】=2，把0弹出来，直接弹出，之后栈顶是3，在计算0的那一个步骤，ans+=id的差=1 * (height【i】=2 - 上一个弹出的数=0)，ans+=2，目前栈为9 6 3 2

height【i】=5，目前栈顶是2，发现小于等于height【i】=5，直接弹出，之后栈顶是3，在计算0的那一个步骤所以ans=ans+（i=7  - top的序号=6-1 ）*（height【i】 - 上一个弹出的值=2），ans+=0，当前栈为9 6 3     ans不对

费案2

用减法，先减去砖块占用水的体积

例如1 0 2 0 3 0 2 5 ，从右向左，mx=5，扫完一遍了，假设-1的位置有无限高的墙，

所以ans=【7-（-1）-1】*5-所有砖块的体积，不对

标答 双指针法 竖着加的

和上面的减法的思路差不多，但他是一个个竖着加起来

lmax代表最左边的墙，rmax代表最右边的墙前两个if表示的是目前的lmax和rmax都不是最高的，应该要更新；第三个条件如果rmax大于lmax，ans加上lmax-h[lpos]；第四个条件如果lmax大于rmax，ans加上rmax-h[rpos]；为什么那么做？因为如果整个盆子左边高于右边，那么右侧的水肯定能装住，如果整个盆子右边高于左边，那么左侧的水肯定能装住。

代码 Runtime6 ms Beats 97.75% Memory19.8 MB Beats 53.37%

注意 lpos<=rpos的等号

class Solution {
public:int trap(vector<int>& h) {int n=h.size()-1;int lmax=h[0],rmax=h[n];int lpos=1,rpos=n-1,ans=0;while(lpos<=rpos){        //等号if(rmax<=h[rpos]){rmax=h[rpos];rpos--;}else if(lmax<=h[lpos]){lmax=h[lpos];lpos++;}else if(rmax>=lmax){ans+=(lmax-h[lpos]);lpos++;}else{ans+=(rmax-h[rpos]);rpos--;}}return ans;}
};

标答 前缀和 竖着加的

dp[i]表示从左到右，以左边的边作为最高的边，每个横坐标 i 能装多少水；之后从右到左，以右边的边作为最高的边，res在每个横坐标 i 上加上min ( 当前的最高 - dp[i] )

代码 Runtime 12 ms Beats 78.67% Memory19.8 MB Beats 53.37%

class Solution {
public:int trap(vector<int>& h) {int n=h.size(),dp[20004]={0};int curmax=-1,ans=0;for(int i=0;i<n;i++){curmax=max(curmax,h[i]);dp[i]=curmax-h[i];}curmax=-1;for(int i=n-1;i>=0;i--){curmax=max(curmax,h[i]);ans+=min(dp[i],curmax-h[i]);}return ans;}
};

标答 单调栈 横着加的

和费案1的思路相仿。栈中的数字越来越小，如果来了一个大的数，把这个数弹出，设cur是这个弹出的数，diff的序号的差，ans+=（min(当前栈顶的数，height[i] ) - 上一个弹出的数）*序号的差

为什么想费案1的时候没有想出来呢？

height【i】=5，目前栈顶是2，发现小于等于height【i】=5，直接弹出，之后栈顶是3，在计算0的那一个步骤所以ans=ans+（i=7  - top的序号=6-1 ）*（height【i】 - 上一个弹出的值=2），ans+=0，当前栈为9 6 3 

因为从最上面的图中可以看出，之前的步骤都是ans+=（min(当前栈顶的数，height[i] ) - 上一个弹出的数），但是当h[i]=5时，ans+=（当前栈顶的数 上一个弹出的数），没有办法把公式统一起来，所以没做出来，明明只要加上取最小就可以了

为什么是取最小呢？

原理和标答1的原理是差不多的，因为答案是和两侧最小的那一条有关

补充：

1. 费案1中的栈根本不需要pair结构，因为有序号有数组就知道了数值了

2. if(st.empty())break;这条语句是指左边没有边可以作为盘子的左边了，装不下水了，所以break了

代码 Runtime 12 ms Beats 78.67% Memory19.8 MB Beats 53.37%

class Solution {
public:int trap(vector<int>& h) {stack<int> st;int n=h.size(),ans=0;for(int i=0;i<n;i++){while(!st.empty()&&h[st.top()]<h[i]){//弹出操作int temp=st.top();st.pop();if(st.empty())break;//注意这句话int cha=i-st.top()-1;//注意这里是-1！！！！！！！ans+=(min(h[i],h[st.top()])-h[temp])*cha;}st.push(i);}return ans;}
};

45. Jump Game II

题意：有n个序号从0开始的数组，你可以从num[i]，向右跳到【num[i]，num[i+j]】之间

我的思路

动态规划，dp表示需要最少的次数，一开始初始化为无穷，dp[n-1]=0，最外层循环是i从n-1到0，第二层循环是j从1到num[i]，找到循环中最小的dp[i+j]，dp[i]=min( dp[ i + j ] + 1 )，返回答案dp[0]

但不幸的是n是1e4，nums是1e3，时间复杂度1e7

代码 Runtime128 ms Beats 39.88% Memory16.8 MB Beats 41.3%

class Solution {
public:int jump(vector<int>& nums) {int n=nums.size();int dp[10004];for(int i=0;i<n;i++)dp[i]=9999;dp[n-1]=0;for(int i=n-2;i>=0;i--){int minn=9999;for(int j=1;j<=nums[i] && i+j<n;j++) minn=min(minn,dp[i+j]);dp[i]=minn+1;}return dp[0];}
};

要优化的话肯定是优化第二个循环，快速找到某个范围内的最小值，想到树状数组，去看了看树状数组的板子，找到的树状数组代码维护的是【1，i】范围的最小值，网上说只有树状数组套树状数组或者线段树才可以达到动态维护区间最小值

但是线段树要从1开始建立，同时修改的时候不是单纯的增减，而是直接替换，所以线段树也不适合

标答 贪心

为什么可以用贪心算法呢？

乍一看想到动态规划去了，才发现忽略了最大步长的信息（没有的话就是DP了），因此不需要考虑跳多了的情况，而且题面能够保证绝对能到达，所以不用担心0步长的情形（跳不出去啦！）。

因此本题可以直接使用贪心算法：向后遍历，找出能够跳的最远的选择。

贪心最麻烦的地方就是全局最优解的证明，我这里给出一个简单的思路：从同一个起点出发，如果当前选择不是贪心选择的，那么下一个选择必然比贪心方案跳的更近。完成一次跳跃后有两种情形：贪心方案的第二次选择的位置是否存在于当前方案的第二次选择中。存在，则最多选择这个方案，此时当前方案会比贪心方案段（第二次选择一样，但是第一次选择短了）；不存在，那么肯定是会短的（两次选择都短）。


参考链接：https://blog.csdn.net/cary_leo/article/details/115451900

简单来说就是比谁跳的远

代码 Runtime 8 ms Beats 95.22% Memory16.6 MB Beats 64.1%

class Solution {
public:int jump(vector<int>& nums) {int n=nums.size(),ans=0;for(int i=1;i<n;i++){//要么选择在这一格跳走，要么就留在这里nums[i]=max(nums[i-1],nums[i]+i);//nums代表在i位置可以到达的最远的位置}int st=0;while(st<n-1){ans++; st=nums[st];}return ans;}
};


46. Permutations

题意：有一个数组，里面的数字各不相同，返回所有排列

我的思路

用dfs做，没写出来；我好像还记得C++库中有个直接全排列的调用

标答 dfs 回溯法

照着我写坏的和表达对照一下，我用了两次dfs，一次是没取走数字，一次是取走了数字；不需要没取走数字的那一组，因为他会因为个数不够而不能加入最终答案的vector，所以只要取走的那一次dfs就可以了

代码 Runtime 6 ms Beats 18.86% Memory8.2 MB Beats 11.7%

class Solution {
public:void dfs(vector<int>& nums,vector<int>& pol,vector<vector<int>>& ans,vector<int> vis){if(pol.size()==nums.size()){ans.push_back(pol);return;}for(int i=0;i<nums.size();i++){if(vis[i]) continue;vis[i]=1;pol.push_back(nums[i]);dfs(nums,pol,ans,vis);pol.pop_back();vis[i]=0;}}vector<vector<int>> permute(vector<int>& nums) {vector<int> pol; vector<vector<int>> ans; vector<int> vis((int)nums.size(),0);dfs(nums,pol,ans,vis);return ans;}
};

标答 dfs 交换

确实，不断交换就可以排序完成了，还不会有多余的没到个数的pol（和上一个做法不同）

代码 Runtime 5 ms Beats 29.21% Memory 7.5 MB Beats 81.96%

class Solution {
public:vector<vector<int>> result;void permutation(vector<int> &nums,int i,int n){if(i==n){result.push_back(nums);return ;}for(int j=i;j<=n;j++){swap( nums[i],nums[j]);permutation(nums,i+1,n);//注意这里是i+1swap( nums[i],nums[j]);}}vector<vector<int>> permute(vector<int>& nums) {permutation(nums,0,nums.size()-1);return result;}
};

48. Rotate Image 

题意：将整个矩阵顺时针旋转90度，注意不要新开一个矩阵

我的思路

按照这个顺序，一个圈层只要3组交换就可以了，实际操作的时候注意 i 和 j 的范围！！！！！

例子1：初始

1 2 3

4 5 6

7 8 9

第一次

7 2 3

8 5 6

9 4 1

第二次

7 2 1

8 5 4

9 6 3

第三次

7 4 1

8 5 2

9 6 3

例子2：初始

4 8

3 6

第一次

3 8

6 4

第二次

3 4

6 8

第三次

循环直接结束了

代码 Runtime 0 ms Beats 100% Memory 7.2 MB Beats 14.63%

class Solution {
public:void rotate(vector<vector<int>>& matrix) {int n=matrix.size();for(int i=0;i<n/2;i++){//圈层for(int j=i;j<n-i;j++){swap(matrix[j][i],matrix[n-1-i][j]);}for(int j=i+1;j<n-i;j++){swap(matrix[n-1-i][j],matrix[n-1-j][n-1-i]);}for(int j=i+1;j<n-1-i;j++){swap(matrix[i][j],matrix[j][n-1-i]);}}}
};

标答 思维

先对角反转，之后逆向

例子1：初始

1 2 3

4 5 6

7 8 9

第一次

1 4 7

2 5 8

3 6 9

第二次

7 4 1

8 5 2

9 6 3

代码 Runtime 0 ms Beats 100% Memory7.3 MB Beats14.63%

class Solution {
public:void rotate(vector<vector<int>>& matrix) {int n = matrix.size();int m = matrix[0].size();vector<vector<int>> temp(n, vector<int>(m, 0));for(int i=0; i<n; i++){for(int j=0; j<i; j++){swap(matrix[i][j], matrix[j][i]);}}for(int i=0; i<n; i++){reverse(matrix[i].begin(), matrix[i].end());}}
};


49. Group Anagrams

题意：给一组字符串，把字母相同的字符串放在一组里

我的思路

只能想到死做，就是map映射，key是字典序排列，value是vector<string>，之后遍历map，组成答案

代码 Runtime 30 ms Beats83.8% Memory20.8 MB Beats 30.73%

class Solution {
public:vector<vector<string>> groupAnagrams(vector<string>& strs) {map<string,vector<string> > mp;int n=strs.size();for(int i=0;i<n;i++){string tmp=strs[i];sort(tmp.begin(),tmp.end());mp[tmp].push_back(strs[i]);}vector< vector<string> > ans;for(auto q:mp)ans.push_back(q.second);return ans;}
};

优化

看了标答，确实是这样做的，但是sort和map和遍历可以优化，map改成unorder_map，for(auto q:mp)加上引用【这一步突然时间少一半】

代码 Runtime 15 ms Beats 99.87% Memory19.5 MB Beats 84.31%

class Solution {
public:vector<vector<string>> groupAnagrams(vector<string>& strs) {unordered_map<string,vector<string> > mp;int n=strs.size();for(int i=0;i<n;i++){string tmp=strs[i];sort(tmp.begin(),tmp.end());mp[tmp].push_back(strs[i]);}vector< vector<string> > ans;for(auto &q:mp)ans.push_back(q.second);return ans;}
};

51. N-Queens

题意：皇后攻击的范围是所属的横线、竖线、斜线，在n*n的棋盘上摆放皇后，使得n个皇后不会互相攻击

我的思路

递归

代码 Runtime4 ms Beats 78.35% Memory7.8 MB Beats 36.39%

class Solution {
public:bool check(int n,int id, int j, vector<int>&pol){for(int i=0;i<pol.size();i++)if(pol[i]==j) return 0;for(int i=0;i<pol.size();i++){if(pol[i]-i ==j-id)return 0;}for(int i=0;i<pol.size();i++){if(pol[i]+i ==j+id)return 0;}return 1;}void se(int n,int id, vector<int>&pol, vector<vector<string>> & result) {if(pol.size()==n){vector<string> mp;for(int j=0;j<n;j++){//列string s (n, '.');s[pol[j]]='Q';mp.push_back(s);}result.push_back(mp);return;}for(int j=0;j<n;j++){//列if(!check(n,id,j,pol))//判断这一列上有无其他数字，判断斜线上有无其他数字;如果不可以放在这里，就跳过continue;pol.push_back(j);se(n,id+1,pol,result);pol.pop_back();}}vector<vector<string>> solveNQueens(int n) {vector<int> pol; vector<vector<string>> result;//假设返回的vector<int>表示每一行的皇后放在第n列se(n,0,pol,result);//id代表在第几行return result;}
};

优化 位运算 没看懂

10394 用位运算速解 n 皇后问题 - 知乎 (zhihu.com)

class Solution {
public:vector <vector <string>> ans;void solve(int n, int row, int colMask, int leftDiagMask, int rightDiagMask, vector <string> &board) {if (row == n) {ans.push_back(board);return;}int rowState = (colMask | leftDiagMask | rightDiagMask) & ((1 << n) - 1);int safePos = rowState ^ ((1 << n) - 1);while (safePos) {int queenPos = safePos & (-safePos);safePos -= queenPos;if (!(queenPos & rowState)) {board[row][log2(queenPos)] = 'Q';solve(n, row + 1, colMask | queenPos, (leftDiagMask | queenPos) << 1, (rightDiagMask | queenPos) >> 1, board);board[row][log2(queenPos)] = '.';}}}vector<vector<string>> solveNQueens(int n) {vector <string> board(n, string (n, '.'));solve(n, 0, 0, 0, 0, board);return ans;}
};

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

前端练手小项目--自定义时间（html+css+js）

前端练手小项目--自定义时间（html+css+js）

自定义时间 写文章的因 关于要写这篇文章的原因 是记录在工作上遇到的困难需求&#xff0c;是希望能给大家提供一些解决问题的思路 接下来我描述这个需求的多样性&#xff0c;难点在哪。 勾选勾选框开始时间与结束时间默认显示昨天与今天。取消勾选框开始时间与结束时间清空。…
阅读更多...
Nginx运行Vue项目：基本运行

Nginx运行Vue项目：基本运行

需求 在Nginx服务器中&#xff0c;运行Vue项目。 说明 Vue项目打包生成的生产文件&#xff0c;是无法直接在浏览器打开的。需要放到Nginx服务器中&#xff0c;才能够访问。 本文章只介绍最基本的情况&#xff1a;Nginx中运行一个Vue项目。 实际生产环境&#xff0c;一个Ng…
阅读更多...
解密 AI 客服；在不同硬件设备上运行大型语言模型的可能性

解密 AI 客服；在不同硬件设备上运行大型语言模型的可能性

&#x1f989; AI新闻 &#x1f680; 微软必应首席执行官称必应聊天优于OpenAI的GPT-4&#xff0c;但成本更高 摘要&#xff1a;微软必应的首席执行官米哈伊尔・帕拉欣表示&#xff0c;必应聊天表现优于OpenAI的GPT-4&#xff0c;但使用了更高成本的检索增强推理技术。必应聊…
阅读更多...
中科亿海微ROM使用

中科亿海微ROM使用

标题 ROM&#xff08;Read-Only Memory&#xff0c;只读存储器&#xff09;是一种在FPGA&#xff08;Field-Programmable Gate Array&#xff0c;现场可编程门阵列&#xff09;中常用的存储器类型。与RAM&#xff08;Random Access Memory&#xff0c;机存取存储器&#xff09;…
阅读更多...
Nginx安全加固，版本隐藏及HTTP请求头修改方法

Nginx安全加固，版本隐藏及HTTP请求头修改方法

1 隐藏nginx版本号 1.1 引言 nginx作为目前较为流行的http server软件&#xff0c;其相关的安全漏洞也非常多&#xff0c;攻击者可以根据我们的nginx版本来了解到相关的漏洞从而针对性的进行攻击。 通过新版本的nginx都会修复一些老版本的已知漏洞&#xff0c;但有时候我们生…
阅读更多...
提示丢失vcomp140.dll怎么办？如何快速修复vcomp140.dll丢失问题

提示丢失vcomp140.dll怎么办？如何快速修复vcomp140.dll丢失问题

最近我遇到了一个程序启动失败的问题&#xff0c;错误提示显示缺少了vcomp140.dll文件。经过一番研究和尝试&#xff0c;我终于成功修复了这个问题。在这里&#xff0c;我将分享一下我的修复方法。 目录 vcomp140.dll是什么&#xff1f; 如何快速修复呢&#xff1f; vcomp140…
阅读更多...
sCrypt编程马拉松于8月13日在复旦大学成功举办

sCrypt编程马拉松于8月13日在复旦大学成功举办

继6月在英国Exeter大学成功举办了为期一周的区块链编程马拉松后&#xff0c;美国sCrypt公司创始人兼CEO刘晓晖博士带领核心团队成员王一强、郑宏锋、周全&#xff0c;于8月13日在复旦大学再次成功举办了一场全新的sCrypt编程马拉松。 本次活动由上海可一澈科技有限公司与复旦大…
阅读更多...
C++笔记之花括号和圆括号初始化区别，列表初始化和初始化列表区别

C++笔记之花括号和圆括号初始化区别，列表初始化和初始化列表区别

C笔记之花括号和圆括号初始化区别&#xff0c;列表初始化和初始化列表区别 code review! 文章目录 C笔记之花括号和圆括号初始化区别&#xff0c;列表初始化和初始化列表区别1.花括号{}进行初始化和圆括号()进行初始化2.列表初始化&#xff08;list initialization&#xff0…
阅读更多...
Vitis高层次综合学习——FPGA

Vitis高层次综合学习——FPGA

高层次综合 什么是高层次综合&#xff1f;就是使用高级语言&#xff08;如C/C&#xff09;来编写FPGA算法程序。 在高层次综合上并不需要制定微架构决策&#xff0c;如创建状态机、数据路径、寄存器流水线等。这些细节可以留给 HLS 工具&#xff0c;通过提供输入约束&#xff…
阅读更多...
专访阿里云席明贤，视频云如何运用大模型与小模型来破茧升级2.0

专访阿里云席明贤，视频云如何运用大模型与小模型来破茧升级2.0

不久前&#xff0c;LiveVideoStack与阿里云视频云负责人席明贤&#xff08;花名右贤&#xff09;展开一场深度的对话&#xff0c;一个是圈内专业的社区媒体&#xff0c;一个是20年的IT老兵&#xff0c;双方有交集、有碰撞、有火花。 面对风云变幻的内外环境&#xff0c;阿里云…
阅读更多...
未来数字银行的样子

未来数字银行的样子

对银行长期发展来讲&#xff0c;这意味着将关闭和减少 低效率的实体分行&#xff0c;加速向数字化发展。实现成本节省和 IT 预算提效的需求&#xff0c;将为数字柜台和银行代理点创造新的机遇。 一个崭新的世界&#xff1a;未来数字银行趋势图 现在是银行迎头赶上并为客户提供超…
阅读更多...
jenkins使用

jenkins使用

安装插件 maven publish over ssh publish over ssh 会将打包后的jar包&#xff0c;通过ssh推送到指定的服务器上&#xff0c;&#xff0c;在jenkins中设置&#xff0c;推送后脚本&#xff0c;实现自动部署jar包&#xff0c;&#xff0c; 装了这个插件之后&#xff0c;可以在项…
阅读更多...
Weak Session IDs (弱会话)

Weak Session IDs (弱会话)

Weak Session IDs (弱会话) 当用户登录后&#xff0c;在服务器就会创建一个会话(session)&#xff0c;叫做会话控制&#xff0c;接着访问页面的时候就不用登录&#xff0c;只需要携带Sesion去访问。 sessionID作为特定用户访问站点所需要的唯一内容。如果能够计算或轻易猜到该…
阅读更多...
深入理解 Flutter 图片加载原理

深入理解 Flutter 图片加载原理

作者&#xff1a;京东零售 徐宏伟 来源&#xff1a;京东云开发者社区 前言 随着Flutter稳定版本逐步迭代更新&#xff0c;京东APP内部的Flutter业务也日益增多&#xff0c;Flutter开发为我们提供了高效的开发环境、优秀的跨平台适配、丰富的功能组件及动画、接近原生的交互体验…
阅读更多...
用对角线去遍历矩阵

用对角线去遍历矩阵

声明 该系列文章仅仅展示个人的解题思路和分析过程&#xff0c;并非一定是优质题解&#xff0c;重要的是通过分析和解决问题能让我们逐渐熟练和成长&#xff0c;从新手到大佬离不开一个磨练的过程&#xff0c;加油&#xff01; 原题链接 用对角线遍历矩阵https://leetcode.c…
阅读更多...
数据结构——栈（C语言）

数据结构——栈（C语言）

需求&#xff1a;无 栈的概念&#xff1a; 栈&#xff1a;一种特殊的线性表&#xff0c;其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶&#xff0c;另一端为栈底。栈中的数据元素遵守后进先出&#xff08;LIFO&#xff09;原则。压栈&…
阅读更多...
自动驾驶——驶向未来的革命性技术

自动驾驶——驶向未来的革命性技术

自动驾驶——驶向未来的革命性技术 自动驾驶的组件自动驾驶的优势自动驾驶的应用自动驾驶的未来中国的自动驾驶 自动驾驶是一种技术&#xff0c;它允许车辆在没有人类驾驶员的情况下自主地进行行驶。它利用各种传感器、计算机视觉、人工智能和机器学习算法来感知和理解周围环境…
阅读更多...
.net连接mysql，提示找不到请求的 .Net Framework Data Provider。可能没有安装

.net连接mysql，提示找不到请求的 .Net Framework Data Provider。可能没有安装

开发完成的.net程序需要连接mysql数据库&#xff0c;在个人电脑上运行没问题&#xff0c;别人运行时提示“提示找不到请求的 .Net Framework Data Provider。可能没有安装”。经过查询&#xff0c;安装Connector/NET 8.1.0&#xff0c;下载地址如下所示&#xff1a; https://d…
阅读更多...
使用腾讯云轻量服务器Matomo应用模板建网站流量统计系统

使用腾讯云轻量服务器Matomo应用模板建网站流量统计系统

腾讯云百科分享使用腾讯云轻量应用服务器Matomo应用模板搭建网站流量统计系统&#xff0c;Matomo 是一款开源的网站数据统计软件&#xff0c;可以用于跟踪、分析您的网站的流量&#xff0c;同时充分保障数据安全性、隐私性。该镜像基于 CentOS 7.6 64位操作系统&#xff0c;已预…
阅读更多...
06-加密算法

06-加密算法

加密算法 一、前言知识1、加密解密2、MD5&#xff08;最常见&#xff09;3、SHA4、进制5、时间戳6、URL编码7、base64编码8、unescape编码9、AES加密10、DES&#xff08;类似于base64&#xff09; 二、常见加密形式算法解析三、演示案例1、某 CTF 比赛题目解析2、某 CMS 密码加…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023