算法学习之动态规划（一）

动态规划的一般思路

1、把原问题分解成子问题

子问题和原问题的形式要相同或者类似，只不过规模变小了，子问题一旦被解决，原问题也就被解决。

2、确定状态

往往将和子问题相关的各个变量的一组取值，称为一个状态，一个状态对应一个或者多个子问题，所谓某个状态的值就是这个状态所对应的子问题的解。
所有状态的集合，构成问题的“状态空间”。“状态空间”的大小，与用动态规划解决问题的时间复杂度直接相关。
** 整个问题的时间复杂度是状态数目乘以计算每个状态所需时间 **。

3、确定一些初始状态值

4、确定状态转移方程

能用动态规划解决的问题的特点

1、问题具有最优子结构性质

如果问题最优解所包含的子问题的解也是最优的，我们就称该问题具有最优子结构。

2、无后效性

当前的若干个状态值一旦确定，则此后过程的演变就只和这若干个状态的值有关，和之前采取哪些手段或经过哪条路径演变到当前状态没有关系。

例子一：数字三角形

                  7
                 3 8
                8 1 0
               2 7 4 4
              4 5 2 6 5
在上面的数字三角形中寻找一条从顶部到底部的路径，使得路径上所经过的数字之和最大。路径上的每一步都只能往左下或右下走。只需求出这个最大和即可。

解法一

#include <iostream>
#include <algorithm>
#define MAX 5
using namespace std;
int MaxSum(int i,int j,int arr[][MAX]);
int MaxSum(int i,int j,int arr[][MAX])
{
    if(i==MAX-1)
        return arr[i][j];
    else
        return arr[i][j]+max(MaxSum(i+1,j,arr),MaxSum(i+1,j+1,arr));
}


int main() {
    int i,j;

    int D[MAX][MAX]={{7},
                 {3,8},
                 {8,1,0},
                 {2,7,4,4},
                 {4,5,2,6,5}};

    std::cout << MaxSum(0,0,D)<< std::endl;
    return 0;
}

一般一个状态调用一个状态不会造成重复计算，如果一个状态调用多个状态就会造成重复计算

递归方法的改进

时间复杂度O(n^2)
空间复杂度O(n^2)

#include <iostream>
#include <algorithm>
#define MAX 5
using namespace std;
int max_sum[MAX][MAX];

int MaxSum(int i,int j,int arr[][MAX]);
int MaxSum(int i,int j,int arr[][MAX])
{
    if(max_sum[i][j]!=-1)
        return max_sum[i][j];
    else if(i==MAX-1)
        max_sum[i][j]=arr[i][j];
    else
        max_sum[i][j]= max(MaxSum(i+1,j,arr),MaxSum(i+1,j+1,arr))+arr[i][j];
    return max_sum[i][j];
}


int main() {
    int i,j;

    int D[MAX][MAX]={{7},
                     {3,8},
                     {8,1,0},
                     {2,7,4,4},
                     {4,5,2,6,5}};
    for(int i=0;i<MAX;i++)
    {
        for(int j=0;j<=i;j++)
            max_sum[i][j]=-1;
    }

    std::cout << MaxSum(0,0,D)<< std::endl;
    return 0;
}

采用递推的方法

时间复杂度O(n^2)
无需额外分配内存

#include <iostream>
#include <algorithm>
#define MAX 5
using namespace std;
int max_sum[MAX][MAX];

void MaxSum(int arr[][MAX]);
void MaxSum(int arr[][MAX])
{
    for(int i=MAX-2;i>=0;i--)
        for(int j=0;j<=i;j++)
        {
            arr[i][j]=arr[i][j]+max(arr[i+1][j],arr[i+1][j+1]);

        }
}


int main() {
    int i,j;

    int D[MAX][MAX]={{7},
                     {3,8},
                     {8,1,0},
                     {2,7,4,4},
                     {4,5,2,6,5}};
    for(int i=0;i<MAX;i++)
    {
        for(int j=0;j<=i;j++)
            max_sum[i][j]=-1;
    }
    MaxSum(D);
    cout<<D[0][0]<<endl;

    return 0;
}

例题二

最小上升子序列

一个数列的序列a[i],当a[1]<a[2]<a[3]<…<a[s]时，我们称这个序列是上升的。对于给定的一个序列(a[1],a[2],…,a[k]),求出最长上升子序列的长度。比如对于序列(1,7,3,5,9,4,8),有一些上升子序列，如子序列(1,3,5,8).

#include <iostream>
#include <algorithm>

int arr[7]={1,7,3,5,9,4,8};
int maxLen[7];

using namespace std;

int main() {
    int size=sizeof(arr)/ sizeof(int);
    for(int i=0;i<size;i++)
        maxLen[i]=1;
    for(int i=1;i<size;i++)
    {
        for(int j=0;j<=i;j++)
        {
            if(arr[i]>arr[j])
            {
               maxLen[i]=max(maxLen[j]+1,maxLen[i]);
            }

        }
    }
    std::cout << *max_element(maxLen,maxLen+size+1) << std::endl;
    return 0;
}

例题三

公共子序列

给出两个字符串，求出这样的一个最长的公共子序列的长度：子序列中的每个字符都能在两个原串中找到，而且每个字符的先后顺序和原串的先后顺序一致。

#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    char str1[]={'p','r','o','g','r','a','m','m','i','n','g'};
    char str2[]={'c','o','n','t','e','s','t'};
    int maxLen[16][16];
    int size1= sizeof(str1)/ sizeof(char);
    int size2= sizeof(str2)/ sizeof(char);
    for(int i=0;i<=size1;i++)
    maxLen[i][0]=0;
    for(int j=0;j<=size2;j++)
        maxLen[0][j]=0;
    for(int i=1;i<=size1;i++)
    {
        for(int j=1;j<=size2;j++)
        {
            if(str1[i-1]==str2[j-1])
                maxLen[i][j]=maxLen[i-1][j-1]+1;
            else
                maxLen[i][j]=max(maxLen[i][j-1],maxLen[i-1][j]);
        }


    }

    cout<<maxLen[size1][size2]<<endl;

    return 0;
}

例题四

最佳加法表达式

有一个由1…9组成的数字串，问如果将m个加号插入到这个数字串中，在各种可能形成的表达式中，值最小的那个表达式的值为多少？

#include <iostream>
#include <algorithm>
using namespace std;
# define MAX 10
int value[MAX][MAX];
int array[]={1,2,3,4};

int num(int s,int e)
{
    int result=0;
    for(int i=s;i<=e;i++)
    {
        result=10*result+array[i-1];
    }
    return result;
}

int v(int add,int n)
{

    if(add==0)
        value[add][n]=num(1,n);
    else if(n<add+1)
        cout<<"Error!It's impossible to finish this task!"<<endl;
    else
    {
        value[add][n]=v(add-1,add)+num(add+1,n);
        for(int i=add+1;i<n;i++)
        {
            value[add][n]=min(v(add-1,i)+num(i+1,n),value[add][n]);
        }
    }

    return value[add][n];
}


int main()
{

    cout<<v(2,4)<<endl;

    return 0;



}

参考：郭炜《程序与算法设计》