算法--动态规划篇

Dynamic Programming（动态规划）

简介：

1）需要辅助空间，记录子问题解决结果。

2）明确各个子问题之间的关系，避免重复计算

3）通常对数组和字符串的高难度面试题有效。

与分治算法比较类似，但不同的是分治算法把原问题划归为几个相互独立的子问题，从而一一解决，而DP则是针对子问题有重叠的情况的一种解决方案。

思路：

利用recursive method，即首先把问题用递归的方法解决，然后用一个table保存recursive中的中间结果，这不就避免了递归中重复计算的低效了吗？遇到需要计算以前计算过的东西，直接查表就OK，总之一句话，先写recursive，然后比葫芦画瓢基本就能把DP的方法写出来。

这里的难点是如何找到recursive。算法导论里面也给的是这个思路。

动归 例题1 Fibornaci Sequence(剑指Offer P73)

普通递归方案，但是效率低下，复杂度较高;

long Fibonacci(int n)
        {
            if (n <= 0)
                return 0;
            if (n == 1)
                return 1;
            return Fibonacci(n - 1) + Fibonacci(n-2);
        }

优化后的算法(动态规划)，O(n); 思路: 从小向大算，根据f(0)和f(1)得出f(2), 根据f(1)、f(2)算出f(3); 以此类推,算f(n)

代码如下:

static int Fibonacci(int n)
        {
            if (n <= 0)
                return 0;
            if (n == 1)
                return 1;
            //存储中间结果， 数组索引从0开始； 所以初始化为n+1。 此处一定要注意！（或者使用List）
            int[] resultArr = new int[n+1];
            resultArr[0] = 0;
            resultArr[1] = 1;
            for (int i = 2; i <= n; i++)
            {
                resultArr[i] = resultArr[i - 1] + resultArr[i - 2];
            }
            return resultArr[n];
        }

动归例题2 爬楼梯

N个阶梯的楼梯，每次爬1个或2个台阶，共有多少种办法爬到顶？

一维数组dp记录每个台阶方法数：

初始化：dp[0]=dp[1]=1

状态方程：dp[i]=dp[i-1]+dp[i-2]

public int climbStairs(int n)
        {
            // write your code here
            if (n == 0 || n == 1) return 1;
            int[] dp = new int[n + 1];//考虑数组下表从0开始
            dp[0] = 1;//可以根据dp1和dp2反推出
            dp[1] = 1;
            for (int i = 2; i <= n; i++)
            {
                dp[i] = dp[i - 1] + dp[i - 2];//是前两个台阶的方法数之和
            }
            return dp[n];
        }

动态规划例题3 

砍木棍问题

有一个长n米的木头，和一个price table，table如下：

长度 i     1　　2　   3　　4　　 5　　   6 。。。

价格 Pi　1　　5　　8　　9　　10　　17。。。

求切木头方法，找出赚钱最多的办法。

思路:  很显然，这个递归的主要思路是我切一刀之后，分成两段，一段我按table的价钱卖了，另一段我当成一个新的子问题，继续作为我的函数的新的参数，这样不就递归了吗？但是问题是这一刀怎么切，没错，我们就来个找最大值，即max_{i =1 to n} Pi + Cut(n-i).

递归函数：

Cut(P, n){ //P 就是我的table，n是木头长度

  if n == 0

      return 0;

  q = -infinity

  for i = 1 to n

      q = max(q,P[i]+Cut(P,n-i))

  return q;

}

然后，根据这个recursive写DP

Cut(P, n){

　　for(int i = 1; i<=n; i++){

　　　　q = -infinity;

　　　　for(int j = 1; j<=i; j++)

　　　　　　q = max(q, P[j] + r[i-j]);

　　　　r[i] = q;

　　}

　　return r[n];

}

动归例题4  

MaxWindowTotal will take an array of integers and a windowSize, and return the maximum total of any  consecutive(连续的) sequence of integers of length windowSize.

For example, given (array =  [5, 12, 25, 7, 9], windowSize = 3), the method will return 44 (the sum of 12, 25, and 7 is the greatest total of any 3 consecutive integers in the array).

Implement MaxWindowTotal

e.g.

input:  5, 12, 25, 7, 9

5, 12, 25 = 42

12, 25, 7 = 44

25, 7, 9 = 41

思路分析：

1 本题需要注意consecutive （连续），不是返回N个元素就可以，必须连续；

2 定义sum时，要以Int32.MinValue为准; 不能初始化为0，否则无法处理负数输入;

3 先用暴力算法，再用动态规划算法； 即存储每次的结果，然后公式： int  sum = resultArr[i] - values[i] + values[i + windowSize  ];

暴力算法

static void Main(string[] args)
        {
            int[] arr = new int[] { 5, 12, 25, 7, 9 };
            int windowSize = 3;
            int sum = MaxWindowTotal(arr, windowSize);
            Console.WriteLine(sum);
            Console.ReadKey();

        }

        static int MaxWindowTotal(int[] values, int windowSize)
        {
            //boundary condition
            if (windowSize > values.Length)
                throw new Exception("windowSize is bigger than value'sLength");

            int max = Int32.MinValue;//此处如果是负数的话;
            for (int i = 0; i <= values.Length - windowSize; i++)
            {
                int sum = GetSum(values, i, i + windowSize);
                if (sum > max)
                    max = sum;
            }
            return max;

        }

        static int GetSum(int[] values, int startIndex, int endIndex)
        {
            int result = 0;
            for (int i = startIndex; i < endIndex; i++)
            {
                result += values[i];
            }
            return result;
        }

优化后的动态规划版本，即每次计算完就存下来，防止下次重复计算求和

static int MaxWindowTotal(int[] values, int windowSize)
        {
            if (windowSize > values.Length)
                throw new Exception("windowSize is bigger than value's Length");
            int max = Int32.MinValue;
            int[] resultArr = new int[values.Length - windowSize + 1];
            resultArr[0] = GetSum(values, 0, 0 + windowSize);
            if (resultArr[0] > max)
                max = resultArr[0];
            for (int i = 0; i < values.Length - windowSize; i++)
            {
                int sum = resultArr[i] - values[i] + values[i + windowSize  ];
                resultArr[i+1] = sum;
                if (sum > max)
                    max = sum;
            }
            return max;
        }
        static int GetSum(int[] values, int startIndex, int endIndex)
        {
            int result = 0;
            for (int i = startIndex; i < endIndex; i++)
            {
                result += values[i];
            }
            return result;
        }