USACO Contact, Stamps， 哈希，动态规划

1、contact

这题估计是丢俺老脸的题，因为俺就直接枚举了。唯一的trick是对于 01, 001这样的字符串，计算hash值的时候，需要记得转换为 101, 1001这样的形式，不然肯定就混淆了，所以直接上代码吧，应该好懂。

1. /*
2. ID:fairyroad
3. LANG:C++
4. TASK:contact
5. */
6. #include <fstream>
7. #include <string>
8. #include <algorithm>
9. using  namespace std ;
10.  
11. ifstream fin ( "contact.in" ) ;
12. ofstream fout ( "contact.out" ) ;
13.  
14. #define MAXNUM 16385 // 1<<14 + 1
15. size_t A, B, N ;
16. string s ;
17.  
18. struct Sequence  {
19.      int cnt ;
20.     string str ;
21.     Sequence ( )  : cnt ( 0 ), str ( "" )  { }
22.     Sequence ( int c, string s )  : cnt (c ), str (s )  { }
23.      bool operator > ( const Sequence & other )  const  {
24.          if (cnt  > other. cnt )  return  true ;
25.          if (cnt  == other. cnt )  {
26.              if (str. length ( )  < other. str. length ( ) )  return  true ;
27.              else  if  (str. length ( )  == other. str. length ( ) )  return str  < other. str ;
28.              else  return  false ;
29.          }
30.          return  false ;
31.      }
32. } ;
33.  
34. Sequence hash [MAXNUM ] ;
35.  
36. int main ( )
37. {
38.     fin  >> A  >> B  >> N ;
39.     string line ;
40.      while (getline (fin, line ) )
41.         s + =line ;
42.  
43.      int num ;
44.      size_t j, k ;
45.  
46.      for ( size_t i  = A ; i  <= B ;  ++i )
47.      {
48.          for (j  =  0  ; j  + i  <= s. size ( ) ;  ++j )
49.          {
50.             num  =  1 ; // 注意这里，关键就在这里了
51.              for (k  = j ; k  - j  < i ;  ++k )
52.              {
53.                 num  <<=  1 ;
54.                  if (s [k ]  ==  '1' ) num  + =  1 ;
55.              }
56.  
57.              if ( !hash [num ]. cnt )
58.              {
59.                 hash [num ]. cnt  =  1 ;
60.                 hash [num ]. str  = string (s, j, i ) ;
61.              }
62.              else
63.             hash [num ]. cnt  ++ ;
64.          }
65.      }
66.  
67.     sort (hash, hash  + MAXNUM, greater <Sequence > ( ) ) ; // 可以在前面的循环中就建立一个大小为N的堆
68.  
69.      int linenum  =  1, precnt  = hash [ 0 ]. cnt ;
70.     fout  << hash [ 0 ]. cnt  <<  '\n'  << hash [ 0 ]. str ;
71.      size_t i, outline  =  1 ;
72.  
73.      for (i  =  1 ; i  < MAXNUM ;  ++i )
74.      {
75.          if ( !hash [i ]. cnt )  break ;
76.  
77.          if (hash [i ]. cnt  == precnt )
78.          {
79.              if (linenum  <  6 )
80.              {
81.                 linenum  ++ ;
82.                 fout  <<  ' '  << hash [i ]. str ;
83.              }
84.              else
85.              {
86.                 linenum  =  1 ;
87.                 fout  <<  '\n'  << hash [i ]. str ;
88.              }
89.          }
90.          else
91.          {
92.              if (outline  == N )  break ;
93.             precnt  = hash [i ]. cnt ;
94.             fout  <<  '\n'  << hash [i ]. cnt  <<  '\n'  << hash [i ]. str ;
95.             linenum  =  1 ;
96.             outline ++ ;
97.          }
98.      }
99.  
100.     fout  << endl ;
101.      return  0 ;
102. }

2、Stamps

这题我比较喜欢，我想凡是做过ACM的多少都有点似曾相识的感觉，因为这题多少可以算是背包问题的变种，而背包问题几乎是ACM必修课了，下面直接给出DP公式：

f(m) = 

1. dp(m) if dp(m) is set

2. min(dp(m-s(i)) + 1, for i in [0, n)

因为2中有一个循环，所以复杂度是O(N*M)。

1. /*
2. ID:fairyroad
3. LANG:C++
4. TASK:stamps
5. */
6. #include <fstream>
7. using  namespace std ;
8.  
9. ifstream fin ( "stamps.in" ) ;
10. ofstream fout ( "stamps.out" ) ;
11.  
12. int k, n ;  // 可以使用的邮票的张数，邮票种类
13. int s [ 50 ] ;
14. int dp [ 10000 * 200 + 1 ] ;
15.  
16. int main ( )
17. {
18.     fin  >> k  >> n ;
19.      int i, min, curr  =  0, tmp ;
20.      for (i  =  0 ;i  < n ;  ++i )
21.      {
22.         fin  >> s [i ] ;
23.         dp [s [i ] ]  =  1 ;  // 这些面值可以直接获取
24.      }
25.  
26.      while ( true )
27.      {
28.          ++curr ;
29.          if (dp [curr ]  ! =  0 )  continue ;  // 注意curr是从1开始升上去的
30.        
31.         min  = k + 1 ;
32.          for ( i  =  0 ; i  < n ;  ++i )
33.          {
34.             tmp  = curr -s [i ] ;
35.              if (tmp  <=  0 )  continue ;   // 输入的邮票面值集合不一定是从小到大排好序的
36.              if (dp [tmp ]  +  1  < min )
37.                 min  = dp [curr -s [i ] ]  +  1 ;
38.          }
39.  
40.          if (min  > k )  break ;
41.  
42.         dp [curr ]  = min ;
43.      }
44.  
45.     fout  << curr - 1  << endl ;
46.      return  0 ;
47. }

老生常谈，大多数情况下，动态规划是缩时利器，虽然空间上会打点折扣。而DP的关键就是要写出那个递推公式。一句八卦就是，如果你熟练掌握了动态规划，大多数情况下，面试中你可以藐视众多面试题~