算法（C#版）动态规划和贪心算法

拼搏现实的明天。 2022-02-25 11:11 493阅读 0赞

**动态规划（****Dynamic Programming****）**

什么是动态规划，我们要如何描述它?

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

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

**动态规划** **-** **钢条切割问题**

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

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

考虑n=4的时候

![20190401190946432.png][]

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

![20190401191011647.png][]

最大收益：

![20190401191028542.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvdXpodWFuamluZzE4NDk_size_16_color_FFFFFF_t_70][]

第一种求最优解方案：

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

![20190401191057314.png][]

将切割方案分成下面几种

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：

![20190401191119537.png][]

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

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace 钢条切割问题_递归实现
 {
 class Program
 {
 static void Main(string[] args)
 {
 int n = 5;//我们要切割售卖的钢条的长度
 int[] p = { 0, 1, 5, 8, 9, 10, 17, 17, 20, 24, 30 };//索引代表 钢条的长度，值代表价格
 Console.WriteLine(UpDown(0, p));
 Console.WriteLine(UpDown(1, p));
 Console.WriteLine(UpDown(2, p));
 Console.WriteLine(UpDown(3, p));
 Console.WriteLine(UpDown(4, p));
 Console.WriteLine(UpDown(5, p));
 Console.WriteLine(UpDown(6, p));
 Console.WriteLine(UpDown(7, p));
 Console.WriteLine(UpDown(8, p));
 Console.WriteLine(UpDown(9, p));
 Console.WriteLine(UpDown(10, p));
 Console.ReadKey();
 
 }
 
 public static int UpDown(int n,int[] p)//求得长度为n的最大收益
 {
 if (n == 0) return 0;
 int tempMaxPrice = 0;
 for (int i = 1; i < n+1; i++)
 {
 int maxPrice = p[i] + UpDown(n - i, p);
 if (maxPrice > tempMaxPrice)
 tempMaxPrice = maxPrice;
 }
 return tempMaxPrice;
 }
 }
 }

![20190401194247503.png][]

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

**动态规划的方法进行求解**

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

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

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

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

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace 钢条切割问题_带备忘的自顶向下法_动态规划_
 {
 class Program
 {
 static void Main(string[] args)
 {
 //int n = 5;//我们要切割售卖的钢条的长度
 int[] result = new int[11];
 int[] p = { 0, 1, 5, 8, 9, 10, 17, 17, 20, 24, 30 };//索引代表 钢条的长度，值代表价格
 Console.WriteLine(UpDown(0, p, result));
 Console.WriteLine(UpDown(1, p, result));
 Console.WriteLine(UpDown(2, p, result));
 Console.WriteLine(UpDown(3, p, result));
 Console.WriteLine(UpDown(4, p, result));
 Console.WriteLine(UpDown(5, p, result));
 Console.WriteLine(UpDown(6, p, result));
 Console.WriteLine(UpDown(7, p, result));
 Console.WriteLine(UpDown(8, p, result));
 Console.WriteLine(UpDown(9, p, result));
 Console.WriteLine(UpDown(10, p, result));
 Console.ReadKey();
 
 }
 
 //带备忘的自顶向下
 public static int UpDown(int n, int[] p, int[] result)//求得长度为n的最大收益
 {
 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 = p[i] + UpDown(n - i, p, result);
 if (maxPrice > tempMaxPrice)
 tempMaxPrice = maxPrice;
 }
 result[n] = tempMaxPrice;
 return tempMaxPrice;
 }
 }
 }

![20190401200026529.png][]

第二种方法是 自底向上法

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

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace 钢条切割问题_自底向上法_动态规划算法_
 {
 class Program
 {
 static void Main(string[] args)
 {
 int[] result = new int[11];
 int[] p = { 0, 1, 5, 8, 9, 10, 17, 17, 20, 24, 30 };//索引代表 钢条的长度，值代表价格
 
 Console.WriteLine(BottomUp(1, p, result));
 Console.WriteLine(BottomUp(2, p, result));
 Console.WriteLine(BottomUp(3, p, result));
 Console.WriteLine(BottomUp(4, p, result));
 Console.WriteLine(BottomUp(5, p, result));
 Console.WriteLine(BottomUp(6, p, result));
 Console.WriteLine(BottomUp(7, p, result));
 Console.WriteLine(BottomUp(8, p, result));
 Console.WriteLine(BottomUp(9, p, result));
 Console.WriteLine(BottomUp(10, p, result));
 Console.ReadKey();
 }
 
 public static int BottomUp(int n, int[] p, int[] result)
 {
 for (int i = 1; i < n + 1; i++)
 {
 //下面取得 钢条长度为i时最大的收益
 int tempMaxPrice = -1;
 for(int j = 1; j <= i; j++)
 {
 int maxPrice = p[j] + result[i - j];
 if (maxPrice > tempMaxPrice)
 tempMaxPrice = maxPrice;
 }
 result[i] = tempMaxPrice;
 }
 return result[n];
 }
 }
 }

![20190401202257959.png][]

**动态规划** **- 01****背包问题**

问题描述：

假设现有容量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，穷举法（把所有情况列出来，比较得到 总价值最大的情况）

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

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace _01背包问题_穷举法
 {
 class Program
 {
 static void Main(string[] args)
 {
 int m;
 int[] w = { 0, 3, 4, 5 };
 int[] p = { 0, 4, 5, 6 };
 Console.WriteLine(Exhaustivity(10, w, p));
 Console.WriteLine(Exhaustivity(3, w, p));
 Console.WriteLine(Exhaustivity(4, w, p));
 Console.WriteLine(Exhaustivity(5, w, p));
 Console.WriteLine(Exhaustivity(7, w, p));
 Console.ReadKey();
 }
 
 public static int Exhaustivity(int m, int[] w, int[] p)
 {
 int i = w.Length - 1;//物品的个数
 
 int maxPrice = 0;
 for (int j = 0; j < Math.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
 //比如85的二进制为1010101.
 //w我们要求第五位二进制位数上是0还是1，那么我们可以通过位运算符的移位操作来进行
 //比如我们可以将85的二进制1010101与1向左移4位来做与运算
 //就是1010101 与 0010000做与运算，看第五位是0还是1，
 //得出这个结果，我们可以将结果0010000右移4位然后将结果与1进行比较即可
 
 public static int Get2(int j,int number)
 {
 int A = j;
 int B = (int)Math.Pow(2, number - 1);
 int result = A & B;
 if (result == 0)
 return 0;
 return 1;
 }
 }
 }

![20190401213532828.png][]

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)

不带备忘的自顶向下法的实现

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace _01背包问题_递归实现_不带备忘的自顶向下法_
 {
 class Program
 {
 static void Main(string[] args)
 {
 int m;
 int[] w = { 0, 3, 4, 5 };
 int[] p = { 0, 4, 5, 6 };
 Console.WriteLine(UpDown(10, 3, w, p));
 Console.WriteLine(UpDown(3, 3, w, p));
 Console.WriteLine(UpDown(4, 3, w, p));
 Console.WriteLine(UpDown(5, 3, w, p));
 Console.WriteLine(UpDown(7, 3, w, p));
 Console.ReadKey();
 }
 
 /// <summary>
 /// 返回值是m可以存储的最大值
 /// </summary>
 /// <param name="m">背包容量</param>
 /// <param name="i">物品个数</param>
 /// <param name="w">物品的重量</param>
 /// <param name="p">物品的价值</param>
 /// <returns></returns>
 public static int UpDown(int m, int i, int[] w, int[] p)
 {
 
 if (i == 0 || m == 0) return 0;
 
 if (w[i] > m)//如果第i个重量超过剩余的重量
 {
 return UpDown(m, i - 1, w, p);
 }
 else
 {
 int maxValue1 = UpDown(m - w[i], i - 1, w, p) + p[i];//放入第i个物品
 int maxValue2 = UpDown(m, i - 1, w, p);//不放入第i个物品
 if (maxValue1 > maxValue2)
 return maxValue1;
 else
 return maxValue2;
 }
 }
 
 }
 }

![2019040219415226.png][]

带备忘的自顶向下法的实现

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace _01背包问题_递归实现_带备忘的自顶向下法_
 {
 class Program
 {
 //用来存储已经计算的最大价值
 //第一个是背包的容量m，第二个是物品的个数i
 public static int[,] result = new int[11, 4];
 
 static void Main(string[] args)
 {
 int m;
 int[] w = { 0, 3, 4, 5 };
 int[] p = { 0, 4, 5, 6 };
 Console.WriteLine(UpDown(10, 3, w, p));
 Console.WriteLine(UpDown(3, 3, w, p));
 Console.WriteLine(UpDown(4, 3, w, p));
 Console.WriteLine(UpDown(5, 3, w, p));
 Console.WriteLine(UpDown(7, 3, w, p));
 Console.ReadKey();
 }
 
 /// <summary>
 /// 返回值是m可以存储的最大值
 /// </summary>
 /// <param name="m">背包容量</param>
 /// <param name="i">物品个数</param>
 /// <param name="w">物品的重量</param>
 /// <param name="p">物品的价值</param>
 /// <returns></returns>
 public static int UpDown(int m, int i, int[] w, int[] p)
 {
 
 if (i == 0 || m == 0) return 0;
 
 if (result[m, i] != 0)
 return result[m, i];
 
 if (w[i] > m)//如果第i个重量超过剩余的重量
 {
 result[m,i] = UpDown(m, i - 1, w, p);
 return result[m, i];
 }
 else
 {
 int maxValue1 = UpDown(m - w[i], i - 1, w, p) + p[i];//放入第i个物品
 int maxValue2 = UpDown(m, i - 1, w, p);//不放入第i个物品
 if (maxValue1 > maxValue2)
 result[m, i] = maxValue1; 
 else
 result[m, i] = maxValue2;
 return result[m, i];
 }
 }
 }
 }

![20190402200354595.png][]

自底向上法的实现（动态规划）

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace _01背包问题_自底向上法_动态规划_
 {
 class Program
 {
 public static int[,] result = new int[11, 4];
 static void Main(string[] args)
 {
 int m;
 int[] w = { 0, 3, 4, 5 };
 int[] p = { 0, 4, 5, 6 };
 Console.WriteLine(BottomUp(10, 3, w, p));
 Console.WriteLine(BottomUp(3, 3, w, p));
 Console.WriteLine(BottomUp(4, 3, w, p));
 Console.WriteLine(BottomUp(5, 3, w, p));
 Console.WriteLine(BottomUp(7, 3, w, p));
 }
 
 
 public static 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];
 }
 }
 }

![20190402203253211.png][]

**贪心算法**

对于许多最优化问题，使用动态规划算法来求最优解有些杀鸡用牛刀了，可以使用更加简单、更加高效的算法。贪心算法就是这样的算法，它在每一步做出当时看起来最佳的选择。也就是说它总是做出局部最优的选择，从而得到全局最优解。

对于某些问题并不保证得到最0优解，但对很多问题确实可以求得最优解。

**贪心算法** **-** **活动选择问题**

有n个需要在同一天使用同一个教室的活动a1,a2,…,an，教室同一时刻只能由一个活动使用。每个活动ai都有一个开始时间si和结束时间fi 。一旦被选择后，活动ai就占据半开时间区间\[si,fi)。如果\[si,fi\]和\[sj,fj\]互不重叠，ai和aj两个活动就可以被安排在这一天。该问题就是要安排这些活动使得尽量多的活动能不冲突的举行（最大兼容活动子集）。例如下图所示的活动集合S，其中各项活动按照结束时间单调递增排序。

\{a3,a9,a11\}是一个兼容的活动子集，但它不是最大子集，因为子集\{a1,a4,a8,a11\}更大，实际上它是我们这个问题的最大兼容子集，但它不是唯一的一个\{a2，a4，a9，a11\}

![20190403164951852.png][]

1，动态规划算法解决思路

我们使用Sij代表在活动ai结束之后，且在aj开始之前的那些活动的集合，我们使用c\[i,j\]代表Sij的最大兼容活动子集的大小，对于上述问题就是求c\[0,12\]的解

a, 当i>=j-1或者Sij 中没有任何活动元素的时候， c\[i,j\]=0

b，当i<j-1

1，Sij不存在活动,c\[i,j\]=0

2，Sij存在活动的时候，c\[i,j\]= max\{c\[i,k\]+c\[k,j\]+1\}  ak属于Sij,这里是遍历Sij的集合，然后求得最大兼容子集

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace 活动选择问题_动态规划思路_自底向上_
 {
 class Program
 {
 static void Main(string[] args)
 {
 int[] s = { 0, 1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12, 24 };
 int[] f = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 24 };
 
 List<int>[,] result = new List<int>[13, 13];//默认值null
 for(int m = 0; m < 13; m++)
 {
 for (int n = 0; n < 13; n++)
 {
 result[m, n] = new List<int>();
 }
 }//默认值是空list集合
 
 for (int j = 0; j < 13; j++)
 {
 for (int i = 0; i < j - 1; i++)
 {
 //S[ij] i结束之后 j开始之前的活动集合
 //f[i] s[j]这个时间区间内的所有活动
 List<int> sij = new List<int>();
 for (int number = 1; number < s.Length - 1; number++)
 {
 if (s[number] >= f[i] && f[number] <= s[j])
 sij.Add(number);
 }
 
 if (sij.Count > 0)
 {
 //result[i,j] = max{ result[i,k]+result[k,j]+1}
 int maxCount = 0;
 List<int> tempList = new List<int>();
 foreach (int number in sij)
 {
 int count = result[i, number].Count + result[number, j].Count + 1;
 if (maxCount < count)
 {
 maxCount = count;
 tempList = result[i, number].Union<int>(result[number, j]).ToList<int>();
 tempList.Add(number);
 }
 }
 result[i, j] = tempList;
 }
 }
 }
 
 List<int> l = result[0, 12];
 foreach (int temp in l)
 {
 Console.WriteLine(temp);
 }
 Console.ReadKey();
 }
 }
 }

![20190404161503929.png][]

2，贪心算法

想要使用贪心算法的话，得先找到适合贪心算法的规律（局部最优选择）

对于任何非空的活动集合S，假如am是S中结束时间最早的活动，则am一定在S的某个最大兼容活动子集中。

（如何证明上面的结论？反证法）

递归解决

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace 活动选择问题_贪心算法_递归解决_
 {
 class Program
 {
 
 static int[] s = { 0, 1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12 };
 static int[] f = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };
 
 public static List<int> ActivitySelection(int startActivityNumber, int endActivityNumber, int startTime, int endTime) 
 {
 if (startActivityNumber > endActivityNumber || startTime >= endTime)
 return new List<int>();
 //找到结束时间最早的活动
 int tempNumber = 0;
 for (int number = startActivityNumber; number <= endActivityNumber; number++)
 {
 if(s[number]>=startTime && f[number] <= endTime)
 {
 tempNumber = number;
 break;
 }
 }
 List<int> list = ActivitySelection(tempNumber + 1, endActivityNumber, f[tempNumber], endTime);
 list.Add(tempNumber);
 return list;
 }
 
 static void Main(string[] args)
 {
 List<int> list = ActivitySelection(1, 11, 0, 24);
 foreach (int temp in list)
 {
 Console.WriteLine(temp);
 }
 Console.ReadKey();
 }
 }
 }

![20190404161605195.png][]

迭代解决

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace 活动选择问题_贪心算法_迭代解决_
 {
 class Program
 {
 static void Main(string[] args)
 {
 int[] s = { 0, 1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12 };
 int[] f = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
 
 int startTime = 0;
 int endTime = 24;
 List<int> list = new List<int>();
 for (int number = 1; number <=11; number++)
 {
 if(s[number]>= startTime && f[number] <= endTime)
 {
 list.Add(number);
 startTime = f[number];
 }
 }
 
 foreach(int i in list)
 {
 Console.WriteLine(i);
 }
 Console.ReadKey();
 }
 }
 }

![20190404161638998.png][]

**贪心算法** **-** **钱币找零问题**

这个问题在我们的日常生活中就更加普遍了。假设1元、2元、5元、10元、20元、50元、100元的纸币分别有c0, c1, c2, c3, c4, c5, c6张。现在要用这些钱来支付K元，至少要用多少张纸币？用贪心算法的思想，很显然，每一步尽可能用面值大的纸币即可。

int Count\[N\]=\{3,0,2,1,0,3,5\};

int Value\[N\]=\{1,2,5,10,20,50,100\};

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace 钱币找零问题_贪心算法
 {
 class Program
 {
 static void Main(string[] args)
 {
 int[] amount = { 1, 2, 5, 10, 20, 50, 100 };
 int[] count = { 3, 0, 2, 1, 0, 3, 5 };
 int[] result = Change(204, count, amount);
 foreach (int i in result)
 {
 Console.Write(i + " ");
 }
 Console.WriteLine();
 Console.ReadKey();
 
 }
 
 public static int[] Change(int k, int[] count, int[] amount)
 {
 if (k == 0) return new int[amount.Length + 1];
 int total = 0;
 int index = amount.Length - 1;
 int[] result = new int[amount.Length+1];
 while (true)
 {
 if (k <= 0 || index <= -1) break;
 if(k > count[index] * amount[index])//我们有的纸币的钱的总额，比k要小
 {
 result[index] = count[index];
 k -= count[index] * amount[index];
 }
 else
 {
 result[index] = k / amount[index];
 k -= result[index] * amount[index];
 }
 index--;
 }
 result[amount.Length] = k;
 return result;
 }
 }
 }

![20190404164540345.png][]

**图**

[http://www.cnblogs.com/edisonchou/p/4672188.html][http_www.cnblogs.com_edisonchou_p_4672188.html]

[20190401190946432.png]: /images/20220225/14958547509340bb81a76b787e6b94b9.png
[20190401191011647.png]: /images/20220225/89bf03f0641f4f5080f625bb4f23a1cd.png
[20190401191028542.png]: /images/20220225/dc287f98e2cb4e9d9e229f9e20b333df.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvdXpodWFuamluZzE4NDk_size_16_color_FFFFFF_t_70]: /images/20220225/e58109cf91a84d1180fa5571d3c1adf1.png
[20190401191057314.png]: /images/20220225/a5f471dcc91740d697e958d2bdb3880e.png
[20190401191119537.png]: /images/20220225/04bd0c5dee954fe3a98e1d71cc060a3b.png
[20190401194247503.png]: /images/20220225/eb36827528d84a2b9e7ac2387a392410.png
[20190401200026529.png]: /images/20220225/039b358669b2464b9c09add21b4f6d66.png
[20190401202257959.png]: /images/20220225/0d8f0ae797a147088cd824a37c6ca9c8.png
[20190401213532828.png]: /images/20220225/695620fe056440b5803131c1af0ac5ee.png
[2019040219415226.png]: /images/20220225/2c60414fea444e089e62c9e8e23374a4.png
[20190402200354595.png]: /images/20220225/400e43d42b6c4b0cb8b1aa22980af8b3.png
[20190402203253211.png]: /images/20220225/67cf224b3a0d4742bf58cce079f93d53.png
[20190403164951852.png]: /images/20220225/531016a1e8a24c758e4c586a4c5610ed.png
[20190404161503929.png]: /images/20220225/5c7904160a2f48da9d57d90d8a8b55c3.png
[20190404161605195.png]: /images/20220225/6e51d0359e764b80bc225922e9eb93b9.png
[20190404161638998.png]: /images/20220225/19e0588a4e4a447c8ad42d80969958c2.png
[20190404164540345.png]: /images/20220225/8dc4d3705da24cccbdc8fc3d43cc9dec.png
[http_www.cnblogs.com_edisonchou_p_4672188.html]: http://www.cnblogs.com/edisonchou/p/4672188.html