C#内功修炼(算法)——动态规划(四)

动态规划（Dynamic Programming）

动态规划算法通常基于一个递推公式及一个或多个初始状态。当前子问题的解将由上一次子问题的解推出。

动态规划和分治法相似，都是通过组合子问题的解来求解原问题。分治法将问题划分成互不相交的子问题，递归求解子问题，再将他们的解组合起来，求出原问题的解。与之相反，动态规划应用于子问题重叠的情况，即不同的子问题具有公共的子子问题。在这种情况下，分治算法会做出许多不必要的工作，它会反复的求解那些公共子问题。而动态规划算法对每个子子问题只求解一次，将结果保存到表格中，从而无需每次求解一个子子问题都要重新计算。

动态规划 - 钢条切割问题

假定我们知道sering公司出售一段长度为I英寸的钢条的价格为pi(i=1,2,3….)钢条长度为整英寸如图给出价格表的描述（任意长度的钢条价格都有）

先给我们一段长度为n的钢条，问怎么切割，获得的收益最大rn?

考虑n=4的时候

假如一个最优解把n段七个成了k段（1<=k<=n）,那么最优切割方案：

        

最大收益：

        

        

第一种求最优解方案：

对于 r n(n>=1)，最优切割收益：

        

将切割方案分成下面几种

1，不切割  收益为pn

2，将它切割成两半，切割成两半的情况有，对每种情况求最优解

      (1,n-1) (2,n-2) (3,n-3) (4,n-4) ..... (n-1,1)

      对这两半分别求最优解,最优解的和就是当前情况的最优解

第二种求最优解方案：

我们从钢条的左边切下长度为i的一段，只对右边剩下长度为n-i的一段继续进行切割，对左边的不再切割。这样，不做任何切割的方案就是：当第一段长度为n的时候，收益为pn，剩余长度为0，对应的收益为0。如果第一段长度为i，收益为pi：

        

代码实现 - 自顶向下递归实现

    private void Start()
    {
        int n = 5;
        int[] price = { 0, 1, 5, 8, 9, 10, 17, 17, 20, 24, 30 };
        UpDown(n, price);
    }

    //递归实现
    private int UpDown(int n, int[] price)
    {
        if (n == 0) return 0;
        int tempMaxPrice = 0;
        for (int i = 1; i < n + 1; i++)
        {
            int maxPrice = price[i] + UpDown(n - 1, price);
            if (maxPrice > tempMaxPrice)
            {
                tempMaxPrice = maxPrice;
            }
        }
        return tempMaxPrice;
    }

分析效率，关于上述方法的运行性能时间问题。

动态规划的方法进行求解

上面的方法之所以效率很低，是因为它反复求解相同的子问题。因此，动态规划算法安排求解的顺序，对每个子问题只求解一次，并将结果保存下来。如果随后再次需要此子问题的解，只需查找保存的结果，不必重新计算。因此动态规划的方法是付出额外的内存空间来节省计算时间。

动态规划有两种等价的实现方法（我们使用上面的钢条切割问题为例，实现这两种方法）

第一种方法是带备忘的自顶向下法

  此方法依然是按照自然的递归形式编写过程，但过程中会保存每个子问题的解（通常保存在一个数组中）。当需要计算一个子问题的解时，过程首先检查是否已经保存过此解。如果是，则直接返回保存的值，从而节省了计算时间；如果没有保存过此解，按照正常方式计算这个子问题。我们称这个递归过程是带备忘的。

    //动态规划
    private void Start()
    {
        int n = 5;
        int[] result = new int[n + 1];  //备忘录
        int[] price = { 0, 1, 5, 8, 9, 10, 17, 17, 20, 24, 30 };
        UpDown(n, price, result);
    }

    //带备忘录
    private int UpDown(int n, int[] price, int[] result)
    {
        if (n == 0) return 0;
        if (result[n] != 0)
        {
            return result[n];
        }
        int tempMaxPrice = 0;
        for (int i = 1; i < n + 1; i++)
        {
            int maxPrice = price[i] + UpDown(n - 1, price, result);
            if (maxPrice > tempMaxPrice)
            {
                tempMaxPrice = maxPrice;
            }
        }
        result[n] = tempMaxPrice;
        return tempMaxPrice;
    }

第二种方法是自底向上法

  首先恰当的定义子问题的规模，使得任何问题的求解都只依赖于更小的子问题的解。因而我们将子问题按照规模排序，按从小到大的顺序求解。当求解某个问题的时候，它所依赖的更小的子问题都已经求解完毕，结果已经保存。 

    private int BottonUp(int n, int[] price, int[] result)
    {
        for (int i = 1; i < n + 1; i++)
        {
            int tempMax = -1;
            for (int j = 1; j <= i; j++)
            {
                int maxPrice = price[j] + result[i - j];
                if (maxPrice > tempMax)
                {
                    tempMax = maxPrice;
                }
            }
            result[i] = tempMax;
        }
        return result[n];
    }

动态规划 - 背包问题

问题描述：

  假设现有容量m kg的背包，另外有i个物品，重量分别为w[1] w[2] ... w[i] （kg）,价值分别为p[1] p[2] ... p[i] （元）,将哪些物品放入背包可以使得背包的总价值最大？最大价值是多少？

（示例一：m=10  i=3  重量和价值分别为3kg-4元 4kg-5元 5kg-6元  ）

1，穷举法（把所有情况列出来，比较得到 总价值最大的情况）

    private void Start()
    {
        int m;
        int[] w = { 0, 3, 4, 5 };
        int[] p = { 0, 4, 5, 6 };
    }

    private int Exhaustivity(int m, int[] w, int[] p)
    {
        int i = w.Length - 1;//物品的个数

        int maxPrice = 0;
        for (int j = 0; j < Mathf.Pow(2, m); j++)
        {
            //取得j 上某一个位的二进制值 
            int weightTotal = 0;
            int priceTotal = 0;
            for (int number = 1; number <= i; number++)
            {
                int result = Get2(j, number);
                if (result == 1)
                {
                    weightTotal += w[number];
                    priceTotal += p[number];
                }
            }
            if (weightTotal <= m && priceTotal > maxPrice)
            {
                maxPrice = priceTotal;
            }
        }
        return maxPrice;
    }

    //取得j上第number位上的二进制值，是1还是0
    public static int Get2(int j, int number)
    {
        int A = j;
        int B = (int)Mathf.Pow(2, number - 1);
        int result = A & B;
        if (result == 0)
            return 0;
        return 1;
    }

  如果容量增大，物品增多，这个方法的运行时间将成指数增长

2，动态规划算法

  我们要求得i个物体放入容量为m(kg)的背包的最大价值（记为c[i，m]）。在选择物品的时候，对于每种物品i只有两种选择，即装入背包或不装入背包。某种物品不能装入多次（可以认为每种物品只有一个），因此该问题被称为0-1背包问题

  对于c[i，m]有下面几种情况：

  a、c[i,0]=c[0,m]=0

  b、c[i,m]=c[i-1,m]  w[i]>m（最后一个物品的重量大于容量，直接舍弃不用）

        w[i]<=m的时候有两种情况，一种是放入i，一种是不放入i

              不放入i c[i,m]=c[i-1,m]

              放入i   c[i,m]=c[i-1,m-w[i]]+p[i]

       c[i,m]=max(不放入i，放入i)

    private void Start()
    {
        int m;
        int[] w = { 0, 3, 4, 5 };
        int[] p = { 0, 4, 5, 6 };
        BottomUp(10, 3, w, p);
    }

    private int[,] result = new int[11, 4];
    private int BottomUp(int m, int i, int[] w, int[] p)
    {
        if (result[m, i] != 0) return result[m, i];
        for (int tempM = 1; tempM < m + 1; tempM++)
        {
            for (int tempI = 1; tempI < i + 1; tempI++)
            {
                if (result[tempM, tempI] != 0) continue;
                if (w[tempI] > tempM)
                {
                    result[tempM, tempI] = result[tempM, tempI - 1];
                }
                else
                {
                    int maxValue1 = result[tempM - w[tempI], tempI - 1] + p[tempI];
                    int maxValue2 = result[tempM, tempI - 1];
                    if (maxValue1 > maxValue2)
                    {
                        result[tempM, tempI] = maxValue1;
                    }
                    else
                    {
                        result[tempM, tempI] = maxValue2;
                    }
                }
            }
        }
        return result[m, i];
    }