lc128
o(n）不排序 hash空间换时间 贪心的写
class Solution {
public:
int longestConsecutive(vector<int>& nums) {
unordered_set<int> st(nums.begin(), nums.end());
int ans = 0;
for (int x : st) {
++if (st.contains(x - 1))++
++continue;++
// x 是序列的起点
int y = x + 1;
++while (st.contains(y))++
++y++;++
// y-1 是最后一个在哈希集合中的数
ans = max(ans, y - x);
// 从 x 到 y-1 一共 y-x 个数
}
return ans;
}
};
lc2943
排序后遍历计算横竖杆的最大连续长度，取两者min+1作为ret正方形的边长
++if (ai == ai-1 + 1) cl++;
else cl = 1;
ml = max(ml, cl);++
class Solution {
public:
int maximizeSquareHoleArea(int n, int m, vector<int>& hBars, vector<int>& vBars)
{
auto f = \[\](vector<int>& a) -> int {
if (a.empty()) return 0;
int ml = 1, cl = 1;
for (int i = 1; i < a.size(); ++i) {
++if (ai == ai-1 + 1) cl++;
else cl = 1;
ml = max(ml, cl);++
}
return ml;
};
sort(hBars.begin(), hBars.end());
sort(vBars.begin(), vBars.end());
int hm = f(hBars);
int vm = f(vBars);
int e = min(hm, vm);
return (e + 1) * (e + 1);
}
};
优化
class Solution {
// 128. 最长连续序列
int longestConsecutive(vector<int>& nums) {
unordered_set<int> st(nums.begin(), nums.end());
int ans = 0;
for (int x : st) { // 遍历哈希集合
++if (st.contains(x - 1))++
++continue;++
// x 是序列的起点
int y = x + 1;
while (st.contains(y))
y++;
// y-1 是最后一个在哈希集合中的数
ans = max(ans, y - x); // 从 x 到 y-1 一共 y-x 个数
}
return ans;
}
public:
int maximizeSquareHoleArea(int, int, vector<int>& hBars, vector<int>& vBars) {
++int side = min(longestConsecutive(hBars), longestConsecutive(vBars)) + 1;++
return side * side;
}
};
discussion发现的圣经
反复诵读TvT
"每个变量、每个逻辑分支对内完成的是什么功能、对外在整体程序中扮演的角色是什么"
"对待游戏一样享受这个过程"
lc2385
dfs不建图
利用负数，一次遍历
class Solution {
int ans = 0, start;
int dfs(TreeNode* node) {
if (node == nullptr) {
return 0;
}
int l_len = dfs(node->left);
int r_len = dfs(node->right);
if (node->val == start) {
// 计算子树 start 的最大深度
ans = -min(l_len, r_len); // 负负得正
return 1; // 用正数表示找到了 start
}
if (l_len > 0 || r_len > 0) {
// 只有在左子树或右子树包含 start 时，才能更新答案
ans = max(ans, abs(l_len) + abs(r_len)); // 两条链拼成直径
return max(l_len, r_len) + 1; // max 会自动取到正数
}
return min(l_len, r_len) - 1; // 用负数表示没有找到 start
}
public:
int amountOfTime(TreeNode* root, int start) {
this->start = start;
dfs(root);
return ans;
}
};
bfs建图
一次bfs建表
一次bfs找最远层数
class Solution {
public:
int amountOfTime(TreeNode* root, int start) {
unordered_map<TreeNode*, TreeNode*> p;
TreeNode* s = nullptr;
queue<TreeNode*> q;
q.push(root);
proot = nullptr;
while (!q.empty()) {
auto t = q.front();
q.pop();
if (t->val == start) s = t;
if (t->left) {
pt-\>left = t;
q.push(t->left);
}
if (t->right) {
pt-\>right = t;
q.push(t->right);
}
}
unordered_map<TreeNode*, bool> v;
q.push(s);
vs = true;
int res = -1;
while (!q.empty()) {
int sz = q.size();
res++;
while (sz--) {
auto t = q.front();
q.pop();
if (t->left && !vt-\>left) {
vt-\>left = true;
q.push(t->left);
}
if (t->right && !vt-\>right) {
vt-\>right = true;
q.push(t->right);
}
if (pt && !vp\[t]) {
vp\[t] = true;
q.push(pt);
}
}
}
return res;
}
};
dfs建图+bfs
class Solution {
public:
int amountOfTime(TreeNode* root, int start) {
unordered_map<int, vector<int>> g;
function<void(TreeNode*)> dfs = \& (TreeNode *root) {
if (root == nullptr || root->left == root->right)
return;
if (root->left) {
int u = root->val, v = root->left->val;
gu.emplace_back(v);
gv.emplace_back(u);
}
if (root->right) {
int u = root->val, v = root->right->val;
gu.emplace_back(v);
gv.emplace_back(u);
}
dfs(root->left);
dfs(root->right);
};
dfs(root);
int time = -1;
queue<int> q;
q.push(start);
unordered_set<int> visited{start};
while (!q.empty()) {
time++;
int len = q.size();
while (len--) {
int cur = q.front();
q.pop();
for (int nei : gcur) {
if (visited.find(nei) != visited.end()) {
continue;
}
q.push(nei);
visited.insert(nei);
}
}
}
return time;
}
};