cache式DP(记忆化dfs)

【bzoj1079】[SCOI2008]着色方案

2014年3月8日 170 0

Description

有n个木块排成一行，从左到右依次编号为1~n。你有k种颜色的油漆，其中第i种颜色的油漆足够涂ci个木块。所有油漆刚好足够涂满所有木块，即c1+c2+...+ck=n。相邻两个木块涂相同色显得很难看，所以你希望统计任意两个相邻木块颜色不同的着色方案。

Input

第一行为一个正整数k，第二行包含k个整数c1, c2, ... , ck。

Output

输出一个整数，即方案总数模1,000,000,007的结果。

Sample Input

3
1 2 3

Sample Output

HINT

【样例2】 Input 5 2 2 2 2 2 Output 39480 【样例3】 Input 10 1 1 2 2 3 3 4 4 5 5 Output 85937576 数据规模】 50%的数据满足：1 <= k <= 5, 1 <= ci <= 3 100%的数据满足：1 <= k <= 15, 1 <= ci <= 5

题解

直接集合dp肯定是不行的..考虑两种油漆如果当前都能涂x次，那么他们本质是一样的。

所以用F[a][b][c][d][e][l]表示当前有能涂1次的油漆a个，能涂2次的b个....前一个颜色为l，再搞下转移就行了。

记忆化实现常数会小一些

 
      
 
      
 
      
 
      
C++
 
   
 
     
      
       
           1 
         

           2 
         

           3 
         

           4 
         

           5 
         

           6 
         

           7 
         

           8 
         

           9 
         

           10 
         

           11 
         

           12 
         

           13 
         

           14 
         

           15 
         

           16 
         

           17 
         

           18 
         

           19 
         

           20 
         

           21 
         

           22 
         

           23 
         

           24 
         

           25 
         

           26 
         

           27 
         

           28 
         

           29 
         

           30 
         

           31 
         

           32 
         

           33 
         

           34 
         

           35 
         

           36 
         

           37 
         
 
        
          #include<iostream> 
         
 
          #include<cstdio> 
         
 
          #define ll long long 
         
 
          #define mod 1000000007 
         
 
          using 
            
          namespace 
            
          std 
          ; 
         
 
          ll 
            
          f 
          [ 
          16 
          ] 
          [ 
          16 
          ] 
          [ 
          16 
          ] 
          [ 
          16 
          ] 
          [ 
          16 
          ] 
          [ 
          6 
          ] 
          ; 
          int 
            
          x 
          [ 
          6 
          ] 
          , 
          n 
          ; 
         
 
          bool 
            
          mark 
          [ 
          16 
          ] 
          [ 
          16 
          ] 
          [ 
          16 
          ] 
          [ 
          16 
          ] 
          [ 
          16 
          ] 
          [ 
          6 
          ] 
          ; 
         
 
          ll  
          dp 
          ( 
          int 
            
          a 
          , 
          int 
            
          b 
          , 
          int 
            
          c 
          , 
          int 
            
          d 
          , 
          int 
            
          e 
          , 
          int 
            
          k 
          ) 
         
 
          { 
         
 
               
          ll 
            
          t 
          = 
          0 
          ; 
         
 
               
          if 
          ( 
          mark 
          [ 
          a 
          ] 
          [ 
          b 
          ] 
          [ 
          c 
          ] 
          [ 
          d 
          ] 
          [ 
          e 
          ] 
          [ 
          k 
          ] 
          ) 
          return 
            
          f 
          [ 
          a 
          ] 
          [ 
          b 
          ] 
          [ 
          c 
          ] 
          [ 
          d 
          ] 
          [ 
          e 
          ] 
          [ 
          k 
          ] 
          ; 
         
 
               
          if 
          ( 
          a 
          + 
          b 
          + 
          c 
          + 
          d 
          + 
          e 
          == 
          0 
          ) 
          return 
            
          1 
          ; 
         
 
               
          if 
          ( 
          a 
          ) 
             
         
 
                   
          t 
          += 
          ( 
          a 
          - 
          ( 
          k 
          == 
          2 
          ) 
          ) 
          * 
          dp 
          ( 
          a 
          - 
          1 
          , 
          b 
          , 
          c 
          , 
          d 
          , 
          e 
          , 
          1 
          ) 
          ; 
             
         
 
               
          if 
          ( 
          b 
          ) 
             
         
 
                   
          t 
          += 
          ( 
          b 
          - 
          ( 
          k 
          == 
          3 
          ) 
          ) 
          * 
          dp 
          ( 
          a 
          + 
          1 
          , 
          b 
          - 
          1 
          , 
          c 
          , 
          d 
          , 
          e 
          , 
          2 
          ) 
          ; 
             
         
 
               
          if 
          ( 
          c 
          ) 
             
         
 
                   
          t 
          += 
          ( 
          c 
          - 
          ( 
          k 
          == 
          4 
          ) 
          ) 
          * 
          dp 
          ( 
          a 
          , 
          b 
          + 
          1 
          , 
          c 
          - 
          1 
          , 
          d 
          , 
          e 
          , 
          3 
          ) 
          ; 
             
         
 
               
          if 
          ( 
          d 
          ) 
             
         
 
                   
          t 
          += 
          ( 
          d 
          - 
          ( 
          k 
          == 
          5 
          ) 
          ) 
          * 
          dp 
          ( 
          a 
          , 
          b 
          , 
          c 
          + 
          1 
          , 
          d 
          - 
          1 
          , 
          e 
          , 
          4 
          ) 
          ; 
             
         
 
               
          if 
          ( 
          e 
          ) 
             
         
 
                   
          t 
          += 
          e 
          * 
          dp 
          ( 
          a 
          , 
          b 
          , 
          c 
          , 
          d 
          + 
          1 
          , 
          e 
          - 
          1 
          , 
          5 
          ) 
          ; 
             
         
 
               
          mark 
          [ 
          a 
          ] 
          [ 
          b 
          ] 
          [ 
          c 
          ] 
          [ 
          d 
          ] 
          [ 
          e 
          ] 
          [ 
          k 
          ] 
          = 
          1 
          ; 
         
 
               
          return 
            
          f 
          [ 
          a 
          ] 
          [ 
          b 
          ] 
          [ 
          c 
          ] 
          [ 
          d 
          ] 
          [ 
          e 
          ] 
          [ 
          k 
          ] 
          = 
          ( 
          t 
          % 
          mod 
          ) 
          ; 
         
 
          } 
         
 
          int 
            
          main 
          ( 
          ) 
         
 
          { 
         
 
               
          scanf 
          ( 
          "%d" 
          , 
          &n 
          ) 
          ; 
         
 
               
          for 
          ( 
          int 
            
          i 
          = 
          1 
          ; 
          i 
          <= 
          n 
          ; 
          i 
          ++ 
          ) 
         
 
               
          { 
         
 
                       
          int 
            
          t 
          ; 
         
 
                       
          scanf 
          ( 
          "%d" 
          , 
          &t 
          ) 
          ; 
         
 
                       
          x 
          [ 
          t 
          ] 
          ++ 
          ; 
         
 
                       
          } 
         
 
               
          printf 
          ( 
          "%lld" 
          , 
          dp 
          ( 
          x 
          [ 
          1 
          ] 
          , 
          x 
          [ 
          2 
          ] 
          , 
          x 
          [ 
          3 
          ] 
          , 
          x 
          [ 
          4 
          ] 
          , 
          x 
          [ 
          5 
          ] 
          , 
          0 
          ) 
          ) 
          ; 
         
 
               
          return 
            
          0 
          ; 
         
 
          } 
         
 
      
 
     
   