leecode刷题3
这里写目录标题
- 40
- 2089
- 2194 excel中的数字
- 剑指 Offer 15. 二进制中1的个数
- 12
- 1115. 交替打印 FooBar
- 2351 第一个出现两次的字母
- 2411. 按位或最大的最小子数组长度
- 2068. 检查两个字符串是否几乎相等
- 704 二分查找
- 面试题 05.03. 翻转数位
- 1137. 第 N 个泰波那契数
-
- 动态规划
- 矩阵快速幂
- 117. 填充每个节点的下一个右侧节点指针 II
- 面试题 17.12. BiNode
- 1248. 统计「优美子数组」
-
- 方法2 前缀和差分
- 707设计链表
- 836 矩形重叠
- 面试题面试题 10.02. 变位词组
- 1339. 分裂二叉树的最大乘积
- 1111. 有效括号的嵌套深度
- LCP 55. 采集果实
- 2438. 二的幂数组中查询范围内的乘积
- 返回最小数目的2的幂
- 2043. 简易银行系统
- 1702. 修改后的最大二进制字符串
- 1816. 截断句子
- 1021. 删除最外层的括号
- 1361. 验证二叉树
- 剑指 Offer II 001. 整数除法
-
- INT_MAX和INT_MIN
- 2135. 统计追加字母可以获得的单词数
- 172 阶乘后的零
- 56. 合并区间
-
- sort 排序默认 会按第一个元素的值排序
- 2575. 找出字符串的可整除数组
- 1410. HTML 实体解析器
- 2135 追加字母
- 938. 二叉搜索树的范围和
- LCP 12. 小张刷题计划
-
- 66. 加一
- A.size()-1因为size返回值是无符号类型所以 A.size()-1越界，是个很大的数
- 2245. 转角路径的乘积中最多能有几个尾随零
- 2285. 道路的最大总重要性
- 1461
- 面试题 04.04. 检查平衡性
- 1162. 地图分析
- 1943
40
他要先排序
打个比方 3 和 {1 ，1 ，1，3}
push 1 称为{1}
dfs ( 0 , target) , start =0
i=start = 0 , push 变为{1}
dfs（1，3 - 1）= dfs（1 ， 2），i=start = 1 , push {1,1}
dfs (2, 2-1) = dfs (2 , 1), i= start = 2, push {1 ,1 ,1}
dfs(3 , 1-1 = 0), return 了， pop 了 ，成为{1，1}
i = 3， 3<4 && 1-3<0 ,不满足，循环结束
pop了，成为 {1}，
i= 2， 2<4 && 2-1=1 ,满足，
i=2 > start = 1 ,1 ==1 continue,
i=3,3<4 && 1-3<0 ,不满足，循环结束，
退出dfs，执行pop变为 {1}，然后i++ 变为1，continue，变为2，continue，变为3，2-3<0 不满足，循环结束
退出dfs，执行pop变为{ }，然后i =1, continue， i =2 continue, i=3,push {3}, return ,结束
// author:rmokerone
#include 2089
class Solution {
public:
vector<int> targetIndices(vector<int>& nums, int target) {
vector<int> ans;
sort(nums.begin(),nums.end());
auto it = find(nums.begin(), nums.end(), target);
if(it == nums.end() )
return ans;
else
{
ans.push_back(distance(nums.begin(),it));
while( it!=nums.end()-1 && *++it == target)
{
ans.push_back(distance(nums.begin(),it));
}
}
return ans;
}
};
2194 excel中的数字
class Solution {
public:
vector<string> cellsInRange(string s) {
char beg1 = s[0];
char beg2 = s[3];
char end1 = s[1];
char end2 = s[4];
vector<string> ans;
//int dis1 = beg[0] - end[0];
//int dis2 = beg[1] - end[1];
int dis1 = beg2 -beg1;
int dis2 = end2 - end1;
for(int i=0 ; i<=dis1;i++)
{
for(int j=0 ; j<=dis2;j++)
{
string a = "";
a+=beg1;
a+=end1;
end1++;
ans.push_back(a);
}
beg1++;
end1 = s[1];
}
return ans;
}
};
class Solution {
public:
vector<string> cellsInRange(string s) {
vector<string> res;
for (char row = s[0]; row <= s[3]; ++row) {
for (char col = s[1]; col <= s[4]; ++col) {
string cell(1, row); 创建string 变量 cell 里面1个 char类型变量row
cell.push_back(col);
res.push_back(cell);
}
}
return res;
}
};
作者：LeetCode-Solution
链接：https://leetcode.cn/problems/cells-in-a-range-on-an-excel-sheet/solution/excel-biao-zhong-mou-ge-fan-wei-nei-de-d-uffw/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
剑指 Offer 15. 二进制中1的个数
class Solution {
public:
int hammingWeight(uint32_t n) {
int ret = 0;
for (int i = 0; i < 32; i++) {
if (n & (1 << i)) {
ret++;
}
}
return ret;
}
};
作者：LeetCode-Solution
链接：https://leetcode.cn/problems/er-jin-zhi-zhong-1de-ge-shu-lcof/solution/er-jin-zhi-zhong-1de-ge-shu-by-leetcode-50bb1/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
class Solution {
public:
int hammingWeight(uint32_t n) {
return __builtin_popcount(n);
}
};
int hammingWeight(uint32_t n) {
string s = to_string(n);
int ans = 0;
for(int i =0;i<s.length();i++)
{
if(s[i])
ans++;
}
return ans;
} 检查上述代码，为何输入为00000000000000000000000000001011，结果为2
上述代码的问题在于对字符串的判定方式不正确。虽然 s[i] 返回的是字符类型，但在 if 语句中会被自动转换成布尔值，而非数值 0 和非零。
因此，如果仅仅使用 if(s[i]) 进行判断，实际上相当于判断当前字符是否为空字符（ASCII 码为 0），而不是当前字符表示的数字是否为 0。在输入为 "00000000000000000000000000001011" 的情况下，第一、二个字符都是空字符，因此只有后两个字符被判定为非空字符，导致计数结果为 2。
解决这个问题的方法是需要将字符类型的 '0' 和 '1' 转化为数值 0 和 1，然后再进行判断。修改后的代码如下：
c++
#include 12
const pair<int, string> valueSymbols[] = {
{1000, "M"},
{900, "CM"},
{500, "D"},
{400, "CD"},
{100, "C"},
{90, "XC"},
{50, "L"},
{40, "XL"},
{10, "X"},
{9, "IX"},
{5, "V"},
{4, "IV"},
{1, "I"},
};
class Solution {
public:
string intToRoman(int num) {
string roman;
for (const auto &[value, symbol] : valueSymbols) {
while (num >= value) {
num -= value;
roman += symbol;
}
if (num == 0) {
break;
}
}
return roman;
}
};
class Solution {
public:
string intToRoman(int num) {
int values[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
string reps[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
string res;
int
for (int i = 0; i < 13; i ++ ) //这里不使用图里的count了，一遍一遍来就行了
while(num >= values[i])
{
num -= values[i];
res += reps[i];
}
return res;
}
};
作者：z1m
链接：https://leetcode.cn/problems/integer-to-roman/solution/tan-xin-ha-xi-biao-tu-jie-by-ml-zimingmeng/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
1115. 交替打印 FooBar
我一开始是在两个 程序里分别用了同一个锁
但是输出是foofoobarbar
他要交替打印foobar
就是在循环里锁
现在构造里把2给锁了，那么函数2中的锁2就只能等待。
循环里 函数1中，锁1 ， 等foo打印了 ，此时锁2解锁 ，
锁2解锁了，那么此时的函数2中的锁2可以执行了，执行bar打印，然后解锁1，循环体再次执行 锁2 ，又卡住了。
然后函数1的 循环体中的锁1又能执行了，又开始。
class FooBar {
private:
int n;
public:
mutex mtx1;
mutex mtx2;
FooBar(int n) {
this->n = n;
}
void foo(function<void()> printFoo) {
for (int i = 0; i < n; i++) {
mtx2.lock();
// printFoo() outputs "foo". Do not change or remove this line.
printFoo();
mtx1.unlock();
}
}
void bar(function<void()> printBar) {
for (int i = 0; i < n; i++) {
mtx1.lock();
// printBar() outputs "bar". Do not change or remove this line.
printBar();
mtx2.unlock();
}
}
};
2351 第一个出现两次的字母
使用set 插入
a.insert()，insert会返回一个pair 第一个为迭代器，第二个为bool
如果 ret.second 为假说明 插入失败
2411. 按位或最大的最小子数组长度
或运算性质 1不可能变成0，0可以变成1
至多可以变多少种？
可以子数组左端点为i的按位或的结果
结果包含 位或结果以及哪些端点对应这个结果
采用递推方式算出一系列结果
另一种方法提出 考虑 最近提供充足 不同位数上的1
逻辑右移就是不考虑符号位，右移一位，左边补零即可。
i从左向右遍历 j 从右向左遍历，意思时最右边的元素能否使我更强大
nums[ i ] 开始从右向左遍历
vector<int> smallestSubarrays(vector<int> &nums) {
int n = nums.size();
vector<int> ans(n);
for (int i = 0; i < n; ++i) {
ans[i] = 1;
for (int j = i - 1; j >= 0 && (nums[j] | nums[i]) != nums[j]; --j) {
nums[j] |= nums[i];
ans[j] = i - j + 1;
}
}
return ans;
}
作者：endlesscheng
链接：https://leetcode.cn/problems/smallest-subarrays-with-maximum-bitwise-or/solution/by-endlesscheng-zai1/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
2068. 检查两个字符串是否几乎相等
可以用一个哈希表，遍历字符，对应元素加1
然后频数加1
后面一个频数都减去1
bool checkAlmostEquivalent(string word1, string word2) {
//map> m;
string s ="abcdefghijklmnopqrstuvwxyz";
for(char c:s )
{
int n1 = count(word1.begin(),word1.end(),c);
int n2 = count(word2.begin(),word2.end(),c);
if((n1-n2)>3 ||(n1-n2)<-3)
return false;
}
return true;
}
class Solution {
public:
bool checkAlmostEquivalent(string word1, string word2) {
unordered_map<char, int> freq; // 频数差哈希表
for (auto ch: word1){
++freq[ch];
}
for (auto ch: word2){
--freq[ch];
}
// 判断每个字符频数差是否均小于等于 3
return all_of(freq.cbegin(), freq.cend(), [](auto&& x) { return abs(x.second) <= 3; });
}
};
作者：LeetCode-Solution
链接：https://leetcode.cn/problems/check-whether-two-strings-are-almost-equivalent/solution/jian-cha-liang-ge-zi-fu-chuan-shi-fou-ji-59go/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
704 二分查找
left right
面试题 05.03. 翻转数位
把对应数字放入bitset里可以快速得出每一位的01情况
考虑两段1是否可以相连
int l=0,r=0,Max=0;//以0为分界点，L是0左边连续1的数量，R是0右边连续1的数量，Max记录最大值
for(int i=0;i<32;i++){
if(num&1) r++;
else l=r+1,r=0; //当遇见0时， 0的左边连续1的数量等于上一个0右边连续1的数量加一（0本身反转后算一个长度）
Max=max(l+r,Max);
num>>=1; num = num >> 1;
}
return Max;
bitset<32> bst(num);
1137. 第 N 个泰波那契数
class Solution {
public:
int fbnq(int n)
{
if(n<2)
return n;
if(n==2)
return 1;
return (fbnq(n-3)+fbnq(n-1)+fbnq(n-2));
}
int tribonacci(int n) {
int ans;
if(n<2)
return n;
if(n==2)
return 1;
ans = fbnq(n-3)+fbnq(n-2)+fbnq(n-1);
return ans;
}
};
动态规划
递归涉及到重复计算
可以用
ans = q+r+e
保存之前计算得到的值
int tribonacci(int n) {
//int ans;
if(n<2)
return n;
if(n==2)
return 1;
int ans,f=0,s=1,t=1;
for(int i =3;i<=n;i++)
{
ans = f+s+t;
f = s;
s = t;
t = ans;
}
return ans;
}
矩阵快速幂
数学关系
计算矩阵的高次幂
117. 填充每个节点的下一个右侧节点指针 II
他弄了一个遍历循环
每次节点导出后 该节点会取出， 后面都是子节点
然后都是子节点， 个数为n
Node* connect(Node* root) {
Node* p;
//若树为空，则直接返回树的根结点
if(root==NULL) return root;
queue<Node*> q;
q.push(root);
while(!q.empty()){
//这里的len即某一层的结点总数
int len=q.size();
Node* pre=NULL;
//遍历该层结点
for(int i=0;i<len;i++){
//取队头结点并弹出它
p=q.front();
q.pop();
if(pre) pre->next=p;
pre=p;
if(p->left) q.push(p->left);
if(p->right) q.push(p->right);
}
}
return root;
}
面试题 17.12. BiNode
我们再来复习一下递归的三要素，返回值，终止条件，单层遍历逻辑。
inorder 返回顺序是从小到大
反inorder是从大到小
递归，
首先是判断是否为空指针
然后先 遍历右子树，
右子树找到了 然后最大值找到了，
他把这个最大值的节点 右边给到空，
他自己更新给历史节点
然后遍历左节点
给空
class Solution {
public:
TreeNode* preNode;
TreeNode* convertBiNode(TreeNode* root) {
reverseInorder(root);
return preNode;
}
void reverseInorder(TreeNode* root){
if(root == nullptr) return;
reverseInorder(root->right);
root->right = preNode;
preNode = root;
reverseInorder(root->left);
root->left = nullptr;
return;
}
};
作者：switchplus
链接：https://leetcode.cn/problems/binode-lcci/solution/by-switchplus-80l2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
1248. 统计「优美子数组」
我的答案仅仅只是加
应该考虑左右边界数量的乘
int numberOfSubarrays(vector<int>& nums, int k) {
int ans;
vector<int> odds;
//int right,left;
for(int i=0; i <nums.size();i++)
{
if(nums[i]%2)
odds.push_back(i);
}
if(odds.size()<k)
return 0;
ans+=odds[0]+1;
ans+=(odds[k]-odds[k-1]-1);
ans+=(odds[odds.size()-k]-odds[odds.size()-k-1]);
ans+=(nums.size()-1-odds[odds.size()-1]);
for(int i=1; i<odds.size()-k; i++)
{
ans+=(odds[i]-odds[i-1]);
ans+=(odds[i+k]-odds[i+k-1]-1);
}
return ans;
}
int numberOfSubarrays(vector<int>& nums, int k) {
int n = (int)nums.size();
int odd[n + 2], ans = 0, cnt = 0;
for (int i = 0; i < n; ++i) {
if (nums[i] & 1) odd[++cnt] = i;
}
odd[0] = -1, odd[++cnt] = n;
for (int i = 1; i + k <= cnt; ++i) {
ans += (odd[i] - odd[i - 1]) * (odd[i + k] - odd[i + k - 1]);
}
return ans;
}
作者：LeetCode-Solution
链接：https://leetcode.cn/problems/count-number-of-nice-subarrays/solution/tong-ji-you-mei-zi-shu-zu-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
方法2 前缀和差分
// 遍历原数组，计算当前的前缀和，统计到 prefixCnt 数组中，
// 并且在 res 中累加上与当前前缀和差值为 k 的前缀和的个数。
int numberOfSubarrays(vector<int>& nums, int k) {
vector<int> v(nums.size()+1);
int pre = 0;
v[0] = 1;
int res = 0;
for(auto x:nums){
pre += x & 1;
v[pre]++;
if(pre >= k) res += v[pre-k];
}
return res;
}
};
pre变量 记录遍历到 x 时，前面的奇数个数，v[pre]表示前缀奇数个数为pre的位置个数。这样的话遍历到x，很容易就找到了前缀奇数为pre-k个 的位置个数
int numberOfSubarrays(vector<int>& nums, int k) {
// 奇数为1, 偶数为0, 子区间和为k的种类数
int len = nums.size();
for (int i=0; i<len; i++) {
if (nums[i] & 1) nums[i] = 1;
else nums[i] = 0;
}
unordered_map<long long, int> mp;
long long sum = 0;
mp[0] = 1;
int res = 0;
for (int i=1; i<=len; i++) {
sum += nums[i-1];
// sum - k = x
res += mp[sum - k];
mp[sum] ++;
}
return res;
}
};
707设计链表
class MyLinkedList {
public:
struct node
{
int val;
node* next;
node(int val):val(val),next(nullptr){}
node(int val, node* node1):val(val),next(node1){}
};
public:
node* n;
MyLinkedList() {
n = new node(0);
}
int get(int index) {
node* n1;
n1=n;
while(index>0)
{
n1 = n1->next;
index--;
}
return n1->val;
}
void addAtHead(int val) {
node* n1 = new node(0);
n1->next=n;
n1->val= val;
n=n1;
}
void addAtTail(int val) {
node* n1 = new node(0);
n1=n;
while(n1->next!=nullptr)
{
n1 = n1->next;
}
n1->val = val;
n1->next = nullptr;
}
void addAtIndex(int index, int val) {
node* n1;
n1=n;
node* pre;
while(index>0)
{
pre = n1;
n1= n1->next;
index--;
}
node* n2 = new node(0);
n2->val = val;
n2->next = pre->next;
pre->next = n2;
}
void deleteAtIndex(int index) {
node* n1;
n1=n;
node* pre;
while(index>0)
{
pre = n1;
n1= n1->next;
index--;
}
pre->next = n1->next;
}
};
/**
* Your MyLinkedList object will be instantiated and called as such:
* MyLinkedList* obj = new MyLinkedList();
* int param_1 = obj->get(index);
* obj->addAtHead(val);
* obj->addAtTail(val);
* obj->addAtIndex(index,val);
* obj->deleteAtIndex(index);
*/
class MyLinkedList {
public:
MyLinkedList() {
this->size = 0;
this->head = new ListNode(0);
}
int get(int index) {
if (index < 0 || index >= size) {
return -1;
}
ListNode *cur = head;
for (int i = 0; i <= index; i++) {
cur = cur->next;
}
return cur->val;
}
void addAtHead(int val) {
addAtIndex(0, val);
}
void addAtTail(int val) {
addAtIndex(size, val);
}
void addAtIndex(int index, int val) {
if (index > size) {
return;
}
index = max(0, index);
size++;
ListNode *pred = head;
for (int i = 0; i < index; i++) {
pred = pred->next;
}
ListNode *toAdd = new ListNode(val);
toAdd->next = pred->next;
pred->next = toAdd;
}
void deleteAtIndex(int index) {
if (index < 0 || index >= size) {
return;
}
size--;
ListNode *pred = head;
for (int i = 0; i < index; i++) {
pred = pred->next;
}
ListNode *p = pred->next;
pred->next = pred->next->next;
delete p;
}
private:
int size;
ListNode *head;
};
作者：LeetCode-Solution
链接：https://leetcode.cn/problems/design-linked-list/solution/she-ji-lian-biao-by-leetcode-solution-abix/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
836 矩形重叠
降维操作
面积重叠 降维 看成 长度 距离上的重叠
面试题面试题 10.02. 变位词组
如果字母都相同 字符串字母排序后都是一样的
以排序的为键 输入键值对
正常 的话
哈希
一种取巧的哈希方法
https://leetcode.cn/problems/group-anagrams-lcci/solution/bian-wei-ci-zu-by-leetcode-solution-g2a8/
哈希表的键 为 字符 以及出现次数
哈希表的值 为对应 字符串列表
如何将哈希表的中 字符以及出现次数作为键
unordered_map<array<int, 26>, vector<string>, ArrayHash> map;
struct ArrayHash {
constexpr size_t operator()(array<int, 26> const& arr) const {
string_view s((char const*)arr.data(), 26 * sizeof(int));
return hash<string_view>{}(s);
}
};
1339. 分裂二叉树的最大乘积
一元二次函数求最值问题
分割时不能从上往下 得从下往上 然后分段
int sum=0;
int best= 0;
void dfs(tree node *root)
{
if(!root)
return;
sum+=root->val;
dfs(root->left);
dfs(root->right);
//sum+=root->val;
}
int dfs2(treenode *node)
{
if(!node)
return 0;
int cur = dfs2(node->left) + dfs2(node->right) + node->val;
if(abs(cur*2-sum)<abs(best*2-sum))
best = cur;
return cur;
}
int maxproduct(treenode* root)
{
dfs(root);
dfs2(root);
return (long long) best*(sum - best)%10000007;
}
1111. 有效括号的嵌套深度
LCP 55. 采集果实
class Solution {
public:
int getMinimumTime(vector<int>& time, vector<vector<int>>& fruits, int limit) {
int time1 =0;
for(int i=0; i< fruits.size(); i++)
{
int ci = fruits[i][1]%limit? fruits[i][1]/limit +1:fruits[i][1]/limit ;
time1+=ci*time[fruits[i][0]];
}
return time1;
}
};
2438. 二的幂数组中查询范围内的乘积
class Solution {
public:
vector<int> two(int &n)
{
vector<int> ans;
int i=0;
while(n>0)
{
if(n&1)
{
ans.push_back(1 << i);
}
n >>= 1;
i++;
}
//reverse(ans.begin(),ans.end());
return ans;
}
vector<int> productQueries(int n, vector<vector<int>>& queries) {
vector<int> power= two(n),ans;
for(int i=0;i<queries.size();i++)
{
int j = queries[i][0];
long tem = 1;
while(j<=queries[i][1])
{
tem = tem*power[j] - tem*power[j] /1000000007 * 1000000007;
j++; // tem = tem*power[j]%1000000007;
}
ans.push_back(tem%1000000007);
tem = 1;
}
return ans;
}
};
返回最小数目的2的幂
Here’s an implementation of a function that returns the least number of integers that are powers of 2 and whose sum is equal to a given number n:
#include 2043. 简易银行系统
class Bank {
public:
Bank(vector<long long>& balance) {
this->money = balance;
this->numb =balance.size();
}
bool transfer(int account1, int account2, long long money) {
if(numb-account1<0 || numb-account2<0 || this->money[account1-1]<money)
return false;
this->money[account1-1]-=money;
this->money[account2-1]+=money;
return true;
}
bool deposit(int account, long long money) {
if(numb-account<0)
return false;
this->money[account-1]+=money;
return true;
}
bool withdraw(int account, long long money) {
if(numb-account<0|| this->money[account-1]<money)
return false;
this->money[account-1]-=money;
return true;
}
public:
vector<long long> money;
int numb;
};
1702. 修改后的最大二进制字符串
智力题，10->01，可以将1移动至最右边，左边都为0，00->10，可以把最后一位变为0，其余位为1，若字符串都为1，则最大；若只有一个0，则不作变换；其他情况可以把字符串变为只有一个0的情况
使用begin标记第一个0出现的位置
使用count记录共有多少个0出现
若count <2，则不做变换
若count>=2，则使用1赋值res[n]，然后将res[begin + count - 1]置为0，即将0最后右移至此位置了
class Solution {
public String maximumBinaryString(String binary) {
int n = binary.length();
int begin = (int)1e6, count = 0;
for(int i = 0; i < n; i++) {
if(binary.charAt(i) == '0') {
count++;
begin = Math.min(begin, i);
}
}
if(count < 2) return binary;
char[] res = new char[n];
Arrays.fill(res, '1');
res[begin + count - 1] = '0';
return new String(res);
}
1816. 截断句子
遍历字符串 遇到空格就减1，直到等于0 退出循环
1021. 删除最外层的括号
left和right可以用同一个 一个+ 一个-
string removeOuterParentheses(string s) {
int left=0,right=0;
string ans;
string cur;
for(char c: s)
{
if(c=='(')
{left++;
cur+=c;
}
if(c==')')
{right++;
cur+=c;
}
if(right == left)
{
right=0;
left=0;
ans+=cur.substr(1,cur.length()-2);
cur = "";
}
}
return ans;
}
};
https://leetcode.cn/problems/remove-outermost-parentheses/solution/shan-chu-zui-wai-ceng-de-gua-hao-by-leet-sux0/
1361. 验证二叉树
剑指 Offer II 001. 整数除法
INT_MAX和INT_MIN
左移一位相当于乘2
右移一位相当于除2
错误代码 还需修改
int divide(int a, int b) {
long num1=1;
long num2=0;
//long b1=b;
bool cal = false;
if(a<0&&b>0)
{
cal = true;
a*=-1;
}
if(a>0&&b<0)
{
cal = true;
b*=-1;
}
long b1=b;
long a1=a;
//if(b==1)
if(a<0&&b<0)
{
long a1=-a;
b=-b;
}
if(a<b)
{
return 0;
}
if(a==b)
{
if(cal==true)
return -1;
else
return 1;
}
if(b1==1)
{
if(cal==true)
return -a;
else
return a;
}
while(a>=b)
{
a-=b1;
num2+=num1;
if(a>b1)
{num1<<=1;
b1<<=1;
}
if(a<0)
{
a+=b1;
num2-=num1;
num1=1;
b1=b;
}
}
num2 = cal? -num2:num2;
if(num2<INT_MIN || num2>INT_MAX)
num2=INT_MAX;
return (int)num2;
}
思路 当被除数 为 负的2的31次方
除数为1 可以输出 为-1的话 就会产生正的数 导致溢出
除数为 负的2的31次方
被除数和除数都是正的反而会有有溢出
都是负的反而没
2135. 统计追加字母可以获得的单词数
172 阶乘后的零
因子10的个数。每有一个2和5的因子的 就多一个0， 转换为求因子2和5的个数
25提供了 两个5的因子 加上前面的4个 就是 6个
int count = 0;
while(n/5!=0){
count+=n/5;
n/=5;
}
class Solution {
public:
int trailingZeroes(int n) {
long sum=1;
int ten=1;
int ans=0;
if(n<5)
return 0;
if(n>=5 && n<10)
return 1;
while(n>=ten)
{
sum*=ten;
if(ten%5==0){
while(sum%10 == 0)
{
ans++;
sum/=10;
}
}
ten++;
sum%=100000;
}
return ans;
}
};
56. 合并区间
如果是 按照区间结束点进行排序的话，情况更为复杂
如果是按照区间开始点进行排序的话，情况稍微简单一些。
sort 排序默认 会按第一个元素的值排序
class Solution {
public:
vector<vector<int>> merge(vector<vector<int>>& intervals) {
vector<vector<int>> ans;
sort(intervals.begin(),intervals.end());
for(int i=0 ; i<intervals.size();)
{
int end1 = intervals[i][1];
int j = i+1;
while(j<intervals.size() && intervals[j][0]<=end1)
{
end1 = max(end1,intervals[j][1]);
j++;
}
ans.push_back({intervals[i][0],end1});
i=j;
}
return ans;
}
};
vector<vector<int>> merge(vector<vector<int>>& intervals) {
vector<vector<int>> ans;
sort(intervals.begin(),intervals.end(),[r=intervals.data()](int a,int b){return r[a][1]<r[b][1];});
ans.push_back(intervals[0]);
for(int i =1; i< intervals.size(); i++)
{
if(intervals[i][0]>ans[ans.size()-1][1])
{
ans.push_back(intervals[i]);
continue;
}
if(intervals[i][0] <=ans[0][1])
{
ans = {};
ans.push_back({min(intervals[i][0],ans[0][0]),intervals[i][1]});
continue;
}
for(int j =0; j<ans.size();j++)
{
if(intervals[i][0]>ans[j][1])
}
intervals[i]
}
return ans;
}
2575. 找出字符串的可整除数组
class Solution {
public:
vector<int> divisibilityArray(string word, int m) {
long an=0;
int tem=0;
vector<int> ans;
for(char c: word)
{
//an= an*10 + c-'0';
an = (an*10 + c-'0')%m;
if(an ==0 )
{
ans.push_back(1);
//an=0;
}
else
{
ans.push_back(0);
//an =tem;
}
}
return ans;
}
};
1410. HTML 实体解析器
class Solution {
public:
string entityParser(string text) {
string ans;
string cur="&";
unordered_map<string, char> hash= {
{""", '\"'},
{"'", '\''},
{"&", '&'},
{">", '>'},
{"<", '<'},
{"⁄", '/'}
};
for(int i=0; i<text.length(); i++)
{
if(text[i]=='&' &&(text[i+1]=='q'||text[i+1]=='a'||text[i+1]=='g'||text[i+1]=='l'
||text[i+1]=='f'))
{
for(int j=1 ; j<7; j++)
{
if(text[i+j]!=';')
{
cur+=text[i+j];
}
else
{
cur+= text[i+j];
if(hash.find(cur)!=hash.end())
{
ans+=hash[cur];
i=i+j; // 上面有 i++ 整个程序执行完会i++ 这里就不需要 i+j+1 了
cur="&";
break;
}
}
}
if(cur!="&")
{ans+=text[i];
cur="&";
}
}
else
ans+=text[i];
}
return ans;
}
};
2135 追加字母
都超出时间限制
用一个26位的二进制整数维护每个单词含有哪些字母
或者
利用位运算
https://leetcode.cn/problems/count-words-obtained-after-adding-a-letter/solution/tong-ji-zhui-jia-zi-mu-ke-yi-huo-de-de-d-9ivl/
class Solution {
public:
int wordCount(vector<string>& startWords, vector<string>& targetWords) {
set<char> s1;
set<char> s2;
set<char> s3;
int ans=0;
for(int i=0;i<targetWords.size(); i++)
{
for(char c: targetWords[i])
{
s1.insert(c);
}
for(int j=0; j<startWords.size(); j++)
{
for(char c: startWords[j])
{
s2.insert(c);
}
set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),inserter(s3,s3.begin()));
if(s3.size()>1||s3.size()==0)
{
s3={};
s2={};
continue;
}
if(s3.size()==1)
{
s3={};
set_difference(s2.begin(),s2.end(),s1.begin(),s1.end(),inserter(s3,s3.begin()));
if(s3.size()==0)
{ans++;
s2={};
break;
}
else
{
s3={};
s2={};
}
}
// s1={};
}
s1={};
}
return ans;
}
};
class Solution {
public:
int wordCount(vector<string>& startWords, vector<string>& targetWords) {
set<char> s1;
vector<set<char>> s2;
s2.resize(startWords.size());
for(int i=0; i<startWords.size(); i++)
{
for(char c:startWords[i])
{
s2[i].insert(c);
}
}
set<char> s3;
int ans=0;
for(int i=0;i<targetWords.size(); i++)
{
for(char c: targetWords[i])
{
s1.insert(c);
}
for(int j=0; j<s2.size();j++)
{
if(s1.size()-1 == s2[j].size())
{
set_difference(s1.begin(),s1.end(),s2[j].begin(),s2[j].end(),inserter(s3,s3.begin()));
if(s3.size()==1)
{
ans++;
break;
}
s3={};
}
}
s1={};
s3={};
}
return ans;
}
};
// 1. 前期铺垫：
// 因为字符数组中的任一字符串中的每个字母最多出现一次
// 所以我们可以取字符串中每一个字符用其 ascii码 - 'a' 进行左移位运算最终得到结果 mask , 不同的字符将体现在 mask 的不同二进制位上。
// 如果要去掉想去掉某个字符, 只需要用该字符 ascii - 'a' 进行左移位运算得到的结果再与该字符串的 mask 进行异或运算, 那么代表该字符的位就被
// 置为 0, 剩下的结果就相当于是取掉该字符后得到的 mask。
// 2. 算法：
// 1) 计算出 startWords 里每一个字符串 startWords[i] 的 mask, 并存入 HashSet。
// 2) 先计算出 targetWords 里面一个字符串 targetWords[i] 的 mask。
// 3) 再遍历 targetWords[i] 的每一个字符 ch, 尝试用该字符的 mask 异或 1 << (ch - 'a'), 去掉 ch 字符代表的那一个二进位位
// 4) 如果 HashSet 中包含该字符串, 表示当前字符串 targetWords[i] 可以被转换, 那么记录结果的变量 res++, 并且无需对该字符继续进判断,
// 跳出循环对下一个字符串进行相同的操作。
// 5) 返回 res。
class Solution {
public:
int wordCount(vector<string> &startWords, vector<string> &targetWords) {
unordered_set<int> s;
for (string &word : startWords) {
int mask = 0;
for (char ch : word) {
mask |= 1 << (ch - 'a');
}
s.insert(mask);
}
给每个字符串设置 标识 mask
int ans = 0;
for (string &word : targetWords) {
int mask = 0;
for (char ch : word) {
mask |= 1 << (ch - 'a');
} 给每个字符串计算标识
for (char ch : word) {
if (s.count(mask ^ (1 << (ch - 'a')))) { // 去掉这个字符 异或运算
++ans;
break; 去掉一个字母的标识 给到 查找 如果有的话 ans++
}
}
}
return ans;
}
};
作者：endlesscheng
链接：https://leetcode.cn/problems/count-words-obtained-after-adding-a-letter/solution/ni-xiang-si-wei-wei-yun-suan-ha-xi-biao-l4153/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
两次都超出时间限制
938. 二叉搜索树的范围和
class Solution {
public:
int ans;
int low1;
int high1;
void treee(TreeNode* root)
{
if(root == nullptr)
return;
int val1= root->val;
if(val1>=low1 && val1<=high1)
{
ans+=val1;
}
treee(root->left);
treee(root->right);
}
int rangeSumBST(TreeNode* root, int low, int high) {
ans=0;
low1=low;
high1= high;
treee(root);
return ans;
}
};
LCP 12. 小张刷题计划
找出满足划分条件的 t
t为每份元素之和最大值
要让t最小。
是否可以让每组删除最大值之后，总和都小于等于t
右移一位 的作用等效于除2
二分法找出这个值
当左始终小于右时持续执行循环
他这个值能不能把所有的数都分进去
1：左闭右闭区间退出循环条件：当 (right > left) 或是(left = right+1)时退出循环即程序运行条件为 while(left <= right)。
2：左闭右开区间则是当 right = nums.length时，（right = left)时退出循环，程序运行条件为 while( left < right)。
6和7 除2结果为6。
如果说6可以分，那么上界变小 7变为6。此时两个6
如果6不可以分，6加1的话变为7。此时两个7
如果判断条件为 l < r 那么 退出循环 返回
66. 加一
不知道为什么 循环中 放入 digits.size（） 他会 持续执行；
digit.size（） 返回的不是一个int
在digit.size()-i ==0 的时候 他会后面一直都是0 ，不会变为负数，从而导致循环一直执行。
vector 的size函数返回vector大小，返回值类型为size_type，Member type size_type is an unsigned integral type，即无符号整数；
vector A;
A.size()-1因为size返回值是无符号类型所以 A.size()-1越界，是个很大的数
所以要用的时候
要么预先定义一个 int n = A.size() - 1;
或者int(A.size() - 1)或者int(A.size()) - 1
或者static_cast(A.size())
这里问了chatgpt 可以
You are correct. The condition (digits.size()-i)>=0 can be simplified
to i<=digits.size(). This is because the value of digits.size()-i will
always be greater than or equal to 0 as long as i is less than or
equal to digits.size().Therefore, the loop will iterate through all the elements in the
vector digits without any index out of bounds errors. Thank you for
pointing that out.
vector<int> plusOne(vector<int>& digits) {
int a = digits.size();
for(int i=a-1; i>=0;i--)
{
if(digits[i]!=9)
{
digits[i]+=1;
return digits;
}
else
digits[i] = 0;
}
if(digits[0]==0)
digits.insert(digits.begin(),1);
return digits;
}
class Solution {
public:
vector<int> plusOne(vector<int>& digits) {
if(digits[digits.size()-1]<9)
{digits[digits.size()-1]+=1;
return digits;
}
int a = digits.size();
for(int i=1;(a-i)>=0;i++)
{
if(digits[digits.size()-i]==9)
{
digits[digits.size()-i]=0;
}
else
{
digits[digits.size()-i]+=1;
break;
}
}
if(digits[0]==0)
{
digits.insert(digits.begin(),1);
}
return digits;
}
};
2245. 转角路径的乘积中最多能有几个尾随零
2285. 道路的最大总重要性
就是算每条路的度数
我想的复杂了 你的路度数已经出来了，可以直接拿度数 乘 他的 重要性。
不必要构造 节点名，度数，节点排名 这么长的数据类型。
class Solution {
public:
long long maximumImportance(int n, vector<vector<int>>& roads) {
long long ans=0;
vector<int> num(n,0);
for(vector<int>&road:roads)
{
num[road[0]]++;
num[road[1]]++;
}
sort(num.begin(),num.end());
int idx = 1;
for(int &n:num )
{
ans+=(long long)n*idx;
idx++;
}
return ans;
}
};
1461
判断哈希集合中是否有 那么多项目
bool hasAllCodes(string s, int k) {
int len = s.length();
if(len<2*k+k-1) return false;
unordered_set<string> hash;
for(int i =0; i+k<=len;i++)
{
hash.insert(move(s.substr(i,k)));
}
return hash.size() == 1<<k;
// set
}
面试题 04.04. 检查平衡性
1162. 地图分析
BFS
多源BFS
每个海洋到最近的陆地，然后在里面的找距离最大的
正难则反
从海洋找陆地，需要记录所有海洋的最近陆地值，然后取最大的一个，这样的思路不够简洁，不如从陆地找海洋，从所有陆地同时出发，向四周的海洋做一次标记（或填海造陆），并将当前位置作为下一层内容等待出发，直到所有海洋都被标记完了，返回层数即最大的最近陆地距离
作者：demouo
链接：https://leetcode.cn/problems/as-far-from-land-as-possible/solution/pu-tong-ren-bao-kan-dong-de-jian-dan-dai-tnzk/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
class Solution {
public:
static constexpr int MAX_N = 100 + 5;
static constexpr int INF = int(1E6);
static constexpr int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
int n;
int d[MAX_N][MAX_N];
struct Coordinate {
int x, y;
};
queue <Coordinate> q;
bool inq[MAX_N][MAX_N];
int maxDistance(vector<vector<int>>& grid) {
this->n = grid.size();
auto &a = grid;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
d[i][j] = INF;
}
} 给到所有距离一个极大值
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (a[i][j]) { 0为海洋 1为陆地 他这里是吧所有的陆地得到
d[i][j] = 0;
q.push({i, j});
inq[i][j] = 1; 布偶值设置为1
}
}
} 将所有的陆地点进行设置并加入
while (!q.empty()) {
auto f = q.front(); q.pop(); inq[f.x][f.y] = 0;
for (int i = 0; i < 4; ++i) {
int nx = f.x + dx[i], ny = f.y + dy[i]; 得到新位置坐标
if (!(nx >= 0 && nx <= n - 1 && ny >= 0 && ny <= n - 1)) {
continue;
} 如果坐标越界就不行
if (d[nx][ny] > d[f.x][f.y] + 1) { 新位置的距离是否被更新，理论上等于当前位置+1
d[nx][ny] = d[f.x][f.y] + 1; 更新新位置的距离
if (!inq[nx][ny]) { 还得看这个点是不是海洋 0的话是海洋，往下执行
q.push({nx, ny}); 队列中加入当前坐标，他是海洋才加入队列，他要找最远的海洋，所
以下一块是陆地就说明这个坐标不需要继续，是海洋的话还需要继续找
inq[nx][ny] = 1; 将海洋的布偶值设置为1，相当于海洋也变成陆地了
}
}
}
}
int ans = -1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (!a[i][j]) { a就是grid，遍历grid，如果当前坐标是海洋，就看距离坐标中的距离判断
ans = max(ans, d[i][j]); 他是从陆地到海洋，这里遍历到海洋说明这个距离肯定是有效的。
}
}
}
return (ans == INF) ? -1 : ans;
}
};
作者：LeetCode-Solution
链接：https://leetcode.cn/problems/as-far-from-land-as-possible/solution/di-tu-fen-xi-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
1943
一排数字，删除一个数字，使得连续1的数量最大的一组
class Solution {
public:
int longestSubarray(vector<int>& nums) {
int ans;
int n = nums.size();
vector<int> num1;
int beg = 0;
int max1 = 0;
for(int i=0; i<n;i++)
{
if(nums[i] ==1)
{beg++;
if(i == n-1)
{
num1.push_back(beg);
}
}
else
{
if(beg !=0)
{
num1.push_back(beg);
}
beg = 0;
num1.push_back(beg);
}
}
if(num1.size()==1)
{
return --num1[0];
}
for(int i =0; i<num1.size(); i++)
{
if(num1[i]!=0)
{
max1 = max(num1[i],max1);
if(i+2<num1.size() && num1[i+2]!=0)
{
max1 = max(max1, (num1[i]+num1[i+2]));
}
}
}
return max1;
}
};