L2-4 大众情人（天梯赛）

人与人之间总有一点距离感。我们假定两个人之间的亲密程度跟他们之间的距离感成反比，并且距离感是单向的。例如小蓝对小红患了单相思，从小蓝的眼中看去，他和小红之间的距离为 1，只差一层窗户纸；但在小红的眼里，她和小蓝之间的距离为 108000，差了十万八千里…… 另外，我们进一步假定，距离感在认识的人之间是可传递的。例如小绿觉得自己跟小蓝之间的距离为 2，则即使小绿并不直接认识小红，我们也默认小绿早晚会认识小红，并且因为跟小蓝很亲近的关系，小绿会觉得自己跟小红之间的距离为 1+2=3。当然这带来一个问题，如果小绿本来也认识小红，或者他通过其他人也能认识小红，但通过不同渠道推导出来的距离感不一样，该怎么算呢？我们在这里做个简单定义，就将小绿对小红的距离感定义为所有推导出来的距离感的最小值。

一个人的异性缘不是由最喜欢他/她的那个异性决定的，而是由对他/她最无感的那个异性决定的。我们记一个人 i 在一个异性 j 眼中的距离感为 Dij​；将 i 的“异性缘”定义为 1/maxj∈S(i)​{Dij​}，其中 S(i) 是相对于 i 的所有异性的集合。那么“大众情人”就是异性缘最好（值最大）的那个人。

本题就请你从给定的一批人与人之间的距离感中分别找出两个性别中的“大众情人”。

输入格式：

输入在第一行中给出一个正整数 N（≤500），为总人数。于是我们默认所有人从 1 到 N 编号。

随后 N 行，第 i 行描述了编号为 i 的人与其他人的关系，格式为：

性别 K 朋友1:距离1 朋友2:距离2 …… 朋友K:距离K

其中 性别 是这个人的性别，F 表示女性，M 表示男性；K（<N 的非负整数）为这个人直接认识的朋友数；随后给出的是这 K 个朋友的编号、以及这个人对该朋友的距离感。距离感是不超过 106 的正整数。

题目保证给出的关系中一定两种性别的人都有，不会出现重复给出的关系，并且每个人的朋友中都不包含自己。

输出格式：

第一行给出自身为女性的“大众情人”的编号，第二行给出自身为男性的“大众情人”的编号。如果存在并列，则按编号递增的顺序输出所有。数字间以一个空格分隔，行首尾不得有多余空格。

输入样例：

6
F 1 4:1
F 2 1:3 4:10
F 2 4:2 2:2
M 2 5:1 3:2
M 2 2:2 6:2
M 2 3:1 2:5

输出样例：

2 3
4

 代码及解释：

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

const int INF = INT_MAX / 2;  // 定义无穷大，避免溢出

// 图的边结构体
class Edge {
public:
    int to, weight;       // to: 目标节点，weight: 边权重（距离感）
    Edge(int t, int w) : to(t), weight(w) {}
};

vector<vector<Edge>> graph;  // 图的邻接表表示（有向图）
vector<char> gender;        // 存储每个人的性别
vector<vector<int>> dist;   // dist[i][j]表示i到j的最短距离

/* Dijkstra算法求单源最短路径
 * @param start: 起点编号
 */
void dijkstra(int start) {
    // 初始化距离数组
    dist[start].assign(graph.size(), INF);
    dist[start][start] = 0;  // 起点到自己的距离为0

    // 优先队列（最小堆），存储(距离, 节点)对
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;
    pq.push({ 0, start });

    while (!pq.empty()) {
        int u = pq.top().second;    // 当前节点
        int d = pq.top().first;     // 当前距离
        pq.pop();

        // 如果当前距离大于已知最短距离，跳过（避免重复处理）
        if (d > dist[start][u]) continue;

        // 遍历所有邻接边
        for (const Edge& e : graph[u]) {
            int v = e.to;          // 邻接节点
            int w = e.weight;      // 边权重
            // 松弛操作：如果找到更短路径则更新
            if (dist[start][v] > dist[start][u] + w) {
                dist[start][v] = dist[start][u] + w;
                pq.push({ dist[start][v], v });
            }
        }
    }
}

int main() {
    int n;  // 总人数
    cin >> n;

    // 初始化数据结构
    graph.resize(n + 1);      // 节点编号1~n
    gender.resize(n + 1);     // 性别存储
    dist.resize(n + 1, vector<int>(n + 1, INF));  // 距离矩阵初始化

    vector<int> males, females;  // 分别存储男女编号

    // 输入处理
    for (int i = 1; i <= n; ++i) {
        char sex;  // 性别
        int k;     // 朋友数量
        cin >> sex >> k;
        gender[i] = sex;

        // 根据性别分类存储
        if (sex == 'M') {
            males.push_back(i);
        }
        else {
            females.push_back(i);
        }

        // 读入朋友关系（有向边）
        while (k--) {
            int id, d;    // 朋友编号和距离感
            char colon;   // 冒号分隔符
            cin >> id >> colon >> d;
            graph[i].emplace_back(id, d);  // 添加单向边
        }
    }

    // 计算所有点对的最短距离
    for (int i = 1; i <= n; ++i) {
        dijkstra(i);  // 计算i到所有节点的最短距离
    }

    // 准备存储每个人的异性缘数据 (max_D, id)
    vector<pair<int, int>> female_data, male_data;

    /* 计算女性数据：
     * 对每个女性，找出所有男性到她的最大距离感
     */
    for (int f : females) {
        int max_D = 0;
        for (int m : males) {
            // 更新最大距离感（注意是m到f的距离）
            max_D = max(max_D, dist[m][f]);
        }
        female_data.emplace_back(max_D, f);
    }

    /* 计算男性数据：
     * 对每个男性，找出所有女性到他的最大距离感
     */
    for (int m : males) {
        int max_D = 0;
        for (int f : females) {
            max_D = max(max_D, dist[f][m]);
        }
        male_data.emplace_back(max_D, m);
    }

    /* 排序比较函数：
     * 1. 优先按max_D升序排列（max_D越小，异性缘越好）
     * 2. max_D相同时，按编号升序排列
     */
    auto cmp = [](const pair<int, int>& a, const pair<int, int>& b) {
        return a.first < b.first || (a.first == b.first && a.second < b.second);
        };

    // 对男女数据分别排序
    sort(female_data.begin(), female_data.end(), cmp);
    sort(male_data.begin(), male_data.end(), cmp);

    // 输出女性大众情人（所有max_D最小的女性）
    int min_D = female_data[0].first;  // 最小的max_D值
    bool first = true;                 // 控制输出格式
    for (const auto& p : female_data) {
        if (p.first != min_D) break;  // 只输出异性缘最好的

        if (!first) cout << " ";      // 非第一个元素前加空格
        cout << p.second;             // 输出编号
        first = false;
    }
    cout << endl;

    // 输出男性大众情人（逻辑同上）
    min_D = male_data[0].first;
    first = true;
    for (const auto& p : male_data) {
        if (p.first != min_D) break;

        if (!first) cout << " ";
        cout << p.second;
        first = false;
    }
    cout << endl;

    return 0;
}

用emplace_back()是因为它的效率比push_back()跟高一些。