ACM寒假集训第七天代码及其思路-优快云博客

本文链接：https://blog.youkuaiyun.com/c123_c/article/details/145738232

一、

1.代码

#include <iostream>
#include <vector>
#include <climits>

using namespace std;

const int INF = INT_MAX / 2; // 避免溢出

int main() {
int n;
while (cin >> n && n != 0) {
vector<vector<int>> adj(n + 1, vector<int>(n + 1, INF));
for (int i = 1; i <= n; ++i) {
adj[i][i] = 0;
int m;
cin >> m;
for (int j = 0; j < m; ++j) {
int v, t;
cin >> v >> t;
adj[i][v] = t;
}
}

// Floyd-Warshall算法
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (adj[i][k] < INF && adj[k][j] < INF) {
adj[i][j] = min(adj[i][j], adj[i][k] + adj[k][j]);
}
}
}
}

int best_time = INF;
int best_node = -1;
for (int i = 1; i <= n; ++i) {
int current_max = 0;
bool valid = true;
for (int j = 1; j <= n; ++j) {
if (i == j) continue;
if (adj[i][j] == INF) {
valid = false;
break;
}
if (adj[i][j] > current_max) {
current_max = adj[i][j];
}
}
if (valid) {
if (current_max < best_time || (current_max == best_time && i < best_node)) {
best_time = current_max;
best_node = i;
}
}
}

if (best_node == -1) {
cout << "disjoint" << endl;
} else {
cout << best_node << " " << best_time << endl;
}
}
return 0;
}

2.思路

输入处理：读取每个测试用例的经纪人数量，并构建邻接矩阵表示各经纪人之间的传递时间。
Floyd-Warshall算法：计算所有经纪人之间的最短路径，以便找到从任一经纪人出发到所有其他经纪人的最短时间。
寻找最优起点：对于每个经纪人，检查其到所有其他经纪人的最大传递时间，并记录最小值及其对应的经纪人编号。若存在无法到达的经纪人，则整个网络不连通。
输出结果：根据计算结果输出最优起点及其时间，若网络不连通则输出"disjoint"。

二、

1.代码

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

pair<int, int> bfs(int start, vector<vector<int>>& adj, int n) {
vector<int> distance(n + 1, -1);
queue<int> q;
q.push(start);
distance[start] = 0;
int farthestNode = start;
int maxDistance = 0;

while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : adj[u]) {
if (distance[v] == -1) {
distance[v] = distance[u] + 1;
q.push(v);
if (distance[v] > maxDistance) {
maxDistance = distance[v];
farthestNode = v;
}
}
}
}
return {farthestNode, maxDistance};
}

int main() {
int n;
cin >> n;
vector<vector<int>> adj(n + 1);
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}

// 第一次BFS找到最远的节点A
pair<int, int> result = bfs(1, adj, n);
int nodeA = result.first;

// 第二次BFS从节点A找到最远的节点B
result = bfs(nodeA, adj, n);
int diameter = result.second;

cout << diameter << endl;
return 0;
}

2.思路

BFS函数：bfs函数从给定的起始节点开始，使用BFS遍历树，计算每个节点到起始节点的距离，并返回最远的节点及其距离。
主函数：
- 读取节点数量n和边的信息，构建邻接表adj。
- 第一次调用bfs从节点1开始，找到最远的节点nodeA。
- 第二次调用bfs从nodeA开始，找到最远的节点nodeB，并计算直径。
- 输出直径的长度。

三、

1.代码

#include <iostream>
#include <vector>
#include <queue>
#include <climits>
#include <functional> // 包含 greater 的头文件
using namespace std;

typedef long long ll;
typedef pair<ll, int> pii;

void dijkstra(int start, vector<vector<pii>>& graph, vector<ll>& dist) {
priority_queue<pii, vector<pii>, greater<pii>> pq; // 使用 std::greater
pq.push({0, start});
dist[start] = 0;

while (!pq.empty()) {
int u = pq.top().second;
ll d = pq.top().first;
pq.pop();

if (d > dist[u]) continue;

for (auto& edge : graph[u]) {
int v = edge.second;
ll w = edge.first;
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pq.push({dist[v], v});
}
}
}
}

int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);

int N;
cin >> N;
while (N--) {
int P, Q;
cin >> P >> Q;

vector<vector<pii>> graph(P + 1), reverse_graph(P + 1);
for (int i = 0; i < Q; ++i) {
int u, v, w;
cin >> u >> v >> w;
graph[u].push_back({w, v});
reverse_graph[v].push_back({w, u});
}

vector<ll> dist_forward(P + 1, LLONG_MAX);
vector<ll> dist_backward(P + 1, LLONG_MAX);

dijkstra(1, graph, dist_forward);
dijkstra(1, reverse_graph, dist_backward);

ll total_cost = 0;
for (int i = 1; i <= P; ++i) {
total_cost += dist_forward[i] + dist_backward[i];
}

cout << total_cost << '\n';
}

return 0;
}

2.思路

构建图：我们有两个图，一个是原始图，另一个是反向图（所有边的方向反转）。
Dijkstra算法：在原始图上运行Dijkstra算法，计算从CCS到所有其他站点的最短路径。
反向Dijkstra算法：在反向图上运行Dijkstra算法，计算从所有其他站点返回到CCS的最短路径。
计算总成本：将两个最短路径的成本相加，得到每天的最小总成本。

四、

1.代码

#include <iostream>
#include <vector>
#include <cstring>

using namespace std;

const int MAX_N = 1500;
vector<int> tree[MAX_N]; // 邻接表存储树
int dp[MAX_N][2]; // dp[i][0]：不放士兵, dp[i][1]：放士兵
bool visited[MAX_N];

void dfs(int u) {
visited[u] = true;
dp[u][0] = 0; // u不放士兵时的最优值
dp[u][1] = 1; // u放士兵时的最优值

for (int v : tree[u]) {
if (!visited[v]) {
dfs(v); // 递归处理子节点
dp[u][0] += dp[v][1]; // u 不放士兵 -> 子节点必须放士兵
dp[u][1] += min(dp[v][0], dp[v][1]); // u 放士兵 -> 子节点可放可不放
}
}
}

int main() {
int n;
cin >> n;

for (int i = 0; i < n; i++) {
int u, k;
cin >> u >> k;
while (k--) {
int v;
cin >> v;
tree[u].push_back(v);
tree[v].push_back(u); // 无向图，双向存储
}
}

memset(visited, false, sizeof(visited));
dfs(0); // 选择 0 作为根节点

cout << min(dp[0][0], dp[0][1]) << endl;
return 0;
}

2.思路

• 先构建无向图并转化为树。

• 选择任意节点作为根（如 0）。

• 递归计算 dp 值。

• 输出 min(dp[root][0], dp[root][1]) 作为最优解