手速要练习下
文章目录
千位分隔数
a.题目
给你一个整数 n，请你每隔三位添加点（即 “.” 符号）作为千位分隔符，并将结果以字符串格式返回。
示例 1
输入：n = 987
输出：“987”
示例 2
输入：n = 1234
输出：“1.234”
示例 3
输入：n = 123456789
输出：“123.456.789”
示例 4
输入：n = 0
输出：“0”
提示
- 0 <= n < 2^31
a.分析
首先二话不说把数字换成字符串 to_string(n)然后再操作
从样例可以看出是从后面开始加小数点的
为了方便（第一题就要快） 直接reverse反转过来从后面开始
然后碰到第三个就给它加个小数点
最后答案再翻过来就行了
时间复杂度为O(log10n) 以10为底的对数 就是那个数的长度
a.参考代码
class Solution {
public:
string thousandSeparator(int n) {
string a=to_string(n);
reverse(a.begin(),a.end()); //翻转
string ans;
for(int i=0;i<a.size();i++){ //每隔三个加点
if(i%3==0&&i)ans.push_back('.');
ans.push_back(a[i]);
}
reverse(ans.begin(),ans.end()); //记得翻回去
return ans;
}
};
可以到达所有点的最少点数目
b.题目
给你一个 有向无环图 ， n 个节点编号为 0 到 n-1 ，以及一个边数组 edges ，其中 edges[i] = [fromi, toi] 表示一条从点 fromi 到点 toi 的有向边。
找到最小的点集使得从这些点出发能到达图中所有点。题目保证解存在且唯一。
你可以以任意顺序返回这些节点编号。
示例 1
输入：n = 6, edges = [[0,1],[0,2],[2,5],[3,4],[4,2]]
输出：[0,3]
解释：从单个节点出发无法到达所有节点。从 0 出发我们可以到达 [0,1,2,5] 。从 3 出发我们可以到达 [3,4,2,5] 。所以我们输出 [0,3] 。
示例 2
输入：n = 5, edges = [[0,1],[2,1],[3,1],[1,4],[2,4]]
输出：[0,2,3]
解释：注意到节点 0，3 和 2 无法从其他节点到达，所以我们必须将它们包含在结果点集中，这些点都能到达节点 1 和 4 。
提示
- 2 <= n <= 10^5
- 1 <= edges.length <= min(10^5, n * (n - 1) / 2)
- edges[i].length == 2
- 0 <= fromi, toi < n
- 所有点对 (fromi, toi) 互不相同。
b.分析
乍一看非常的牛逼这第二题
而且样例也没有给出足够的信息
然后思考了一下发现
假如 我先把全部点都塞进了答案 那样肯定不是最小的
那么需要排除哪些点呢 就要排除出可以被遍历到的点
可以被遍历到的点都有个特征 就是存在某个路径可以到达它
因此它的入度必然>=1
那么剩下的点自然是 入度为0的点
因此就这么简单 入度为0的点就是答案
时间复杂度为O（m） m为边数
b.参考代码
class Solution {
public:
vector<int> findSmallestSetOfVertices(int n, vector<vector<int>>& edges) {
vector<int> in(n,0); //入度
for(auto edge:edges)
{
int from=edge[0],to=edge[1];
in[to]++; //遍历全部边
}
vector<int> ans;
for(int i=0;i<n;i++)if(!in[i])ans.push_back(i); //入度为0的都是答案
return ans;
}
};
得到目标数组的最少函数调用次数
c.题目
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b6Tk2WI6-1598114496972)(https://assets.leetcode.com/uploads/2020/07/10/sample_2_1887.png)]
给你一个与 nums 大小相同且初始值全为 0 的数组 arr ，请你调用以上函数得到整数数组 nums 。
请你返回将 arr 变成 nums 的最少函数调用次数。
答案保证在 32 位有符号整数以内。
给你一个与 nums 大小相同且初始值全为 0 的数组 arr ，请你调用以上函数得到整数数组 nums 。
请你返回将 arr 变成 nums 的最少函数调用次数。
答案保证在 32 位有符号整数以内。
示例 1
输入：nums = [1,5]
输出：5
解释：给第二个数加 1 ：[0, 0] 变成 [0, 1] （1 次操作）。
将所有数字乘以 2 ：[0, 1] -> [0, 2] -> [0, 4] （2 次操作）。
给两个数字都加 1 ：[0, 4] -> [1, 4] -> [1, 5] （2 次操作）。
总操作次数为：1 + 2 + 2 = 5 。
示例 2
输入：nums = [2,2]
输出：3
解释：给两个数字都加 1 ：[0, 0] -> [0, 1] -> [1, 1] （2 次操作）。
将所有数字乘以 2 ： [1, 1] -> [2, 2] （1 次操作）。
总操作次数为： 2 + 1 = 3 。
示例 3
输入：nums = [4,2,5]
输出：6
解释：（初始）[0,0,0] -> [1,0,0] -> [1,0,1] -> [2,0,2] -> [2,1,2] -> [4,2,4] -> [4,2,5] （nums 数组）。
示例 4
输入：nums = [3,2,2,4]
输出：7
示例 5
输入：nums = [2,4,8,16]
输出：8
提示
- 1 <= nums.length <= 10^5
- 0 <= nums[i] <= 10^9
c.分析
对于这种求最小操作数的 我们必须自己先搞明白怎样才是最小操作才能去写
不可能通过计算机暴力出来然后求min 除非是第一题
那么先假设只有一个数n 然后你只能/2或者-1 如何才是最小次数把它变为0
思考出来的结论：
- 偶数就/2
- 奇数就-1
我们来证明一下 最小的偶数是2 然后2/2==1 和 2-1==1 的答案是一样的
那么就意味着 大于2的所有偶数 even/(2*x)==a 和 even-(1*y)==a
此处肯定是 x<y 也就是/2的操作数比不断-1的操作数要小
而奇数的时候你只能-1了 没办法/2 不然就会变成小数了
那么知道了单个数的操作 我们再来看看多个数的操作：
偶数/2这个部分是共享的 也就是说 可以先把全部数减到偶数然后一起/2 那么这一次就共享了
因此 最多只会进行 最大元素能/2的次数 次除法
综上 所以答案就是 每个数减的次数之和+最大元素能/2的次数
可能有同学会问 这里默认了除以了最大元素的次数 对小的元素没有影响吗？
不会有影响的 因为0/2=0 这个从样例就能看出来 0*2=0
总的时间复杂度是O（nlogn）的 因为求出一个数要除和要减的次数是对数级别
c.参考代码
class Solution {
public:
int div=0,sub=0;
int minOperations(vector<int>& nums) {
for(auto num:nums)deal(num);
return div+sub;
}
void deal(int n){ //算一个数的减和除的次数
int d=0;
while(n){
if(n&1){ //奇数减一
n--;
sub++;
}
else{ //偶数除以二
d++;
n>>=1;
}
}
div=max(div,d); //只要最大的/2次数
}
};
二维网格图中探测环
d.题目
给你一个二维字符网格数组 grid ，大小为 m x n ，你需要检查 grid 中是否存在 相同值 形成的环。
一个环是一条开始和结束于同一个格子的长度 大于等于 4 的路径。对于一个给定的格子，你可以移动到它上、下、左、右四个方向相邻的格子之一，可以移动的前提是这两个格子有 相同的值 。
同时，你也不能回到上一次移动时所在的格子。比方说，环 (1, 1) -> (1, 2) -> (1, 1) 是不合法的，因为从 (1, 2) 移动到 (1, 1) 回到了上一次移动时的格子。
如果 grid 中有相同值形成的环，请你返回 true ，否则返回 false 。
示例 1
输入：grid = [[“a”,“a”,“a”,“a”],[“a”,“b”,“b”,“a”],[“a”,“b”,“b”,“a”],[“a”,“a”,“a”,“a”]]
输出：true
解释：如下图所示，有 2 个用不同颜色标出来的环：
示例 2
输入：grid = [[“c”,“c”,“c”,“a”],[“c”,“d”,“c”,“c”],[“c”,“c”,“e”,“c”],[“f”,“c”,“c”,“c”]]
输出：true
解释：如下图所示，只有高亮所示的一个合法环：
示例 3
输入：grid = [[“a”,“b”,“b”],[“b”,“z”,“b”],[“b”,“b”,“a”]]
输出：false
提示
- m == grid.length
- n == grid[i].length
- 1 <= m <= 500
- 1 <= n <= 500
- grid 只包含小写英文字母。
d.分析
这题纯搜索题 我写dfs爆栈罚时一次太sb了
首先用人脑做一遍题目：
- 肯定就是先随便选一个位置作为起点
- 然后往隔壁的格子看看是不是起点的字符 不是就跳过
- 然后都扫完了 看下能不能成圈 就是能不能通过第二点看到走过的点
- 不能成圈就随便找下一个格子（之前没看过的 因为看过的肯定不是）当起点重复操作
可以看到 这个思路十分清晰 按照这个思路直接搜就行了 这里需要小思考三点：
- 是否找过的肯定不能成圈
- 肯定的 因为隔壁这个概念是相对性的 已经搜索过的区域中的任何一个格子 重新搜索都能完整通过遍历隔壁来搜出完整的区域
- 怎么判断圈
- 只要在同一次搜索中碰到非回头且已搜索过的格子即为圈
- 不可能在不同次搜索碰到之前搜索过的格子 因为搜索是具有区域性的 会把连通块在一次全部搜完 所以不同次搜索肯定是搜不同的连通块
- 按照什么作为起点搜
- 按照字母搜 不行 同一个字母可能在不同连通块中
- 随便搜 只要没有搜过的就行了 那么它肯定在其他未知的连通块中
这题重点是在非回头这里 我们只需要把每个状态都记录多一个从哪里来的即可
代码表示就是记录两个position 用一个pair< pair<int,int> , pair<int,int> > 来分别记录当前节点和上个节点的坐标
总的时间复杂度是O（nm）的 因为遍历过的就不会再重复遍历 所以总的是会把整个图都遍历的
千万不要用dfs搜 25000的 深度 会爆栈 感兴趣的同学可以去查下函数栈的最大深度是多少 虽然ide可以改栈深度 但是leetcode不太清楚 所以同学们还是用bfs去搜
d.参考代码
class Solution {
public:
bool ans=false;
vector<vector<bool>> vis; //记录是否走过
int n,m;
vector<vector<char>> g; //图
int dx[4]={0,1,0,-1}; //四个方向
int dy[4]={1,0,-1,0}; //四个方向
bool containsCycle(vector<vector<char>>& grid) {
n=grid.size();
m=grid[0].size();
g=grid;
vis=vector<vector<bool>>(n+5,vector<bool>(m+5,false));
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(!vis[i][j]&&!ans) //没有遍历过的随便找个位置
bfs({i,j},g[i][j]);
return ans;
}
void bfs(pair<int,int> pos,char c){
queue< pair< pair<int,int> , pair<int,int> > > q;
q.push({pos,{-1,-1}}); //起点
vis[pos.first][pos.second]=true;
while(q.size()){
auto now=q.front();
q.pop();
for(int k=0;k<4;k++)
{
int newx=now.first.first+dx[k],newy=now.first.second+dy[k]; //隔壁的坐标
if(newx<0||newy<0||newx>=n||newy>=m)continue; //不可达
if(make_pair(newx,newy)==now.second)continue; //回头了
if(g[newx][newy]!=c)continue; //不同字符不可达
if(vis[newx][newy]){ //碰到就肯定是
ans=true;
return;
}
vis[newx][newy]=true;
q.push({{newx,newy},now.first}); //记得往隔壁开拓连通块
}
}
}
};
扫一扫
1115
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
