HDU 3625 Examining the Rooms

Examining the Rooms

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1076    Accepted Submission(s): 649

Problem Description

A murder happened in the hotel. As the best detective in the town, you should examine all the N rooms of the hotel immediately. However, all the doors of the rooms are locked, and the keys are just locked in the rooms, what a trap! You know that there is exactly one key in each room, and all the possible distributions are of equal possibility. For example, if N = 3, there are 6 possible distributions, the possibility of each is 1/6. For convenience, we number the rooms from 1 to N, and the key for Room 1 is numbered Key 1, the key for Room 2 is Key 2, etc.
To examine all the rooms, you have to destroy some doors by force. But you don’t want to destroy too many, so you take the following strategy: At first, you have no keys in hand, so you randomly destroy a locked door, get into the room, examine it and fetch the key in it. Then maybe you can open another room with the new key, examine it and get the second key. Repeat this until you can’t open any new rooms. If there are still rooms un-examined, you have to randomly pick another unopened door to destroy by force, then repeat the procedure above, until all the rooms are examined.
Now you are only allowed to destroy at most K doors by force. What’s more, there lives a Very Important Person in Room 1. You are not allowed to destroy the doors of Room 1, that is, the only way to examine Room 1 is opening it with the corresponding key. You want to know what is the possibility of that you can examine all the rooms finally.

 

Input

The first line of the input contains an integer T (T ≤ 200), indicating the number of test cases. Then T cases follow. Each case contains a line with two numbers N and K. (1 < N ≤ 20, 1 ≤ K < N)

 

Output

Output one line for each case, indicating the corresponding possibility. Four digits after decimal point are preserved by rounding.

 

Sample Input

  
  

   
   3
3 1
3 2
4 2
  
  

 

Sample Output

  
  

   
   0.3333
0.6667
0.6250

   
   

    
    

     
     Hint
    
    
Sample Explanation

When N = 3, there are 6 possible distributions of keys:

	Room 1	Room 2	Room 3	Destroy Times
#1	Key 1	Key 2	Key 3	Impossible
#2	Key 1	Key 3	Key 2	Impossible
#3	Key 2	Key 1	Key 3	Two
#4	Key 3	Key 2	Key 1	Two
#5	Key 2	Key 3	Key 1	One
#6	Key 3	Key 1	Key 2	One

In the first two distributions, because Key 1 is locked in Room 1 itself and you can’t destroy Room 1, it is impossible to open Room 1. 
In the third and forth distributions, you have to destroy Room 2 and 3 both. In the last two distributions, you only need to destroy one of Room 2 or Room 

   
   
   
    
  
  

 

Source

2010 Asia Regional Tianjin Site —— Online Contest

解题思路：n把钥匙随机放在n个房间内，除了1号房间的门不能砸开外，你有k次砸门的机会，求k次机会之内你能开所有门的概率。转化为第一类stirling数问题，即n个人排成k的圈，在考虑圈内顺序的情况下求一共有多少种实现方法，所谓形成一个圈是指形如2号房间装有3号房间的钥匙，3号房间装有4号房间的钥匙，4号房间装有2号房间的钥匙，换言之，这3个房间形成了一个闭合回路，只要砸开任意一扇门就可以打开所有房间的门，因此k次砸门机会等价于n个房间形成了小于等于k的圈的且1号房间不单独成一个圈的总方案数，ans=sigma(s(n,i)-s(n-1,i-1),1<=i<=k),s(n,k)=s(n-1,k-1)+(n-1)*s(n-1,k),s(n,0)=0,s(1,1)=1，s(n,k)即为stirling数

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#define eps 1e-7
#define LL long long
using namespace std;
LL fac[21]={1};
LL stir1[21][21];
int main(){
    for(int i=1;i<21;i++)
        fac[i]=fac[i-1]*i;
    for(int i=1;i<=20;i++){
        stir1[i][0]=0;
        stir1[i][i]=1;
       for(int j=1;j<i;j++)
           stir1[i][j]=stir1[i-1][j-1]+(i-1)*stir1[i-1][j];
    }
    int t,n,k;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&k);
        if(n==1){
            printf("0.0000\n");
            continue;
        }
        LL sum=0;
        for(int i=1;i<=k;i++)
            sum+=stir1[n][i]-stir1[n-1][i-1];
        printf("%.4f\n",(double)sum/fac[n]);
    }
    return 0;
}