2014北京网络预选赛1005（强连通缩点+期望）HDU5036_everyone knows matt enjoys playing games very much-优快云博客

本文探讨了一种游戏场景下的数学问题，通过构建图论模型，采用强连通分量缩点的方法解决游戏中开门期望次数的问题，并给出了具体的实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Explosion

Time Limit: 6000/3000 MS (Java/Others) Memory Limit: 262144/262144 K (Java/Others)
Total Submission(s): 243 Accepted Submission(s): 63

Problem Description

Everyone knows Matt enjoys playing games very much. Now, he is playing such a game. There are N rooms, each with one door. There are some keys(could be none) in each room corresponding to some doors among these N doors. Every key can open only one door. Matt has some bombs, each of which can destroy a door. He will uniformly choose a door that can not be opened with the keys in his hand to destroy when there are no doors that can be opened with keys in his hand. Now, he wants to ask you, what is the expected number of bombs he will use to open or destroy all the doors. Rooms are numbered from 1 to N.

Input

The first line of the input contains an integer T, denoting the number of testcases. Then T test cases follow.

In the first line of each test case, there is an integer N (N<=1000) indicating the number of rooms.

The following N lines corresponde to the rooms from 1 to N. Each line begins with an integer k (0<=k<=N) indicating the number of keys behind the door. Then k integers follow corresponding to the rooms these keys can open.

Output

For each test case, output one line "Case #x: y", where x is the case number (starting from 1), y is the answer which should be rounded to 5 decimal places.

Sample Input

Sample Output

Case #1: 1.00000
Case #2: 3.00000

题意：RT

思路：如果一个门被打开，那么它里面装的钥匙的门一定都打开了

不难想到，如果存在环，那么选择环里的任何门打开，整个环就都打开了

先强连通缩点，变成了一个DAG

只要一遍DFS处理出哪些点可以被哪些点到达，这个可以用bitset维护

然后要算打开所有门的期望，实际上就是要算出对于每个门来讲，它打开的期望，然后加起来即可

对于门i，如果有x个门可以到达它，那么打开它的概率为cnt[i]/x，期望也即cnt[i]/x，这里的门已经是强连通缩点后的，cnt[i]为i里面门的数量

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

const int MAXN = 1010;
int sccno[MAXN];
int dfs_clock;
int now[MAXN];
int low[MAXN];
int cnt[MAXN];
int vis[MAXN];
int is[MAXN][MAXN];
int scc_cnt;
stacks;
bitsetq[MAXN];
int head[MAXN];
int edge[MAXN*MAXN];
int next[MAXN*MAXN];
int esz;
int head1[MAXN];
int edge1[MAXN*MAXN];
int next1[MAXN*MAXN];
int esz1;
int fx[MAXN];

void add(int u,int v)
{
    edge[esz]=v;
    next[esz]=head[u];
    head[u]=esz++;
}

void add1(int u,int v)
{
    edge1[esz1]=v;
    next1[esz1]=head1[u];
    head1[u]=esz1++;
}

void init()
{
    memset(low,0,sizeof(low));
    memset(now,0,sizeof(now));
    dfs_clock=0;esz=0;esz1=0;scc_cnt=0;
    memset(cnt,0,sizeof(cnt));
    memset(sccno,0,sizeof(sccno));
    memset(vis,0,sizeof(vis));
    memset(head,-1,sizeof(head));
    memset(head1,-1,sizeof(head1));
    memset(fx,0,sizeof(fx));
    memset(is,0,sizeof(is));
}

void tarjan(int u)
{
    low[u]=now[u]=++dfs_clock;
    s.push(u);
    for(int i=head[u];i!=-1;i=next[i]){
        int v=edge[i];
        if(!now[v]){
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(!sccno[v]){
            low[u]=min(low[u],now[v]);
        }
    }
    if(low[u]==now[u]){
        ++scc_cnt;
        while(1){
            int x=s.top();s.pop();
            sccno[x]=scc_cnt;
            cnt[scc_cnt]++;
            if(x==u)break;
        }
    }
}

void dfs(int u)
{
    if(vis[u])return;
    vis[u]=1;
    q[u].reset();
    q[u].set(u);
    for(int i=head1[u];i!=-1;i=next1[i]){
        int v=edge1[i];
        dfs(v);
        q[u]|=q[v];
    }
}

int main()
{
    int t,tt=0;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        scanf("%d",&n);
        init();
        for(int i=1;i<=n;i++)
        {
            int k;
            scanf("%d",&k);
            for(int j=0;j