当前位置：首页 > news >正文

10.17 枚举中间|图论

news 2025/10/18 9:41:20

lc2867

先标记出非质数，再构建树的结构

（DFS）统计每个由非质数组成的连通块大小

计算满足恰好含一个质数节点的合法路径数量。

const int MX = 1e5;
bool np[MX + 1]; // 质数=false 非质数=true
int init = []() {
np[1] = true;
for (int i = 2; i * i <= MX; i++) {
if (!np[i]) {
for (int j = i * i; j <= MX; j += i) {
np[j] = true;
}
}
}
return 0;
}();

class Solution {
public:
long long countPaths(int n, vector<vector<int>> &edges) {
vector<vector<int>> g(n + 1);
for (auto &e: edges) {
int x = e[0], y = e[1];
g[x].push_back(y);
g[y].push_back(x);
}

vector<int> size(n + 1);
vector<int> nodes;
function<void(int, int)> dfs = [&](int x, int fa) {
nodes.push_back(x);
for (int y: g[x]) {
if (y != fa && np[y]) {
dfs(y, x);
}
}
};

long long ans = 0;
for (int x = 1; x <= n; x++) {
if (np[x]) continue; // 跳过非质数
int sum = 0;
for (int y: g[x]) { // 质数 x 把这棵树分成了若干个连通块
if (!np[y]) continue;
if (size[y] == 0) { // 尚未计算过
nodes.clear();
dfs(y, -1); // 遍历 y 所在连通块，在不经过质数的前提下，统计有多少个非质数
for (int z: nodes) {
size[z] = nodes.size();
}
}
// 这 size[y] 个非质数与之前遍历到的 sum 个非质数，两两之间的路径只包含质数 x
ans += (long long) size[y] * sum;
sum += size[y];
}
ans += sum; // 从 x 出发的路径
}
return ans;
}
};

lc2242

先构建图，把每个点连接的点按分数排序并保留前3个

if (vs.size() > 3)
nth_element(vs.begin(), vs.begin() + 3, vs.end());
vs.resize(3);

然后枚举中间边(x-y) a-x-y-b

找边两端点各自连接的点中合适的(除环)，计算能组成的最大得分

if (a != y && b != x && a != b)
ans = max(ans, -score_a + scores[x] + scores[y] - score_b);

返回最大得分（没有符合的就返回-1）

class Solution {
public:
int maximumScore(vector<int> &scores, vector<vector<int>> &edges)

{
int n = scores.size();
vector<vector<pair<int, int>>> g(n);
for (auto &e : edges) {
int x = e[0], y = e[1];
g[x].emplace_back(-scores[y], y);
g[y].emplace_back(-scores[x], x);
}
for (auto &vs : g)
if (vs.size() > 3) {
nth_element(vs.begin(), vs.begin() + 3, vs.end());
vs.resize(3);
}

int ans = -1;
for (auto &e : edges) {
int x = e[0], y = e[1];
for (auto &[score_a, a] : g[x])
for (auto &[score_b, b] : g[y])
if (a != y && b != x && a != b)
ans = max(ans, -score_a + scores[x] + scores[y] - score_b);
}
return ans;
}
};

为了对图中每个节点，只保留与它相连的、分数最大的前三个节点

if (vs.size() > 3)
nth_element(vs.begin(), vs.begin() + 3, vs.end());
vs.resize(3);

- 首先遍历图 g 中的每个节点的邻接列表 vs 。
- 如果邻接列表的长度超过3，就使用 nth_element 函数，把第3大的元素放到 vs.begin() + 3 的位置，这样前3个元素就是最大的三个。
- 然后通过 vs.resize(3) ，将邻接列表的长度调整为3，从而只保留分数最大的前三个相邻节点

思考枚举点还是边
将问题放小，假设三个点怎么办
三个点则枚举中间点，再枚举两边最优
优化，贪心每次选最大的权值
则一个点最多往外连三个点
写的时候可以借助提供的边一下子确定两个点，灵活运用点和边的关系
(这样就不用写四个循环和一堆判断了)

lc2874

预处理+单调性

class Solution {
public:
long long maximumTripletValue(vector<int>& nums)
{
//dan diao xin
int n=nums.size();
vector<int> max_left(n,0);
vector<int> max_right(n,0);
long long ret=LONG_MIN;

for(int i=1;i<n-1;i++)
{
max_left[i]=max(max_left[i-1],nums[i-1]);
}

for(int i=n-2;i>0;i--)
{
max_right[i]=max(max_right[i+1],nums[i+1]);
}

for(int i=1;i<n-1;i++)
{
ret=max(ret,(long long)(max_left[i]-nums[i])*max_right[i]);
}
return ret<0?0:ret;
}
};