2019ICPC沈阳网络赛-B-Dudu's maze(缩点)

链接:

https://nanti.jisuanke.com/t/41402

题意:

To seek candies for Maomao, Dudu comes to a maze. There are nn rooms numbered from 11 to nn and mm undirected roads.

There are two kinds of rooms in the maze -- candy room and monster room. There is one candy in each candy room, and candy room is safe. Dudu can take the only candy away when entering the room. After he took the candy, this candy room will be empty. A empty room is also safe. If Dudu is in safe, he can choose any one of adjacent rooms to go, whatever it is. Two rooms are adjacent means that at least one road connects the two rooms.

In another kind of rooms, there are fierce monsters. Dudu can't beat these monsters, but he has a magic portal. The portal can show him a randomly chosen road which connects the current room and the other room.

The chosen road is in the map so Dudu know where it leads to. Dudu can leave along the way to the other room, and those monsters will not follow him. He can only use the portal once because the magic energy is not enough.

Dudu can leave the maze whenever he wants. That's to say, if he enters a monster room but he doesn't have enough energy to use the magic portal, he will choose to leave the maze immediately so that he can save the candies he have. If he leave the maze, the maze will never let him in again. If he try to fight with the monsters, he will be thrown out of the maze (never let in, of course). He remembers the map of the maze, and he is a clever guy who can move wisely to maximum the expection of candies he collected.

Maomao wants to know the expected value of candies Dudu will bring back. Please tell her the answer. He will start his adventure in room 1, and the room 1 is always a candy room. Since there may be more than one road connect the current room and the room he wants to go to, he can choose any of the roads.

思路:

将所有连起来的点并且中间没有怪物的点连起来, 1的联通必选, 在从1能到的怪物的点挨个枚举, 选一个期望最大的点即可.

代码:

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 1e5+10;
vector<int> G[MAXN];
int Fa[MAXN], Sum[MAXN];
bool Vis[MAXN];
int n, m, k;

int GetF(int x)
{
    if (Fa[x] == x)
        return x;
    Fa[x] = GetF(Fa[x]);
    return Fa[x];
}

int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d%d", &n, &m, &k);
        for (int i = 1;i <= n;i++)
            Fa[i] = i, Sum[i] = 1, Vis[i] = false, G[i].clear();
        int u, v;
        for (int i = 1;i <= m;i++)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        for (int i = 1;i <= k;i++)
        {
            scanf("%d", &u);
            Vis[u] = true;
            Sum[u] = 0;
        }
        for (int i = 1;i <= n;i++)
        {
            for (int j = 0;j < G[i].size();j++)
            {
                int a = i, b = G[i][j];
                if (Vis[a] || Vis[b])
                    continue;
                a = GetF(a);
                b = GetF(b);
                if (a != b)
                {
                    if (a == 1)
                    {
                        Fa[b] = a;
                        Sum[a] += Sum[b];
                    }
                    else
                    {
                        Fa[a] = b;
                        Sum[b] += Sum[a];
                    }
                }
            }
        }
        double res = 0;
        for (int i = 1;i <= n;i++)
        {
            if (!Vis[i])
                continue;
            bool Flag = false;
            for (int j = 0;j < G[i].size();j++)
            {
                if (GetF(G[i][j]) == 1)
                {
                    Flag = true;
                    break;
                }
            }
            if (!Flag)
                continue;
            double tmp = 0;
            for (int j = 0;j < G[i].size();j++)
            {
                int node = GetF(G[i][j]);
                if (node != 1)
                {
//                    cout << Sum[node] << ' ' << G[i].size() << endl;
                    tmp += (Sum[node]*1.0)/(int)G[i].size();
                }
            }
            res = max(res, tmp);
        }
        res += Sum[1];
        printf("%.6lf\n", res);
    }

    return 0;
}