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

最新推荐文章于 2023-11-29 14:55:05 发布

鹅厂程序小哥

最新推荐文章于 2023-11-29 14:55:05 发布

阅读量608

点赞数 1

分类专栏： C# 数据结构与算法文章标签： C#

C# 同时被 2 个专栏收录

107 篇文章 10 订阅

订阅专栏

数据结构与算法

47 篇文章 12 订阅

订阅专栏

动态规划（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：

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

[csharp]view plain copy
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;  
}  

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

动态规划的方法进行求解

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

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

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

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

[csharp]view plain copy
//动态规划  
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;  
}  

第二种方法是自底向上法

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

[csharp]view plain copy
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，穷举法（把所有情况列出来，比较得到总价值最大的情况）

[csharp]view plain copy
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)

[csharp]view plain copy
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];  
}  

鹅厂程序小哥

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
C#内功修炼(算法)——动态规划(四)

动态规划（Dynamic Programming）动态规划算法通常基于一个递推公式及一个或多个初始状态。当前子问题的解将由上一次子问题的解推出。动态规划和分治法相似，都是通过组合子问题的解来求解原问题。分治法将问题划分成互不相交的子问题，递归求解子问题，再将他们的解组合起来，求出原问题的解。与之相反，动态规划应用于子问题重叠的情况，即不同的子问题具有公共的子子问题。在这种情况下，分治算法会做出许多...
复制链接

扫一扫

专栏目录