The beauty of programming Reading Notes (13): "finding qualified integers"

Question: given a positive integer N, evaluate a minimum positive integer m (M> 1) so that the decimal representation of N * M contains only 1 and 0.
To solve this problem, first consider whether such M must exist for any n. It can be proved that M exists and is not unique.
Simple Proof: Because

 

This is an infinite series, but each value in the series is between [0, N-1. Therefore, the infinite series must have cyclic knots in the middle. That is, if there is S, T is a positive integer, and S <t, there is. The cycle length is t-s. So 10 ^ s = 10 ^ t. Therefore:
, So

For example, if n = 3 is used, because any non-negative modulo 3 of 10 is 1, the cycle of the cyclic section is 1. There are:

Given N, evaluate M:
Method 1Given N, let m start from 2, enumerate m values until a m is met so that the decimal representation of N * m is only 1 and 0.
Method 2: Obtain the remainder sequence of the nth power sequence modulo n and find the cyclic section. Then search for the remainder sequence. The search aims to find some numbers in the remainder sequence so that their sum is a multiple of N. For example, n = 13. The sequence is 1, 10, 9, 12, 3, 4, and then repeats continuously. Obviously, 1 + 12 = 13, while 1 is the 0 power of 10, 12 is the 3 power of 10, so this number is 1000 + 1 = 1001, M is 1001/13 = 77.
Method 3: Because the value of N * m is 11,100,101,110,111,... so search in this space directly, this is an improvement to method 1. Search for this sequence until you find a number that can be divisible by N, which is N * m, and then calculate M. For example, if n = 3, the search tree is as follows:

The remainder of Modulo 3 in brackets. It indicates the number of searched items. The left subtree represents 0, and the right subtree represents 1. when the second layer is found (the root layer is layer 0th), it encounters 111, and the remainder of Modulo 3 is 0. so N * m = 111, M = 111/3 = 37.
Method 4: Improvement on method 3. The search space in method 3 is classified by model N remainder, so that the search time and space are reduced from the original exponential level to O (n ). Principle of improvement: Assuming that a K-digit decimal number consisting of 0 and 1 is being searched, the K-digit decimal number is 2 ^ K. Assume that there are two numbers x and y, and their modulo n is the same remainder, then when you search for k + 1 decimal numbers composed of 0 and 1, X and Y are extended to four numbers: 10x, 10x + 1, 10y, 10y + 1. Because X and Y are the same (they can be considered equal), 10 X and 10 y are the same, and 10 x + 1 and 10 y + 1 are the same. That is to say, the subtree extended by Y and the subtree generated by X extension produce the same remainder. If X is smaller than Y, Y is definitely not the smallest number that meets the requirements, so y can be cut off. In this way, the number of 2 ^ K is classified by the remainder of the modulo n, and only the smallest number of each type is reserved for expansion. Originally, we needed to search for the number of 2 ^ K at this layer. Now we only need to search for the number of O (n. For example, when n = 9, layer 0th is 1 (1 ),

As shown in, 2nd and 110 of Layer 3 are all cut out because the same layer has the same number and smaller number. If you search by method 3, the third layer should have eight nodes, but now there are only four nodes.

 

Source code of Method 1:

1. # Include <stdio. h>
3. IntHasonlyoneandzero (unsignedIntN ){
4. While(N ){
5. If(N % 10> = 2)Return0;
6. N/= 10;
7. }
8. Return1;
9. }
11. IntMain (){
12. IntN, m;
13. While(Scanf ("% d", & N )! = EOF ){
14. For(M = 1; m ++ ){
15. If(Hasonlyoneandzero (N * m )){
16. Printf ("n = % d, M = % d, n * m = % d/N", n, m, n * m );
17. Break;
18. }
19. }
20. }
21. Return0;
22. }

Source code of method 3:

1. // Solution 3 (1): breadth-first search
2. # DEFINE _ crt_secure_no_warnings 1
4. # Include <cstdio>
5. # Include <queue>
6. Using NamespaceSTD;
8. IntMain (){
9. IntN;
10. While(Scanf ("% d", & N )! = EOF ){
11. Queue <Int> Q;
12. Q. Push (1 );
13. While(! Q. Empty ()){
14. IntT = Q. Front ();
15. Q. Pop ();
16. If(T % N = 0 ){
17. Printf ("n = % d, M = % d, n * m = % d/N", N, T/N, t );
18. Break;
19. }
20. Q. Push (T * 10 );
21. Q. Push (T * 10 + 1 );
22. }
23. }
24. Return0;
25. }

Method 4 source code:

1. // Solution 4: divide the search space into the breadth of the category, so that the space is occupied by O (n) instead
2. // Exponential level. The classification principle is to classify according to the remainder of model N.
3. # DEFINE _ crt_secure_no_warnings 1
5. # Include <cstdio>
6. # Include <bitset>
7. # Include <vector>
8. # Include <queue>
9. Using NamespaceSTD;
11. StructQnode {
12. IntV, R; // v is value, R is Remainder
13. Qnode (IntVV,IntRr): V (VV), R (RR ){}
14. Qnode (): V (0), R (0 ){}
15. };
17. IntMain (){
18. IntN;
19. While(Scanf ("% d", & N )! = EOF ){
20. // Bitset <n> Bn;
21. Queue <qnode> q;
22. Q. Push (qnode (1, 1 ));
23. While(! Q. Empty ()){
24. // Bn. Reset ();
25. Vector <Bool> Bn (n,False);
26. IntS = Q. Size ();
27. While(S --){
28. Qnode T = Q. Front ();
29. If(T. R = 0 ){
30. Printf ("n = % d, M = % d, n * m = % d/N", N, T. V/N, T. V );
31. GotoOK;
32. }
33. Q. Pop ();
34. If(! BN [T. R * 10% N]) {
35. BN [T. R * 10% N] =True;
36. Q. Push (qnode (T. V * 10, T. R * 10% n ));
37. }
38. If(! BN [(T. R * 10 + 1) % N]) {
39. BN [(T. R * 10 + 1) % N] =True;
40. Q. Push (qnode (T. V * 10 + 1, (T. R * 10 + 1) % N ));
41. }
42. }
43. }
44. OK :;
45. }
46. Return0;
47. }

Link: http://blog.csdn.net/jcwKyl/archive/2009/02/02/3859155.aspx