USACO fact4, spin

1、fact4

这个问题在《编程之美》上有过一个类似的问题，大概是求阶乘 n! 后面有多少个0，最后可以转换为求[1,N]之间因子5有多少次。这个问题和fact4有点渊源，对于 n! 的尾数，看看规律就知道了：

1!  = 1
2!  = 2
3!  = 6
4!  = 24
5!  = 120
6!  = 720
7!  = 5,040
8!  = 40,320
9!  = 362,880
10! = 3,628,800
11! = 39,916,800
12! = 479,001,600
13! = 6,227,020,800
14! = 87,178,291,200
15! = 1,307,674,368,000
16! = 20,922,789,888,000

其实都是有 (n-1)! 的非0尾数与 n 乘积的尾数，唯一的麻烦是遇到了5，就会使得尾数变0，这时候要往进位去找新产生的尾数。好了，所有的 Trick 都在这了。我们看到题目指出 n 不大于4220 < 5^6，所以，代码如下，注意那个pow：

1. #include
2. using  namespace std ;
3.  
4. ifstream fin ( "fact4.in" ) ;
5. ofstream fout ( "fact4.out" ) ;
6.  
7. int N ;
8.  
9. int main ( )
10. {
11.     fin  >> N ;
12.  
13.      int multiplier  =  1,  pow  =  100000, factor ;
14.      for ( int i  =  1 ; i  <= N ;  ++i )
15.      {
16.         factor  = i  %  pow ;
17.         multiplier  = multiplier  * factor ;
18.  
19.          while (multiplier  %  10  ==  0 )
20.             multiplier  / =  10 ;
21.  
22.          while (multiplier  /  pow  >  0 )
23.             multiplier  % =  pow ;
24.      }
25.  
26.     fout  << multiplier  %  10  << endl ;
27.  
28.      return  0 ;
29. }

2、spin

单纯朴素模拟，借助STL的bitset来存储轮子们的位置信息，因为数据量实在是小，所以没必要用线段树来做时空优化了，要是用线段树，肯定要快N倍吧。然后其实你不用bitset，直接开一个bool数组也是OK的。

1. #include
2. #include
3. using  namespace std ;
4. ifstream fin ( "spin.in" ) ;
5. ofstream fout ( "spin.out" ) ;
6.  
7. #define PI 360
8. int speed [ 6 ] ;
9. bitset <PI > curr [ 6 ], next [ 6 ] ;
10.  
11. int main ( )
12. {
13.      int num, start, end ;
14.      for ( int i = 1 ; i <= 5 ; i ++ )
15.      {
16.         fin  >> speed [i ]  >> num ;
17.          for ( int j  =  1 ; j  <= num ; j ++ )
18.          {
19.             fin  >> start  >> end ;
20.             end  + = start ;
21.              for ( int k  = start ; k  <= end ; k ++ )
22.                 curr [i ]. set (k %PI ) ;
23.          }
24.      }
25.    
26.      int angle  =  0 ;
27.      bool flag ;
28.      while (angle  < PI )
29.      {
30.          for ( int i  =  0 ; i  < PI ;  ++i )
31.          {
32.             flag  =  false ;
33.              for ( int j  =  1 ; j  <=  5 ; j ++ )
34.              {
35.                  if ( !curr [j ]. test (i ) )
36.                  {
37.                     flag  =  true ;
38.                      break ;
39.                  }
40.              }
41.              if ( !flag )
42.              {
43.                 fout  << angle  << endl ;
44.                  return  0 ;
45.              }
46.          }
47.        
48.          for ( int i  =  1 ; i  <=  5 ; i ++ )
49.          {
50.              for ( int j  =  0 ; j  < PI ; j ++ )
51.                 next [i ] [j ]  = curr [i ] [ (j +PI -speed [i ] ) %PI ] ;
52.             curr [i ] =next [i ] ;
53.          }
54.        
55.          ++angle ;
56.      }
57.    
58.     fout  <<  "none"  << endl ;
59.      return  0 ;
60. }