算法-动态规划

动态规划最重要的就是定义问题的状态。

定义出问题状态之后，可以通过对简单例子的推导，得到状态转移方程。之后的东西就简单多了。

例如：

有m*n的方格，每个方格存放了若干个苹果。

从左上角的格子开始，只能向右或者向下走，每走到一个格子，就把格子内的苹果收集起来，

这样下去，你最多能收集到多少苹果？

分析：

定义状态为d[i，j]，表示在i*j方格内，最多收集的苹果数。

A[i，j]表示在行数为i，列数为j的方格内存放的苹果数。

先从最简单的情况开始分析

d[1，1] = A[0，0] 在1*1的方格内，最多收集到的苹果数就是存放在A[0，0]处的苹果数。

d[1，2] = A[0，0] + A[0，1] = d[1，1]+A[0，1]

d[1，3] = A[0，0] + A[0，1] +A[0，2] = d[1，2]+A[0，2]

d[2，2] = A[0，0] + A[0，1] + A[1，1] = d[1，2] + A[1，1]

或者

d[2，2] = A[0，0] + A[1，0] + A[1，1] = d[2，1] + A[1，1]

因此d[2，2] = max（d[1，2]， d[2，1]）+A[1，1]

可以得到d[i，j] = max{d[i-1，j]， d[i，j-1]}+A[i-1，j-1]；

代码如下：

#define ROW (3)
#define COL (3)
int max(int a, int b)
{
return (a > b) ? a : b;
}

int d[ROW+1][COL+1];
int collect_apple(int M[ROW][COL], int m, int n)
{
if ((m <= 0)||(n <= 0)||(NULL == M))
{
return 0;
}
int i = 0;
int j = 0;
for (i = 0; i <= m; i++)
{
d[i][0] = 0;
}
for (j = 0; j <= n; j++)
{
d[0][j] = 0;
}
for (i = 1; i <= m; i++)
{
for (j = 1; j <= n; j++)
{
int t1 = d[i-1][j];
int t2 = d[i][j-1];
int tmax = max(t1, t2);
d[i][j] = tmax + M[i-1][j-1];
}
}
return d[m]
;
}

int collect_apple_demo()
{
int table[ROW][COL] = {{2, 9, 5}, {4, 5, 5}, {2, 7, 9}};
int apple = collect_apple(table, ROW, COL);
printf("apples:%d\n", apple);
collect_apple_path_print(table, ROW, COL);
getchar();
return 0;
}

int collect_apple_path_print(int M[ROW][COL], int m, int n)
{
int i = 1;
int j = 1;
while (1)
{
printf("M[%d][%d]=%d\n", i-1, j-1, M[i-1][j-1]);
if ((i == m)&&(j == n))
{
break;
}
if (d[i+1][j] >= d[i][j+1])
{
i = i + 1;
}
else
{
j = j + 1;
}
}
return 0;
}

带备忘录的递归算法也可以是一种动态规划算法，这个在《算法的乐趣》中有提到，也是一种非常方便直观的方法。

/**
有1，3，5三种面值的硬币，请问为了得到价值为11，最少需要多少枚硬币。
*/
int coins[] = {1, 3, 5};

int memo_cnt[MAX_SUM_VALUE] = {0};

int f_count = 0;
int dp_min_coin_count(int value)
{
f_count++;
int min_count = 0;
int i = 0;
int min = 0xfff;
if (value == 0)
{
return 0;
}
if (memo_cnt[value] != 0)
{
return memo_cnt[value];
}
for (i = 0; i < sizeof(coins)/sizeof(coins[0]); i++)
{
if (value >= coins[i])
{
int s_value = value - coins[i];
int s_min = dp_min_coin_count(s_value);
if (s_min < min)
{
min = s_min;
}
}

}

min_count = min + 1;
memo_cnt[value] = min_count;
return min_count;

}

int dp_min_coin_count_demo()
{
int min_count = 0;
int i = 0;
for (i = 1; i <= 11; i++)
{
min_count = dp_min_coin_count(i);
printf("min coin count:%d of value:%d  enter func count:%d\n", min_count, i, f_count);

}
return min_count;
}

参考：

1.《算法的乐趣》

2. http://www.hawstein.com/posts/dp-novice-to-advanced.html