动态规划_C#

先不管动态规划，先看斐波那契数列

斐波那契数列：F1=Fn-1+Fn-2

分别用递归和非递归实现一下

递归

    //递归
    public int FibnacciA(int n)
    {
        int res;
        if (n == 1 || n == 2)
            res = 1;
        else
            res = (FibnacciA(n - 1) + FibnacciA(n - 2));
        return res;
    }

非递归

    //非递归
    public int FibnacciB(int n)
    {
        List<int> f = new List<int>() { 0, 1, 1 };//斐波那契数列先初始化前3个特殊的
        if (n>2)
        {
            //n=3 计算1次 n=5 计算3次
            for (int i = 0; i < n-2; i++)
            {
                int fl= f.Count;
                f.Add(f[fl - 1] + f[fl - 2]);
            }
        }
        return f[n];
    }

经过测试都是对的，但是重点不是这个，重点是运行时间

很明显非递归快的多，而且递归50或者100的时候，我直接卡死了。为啥

因为递归方法里有很多子问题的重复计算，而且数字越大，子问题重复越严重 

而非递归的方法里子问题不会重复，而是存起来了

那么非递归的那个方法就可以称为动态规划（DP） 

能够动态规划的问题需要两个关键点 1有递推式 2有重复子问题

---

钢条切割问题

某公司出售钢条，出售价格与钢条长度之间的关系如下表：

问题：现有一段长度为n的钢条和上面的价格表，求切割钢条方案，使得总收益最大。 

 举个栗子，下面列出的是0-10的最优收益

长度1的时候不用切就是1,长度2的时候可以切1+1，可以不切5，得到5，长度3的时候，首先不切是8，切1和2，2还可以切，但是2其实我们之前已经切过了，最优是5，所以不用继续考虑了，1和2就是1+5=6，最优是8，直接看长度8的时候，可以不切20，

可以切1和7,7之前也考虑过了是17，所以1和7就是1+18=19，最后发现最优是2和6，也就是5+17=22。

到这里其实我们发现这是一个递归的问题。那么我们需要一个递推式

递推式 R(n)=Max(P(n),R(1)+R(n-1),R(2)+R(n-2),.....,R(n-1)+R(1));

 

 //递推式 R(n)=Max(P(n),R(1)+R(n-1),R(2)+R(n-2),.....,R(n-1)+R(1));
    public int CutRodA(int n)
    {
        int[] P = new int[] { 0, 1, 5, 8, 9, 10, 17, 17, 20, 24, 30 };//价格表
        int res = 0;
        if (n == 0)
            res= 0;
        else
        {
            res = P[n];//不切
            for (int i = 1; i < n; i++)
            {
                res = Mathf.Max(res,CutRodA(i)+CutRodA(n-i));
            }
        }
        return res;
    }

测试一下

 其实这个递推式还可以再简化，就是

从钢条的左边切割下长度为i的一段，只对右边剩下的一段继续进行切割，左边的不再切割

递推式就变成

    public int CutRodB(int n)
    {
        int[] P = new int[] { 0, 1, 5, 8, 9, 10, 17, 17, 20, 24, 30 };//价格表
        int res = 0;
        if (n == 0)
            res = 0;
        else
        {
            res = P[n];//不切
            //1<=i<=max
            for (int i = 1; i < n+1; i++)
            {
                res = Mathf.Max(res, P[i] + CutRodA(n - i));
            }
        }
        return res;
    }

 测试一下

但是 ，这两种方法都是自顶向下递归，会产生子问题重复，而且也是钢条越长，子问题重复越厉害

 自顶向下从n开始，问题越分越细

也就是4需要3210,3需要210，越分越细

那么1有递推式，2有重复子问题，我们就可以用动态规划了，自底向上实现

    //自底向上
    public int CutRodC(int n)
    {
        int[] P = new int[] { 0, 1, 5, 8, 9, 10, 17, 17, 20, 24, 30 };//价格表
        List<int> r = new List<int>();//还是需要一个列表存子问题
        r.Add(0);//0长度收益0
        for (int i = 1; i < n + 1; i++)//自底向上从1开始存子问题
        {
            int res = 0;//每次需要重新计算收益
            //利用的是简化的递推式2，对于这个循环i就是n,j就是i
            for (int j = 1; j < i + 1; j++)
            {
                //本来r[i-j]也就是n-1，是需要递归，但是因为我们已经存过了，直接取就好了
                res = Mathf.Max(res,P[j]+r[i-j]);
            }
            r.Add(res);
        }
        return r[n];
    }

我尽力注释了，但是还是可能有点绕，需要好好理解

测试一下他们的时间

动态规划明显快了很多

如果你想测试更长的钢条，你需要自己定制一个相应长度的价格表