leetcode每日一题
给你一个整数数组
nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。 找出只出现一次的那两个元素。你可以按 任意顺序 返回答案。你必须设计并实现线性时间复杂度的算法且仅使用常量额外空间来解决此问题。
#解题思路和代码优化思路
这道题看完题目肯定会有一个想法就是 去用哈希表统计每个数出现的次数 看哪两个数字是出现了1次的 最后返回这两个数就可以了 但是相对于另一种方法 他的时间复杂度和空间复杂度还是搞了很多 最优的解题思路是利用异或来解决问题 异或是指在二进制下两个数字的某一位上相同为0 不同为1 如何利用异或来解决这道题呢 首先理解 a异或a等于0 因为他们每一位都相等 还有就是 a异或0 等于a 因为相同为0 不同为1 算下来就是a本身 所以我们可以把数组的数字全都异或一遍 设两个出现了1次的数字是 a 和 b 则最后答案是 a异或b 怎么样才可以把他拆开呢 我们可以设想 这个数字一定不是 0 所以这个数字的某一位一定是1 即a 和 b 在这一位的数字是不一样的 所以我们可以把某一位是1的数字提取出来 就可以解决问题 可是怎么才能 提取出来一个1呢 num&(~num+1) 就是一个很好的 可以提取到 num 最右端的1的公式 利用 num为1010 则 ~num+1为0110 二者做与运算后 得到 0010 即取到了num最右端的1 最后在数组做一遍异或运算 就可以得到答案
#Coding
class Solution {
public:
vector<int> singleNumber(vector<int>& nums) {
long long sum1=0;
for(int i=0;i<nums.size();++i)
{
sum1^=nums[i];
}
int lastBit=sum1&(~sum1+1);
long long sum2=0;
for(int i=0;i<nums.size();++i)
{
if(nums[i]&lastBit) sum2^=nums[i];
}
vector<int> res;
res.push_back(sum1^sum2);
res.push_back(sum2);
return res;
}
};提示
给你一个正整数
n，请你计算在[1，n]范围内能被3、5、7整除的所有整数之和。返回一个整数，用于表示给定范围内所有满足约束条件的数字之和。
#解题思路和代码优化思路
今天的题是简单题 所以解题思路也很简单 但是需要优化算法素数筛 可以通过素数筛来大大的降低时间复杂度
#Coding
class Solution {
public:
int sumOfMultiples(int n) {
vector<int> vis(n+1,0);
int res=0;
for(int i=1;i<=n;++i)
{
if(vis[i]) continue;
if(i%3==0 || i%5==0 || i%7==0)
{
res+=i;
vis[i]=1;
for(int k=2;k*i<=n;++k)
{
if(vis[i]) continue;
res+=k*i;
vis[k*i]=1;
}
}
}
return res;
}
};给你一个下标从 0 开始的整数数组
nums和一个整数k。你的 起始分数 为0。在一步 操作 中：
- 选出一个满足
0 <= i < nums.length的下标i，- 将你的 分数 增加
nums[i]，并且- 将
nums[i]替换为ceil(nums[i] / 3)。返回在 恰好 执行
k次操作后，你可能获得的最大分数。向上取整函数
ceil(val)的结果是大于或等于val的最小整数。
#解题思路和代码优化思路
根据题目含义 需要求 最大的 k个数的和 所以 我们使用 大根堆来解题是最好的思路 我们可以将nums数组的所有数字放到堆中 每次就堆顶弹出并且和res求和 并且 将他变成 (val+2)/3再放入大根堆中 循环k次就是答案
#Coding
class Solution {
public:
long long maxKelements(vector<int>& nums, int k) {
priority_queue<int> q;
for(int i=0;i<nums.size();++i)
{
q.push(nums[i]);
}
long long res=0;
while(!q.empty() && k)
{
int val=q.top();
q.pop();
res+=val;
q.push((val+2)/3);
k--;
}
return res;
}
};给你一个由 不同 正整数组成的数组
nums，请你返回满足a * b = c * d的元组(a, b, c, d)的数量。其中a、b、c和d都是nums中的元素，且a != b != c != d。
#解题思路和代码优化思路
由于数组中每一个数都不一样 所以大大的简化了作题难度 统计每两个数字的乘积 用uamp来存放每个乘机的个数 最后遍历umap 然后就是排列组合问题了 从k个里面随机抽两个 一共有多少种方法种方法 累加就是答案 当然每一种都有八个
#Coding
class Solution {
public:
int tupleSameProduct(vector<int>& nums) {
unordered_map<int,int> umap;
for(int i=0;i<nums.size();++i)
{
for(int j=i+1;j<nums.size();++j)
{
umap[nums[i]*nums[j]]++;
}
}
int res=0;
for(auto& x : umap)
{
int val=x.second;
if(val==1) continue;
res+=8*(val)*(val-1)/2;
}
return res;
}
};给你一个整数
n，表示一张 无向图 中有n个节点，编号为0到n - 1。同时给你一个二维整数数组edges，其中edges[i] = [ai, bi]表示节点ai和bi之间有一条 无向 边。请你返回 无法互相到达 的不同 点对数目 。
#解题思路和代码优化思路
这道题用到的是非常典型的数据结构并查集 通过对每个数字的统计 让不同的数字 根据他们之间的关系 进入到相应的集合中 最后统计每个集合的数字个数以及集合的个数 计算总边值只需要每次计算当前集合对于其他集合的边数 即为 当前集合的点数 * 其他集合的点数 为了避免算重复 所以计算完当前集合 就需要把当前集合踢出去 最后累加即为答案
#Coding
给你四个整数
length，width，height和mass，分别表示一个箱子的三个维度和质量，请你返回一个表示箱子 类别 的字符串。
- 如果满足以下条件，那么箱子是
"Bulky"的：
- 箱子 至少有一个 维度大于等于
104。- 或者箱子的 体积 大于等于
109。- 如果箱子的质量大于等于
100，那么箱子是"Heavy"的。- 如果箱子同时是
"Bulky"和"Heavy"，那么返回类别为"Both"。- 如果箱子既不是
"Bulky"，也不是"Heavy"，那么返回类别为"Neither"。- 如果箱子是
"Bulky"但不是"Heavy"，那么返回类别为"Bulky"。- 如果箱子是
"Heavy"但不是"Bulky"，那么返回类别为"Heavy"。注意，箱子的体积等于箱子的长度、宽度和高度的乘积。
#解题思路和代码优化思路
这道题很简单 但是 volume 的数值很大 很容易超过 long long 的 极限 所以我们可以将其简化 利用 log函数 来将 长 宽 高 化为 10 的 几次方 这样就很简单了 只需要求 他的和是不是大于9就好了 不需要考虑volume是不是会超数据
#Coding
class Solution {
public:
string categorizeBox(int length, int width, int height, int mass) {
double a=log10(length),b=log10(width),c=log10(height);
cout<<a+b+c;
bool flag1=mass>=100;
bool flag2=a+b+c>=9 || (a>=4 || b>=4 || c>=4);
if(flag1 && flag2) return "Both";
else if(flag1) return "Heavy";
else if(flag2) return"Bulky";
else return"Neither";
}
};LeetCode周赛
给你一个下标从 0 开始、长度为
n的整数数组nums，以及整数indexDifference和整数valueDifference。你的任务是从范围
[0, n - 1]内找出 2 个满足下述所有条件的下标i和j：
abs(i - j) >= indexDifference且abs(nums[i] - nums[j]) >= valueDifference返回整数数组
answer。如果存在满足题目要求的两个下标，则answer = [i, j]；否则，answer = [-1, -1]。如果存在多组可供选择的下标对，只需要返回其中任意一组即可。注意：
i和j可能 相等 。
#解题思路和代码优化思路
这道题很简单 但是还有有 优化思路 就是 j不需要从0开始循环 而是 i+indexDifference 开始循环 这样就可以减少很多的时间复杂度
#Coding
class Solution {
public:
vector<int> findIndices(vector<int>& nums, int indexDifference, int valueDifference) {
for(int i=0;i<nums.size();++i)
{
for(int j=i+indexDifference;j<nums.size();++j)
{
if(abs(nums[i]-nums[j])>=valueDifference) return {i,j};
}
}
return {-1,-1};
}
};给你一个下标从 0 开始、长度为
n的整数数组nums，以及整数indexDifference和整数valueDifference。你的任务是从范围
[0, n - 1]内找出 2 个满足下述所有条件的下标i和j：
abs(i - j) >= indexDifference且abs(nums[i] - nums[j]) >= valueDifference返回整数数组
answer。如果存在满足题目要求的两个下标，则answer = [i, j]；否则，answer = [-1, -1]。如果存在多组可供选择的下标对，只需要返回其中任意一组即可。注意：
i和j可能 相等 。
#解题思路和代码优化思路
上一道题的进一步优化套路 如果按照上一道题的解题思路 最差情况是O( ) 这显然在大数据量的情况下是不符合标准的 所以我们需要优化思路 优化掉时间复杂度 我们可以借用大小根堆来优化数据结构 可以在比较之前将根堆的不符合的值弹出去 在将 当前的nums[i] 与 大小根堆的堆顶值进行比较 如果符合就弹出 不符合就继续循环
#Coding
class Solution {
public:
vector<int> findIndices(vector<int>& nums, int indexDifference, int valueDifference) {
priority_queue<pair<int,int>> maxQ;
priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> minQ;
for(int i=0;i<nums.size();++i)
{
maxQ.push(make_pair(nums[i],i));
minQ.push(make_pair(nums[i],i));
}
for(int i=0;i<nums.size();++i)
{
while(!maxQ.empty() && maxQ.top().second<i+indexDifference) maxQ.pop();
while(!minQ.empty() && minQ.top().second<i+indexDifference) minQ.pop();
if(maxQ.empty() && minQ.empty()) return{-1,-1};
int maxValue=maxQ.top().first,minValue=minQ.top().first;
if(maxValue-nums[i]>=valueDifference) return {i,maxQ.top().second};
if(nums[i]-minValue>=valueDifference) return {i,minQ.top().second};
}
return {-1,-1};
}
};给你一个二进制字符串
s和一个正整数k。如果
s的某个子字符串中1的个数恰好等于k，则称这个子字符串是一个 美丽子字符串 。令
len等于 最短 美丽子字符串的长度。返回长度等于
len且字典序 最小 的美丽子字符串。如果s中不含美丽子字符串，则返回一个 空 字符串。对于相同长度的两个字符串
a和b，如果在a和b出现不同的第一个位置上，a中该位置上的字符严格大于b中的对应字符，则认为字符串a字典序 大于 字符串b。
- 例如，
"abcd"的字典序大于"abcc"，因为两个字符串出现不同的第一个位置对应第四个字符，而d大于c
#解题思路和代码优化思路
这道题的大体解题思路是滑动窗口 最小的满足要求的字符串他的1的个数一定是k个 如果大于k个 就说明它可以继续缩小 所以思路就是保持窗口内部的1的个数为k 再判断其长度是否是最小 以及相同长度下是否为最小字典序的字符串
#Coding
class Solution {
public:
string shortestBeautifulSubstring(string s, int k) {
int index=0,lens=INT_MAX,count=0,left=0;
for(int i=0;i<s.size();++i)
{
if(s[i]=='1') count++;
while(count>k)
{
if(s[left]=='1') count--;
left++;
}
while(left<i && s[left]=='0') left++;
if(count==k && lens>=i-left+1)
{
if(lens>i-left+1)
{
index=left;
lens=i-left+1;
}
else if(lens==i-left+1)
{
if(s.substr(left,lens)>s.substr(index,lens)) continue;
index=left;
lens=i-left+1;
}
}
}
if(lens==INT_MAX) return"";
return s.substr(index,lens);
}
};给你一个长度为
n下标从 0 开始的数组nums，数组中的元素为 互不相同 的正整数。请你返回让nums成为递增数组的 最少右移 次数，如果无法得到递增数组，返回-1。一次 右移 指的是同时对所有下标进行操作，将下标为
i的元素移动到下标(i + 1) % n处。
#解题思路和代码优化思路
这道题的解题思路是 先找到最小值 再从最小值开始遍历数组 看是不是每一个都是 前一个数小于后一个数字
#Coding
class Solution {
public:
int minimumRightShifts(vector<int>& nums) {
int minIdx=0;
for(int i=1;i<nums.size();++i)
{
minIdx=nums[minIdx]<nums[i]?minIdx:i;
}
cout<<minIdx;
for(int i=0;i<nums.size()-1;++i)
{
if(nums[(minIdx+i)%nums.size()]>nums[(minIdx+i+1)%nums.size()])
return -1;
}
if(minIdx==0) return minIdx;
return nums.size()-minIdx;
}
};给你一个下标从 0 开始的字符串数组
words，其中words[i]要么是一个字符串形式的正整数，要么是字符串"prev"。我们从数组的开头开始遍历，对于
words中的每个"prev"字符串，找到words中的 上一个遍历的整数 ，定义如下：
k表示到当前位置为止的连续"prev"字符串数目（包含当前字符串），令下标从 0 开始的 整数 数组nums表示目前为止遍历过的所有整数，同时用nums_reverse表示nums反转得到的数组，那么当前"prev"对应的 上一个遍历的整数 是nums_reverse数组中下标为(k - 1)的整数。- 如果
k比目前为止遍历过的整数数目 更多 ，那么上一个遍历的整数为-1。请你返回一个整数数组，包含所有上一个遍历的整数。
#解题思路和代码优化思路
这道题乍一看用栈 但是栈不能存放 所以用数组更为合适 利用 cur 来记录当前下标 当新加入元素后 就把 cur 更新 否则就一直向前减一
#Coding
class Solution {
public:
vector<int> lastVisitedIntegers(vector<string>& words) {
vector<int> nums;
vector<int> res;
int cur=0;
for(int i=0;i<words.size();++i)
{
if(words[i][0]=='p')
{
if(cur<0 || nums.empty()) res.push_back(-1);
else res.push_back(nums[cur]);
cur--;
}
else
{
int number=stoi(words[i]);
nums.push_back(number);
cur=nums.size()-1;
}
}
return res;
}
};LeetCode专项训练
有
n个城市，其中一些彼此相连，另一些没有相连。如果城市a与城市b直接相连，且城市b与城市c直接相连，那么城市a与城市c间接相连。省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。
给你一个
n x n的矩阵isConnected，其中isConnected[i][j] = 1表示第i个城市和第j个城市直接相连，而isConnected[i][j] = 0表示二者不直接相连。返回矩阵中 省份 的数量。
#解题思路和代码优化思路
并查集的经典题目 这道题的思路就是利用并查集来找到分支个数 主要是对并查集的熟悉建立 其余都是很简单的
#Coding
class Solution {
vector<int> father;
void init(int n)
{
father.resize(n);
for(int i=0;i<n;++i) father[i]=i;
}
int find(int x)
{
return father[x]==x?x:father[x]=find(father[x]);
}
void unit(int x,int y)
{
int fx=find(x),fy=find(y);
father[fx]=fy;
}
public:
int findCircleNum(vector<vector<int>>& a) {
init(201);
int m=a.size(),n=a[0].size();
for(int i=0;i<m;++i)
{
for(int j=0;j<n;++j)
{
if(a[i][j]==1) unit(i,j);
}
}
int res=0;
for(int i=0;i<m;++i) if(father[i]==i) res++;
return res;
}
};
1105
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
