整數劃分

時間 2019-11-18

標籤整數劃分简体版

原文原文鏈接

整數劃分問題是算法中的一個經典命題之一，有關這個問題的講述在講解到遞歸時基本都將涉及。所謂整數劃分，是指把一個正整數n寫成以下形式：html

n=m1+m2+...+mi; （其中mi爲正整數，而且1 <= mi <= n），則{m1,m2,...,mi}爲n的一個劃分。node

若是{m1,m2,...,mi}中的最大值不超過m，即max(m1,m2,...,mi)<=m，則稱它屬於n的一個m劃分。這裏咱們記n的m劃分的個數爲f(n,m);算法

例如但n=4時，他有5個劃分，{4},{3,1},{2,2},{2,1,1},{1,1,1,1};c#

注意4=1+3 和 4=3+1被認爲是同一個劃分。數組

該問題是求出n的全部劃分個數，即f(n, n)。下面咱們考慮求f(n,m)的方法;函數

---------------------------------------------------------------------ui

（一）遞歸法this

---------------------------------------------------------------------spa

根據n和m的關係，考慮如下幾種狀況：code

（1）當 n = 1 時，不論m的值爲多少（m > 0 )，只有一種劃分即 { 1 };

(2) 當 m = 1 時，不論n的值爲多少，只有一種劃分即 n 個 1，{ 1, 1, 1, ..., 1 };

(3) 當 n = m 時，根據劃分中是否包含 n，能夠分爲兩種狀況：

(a). 劃分中包含n的狀況，只有一個即 { n }；

(b). 劃分中不包含n的狀況，這時劃分中最大的數字也必定比 n 小，即 n 的全部 ( n - 1 ) 劃分。

所以 f(n, n) = 1 + f(n, n-1);

(4) 當 n < m 時，因爲劃分中不可能出現負數，所以就至關於 f(n, n);

(5) 但 n > m 時，根據劃分中是否包含最大值 m，能夠分爲兩種狀況：

(a). 劃分中包含 m 的狀況，即 { m, { x1, x2, ..., xi } }, 其中 { x1, x2, ..., xi } 的和爲 n - m，可能再次出現 m，所以是（n - m）的 m 劃分，所以這種劃分

個數爲 f(n-m, m);

(b). 劃分中不包含 m 的狀況，則劃分中全部值都比 m 小，即 n 的 ( m - 1 ) 劃分，個數爲 f(n, m - 1);

所以 f(n, m) = f(n - m, m) + f(n, m - 1);

綜合以上狀況，咱們能夠看出，上面的結論具備遞歸定義特徵，其中（1）和（2）屬於迴歸條件，（3）和（4）屬於特殊狀況，將會轉換爲狀況（5）。而狀況（5）爲通用狀況，屬於遞推的方法，其本質主要是經過減少m以達到迴歸條件，從而解決問題。其遞推表達式以下：

f(n, m) = 1; ( n = 1 or m = 1 )

f(n, n); ( n < m )

1+ f(n, m - 1); ( n = m )

f(n - m, m) + f(n, m - 1); ( n > m )

所以咱們能夠給出求出 f(n, m) 的遞歸函數代碼以下（引用 Copyright Ching-Kuang Shene July / 23 / 1989 的代碼）：

 1 unsigned long  GetPartitionCount(int n, int max)
 2  {
 3      if (n == 1 || max == 1)
 4          return 1;
 5      else if (n < max)
 6          return GetPartitionCount(n, n);
 7      else if (n == max)
 8          return 1 + GetPartitionCount(n, max-1);
 9      else
10          return GetPartitionCount(n,max-1) + GetPartitionCount(n-max, max);
11  }

咱們能夠發現，這個命題的特徵和另外一個遞歸命題：

「上臺階」問題（斐波那契數列）（http://www.cnblogs.com/hoodlum1980/archive/2007/07/13/817188.html）

類似，也就是說，因爲樹的「自然遞歸性」，使這類問題的解能夠經過樹來展示，每個葉子節點的路徑是一個解。所以把上面的函數改造一下，讓全部劃分裝配到一個.NET類庫中的TreeView控件，相關代碼（c#）以下：

 1  /// <param name="root">樹的根結點</param>
 2          /// <param name="n">被劃分的整數</param>
 3          /// <param name="max">一個劃分中的最大數</param>
 4          /// <returns>返回劃分數，即葉子節點數</returns>
 5          private int BuildPartitionTree(TreeNode root, int n, int max)
 6          {
 7              int count=0;
 8              if( n==1)
 9              {
10                  //{n}即1個n
11                  root.Nodes.Add(n.ToString());//{n}
12                  return 1;
13              }
14              else if( max==1)
15              {
16                  //{1,1,1,,1} 即n個1
17                  TreeNode lastNode=root;
18                  for(int j=0;j<n;j++)
19                  {
20                      lastNode.Nodes.Add("1");
21                      lastNode=lastNode.LastNode;
22                  }
23                  return 1;
24              }
25              else if(n<max)
26              {
27                  return BuildPartitionTree(root, n, n);
28              }
29              else if(n==max)
30              {
31                  root.Nodes.Add(n.ToString()); //{n}
32                  count=BuildPartitionTree(root, n, max-1);
33                  return count+1;
34              }
35              else
36              {
37                  //包含max的分割，{max, {n-max}}
38                  TreeNode node=new TreeNode(max.ToString());
39                  root.Nodes.Add(node);
40                  count += BuildPartitionTree(node, n-max, max);
41  
42                 //不包含max的分割，即全部max-1分割
43                  count += BuildPartitionTree(root, n, max-1);
44                  return count;
45              }
46          }

若是咱們要輸出全部解，只須要輸出全部葉子節點的路徑便可，能夠一樣用遞歸函數來輸出全部葉子節點（代碼中使用了一個StringBuilder對象來接收全部葉子節點的路徑）：

 1 private void PrintAllLeafPaths(TreeNode node)
 2          {
 3              //屬於葉子節點?
 4              if(node.Nodes.Count==0)
 5                  this.m_AllPartitions.AppendFormat("{0}\r\n", node.FullPath.Replace('\\',','));
 6              else
 7              {
 8                  foreach(TreeNode child in node.Nodes)
 9                  {
10                      this.PrintAllLeafPaths(child);
11                  }
12              }
13          }

這個小例子的運行效果以下（源代碼都在文中，就不提供下載連接）：

經過遞歸思路，咱們給出了n的劃分個數的算法，也把全部劃分組裝到一棵樹中。好，關於遞歸思路咱們就暫時介紹到這裏。關於輸出全部劃分的標準代碼在這裏省略了，咱們有時間再作詳細分析。

---------------------------------------------------------------------

（二）母函數法

---------------------------------------------------------------------

下面咱們從另外一個角度即「母函數」的角度來考慮這個問題。

所謂母函數，即爲關於x的一個多項式G（x）：

有 G（x）= a0 + a1*x + a2*x^2 + a3*x^3 + ...

則咱們稱G（x）爲序列（a0，a1，a2，...）的母函數。關於母函數的思路咱們不作更多分析。

咱們從整數劃分考慮，假設n的某個劃分中，1的出現個數記爲a1，2的個數記爲a2，..., i的個數記爲ai，

顯然: ak<=n/k; (0<= k <=n)

所以n的劃分數f(n,n)，也就是從1到n這n個數字中抽取這樣的組合，每一個數字理論上能夠無限重複出現，即個數隨意，使他們的總和爲n。顯然，數字i能夠有以下可能，出現0次（即不出現），1次，2次，..., k次，等等。把數字i用(x^i)表示，出現k次的數字i用 x^(i*k)表示，不出現用1表示。例如數字2用x^2表示，2個2用x^4表示，3個2用x^6表示，k個2用x^2k表示。

則對於從1到N的全部可能組合結果咱們能夠表示爲：

G(x) = (1+x+x^2+x^3+...+x^n) (1+x^2+x^4+...) (1+x^3+x^6+...) ... (1+x^n)

= g(x,1) g(x,2) g(x,3) ... g(x, n)

= a0 + a1* x + a2* x^2 + ... + an* x^n + ... ; （展開式）

上面的表達式中，每個括號內的多項式表明了數字i的參與到劃分中的全部可能狀況。所以該多項式展開後，因爲x^a * x^b=x^(a+b)，所以 x^i 就表明了i的劃分，展開後(x^i)項的係數也就是i的全部劃分的個數，即f(n,n)=an （上式中g（x，i）表示數字i的全部可能出現狀況）。

由此咱們找到了關於整數劃分的母函數G（x）；剩下的問題是，咱們須要求出G（x）的展開後的全部係數。

爲此咱們首先要作多項式乘法，對於咱們來講並不困難。咱們把一個關於x的一元多項式用一個整數數組a[]表示，a[i]表明x^i的係數，即：

g(x) = a[0] + a[1]x + a[2]x^2 + ... + a[n]x^n;

則關於多項式乘法的代碼以下，其中數組a和數組b表示兩個要相乘的多項式，結果存儲到數組c：

 1 #define N 130
 2  unsigned long a[N];/*多項式a的係數數組*/
 3  unsigned long b[N];/*多項式b的係數數組*/
 4  unsigned long c[N];/*存儲多項式a*b的結果*/
 5  
 6 /*兩個多項式進行乘法，係數分別在a和b中，結果保存到c ，項最大次數到N */
 7  /*注意這裏咱們只須要計算到前N項就夠了。*/
 8  void Poly()
 9  {
10      int i,j;
11      memset(c,0,sizeof(c));
12      for(i=0; i<N; i++)
13              for(j=0; j<N-i; j++) /*y<N-i： 確保i+j不會越界*/
14                    c[i+j] += a[i]*b[j];
15  }

下面咱們求出G（x）的展開結果，G（x）是n個多項式連乘的結果：

 1 /*計算出前N項係數！即g(x,1) g(x,2)... g(x,n)的展開結果*/
 2  void Init()
 3  {
 4      int i,k;
 5      memset(a,0,sizeof(a));
 6      memset(c,0,sizeof(c));
 7      for(i=0;i<N;i++) a[i]=1; /*第一個多項式：g(x, 1) = x^0 + x^1 + x^2 + x^3 +  */
 8      for(k=2;k<N;k++)
 9      {
10          memset(b,0,sizeof(b));
11          for(i=0;i<N;i+=k) b[i]=1;/*第k個多項式：g(x, k) = x^0 + x^(k) + x^(2k) + x^(3k) +  */
12          Poly(); /* 多項式乘法：c= a*b */
13          memcpy(a,c,sizeof(c)); /*把相乘的結果從c複製到a中：c=a; */
14      }
15  }

經過以上的代碼，咱們就計算出了G（x）的展開後的結果，保存到數組c中。此時有：f(n,n)=c[n];剩下的工做只是把相應的數組元素輸出便可。

問題到了這裏已經解決完畢。但咱們發現，針對該問題，g(x,k)是一個比較特殊的多項式，特色是隻有k的整數倍的索引位置有項，而其餘位置都爲0，具備項「稀疏」的特色，而且項次分佈均勻（次數跨度爲k）。這樣咱們就能夠考慮在計算多項式乘法時，能夠減小一些循環。所以能夠對Poly函數作這樣的一個改進，即把k做爲參數傳遞給Poly：

 1 /*兩個多項式進行乘法，係數分別在a和b中，結果保存到c ，項最大次數到N */
 2  /*改進後，多項式a乘以一個有特殊規律的多項式b，即b中只含有x^(k*i)項，i=0,1,2,*/
 3  /*若是b沒有規律，只須要把k設爲1，即與原來函數等效*/
 4  void Poly2(int k) /*參數k的含義：表示b中只有b[k*i]不爲0！*/
 5  {
 6      int i,j;
 7      memset(c,0,sizeof(c));
 8      for(i=0; i<N; i++)
 9              for(j=0; j<N-i; j+=k)
10                    c[i+j] += a[i]*b[j];
11  }

這樣，原有的函數能夠認爲是k=1的狀況（即多項式b不具備上訴規律）。相應的，在上面的Init函數中的調用改成Poly2(k)便可。

---------------------------------------------------------------------------------

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。