活动选择问题——贪心算法与动态规划

最优子结构

设Sij表示活动i开始时间后且活动j时间结束前的活动集，假设有一个最大兼容活动子集Aij,其中包括了活动k。由于最优解包含活动k，可以得到两个子问题：寻找Sik以及Skj中的兼容活动子集。原问题解变为：Aij = Aik ∪k ∪Akj。

有了最优子结构，意味着可以用动态规划解。

如果用c[i][j] 表示集合Sij的最优解的大小，则可得递归式：

​ c[i][j] = c[i][k] + 1 + c[k][j]

最优解是c[0][N+1]。

当然如果不知道最优解包含哪一个活动k的话就必须要考察所有的选择k，于是最优解：

​ c[i][j] = max( c[i][k] + 1 + c[k][j] ) (Sij 不空) (k = i+1….j-1 且k和前后前后活动兼容)

​ = 0 (Sij 空)

/*测试数据
    注意Sij表示的意义是活动i结束后，活动j结束前的兼容活动，所以是双开区间
    int s[] = { 0,1,3,0,5,3,5,6,8,8,2,12,_CRT_INT_MAX };
    int f[] = { 0,4,5,6,7,9,9,10,11,12,14,16,_CRT_INT_MAX };
*/
#define N 11
void dp_act(int s[], int f[])
{
    int i = 0;
    int c[N + 2][N + 2] = { 0 };
    for (int len = 2; len <= N+1; len++) {

        for (i = 0; i <= N -len+1; i++) {
            int j = i + len;
            //Sij不为空
            if (f[i] <= s[j]) {
                int maxn = -1;
                for (int k = i+1 ; k <j; k++) {
                    if (s[k] >= f[i] && f[k] <= s[j]) {
                        maxn = c[i][k] + c[k][j] + 1;
                        if (maxn > c[i][j]) {
                            c[i][j] = maxn;
                        }
                    }
                }

            }
        }
    }
}

递归贪心形式

动归形式考察了递归式中所有选择k的过程，如果使用贪心选择出最早结束的活动，就剩下一个子问题待解决。

贪心算法和动归的不同：

动归的每一步都要进行一次选择，但选择依赖于子问题的解。因此通常使用自底向上求解，先求较小子问题，再求较大子问题。在贪心算法中，总是选择当时最佳的选择，剩下唯一待解的子问题，子问题不依赖于任何将来的选择。

因此，与动归先求解子问题才能进行第一次选择不同，贪心在进行第一次选择前不用求任何子问题。

当然，我们需要证明每次贪心选择能生成全局最优解。

int ret[10];
int ans = 0;
void recur_act_select(int s[], int f[], int k, int n)
{
    int m = k + 1;  //m是每次第一个结束的活动的下标
    while (m <= n && s[m] < f[k]) {
        m++;
    }
    if (m <= n) {
        ret[ans++] = m;
        return recur_act_select(s, f, m, n);
    }
    return;
}

迭代

尾递归改为迭代，关键是每次计算结果参与下次计算。

//尾递归改成循环
void gred_act_select(int s[], int f[], int n)
{
    int k = 0;
    int m = 0;
    int ret[10] = { 0 };
    int ans = 0;
    while (k <= n) {
        if (s[k] >= f[m]) {
            ret[ans++] = k;
            m = k;
        }
        k++;
    }
}