Question: Keep n dice on the ground. The sum of all dice points is S. Input n to print the probability of all possible values of S.
Analysis 1: It is easy to know that if there are n dice, the minimum value of S is n (all is 1), and the maximum value is 6N (all is 6 ).
If there is only one dice, it is very simple. The number of s in the case of 1, 2, 3, 4, 5 and 6 is 1, and the probability is 1/6. Suppose there are n dice, and the sum of appearance is S, we can consider this if the first dice has 6 in the case, take 1, 2, 3, 4, 5, 6; then the sum of N-1-1 dice take s-1, S-2, S-3, S-4, s-5, S-6, we can sum up all of these situations to get the total number of cases. See? What's the problem? By the way, it is still a recursive problem. Based on the above analysis, we can easily write the following recursive formula:
Description of the formula: (1) f (S, N) indicates the total number of cases where n dice exist and the sum is S. (2) Explain the second line of the formula; if there is a dice, the number of points is 8 or 0, And we record it as 0, so that we can make it easier to solve the recursion. For example, we can see that F (8, 2) has a formula) = f () + f () If we specify F) if the value is 0, the calculation is much more convenient.
With the above analysis, we can write the following C ++Code:
1 # Include <iostream>
2 # Include < String >
3 # Include <cmath>
4 Using Namespace STD;
5
6
7 Int Dicemaxvalue = 6 ;
8 // Calculates the total number of dicenumber dice that appear in all possible conditions for the sum of dicetotalsum.
9 Int Fun ( Int Dicetotalsum, Int Dicenumber)
10 {
11 // The number of dice is less than 1, which is incorrect;
12 If (Dicenumber < 1 )
13 {
14 Cout < " Dicenumber must> = 1 " <Endl;
15 Return 0 ;
16 }
17
18 // Number of dice = 1; if it is between [1, 6] and S, the number of dice is 1;
19 // Otherwise, it is zero. For example, if there is a dice, it is impossible if the number of points is 0 or 8, and 0 is returned.
20 If (Dicenumber = 1 )
21 {
22 If (Dicetotalsum> = dicenumber & dicetotalsum <= dicemaxvalue * dicenumber ))
23 Return 1 ;
24 Else
25 Return 0 ;
26 }
27
28 // N> 1, recursion;
29 If (Dicenumber> 1 )
30 {
31 Int Sum = 0 ;
32 For ( Int I = 1 ; I <= dicemaxvalue; ++ I ){
33 Sum + = fun (dicetotalsum-I, dicenumber- 1 );
34 }
35 Return SUM;
36 }
37 }
38
39 // Given the number of dice, print the probability of various situations
40 Void Printsumprobabilityofdice ( Int Number)
41 {
42 If (Number < 1 )
43 {
44 Return ;
45 }
46
47 Int Maxsum = Number * dicemaxvalue;
48 Float * Pprobability = New Float [Maxsum-Number + 1 ];
49
50 // Array pprobability storage and S
51 For ( Int S = number; S <= maxsum; ++ S)
52 {
53 Pprobability [S-number] = fun (S, number );
54 }
55
56 // Calculate the total number of all cases
57 Int Total = POW (dicemaxvalue, number );
58
59 // Calculate probability and print Probability
60 For ( Int J = 0 ; J <maxsum-Number + 1 ; ++ J)
61 {
62 Pprobability [J]/= total;
63 Cout <j + number < " \ T " <Pprobability [J] <Endl;
64 }
65 Delete [] pprobability;
66 }
67
68
69
70 Int Main ()
71 {
72 Cout < " S " < " \ T " < " Probablility " <Endl;
73 Printsumprobabilityofdice (3 );
74 Return 0 ;
75 }
We calculate the three dice and the running condition is as follows:
In the definition at the beginning, I defined a variable that represents the maximum value of a single dice and assigned a value of 6, which draws on what he Haitao said to ensure the reusability of the Code.
Analysis 2: andAlgorithmThe method for solving the Fibonacci series in 2 is similar, the efficiency of recursion is too bad, we can solve it in a forward way, suppose we have an array to represent the number of points in the K-1 dice, so that the second component is expressed as the sum of the total number of cases, then when there are K dice is, the sum of S is the total number of cases, is to represent the K-1 of the array of the S-2 dice s-1, s-3, S-4, S-5, S-6 and (respectively to introduce the K dice values were 1, 2, 3, 4, 5, 6 can be, in fact, and the analysis of the idea of 1 is not too much ). Based on this idea, we can use two arrays to represent the array K-1 and array K, so we have the following code:
# Include <iostream>
# Include < String >
# Include <cmath>
Using Namespace STD;
Int Dicemaxvalue = 6 ;
Void Printprobabilityofdice ( Int Number)
{
Double * Pprobability [ 2 ];
Pprobability [ 0 ] = New Double [Number * dicemaxvalue + 1 ];
Pprobability [ 1 ] = New Double [Number * dicemaxvalue + 1 ];
// Initialize an array
For ( Int I = 0 ; I <Number * dicemaxvalue +1 ; ++ I)
{
Pprobability [ 0 ] [I] = 0 ;
Pprobability [ 1 ] [I] = 0 ;
}
Int Flag = 0 ;
// Assign a value of 1-6 to the subscript of the first Array
For (Int A = 1 ; A <= dicemaxvalue; ++)
{
Pprobability [flag] [a] = 1 ;
}
// The number of dice K cycles from 2 to N. For each K, the value of S is [K, 6 K], and the previous array is calculated for each S.
// The S-1, S-2, S-3, S-4, S-5, S-6; because the minimum value of the previous array is K-1, because S-j> = K-1;
For ( Int K = 2 ; K <= number; ++ K)
{
For ( Int S = K; S <= dicemaxvalue * k; ++ S)
{
Pprobability [ 1 -Flag] [s] = 0 ;
For ( Int J = 1 ; J <= dicemaxvalue & J <= s-K + 1 ; ++ J)
{
Pprobability [1 -Flag] [s] + = pprobability [flag] [S-J];
}
}
Flag = 1 -Flag;
}
// Divide By the total number to calculate and output the probability;
Double Total = POW (( Double ) Dicemaxvalue, number );
For ( Int Ss = number; SS <= Number * dicemaxvalue; ++ SS)
{
Pprobability [flag] [ss]/= total;
Cout <SS < " \ T " <Pprobability [flag] [ss] <Endl;
}
Delete [] pprobability [ 0 ];
Delete [] pprobability [ 1 ];
}
Int Main ()
{
Cout < " S " < " \ T " < " Probability " <Endl;
Printprobabilityofdice ( 4 );
Return 0 ;
}
The running result is as follows:
Finally, we can see that, as mentioned in [algorithm 02], although the time complexity of this algorithm has improved a lot, two arrays are created dynamically, in addition, the length of each array is not analyzed. The length of 1 is equal to N, so it is still the idea of changing the space for time. Now, this algorithm is here. I wish you a pleasant stay!
References:
[1] He Haitao blog: http://zhedahht.blog.163.com/blog/static/254111742009101524946359/
[2] Wikipedia: http://en.wikipedia.org/wiki/Dice#Probability
[3] http://www.helium.com/items/1538174-how-to-calculate-probability-using-multiple-dice
Note:
1) Compile all the code environments in this blogWin7 + vc6. All code has been debugged by the blogger.
2) BloggerPython27This blogArticleCopyright. For Network reprinting, please indicate the sourceHttp://www.cnblogs.com/python27/. You have any suggestions for solving the problem. Please feel free to comment on them.