poj 1036 Gangster -- 最长上升子序列解法

/*
 *  poj 1036 Gangster

    题目大意:
        N个抢匪陆续的进入一家餐馆，餐馆的们有K个开放度，每个绑匪只有在开放度适合
        自己时才能进入，并给餐馆带来相应收益P。问通过控制门的开、关(一个时间单位
        门只能开1、关1或者保持不变)，餐馆能获得的最大收益是多少?

    数学模型:
        1、假设所有歹徒已经按照进入时刻，按照从先到后的顺序进行了排序。
        
        2、s(i)表示前第i个歹徒与歹徒g[i]兼容的歹徒组成的集合，包括g[i]。

           f(i)表示通过控制门的开关使得集合s(i)中歹徒进入餐馆所能获得的最大收益。
           
        3、兼容性的数学表示: -- 歹徒a和b兼容(不失一般性，假设T[a]>T[b])
                T[a]-T[b] >= |S[a]-S[b]|
        

        4、由以上3点，得出由如下递归式成立:

           f(i) = max{f(k)+P[i] | k<i 并且 g[k]兼容g[i]}

           此解法类似最长上升子序列的问题的解法，下面来证明递归式的正确性。

           其中子问题是在第i个歹徒之前，且与g[i]兼容的子集s(k)所能取得的最大收益值。

           g[i] U s(k)是s(i)的一个解。 -- 要知道的是，s(i)有多个解，具体哪个解能取得
           最大收益，就需要采取枚举来判定了。

        5、证明: 按照进入时刻排序后，如果g[i]兼容于g[k]，则g[i]兼容s(k)中任一元素

           证明:
               假设存在歹徒g[x] belong_to s(k)则根据兼容性，有如下表达式成立:

                I) T[k]-T[x] >= |S[k]-S[x]|
               II) T[i]-T[k] >= |S[i]-S[k]|

               合并表达式I、II得:
              III) T[i]-T[x] >= |S[i]-S[k]| + |S[k]-S[x]|  -->绝对值的和 >= 和的绝对值
                             >= |S[i]-S[x]| 

               结论得证。

            
        6、举个例子说明不排序，则上述递归式无法成立。
        
           反例:

                    G |  T   K
                    --|--------
                    x |  8   1
                      |
                    k |  1   1
                      |
                    i |  10  10

            上例中歹徒g[x] belong_to s(k)，g[i]与g[k]兼容，但是明显g[x]与g[i]
            互不兼容，因此他们构成的解也肯定不是s(i)的正确解!
*/

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>

namespace {
    using namespace std;

    typedef struct GANGSTER
    {
        int t, k, p;
    }GANGSTER_S;

    int gangster_comp(const void *pOP1, const void *pOP2)
    {
        GANGSTER_S *pG1 = (GANGSTER_S *)pOP1;
        GANGSTER_S *pG2 = (GANGSTER_S *)pOP2;

        if (pG1->t < pG2->t)  return -1;
        if (pG1->t == pG2->t) return 0;
        if (pG1->t > pG2->t)  return 1;
    }

    inline bool gangster_compatible(const GANGSTER_S &G1, const GANGSTER_S &G2)
    {
        return abs(G1.t-G2.t) >= abs(G1.k-G2.k);
    }

    const int N_MAX = 100;
    GANGSTER_S G[N_MAX+1]; // 歹徒存储

    int f[N_MAX+1]; // f(i)
    int n; // 实际有效的歹徒个数

    int gangster()
    {
        qsort(&G[1], n, sizeof(G[1]), gangster_comp); // 排序，保证子问题的解可以构成原问题的解

        int mp = 0;
        for (int i=1; i<=n; i++)
        {
            for (int j=i-1; j>=0; j--)
            {
                if (gangster_compatible(G[i], G[j]))
                {
                    if (f[j]+G[i].p > f[i])
                    {
                        f[i] = f[j]+G[i].p;
                    }
                }
            }

            if (f[i]>mp) mp=f[i];
        }

        return mp;
    }
}

int main()
{
    int N, K, T;
    scanf("%d%d%d", &N, &K, &T);

    for (int i=1; i<=N; i++)
    {
        scanf("%d", &G[i].t);
    }
    for (int i=1; i<=N; i++)
    {
        scanf("%d", &G[i].p);
    }
    for (int i=1; i<=N; i++)
    {
        scanf("%d", &G[i].k);
    }

    int i=1; n=N;
    while (i<=n)
    {
        // 去除无效的歹徒
        if (G[i].k>K || G[i].k>T ||G[i].k>G[i].t)
        {
            swap(G[i], G[n]);
            n--;
            
            continue;
        }

        ++i;
    }

    printf("%d\n", gangster());
    
    return 0;
}