DP基础_2 2016.5.16

--转自hdu lcy老师的ppt，感谢老师的分享

一、动态规划的基本思想

如果各个子问题不是独立的，不同的子问题的个数只是多项式量级
如果我们能够 保存已经解决的子问题的答案
而在需要的时候再找出已求得的答案，这样就可以避免大量的重复计算
由此而来的基本思路是，用一个表记录所有已解决的子问题的答案
不管该问题以后是否被用到，只要它被计算过，就将其结果填入表中

二、动态规划的基本步骤

动态规划算法通常用于求解具有某种最优性质的问题
在这类问题中，可能会有许多可行解
每一个解都对应于一个值，我们希望找到具有最优值（最大值或最小值）的那个解

设计一个动态规划算法，通常可以按以下几个步骤进行：

（1）找出最优解的性质，并刻画其结构特征
（2）递归地定义最优值
（3）以自底向上的方式计算出最优值
（4）根据计算最优值时得到的信息，构造一个最优解
    其中（1）－（3）步是动态规划算法的基本步骤
    在只需要求出最优值的情形，步骤（4）可以省去
    若需要求出问题的一个最优解，则必须执行步骤（4）
    此时，在步骤（3）中计算最优值时，通常需记录更多的信息，以便在步骤（4）中，根据所记录的信息，快速构造出一个最优解

三、动态规划问题的特征

动态规划算法的有效性依赖于问题本身所具有的两个重要性质：
1、最优子结构：
    当问题的最优解包含了其子问题的最优解时，称该问题具有最优子结构性质
2、重叠子问题：
    在用递归算法自顶向下解问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次
    动态规划算法正是利用了这种子问题的重叠性质，对每一个子问题只解一次
    而后将其解保存在一个表格中，在以后尽可能多地利用这些子问题的解

HDU 1466 计算直线的交点数

题意：

平面上有n条直线，且无三线共点，问这些直线能有多少种不同交点数

解题思路：

初步分析:
我们知道:

n条直线互不平行且无三线共点的最多交点数max=1+2+……(n-1)=n(n-1)/2,

但本题不这么简单，因为问题问的是：这些直线有多少种不同的交点数？

分析思路——
首先，容易列举出N=1,2,3的情况：
    0
    0，1
    0，2，3

然后，假设<=n-1的情况都已经知道——

重点分析——n的情况：

先来看个统计的方法：
假设一共有n=a+b条直线
（即n条直线分成2组，分别为a条和b条）
则总的交点数= a内的交点数
                ＋b内的交点数
                ＋a，b之间的交点数

                
我们来分析加入第N条直线的情况(这里以N=4为例)：
（分类方法：和第N条直线平行的在a组，其余在b组）
1、第四条与其余直线全部平行 => 0+4*0+0=0；
2、第四条与其中两条平行，交点数为0+(n-1)*1+0=3;
3、第四条与其中一条平行，这两条平行直线和另外两点直线的交点数为(n-2)*2=4,而另外两条直线既可能平行也可能相交，因此可能交点数为：
    0+（n-2）*2+0=4    或者  0+(n-2)*2+1=5     
4、 第四条直线不与任何一条直线平行，交点数为：
    0+(n-3)*3+0=3  或0+ (n-3)*3+2=5  或0+ (n-3)*3+3=6
即n=4时，有0个，3个，4个，5个，6个不同交点数。


从上述 n = 4 的分析过程中，我们发现：
m条直线的交点方案数
=（m-r）条平行线与r条直线交叉的交点数
      + r条直线本身的交点方案
=（m-r）*r+r条之间本身的交点方案数（0<=r<m）

一：动态规划

转自http://blog.csdn.net/cqlf__/article/details/7068570

用 dp[i][j] 表示 i 条直线时是否存在 j 个交点
首先当这 i 条直线平行时，dp[i][0] 是存在的

当 i > r 且 r 条直线存在 j 个交点时
dp[i][(i-r)*r+j]也是存在的

二：记忆化搜索

转自http://www.cnblogs.com/felixfang/archive/2012/03/10/2389493.html

递归函数定义：

定义IsExist(int lines, int nodes)

lines表示直线数，nodes表示交点数

由上面的结论可知

当 m 条直线存在 n 个交点时，必然存在 r(0 =< r < m) 使得 n = (m - r) * r + r条之间本身的交点方案数  成立

那么 r条之间本身的交点方案数 = n - (m - r) * r 也成立，也就是说 IsExist(r, n-(m-r)*r) == 1

为避免重复计算首先将数组初始化为 -1

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;

const int INF = 0x7fffffff;
bool dp[30][200];

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    for (int i = 0; i < 30; ++i) {
        for (int j = 0; j < 200; ++j) {
            dp[i][j] = (j == 0) ? true : false;
        }
    }
    for (int i = 0; i < 30; ++i) {
        for (int r = 0; r < i; ++r) {
            for (int j = 0; j < 200; ++j) {
                if (dp[r][j]) {
                    dp[i][(i-r)*r+j] = true;
                }
            }
        }
    }
    int n;
    while (scanf("%d", &n) != EOF) {
        int t = n*(n-1)/2;
        for (int i = 0; i < t; ++i) {
            if (dp[n][i]) {
                printf("%d ", i);
            }
        }
        printf("%d\n", t);
    }
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;

const int INF = 0x7fffffff;
int dp[30][200];

int IsExist(int lines, int nodes);

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    memset(dp, -1, sizeof(dp));
    for (int i = 0; i < 30; ++i) {
        dp[i][0] = 1;
    }
    int n;
    while (scanf("%d", &n) != EOF) {
        printf("0");
        int t = n*(n-1)/2;
        for (int i = 1; i <= t; ++i) {
            if (IsExist(n, i)) {
                printf(" %d", i);
            }
        }
        printf("\n");
    }
    return 0;
}

int IsExist(int lines, int nodes)
{
    if (dp[lines][nodes] != -1) {
        return dp[lines][nodes];
    } else {
        bool flag = false;
        for (int r = 0; r < lines; ++r) {
            int t = nodes - (lines-r) * r;
            if (t >= 0 && IsExist(r, t)) {
                flag = true;
                break;
            }
        }
        dp[lines][nodes] = (flag ? 1 : 0);
        return dp[lines][nodes];
    }
}

转自《算法竞赛入门经典》lrj

HDU 2084 数塔

#include <iostream>
#include <cstdio>

using namespace std;

const int maxn = 100 + 5;
int dp[maxn][maxn];

int main()
{
//    freopen("in.txt", "r", stdin);
    int C;

    while (cin>>C) {
        while (C--) {
            int L;
            cin>>L;
            int K;
            for (int i=0; i<L; ++i) {
                for (int j=0; j<=i; ++j) {
                    cin>>K;
                    dp[i][j] = K;
                }
            }
            for (int i=L-2; i>=0; --i) {
                for (int j=0; j<=L-2; ++j) {
                    dp[i][j] += max(dp[i+1][j], dp[i+1][j+1]);
                }
            }
            cout<<dp[0][0]<<endl;
        }
    }
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;

const int INF = 0x7fffffff;
const int maxn = 100 + 10;
int num[maxn][maxn];
int dp[maxn][maxn];
int N;

int Max_Sum(int x, int y);

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    int C;
    scanf("%d", &C);
    while (C--) {
        memset(dp, -1, sizeof(dp));
        scanf("%d", &N);
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j <= i; ++j) {
                scanf("%d", &num[i][j]);
            }
        }
        printf("%d\n", Max_Sum(0, 0));
    }
    return 0;
}

int Max_Sum(int x, int y)
{
    if (dp[x][y] != -1) {
        return dp[x][y];
    } else {
        dp[x][y] = num[x][y] + (x == N ? 0 : max(Max_Sum(x+1, y), Max_Sum(x+1, y+1)));
        return dp[x][y];
    }
}