整数划分和跳台阶问题

来源：互联网发布：三鹿乳业的网络公关编辑：程序博客网时间：2024/05/16 15:38

整数划分问题是算法中的一个经典命题之一，有关这个问题的讲述在讲解到递归时基本都将涉及。所谓整数划分，是指把一个正整数n写成如下形式：

n=m1+m2+...+mi; （其中mi为正整数，并且1 <= mi <= n），则{m1,m2,...,mi}为n的一个划分。

如果{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};

注意4=1+3 和 4=3+1被认为是同一个划分。

该问题是求出n的所有划分个数，即f(n, n)。下面我们考虑求f(n,m)的方法;

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

递归法

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

根据n和m的关系，考虑以下几种情况：

（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的代码）：

unsigned long  GetPartitionCount(int n, int max)
{
    if (n == 1 || max == 1)
        return 1;
    else if (n < max)
        return compute(n, n);
    else if (n == max)
        return 1 + GetPartitionCount(n, max-1);
    else
        return GetPartitionCount(n,max-1) + GetPartitionCount(n-max, max);
}

跳台阶问题
题目：一个台阶总共有n级，如果一次可以跳1级，也可以跳2级。求总共有多少总跳法，并分析算法的时间复杂度。

分析：这道题最近经常出现，包括MicroStrategy等比较重视算法的公司都曾先后选用过个这道题作为面试题或者笔试题。

首先我们考虑最简单的情况。如果只有1级台阶，那显然只有一种跳法。如果有2级台阶，那就有两种跳的方法了：一种是分两次跳，每次跳1级；另外一种就是一次跳2级。

现在我们再来讨论一般情况。我们把n级台阶时的跳法看成是n的函数，记为f(n)。当n>2时，第一次跳的时候就有两种不同的选择：一是第一次只跳1级，此时跳法数目等于后面剩下的n-1级台阶的跳法数目，即为f(n-1)；另外一种选择是第一次跳2级，此时跳法数目等于后面剩下的n-2级台阶的跳法数目，即为f(n-2)。因此n级台阶时的不同跳法的总数f(n)=f(n-1)+(f-2)。

我们把上面的分析用一个公式总结如下：

        / 1                          n=1
f(n)=      2                          n=2
        \ f(n-1)+(f-2)               n>2

分析到这里，相信很多人都能看出这就是我们熟悉的Fibonacci序列。

问题的解，是一个树形结构，我引入了TreeView中的节点TreeNode来成生这个树，它是一个典型递归：

//组装一个根节点成为一颗树
    static void AddNode(System.Windows.Forms.TreeNode root,int n)
    {
        if(n>2)
        {
            root.Nodes.Add("1");
            root.Nodes.Add("2");
            AddNode(root.Nodes[0],n-1);
            AddNode(root.Nodes[1],n-2);

        }
        else if(n==1)
        {
            root.Nodes.Add("1");
        }
        else if(n==2)
        {
            root.Nodes.Add("1");
            root.Nodes[0].Nodes.Add("1");

            root.Nodes.Add("2");
        }
    }

树组装好以后，每一个叶子节点的全路径就是一个解，因此将叶子节点的FullPath（路径）打印出来即为一个解，这里为了找到叶子节点，也是使用递归：

//打印出所有叶子节点的全路径
static void PrintNode(TreeNode node)
{
    //属于叶子节点！！！！则打印这个路径
    if(node.Nodes.Count==0)
        Console.WriteLine(node.FullPath);
    else
    {
        foreach(TreeNode child in node.Nodes)
        {
            PrintNode(child);
        }
    }
}

当输入n=5时，打印出所有叶子节点的FullPath如下：

root\1\1\1\1\1
root\1\1\1\2
root\1\1\2\1
root\1\2\1\1
root\1\2\2
root\2\1\1\1
root\2\1\2
root\2\2\1

我们可以把一个解在一个TreeView里面完整显示出来：

递归算法有一个很受限制的地方，它占用栈空间以深度的级数速度增长，如果深度太大，会迅速达到空间上限。因此只适合较浅深度求解。

1 0