Contest3636 - 2024小学期程序设计实训竞-赛-班专题训练五（图论专题）

问题A：北极通讯网络

题目描述
北极的某区域共有n座村庄，每座村庄的坐标用一对整数(x,y)表示。为了加强联系，决定在村庄之间建立通讯网络。通讯工具可以是无线电收发机，也可以是卫星设备。所有的村庄都可以拥有一部无线电收发机，且所有的无线电收发机型号相同。但卫星设备数量有限，只能给一部分村庄配备卫星设备。
不同型号的无线电收发机有一个不同的参数d，两座村庄之间的距离如果不超过d就可以用该型号的无线电收发机直接通讯，d值越大的型号价格越贵。拥有卫星设备的两座村庄无论相距多远都可以直接通讯。
现在有k台卫星设备，请你编一个程序，计算出应该如何分配这k台卫星设备，才能使所拥有的无线电收发机的d值最小，并保证每两座村庄之间都可以直接或间接地通讯。
例如，对于下面三座村庄：

如果没有任何卫星设备或只有1台卫星设备(k=0或k=1)，则满足条件的最小的d=20，因为A和B，B和C可以用无线电直接通讯；而A和C可以用B中转实现间接通讯(即消息从A传到B，再从B传到C)；
如果有2台卫星设备(k=2)，则可以把这两台设备分别分配给B和C，这样最小的d可取10，因为A和B之间可以用无线电直接通讯；B和C之间可以用卫星直接通讯；A和C可以用B中转实现间接通讯。
如果有3台卫星设备，则A,B,C两两之间都可以直接用卫星通讯，最小的d可取0。

输入
第一行为由空格隔开的两个整数n,k;
第2∼n+1行，每行两个整数，第i行的xi,yi表示第i座村庄的坐标(xi,yi)。

输出
一个实数，表示最小的d值，结果保留2位小数。

建立最小生成树，$d$最小，那么$k$个通讯设备应该覆盖前$k$大的边，此时$d$的值就是第$k+1$条边的边权

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5+5;
int n, k;
int p[N];

struct edge{
    int u, v;
    double w;
    bool operator<(const edge& c)const{
        return w < c.w;
    }
};

int find(int x)
{
    if(p[x]!=x)
        p[x] = find(p[x]);
    return p[x];
}
void unite(vector<int>& rank,int x, int y){
    int xx = find(x);
    int yy = find(y);
    if(xx!=yy){
        if(rank[xx]>rank[yy])
            p[yy] = xx;
        else if(rank[xx]<rank[yy]){
            p[xx] = yy;
        }
        else{
            p[yy] = xx;
            rank[xx]++;
        }
    }
}
void solve()
{
    cin >> n >> k;
    vector<pair<int, int>> pos(n);
    vector<int> rank(n, 0);
    for (int i = 0; i < n; i++)
    {
        cin >> pos[i].first >> pos[i].second;
        p[i] = i;
    }
    vector<edge> edges;
    for (int i = 0; i < n;i++){
        
        for (int j = i + 1; j < n; j++)
        {
            double dis = hypot(pos[i].first - pos[j].first, pos[i].second - pos[j].second);
            edges.push_back({i, j, dis});
        }
    }
    sort(edges.begin(), edges.end());
    int cnt = 0;
    double nth_edge = 0; // 第n大的边
    for(auto e:edges){
        if(find(e.u)!=find(e.v)){
            unite(rank, e.u, e.v);
            nth_edge = e.w;
            cnt++;
            if (cnt == n - k)
            {
                break;
                }
        }
    }
    printf("%.2f", nth_edge);
}

int main()
{
    int t;
    t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

问题B：FBI树

题目描述
我们可以把由“0”和“1”组成的字符串分为三类：全“0”串称为B串，全“1”串称为I串，既含“0”又含“1”的串则称为F串。
FBI树是一种二叉树 ，它的结点类型也包括F结点，B结点和I结点三种。由一个长度为2N的“01”串S可以构造出一棵FBI树T，递归的构造方法如下：

1. T的根结点为R，其类型与串S的类型相同；
2. 若串S的长度大于1，将串S从中间分开，分为等长的左右子串S1和S2；由左子串S1构造R的左子树T1，由右子串S2构造R的右子树T2。
   现在给定一个长度为2N的“01”串，请用上述构造方法构造出一棵FBI树，并输出它的后序遍历序列。

输入
输入的第一行是一个整数N（0 <= N <= 10），第二行是一个长度为$2^N$的“01”串。

输出
输出包括一行，这一行只包含一个字符串，即FBI树的后序遍历序列。

后序遍历，递归处理字符串

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5+5;
string s;
void traversal(int l, int r){
    if(l==r){
        if(s[l]=='0')
            cout << "B";
        else{
            cout << "I";
        }
        return;
    }
    int mid = (l + r) / 2;
    traversal(l, mid);
    traversal(mid+1, r);
    bool has0 = false, has1 = false;
    for (int i = l; i <= r; i++)
    {
        if(s[i]=='0')
            has0 = true;
        if(s[i]=='1')
            has1 = true;
    }
    if(has0&&has1)
        cout << "F";
    else if(has0){
        cout << "B";
    }
    else{
        cout << "I";
    }
    return;
}
void solve(){
    int n;
    cin >> n;
    cin >> s;
    traversal(0,(1<<n)-1);
}

int main()
{
    int t;
    t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

问题 E: 赵子龙七进七出

题目描述
赵云背着阿斗，被曹军堵截，他现在在山口的位置，而突破在遥远的东方。赵子龙特别着急，想赶紧把阿斗还给刘备让他摔一摔。
我们可以把密密麻麻人群中的空隙看作点，把那些赵云的马可以跳上的盾牌看作边，那么有$n$个点，$m$条有向边，问子龙的最少前进步数。
但是子龙的这匹马，它有点点神经质，它是数字3的爱好者，一下子得跳过三条边，而三次算一步。
所以如果有这么一种情况1–>2—>3–>1 如果起点是1终点是2 那么，子龙就会因为它那马而永远陷入曹军的包围中，如果是这种情况就输出-1
$2\le n\le 1e5,0\le m\le \frac{n(n+1)}{2}$
最后一行输入起点$S$和终点$T$
$1\le S\le N,S\ne T$

输入
n m
u1 v1
u2 v2
…
un vn
S T

输出
输出一个整数，代表最少前进步数或者-1

用$dis[i][3]$存第几步到达哪个点，然后进行bfs遍历，下一步的状态$next\_step$等于当前步数加一然后模3，即$next\_step=(step+1)\%3$，因为三步合一步，所以最后的步数是$dis[t][0]/3$

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5+5;
int n, m,s,t;
int dis[N][3];
vector<int> adj[N];

void bfs(int x){
    queue<pair<int,int>> q;
    q.push({s, 0});
    dis[s][0] = 0;
    while (!q.empty())
    {
        int u = q.front().first;
        int step = q.front().second;
        q.pop();

        for(int v:adj[u]){
            int next_step = (step + 1) % 3;
            if(dis[v][next_step]==-1){
                dis[v][next_step] = dis[u][step] + 1;
                q.push({v, next_step});
            }
        }
    }
}
void solve()
{
    cin >> n >> m;
    memset(dis, -1, sizeof(dis));
    for (int i = 0; i < m;i++){
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
    }
    cin >> s >> t;
    bfs(s);
    if(dis[t][0]!=-1){
        cout << dis[t][0]/3;
    }
    else{
        cout << -1;
    }
}

int main()
{
    int t;
    t=1;
    //cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

问题 F: 受欢迎的牛

题目描述
每一头牛的愿望就是变成一头最受欢迎的牛。现在有N头牛，给你M对整数(A,B)，表示牛A认为牛B受欢迎。这种关系是具有传递性的，如果A认为B受欢迎，B认为C受欢迎，那么牛A也认为牛C受欢迎。你的任务是求出有多少头牛被除自己之外的所有牛认为是受欢迎的。

输入
第一行两个数N,M；
接下来M行，每行两个数A,B，意思是A认为B是受欢迎的（给出的信息有可能重复，即有可能出现多个A,B）。

输出
输出被除自己之外的所有牛认为是受欢迎的牛的数量。

使用tarjan算法找到所有强连通分量，并将这些强连通分量缩成一个点，然后遍历缩点后的图，出度为0的点就是受欢迎的牛，因为所有人喜欢他，但是他不喜欢别人，并且不可能存在两个出度为0的点，因为这样这两个点都得不到对方的喜欢，自然就不能成为受欢迎的牛

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5 + 5;

int dfn[N], low[N];
int du[N], id[N], num[N]; // 强连通分量出度 强连通分量编号 每个强连通分量节点数
bool insta[N];
int tot, cnt, scc;
stack<int> s;
vector<int> adj[N];
void tarjan(int x)
{
    dfn[x] = low[x] = ++tot;
    s.push(x);
    insta[x] = true;
    for (int v : adj[x])
    {
        if (!dfn[v])
        {
            tarjan(v);
            low[x] = min(low[x], low[v]);
        }
        else if (insta[v])
        {
            low[x] = min(low[x], dfn[v]);
        }
    }
    if (low[x] == dfn[x])
    {
        int k;
        ++scc;
        do
        {
            k = s.top();
            s.pop();
            insta[k] = false;
            id[k] = scc;
            num[scc]++;
        } while (x != k);
    }
}
int main()
{
    int n, m;
    cin >> n >> m;

    for (int i = 1; i <= m; i++)
    {
        int a, b;
        cin >> a >> b;
        adj[a].push_back(b);
    }
    for (int i = 1; i <= n; i++)
    {
        if (!dfn[i])
            tarjan(i);
    }
    for (int i = 1; i <= n; i++)
    {
        for (int v : adj[i])
        {
            if (id[i] != id[v])
            {
                du[id[i]]++;
            }
        }
    }
    int tt = 0; // 记录唯一出度为0的强连通分量编号
    for (int i = 1; i <= scc; i++)
    {
        if (!du[i])
        {
            if (tt)
            { // 如果已经存在一个出度为0的点
                cout << 0;
                return 0;
            }
            tt = i;
        }
    }
    cout << num[tt];
    return 0;
}