LeetCode 2024/7 每日一题 合集
2024-7-1 2065. 最大化一张图中的路径价值
分析
注意观察到至多走十条边，因此直接爆搜即可。
代码实现
class Solution {
public:
int maximalPathQuality(vector<int>& values, vector<vector<int>>& edges, int maxTime) {
int n = size(values), m = size(edges);
std::vector<std::vector<std::pair<int, int>>> g(n);
for (auto &edge : edges) {
int u = edge[0], v = edge[1], w = edge[2];
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
}
std::vector<bool> vis(n);
vis[0] = true;
int ans = 0;
auto dfs = [&](auto &&self, int u, int times, int cost)->void {
if (u == 0) {
ans = std::max(ans, cost);
}
for (auto [v, w] : g[u]) if (times + w <= maxTime) {
if (!vis[v]) {
vis[v] = true;
self(self, v, times + w, cost + values[v]);
vis[v] = false;
} else {
self(self, v, times + w, cost);
}
}
};
dfs(dfs, 0, 0, values[0]);
return ans;
}
};
2024-7-2 3115. 质数的最大距离
代码实现
std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
namespace Factorizer {
std::vector<int> primes;
std::vector<int> least;
void sieve(int n) {
std::vector<int> nums;
least.assign(n + 1, 0);
for (int i = 2; i <= n; ++i) {
if (least[i] == 0) {
least[i] = i;
nums.push_back(i);
}
int now = 0;
while (now < (int)nums.size()
&& nums[now] <= least[i] && i * nums[now] <= n) {
least[i * nums[now]] = nums[now];
now += 1;
}
}
primes = nums;
}
constexpr bool miller_rabin(long long n) {
if (n <= 1 || (n != 2 && n % 2 == 0)) return false;
for (auto a : {3, 5, 7, 11, 13, 17, 19, 23, 29}) {
if (n % a == 0) return n == a;
}
if (n < 31 * 31) return true;
long long d = n - 1;
while (d % 2 == 0) d /= 2;
constexpr long long bases[] = {
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37
};
for (long long a : bases) {
if (n == a) return true;
long long t = d;
long long y = 1 % n;
for (long long _t = t; _t != 0; _t >>= 1) {
if (_t & 1) y = (__int128) y * a % n;
a = (__int128) a * a % n;
}
while (t != n - 1 && y != 1 && y != n - 1) {
y = (__int128) y * y % n;
t <<= 1;
}
if (y != n - 1 && t % 2 == 0) return false;
}
return true;
}
long long pollard_rho(long long n) {
if (n == 1 || miller_rabin(n)) return n;
long long now = 0;
do {
long long t = std::gcd(++now, n), r = t;
if (t != 1 && t != n) return t;
long long g = 1;
do {
t = ((__int128) t * t % n + now) % n;
r = ((__int128) r * r % n + now) % n;
r = ((__int128) r * r % n + now) % n;
} while ((g = std::gcd(abs(t - r), n)) == 1);
if (g != n) return g;
} while (now < n / now);
return 0;
}
std::vector<long long> factor(long long n) {
if (n == 1) return {};
std::vector<long long> g, d;
d.push_back(n);
while (!d.empty()) {
auto v = d.back();
d.pop_back();
auto rho = pollard_rho(v);
if (rho == v) {
g.push_back(rho);
} else {
d.push_back(rho);
d.push_back(v / rho);
}
}
std::sort(g.begin(), g.end());
return g;
}
}
class Solution {
public:
int maximumPrimeDifference(vector<int>& nums) {
int n = size(nums);
int l = 0, r = n - 1;
while (Factorizer::factor(nums[l]).size() != 1 || nums[l] == 1) {
l += 1;
}
while (Factorizer::factor(nums[r]).size() != 1 || nums[r] == 1) {
r -= 1;
}
return r - l;
}
};
2024-7-3 3099. 哈沙德数
代码实现
class Solution {
public:
int sumOfTheDigitsOfHarshadNumber(int x) {
int ans = 0, y = x;
while (x) {
ans += x % 10;
x /= 10;
}
return y % ans ? -1 : ans;
}
};
2024-7-4 3086. 拾起 K 个 1 需要的最少行动次数
分析
（难度在于读题的题目）贪心+枚举，可以发现如果先执行操作1再执行操作2，一定可以得到一个k并且如果此时选择的位置为1，可以直接用代价1收集到1，因此可以对于maxChanges >= k - c的情况可以直接特判，最后只要枚举一下在所有位置的aliceIndex的代价即可，用双指针维护。
代码实现
class Solution {
public:
long long minimumMoves(vector<int>& nums, int k, int maxChanges) {
int n = size(nums);
std::vector<int> pos;
for (int i = 0; i < n; ++i) if (nums[i]) {
pos.emplace_back(i);
}
int maxl = 0;
for (int i = 0; i < (int)size(pos); ++i) {
int len = 1;
while (i + 1 < (int)size(pos) && pos[i + 1] - pos[i] == 1) {
i += 1, len += 1;
}
maxl = std::max(maxl, len);
}
int c = std::min(3, maxl);
if (size(pos) == 0) {
return k * 2;
} else if (k <= c) {
return k - 1;
} else if (c + maxChanges >= k) {
return c - 1 + (k - c) * 2;
} else {
k -= maxChanges;
std::vector<int> pre(n + 1);
for (int i = 0; i < n; ++i) {
pre[i + 1] = pre[i] + nums[i];
}
long long ans = 0;
for (int i = 1; i < k; ++i) {
ans += pos[i] - pos[0];
}
int l = 0, r = k - 1;
long long last = ans;
for (int i = pos[0] + 1; i < n; ++i) {
long long sum = last;
sum += (long long)(pre[i] - pre[pos[l]]) - (pre[pos[r] + 1] - pre[i]);
while (r + 1 < size(pos) && i - pos[l] >= pos[r + 1] - i) {
sum = sum - (i - pos[l]) + (pos[r + 1] - i);
l += 1, r += 1;
}
ans = std::min(ans, sum);
last = sum;
}
return ans + 2 * maxChanges;
}
}
};
2024-7-5 3033. 修改矩阵
代码实现
class Solution {
public:
vector<vector<int>> modifiedMatrix(vector<vector<int>>& matrix) {
int n = size(matrix), m = size(matrix[0]);
for (int i = 0; i < m; ++i) {
int max = 0;
for (int j = 0; j < n; ++j) {
max = std::max(max, matrix[j][i]);
}
for (int j = 0; j < n; ++j) {
if (matrix[j][i] == -1) {
matrix[j][i] = max;
}
}
}
return matrix;
}
};
2024-7-6 3101. 交替子数组计数
代码实现
class Solution {
public:
long long countAlternatingSubarrays(vector<int>& nums) {
int n = size(nums);
long long ans = 0;
for (int i = 1; i < n; ++i) {
int len = 1;
while (i < n && nums[i] != nums[i - 1]) {
i += 1, len += 1;
}
ans += (long long)len * (len - 1) / 2;
}
return ans + n;
}
};
2024-7-7 1958. 检查操作是否合法
代码实现
class Solution {
public:
bool checkMove(vector<vector<char>>& board, int rMove, int cMove, char color) {
int n = size(board), m = size(board[0]);
for (auto [x, y] : {std::pair{1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}}) {
int fx = rMove + x, fy = cMove + y;
if (fx >= 0 && fx < n && fy >= 0 && fy < m && board[fx][fy] == (color ^ 'B' ^ 'W')) {
while (true) {
fx += x, fy += y;
if (fx < 0 || fx >= n || fy < 0 || fy >= m || board[fx][fy] == '.') {
break;
}
if (board[fx][fy] == color) {
return true;
}
}
}
}
return false;
}
};
2024-7-8 724. 寻找数组的中心下标
代码实现
class Solution {
public:
int pivotIndex(vector<int>& nums) {
int n = size(nums);
std::vector<int> pre(n + 1);
for (int i = 0; i < n; ++i) {
pre[i + 1] = pre[i] + nums[i];
}
for (int i = 1; i <= n; ++i) {
if (pre[i - 1] == pre[n] - pre[i]) {
return i - 1;
}
}
return -1;
}
};
2024-7-9 3102. 最小化曼哈顿距离
代码实现
class Solution {
public:
int minimumDistance(vector<vector<int>>& points) {
std::multiset<int> xs, ys;
for (auto &p : points) {
xs.emplace(p[0] + p[1]);
ys.emplace(p[0] - p[1]);
}
int ans = 2e9;
for (auto &p : points) {
int x = p[0] + p[1], y = p[0] - p[1];
xs.erase(xs.lower_bound(x));
ys.erase(ys.lower_bound(y));
ans = std::min(ans, std::max<int>(*xs.rbegin() - *xs.begin(), *ys.rbegin() - *ys.begin()));
xs.emplace(x);
ys.emplace(y);
}
return ans;
}
};
2024-7-10 2970. 统计移除递增子数组的数目 I
代码实现
class Solution {
public:
int incremovableSubarrayCount(vector<int>& nums) {
int n = size(nums);
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
std::vector<int> ver;
ver.insert(ver.end(), nums.begin(), nums.begin() + i);
ver.insert(ver.end(), nums.begin() + j + 1, nums.end());
bool ok = true;
for (int k = 1; k < size(ver); ++k) {
ok &= (ver[k] > ver[k - 1]);
}
ans += ok;
}
}
return ans;
}
};
2024-7-11 2972. 统计移除递增子数组的数目 II
代码实现
class Solution {
public:
long long incremovableSubarrayCount(vector<int>& nums) {
int n = size(nums);
int idx = 0;
while (idx < n - 1 && nums[idx] < nums[idx + 1]) {
idx += 1;
}
if (idx == n - 1) {
return (long long) n * (n + 1) / 2;
}
long long ans = idx + 2;
for (int i = n - 1; i == n - 1 || nums[i] < nums[i + 1]; --i) {
while (idx >= 0 && nums[idx] >= nums[i]) {
idx -= 1;
}
ans += idx + 2;
}
return ans;
}
};
2024-7-12 2974. 最小数字游戏
代码实现
class Solution {
public:
vector<int> numberGame(vector<int>& nums) {
std::ranges::sort(nums);
for (int i = 1; i < (int)size(nums); i += 2) {
std::swap(nums[i], nums[i - 1]);
}
return nums;
}
};
2024-7-13 3011. 判断一个数组是否可以变为有序
代码实现
class Solution {
public:
bool canSortArray(vector<int>& nums) {
int n = size(nums);
for (int i = 0; i < n; ++i) {
int x = __builtin_popcount(nums[i]), j = i;
while (j < n && __builtin_popcount(nums[j]) == x) {
j += 1;
}
std::sort(nums.begin() + i, nums.begin() + j);
}
return std::is_sorted(nums.begin(), nums.end());
}
};
2024-7-14 807. 保持城市天际线
代码实现
class Solution {
public:
int maxIncreaseKeepingSkyline(vector<vector<int>>& grid) {
int n = size(grid);
std::vector<int> maxr(n), maxc(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
maxr[i] = std::max(maxr[i], grid[i][j]);
maxc[j] = std::max(maxc[j], grid[i][j]);
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
ans += std::min(maxr[i], maxc[j]) - grid[i][j];
}
}
return ans;
}
};
2024-7-15 721. 账户合并
代码实现
struct DSU {
std::vector<int> p, siz;
DSU(int n) : p(n), siz(n, 1) { std::iota(p.begin(), p.end(), 0); }
int leader(int x) {
while (x != p[x]) x = p[x] = p[p[x]];
return x;
}
bool same(int x, int y) { return leader(x) == leader(y); }
bool merge(int x, int y) {
x = leader(x), y = leader(y);
if (x == y) return false;
siz[x] += siz[y], p[y] = x;
return true;
}
int size(int x) { return siz[leader(x)]; }
};
class Solution {
public:
vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
int n = size(accounts);
DSU dsu(n);
auto isEdge = [&](int x, int y) {
for (int i = 1; i < size(accounts[x]); ++i) {
for (int j = 1; j < size(accounts[y]); ++j) {
if (accounts[x][i] == accounts[y][j]) {
return true;
}
}
}
return false;
};
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (isEdge(i, j)) {
dsu.merge(i, j);
}
}
}
std::vector<std::vector<std::string>> ans;
std::vector<std::vector<int>> set(n);
for (int i = 0; i < n; ++i) {
set[dsu.leader(i)].emplace_back(i);
}
for (int i = 0; i < n; ++i) if (size(set[i])) {
std::vector<std::string> add = {accounts[i][0]};
for (auto t : set[i]) {
for (int j = 1; j < (int)size(accounts[t]); ++j) {
add.emplace_back(accounts[t][j]);
}
}
std::sort(add.begin() + 1, add.end());
add.erase(std::unique(add.begin(), add.end()), add.end());
ans.emplace_back(add);
}
return ans;
}
};
2024-7-16 2956. 找到两个数组中的公共元素
代码实现
class Solution {
public:
vector<int> findIntersectionValues(vector<int>& nums1, vector<int>& nums2) {
int n = size(nums1), m = size(nums2);
std::vector<int> ans{0, 0};
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (nums1[i] == nums2[j]) {
ans[0] += 1;
break;
}
}
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
if (nums1[j] == nums2[i]) {
ans[1] += 1;
break;
}
}
}
return ans;
}
};
2024-7-17 2959. 关闭分部的可行集合数目
分析
可以发现\(n \leq 10\)，显然可以直接进行二进制枚举选择是否关闭分部。然后进行连边，floyed暴力跑看图是否联通和最长路径即可。
代码实现
class Solution {
public:
int numberOfSets(int n, int maxDistance, vector<vector<int>>& roads) {
auto work = [&](int choice) {
std::vector g(n, std::vector<int>(n, 1e9));
for (int i = 0; i < n; ++i) {
g[i][i] = 0;
}
for (auto road : roads) {
int u = road[0], v = road[1], w = road[2];
if ((choice >> u & 1) && (choice >> v & 1)) {
g[u][v] = g[v][u] = std::min(g[u][v], w);
}
}
for (int k = 0; k < n; ++k) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
g[i][j] = std::min(g[i][j], g[i][k] + g[k][j]);
}
}
}
int max = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (g[i][j] < 1e9) {
max = std::max(max, g[i][j]);
}
}
}
bool ok = true;
for (int i = 0; i < n; ++i) if (choice >> i & 1) {
for (int j = 0; j < n; ++j) if (choice >> j & 1) {
ok &= (g[i][j] < 1e9);
}
}
return max <= maxDistance && ok;
};
int ans = 0;
for (int i = 0; i < (1 << n); ++i) {
ans += work(i);
}
return ans;
}
};
2024-7-18 3112. 访问消失节点的最少时间
代码实现
class Solution {
public:
vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {
std::vector<std::vector<std::pair<int, int>>> g(n);
for (auto edge : edges) {
int u = edge[0], v = edge[1], w = edge[2];
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
}
std::vector<int> dist(n, 1e9);
std::vector<bool> st(n);
std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>, std::greater<>> heap;
heap.emplace(0, 0);
dist[0] = 0;
while (size(heap)) {
auto [d, u] = heap.top();
heap.pop();
if (st[u]) continue;
st[u] = true;
for (auto [v, w] : g[u]) {
if (d + w < dist[v] && disappear[v] > d + w) {
dist[v] = dist[u] + w;
heap.emplace(dist[v], v);
}
}
}
for (int i = 0; i < n; ++i) {
if (dist[i] >= 1e9) {
dist[i] = -1;
}
}
return dist;
}
};
2024-7-19 3096. 得到更多分数的最少关卡数目
代码实现
class Solution {
public:
int minimumLevels(vector<int>& possible) {
int n = size(possible);
int sum = std::accumulate(possible.begin(), possible.end(), 0) * 2 - n;
int pre = 0;
for (int i = 0; i < n - 1; ++i) {
pre += possible[i] == 1 ? 1 : -1;
if (2 * pre > sum) return i + 1;
}
return -1;
}
};
2024-7-20 2850. 将石头分散到网格图的最少移动次数
代码实现
class Solution {
public:
int minimumMoves(vector<vector<int>>& grid) {
std::vector<std::pair<int, int>> from, to;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (grid[i][j]) {
for (int k = 1; k < grid[i][j]; ++k) {
from.emplace_back(i, j);
}
} else {
to.emplace_back(i, j);
}
}
}
int ans = 1e9;
do {
int sum = 0;
for (int i = 0; i < (int)size(from); ++i) {
sum += std::abs(from[i].first - to[i].first) + std::abs(from[i].second - to[i].second);
}
ans = std::min(ans, sum);
} while (std::next_permutation(from.begin(), from.end()));
return ans;
}
};
2024-7-21 2850. 将石头分散到网格图的最少移动次数
代码实现
class Solution {
public:
int maximumSum(vector<int>& arr) {
int dp0 = arr[0], dp1 = 0, res = arr[0];
for (int i = 1; i < arr.size(); ++i) {
dp1 = max(dp0, dp1 + arr[i]);
dp0 = max(dp0, 0) + arr[i];
res = max(res, max(dp0, dp1));
}
return res;
}
};
2024-7-22 2101. 引爆最多的炸弹
代码实现
class Solution {
public:
int maximumDetonation(vector<vector<int>>& bombs) {
int n = size(bombs);
auto get = [&](int a1, int b1, int a2, int b2) {
return std::hypot(a1 - a2, b1 - b2);
};
std::vector<std::vector<int>> g(n);
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
double dist = get(bombs[i][0], bombs[i][1], bombs[j][0], bombs[j][1]);
if (1. * bombs[i][2] >= dist) {
g[i].push_back(j);
}
if (1. * bombs[j][2] >= dist) {
g[j].push_back(i);
}
}
}
std::vector<bool> vis(n);
auto dfs = [&](auto &&self, int u)->int {
int cnt = 1;
vis[u] = true;
for (auto v : g[u]) if (!vis[v]) {
cnt += self(self, v);
}
return cnt;
};
int ans = 0;
for (int i = 0; i < n; ++i) {
vis.assign(n, false);
ans = std::max(ans, dfs(dfs, i));
}
return ans;
}
};
2024-7-23 3098. 求出所有子序列的能量和
代码实现
constexpr int P = 1e9 + 7;
class Solution {
public:
int sumOfPowers(vector<int>& nums, int k) {
std::unordered_map<long long, int> f;
int n = size(nums);
std::sort(nums.begin(), nums.end());
auto dfs = [&](auto&& dfs, int i, int j, int k, int mi) -> int {
if (i >= n) {
return k == 0 ? mi : 0;
}
if (n - i < k) {
return 0;
}
long long key = (1LL * mi) << 18 | (i << 12) | (j << 6) | k;
if (f.contains(key)) return f[key];
long long ans = dfs(dfs, i + 1, j, k, mi);
if (j == n) {
ans += dfs(dfs, i + 1, i, k - 1, mi);
} else {
ans += dfs(dfs, i + 1, i, k - 1, min(mi, nums[i] - nums[j]));
}
ans %= P;
return f[key] = ans;
};
return dfs(dfs, 0, n, k, 1e9);
}
};
2024-7-24 2766. 重新放置石块
代码实现
class Solution {
public:
vector<int> relocateMarbles(vector<int>& nums, vector<int>& moveFrom, vector<int>& moveTo) {
std::map<int, int> mp;
int n = size(nums), m = size(moveFrom);
for (int i = 0; i < n; ++i) {
mp[nums[i]] += 1;
}
for (int i = 0; i < m; ++i) {
int u = moveFrom[i], v = moveTo[i];
if (mp.count(u)) {
mp[v];
if (u != v) {
mp.erase(u);
}
}
}
std::vector<int> ans;
for (auto [x, _] : mp) {
ans.push_back(x);
}
return ans;
}
};
2024-7-25 2844. 生成特殊数字的最少操作
代码实现
class Solution {
public:
int minimumOperations(string num) {
int ans = size(num) - 1;
int suc = 0;
{
std::string s = num;
int p5 = s.rfind('5');
if (p5 != -1) {
int cnt = (int)size(num) - p5 - 1;
s.erase(s.begin() + p5, s.end());
int p2 = s.rfind('2'), p7 = s.rfind('7');
if (p2 != -1) {
ans = std::min(ans, cnt + (int)size(s) - p2 - 1);
suc += 1;
}
if (p7 != -1) {
ans = std::min(ans, cnt + (int)size(s) - p7 - 1);
suc += 1;
}
}
}
{
std::string s = num;
int p0 = s.rfind('0');
if (p0 != -1) {
int cnt = (int)size(num) - p0 - 1;
s.erase(s.begin() + p0, s.end());
int p00 = s.rfind('0'), p5 = s.rfind('5');
if (p00 != -1) {
ans = std::min(ans, cnt + (int)size(s) - p00 - 1);
suc += 1;
}
if (p5 != -1) {
ans = std::min(ans, cnt + (int)size(s) - p5 - 1);
suc += 1;
}
}
}
if (suc == 0 && std::count(num.begin(), num.end(), '0') == 0) {
return size(num);
}
return ans;
}
};
2024-7-26 2740. 找出分区值
代码实现
class Solution {
public:
int findValueOfPartition(vector<int>& nums) {
int n = size(nums);
std::sort(nums.begin(), nums.end());
int ans = 2e9;
for (int i = 1; i < n; ++i) {
ans = std::min(ans, nums[i] - nums[i - 1]);
}
return ans;
}
};
2024-7-27 3106. 满足距离约束且字典序最小的字符串
代码实现
class Solution {
public:
string getSmallestString(string s, int k) {
for (auto &c : s) {
int x = std::min(c - 'a', 'z' - c + 1);
if (x > k) {
c -= k;
return s;
}
c = 'a', k -= x;
}
return s;
}
};
2024-7-28 699. 掉落的方块
代码实现
class Solution {
public:
vector<int> fallingSquares(vector<vector<int>>& positions) {
int n = size(positions);
std::vector<int> h(n);
for (int i = 0; i < n; ++i) {
int l1 = positions[i][0], r1 = positions[i][0] + positions[i][1] - 1;
h[i] = positions[i][1];
for (int j = 0; j < i; ++j) {
int l2 = positions[j][0], r2 = positions[j][0] + positions[j][1] - 1;
if (r1 >= l2 && r2 >= l1) {
h[i] = std::max(h[i], h[j] + positions[i][1]);
}
}
}
for (int i = 1; i < n; ++i) {
h[i] = std::max(h[i], h[i - 1]);
}
return h;
}
};
2024-7-29 682. 棒球比赛
代码实现
class Solution {
public:
int calPoints(vector<string>& operations) {
int n = size(operations);
std::vector<int> ans;
for (auto op : operations) {
if (op == "+") {
ans.push_back(ans.rbegin()[0] + ans.rbegin()[1]);
} else if (op == "D") {
ans.push_back(ans.rbegin()[0] * 2);
} else if (op == "C") {
ans.pop_back();
} else {
ans.push_back(std::stoi(op));
}
}
return std::accumulate(ans.begin(), ans.end(), 0LL);
}
};
2024-7-30 682. 棒球比赛
代码实现
class Solution {
public:
vector<int> getGoodIndices(vector<vector<int>>& variables, int target) {
auto power = [&](int a, int b, int p) {
int c = 1;
while (b) {
if (b & 1) c = c * a % p;
a = a * a % p;
b >>= 1;
}
return c;
};
std::vector<int> ans;
for (int i = 0; i < size(variables); ++i) {
int a = variables[i][0];
int b = variables[i][1];
int c = variables[i][2];
int m = variables[i][3];
if (power(power(a, b, 10), c, m) == target) {
ans.push_back(i);
}
}
return ans;
}
};
2024-7-31 3111. 覆盖所有点的最少矩形数目
分析
显然的发现y轴对于题目并没有影响，因此直接记录x的坐标并对其排序去重，最后贪心的放置即可。
代码实现
class Solution {
public:
int minRectanglesToCoverPoints(vector<vector<int>>& points, int w) {
int n = size(points);
std::vector<int> px(n);
for (int i = 0; i < n; ++i) {
px[i] = points[i][0];
}
std::sort(px.begin(), px.end());
px.erase(std::unique(px.begin(), px.end()), px.end());
n = size(px);
int cnt = 0;
for (int i = 0; i < n; ++i) {
int first = px[i], j = i + 1;
while (j < n && px[j] - first <= w) {
j += 1;
}
i = j - 1;
cnt += 1;
}
return cnt;
}
};
