poj1015 动态规划

/*
poj1015 动态规划
reference:http://blog.csdn.net/lyy289065406/article/details/6671105
题目大意：从n个人中选取m个人组成陪审团，要求这控方（d）和辩方（p）给这m个人的总分之差的绝对值最小，
如果分数相同，那么选择分数之和最大的。输出最符合要求的m个人，然后输出辩方总值和控方总值。
题目分析：动态规划(关键是确定状态和状态转移)
1<=n<=200, 1<=m<=20.d, p无法用一维dp解决.因此如果用dp[i][j]表示的是什么状态呢？
要选择m个人,1<=m<=20,那么m应该在dp里面。i表示选了i个人的情况。
对于j的选取，要考虑状态转移，dp[i][j]同dp[i-1][x]加入一个人后变为dp[i][j]
我们选择j为当前的pd差，那么dp[i-1][j+p-d]就可以得到状态转移方程。
因此：dp[i][j]表示的是选第i个人后pd差是j的情况下 pd和最大 的和。
有dp[i-1][x]变为dp[i][j]的条件为：存在某个候选人i,在dp[i-1][x]中没有被选上，
且x+d-p = j;选出dp[i-1][x]+d+p的值最大的那个(i)，那么方案dp[i-1][x]再加上i,就变成方案dp[i][j]
在这个中间，我们需要将一个方案都选了哪些人记录下来。用path[i][j]将dp[i][j]中最后选的那个人的序号记录下来，
那么倒数第二个人的编号为path[i-1][j-V[path[i][j]]].因此我们找到了最终解的方案的辩控差k，那么从path[m][k]出发
就能一步一步回溯求出所有别选中的候选人。
初始条件：dp[0][0]=0,其他均为-1.

小技巧：由于pd的差可能为负数，我们把整个右移m*20,j的范围就从-400-400变成了0-800。


样例：
样例输入
4 2
1 2
2 3
4 1
6 2
0 0
样例输出
Jury #1
Best jury has value 6 for prosecution and value 4 for defence:
 2 3
*/

#include <iostream>
#include <cmath>
#include <algorithm>

using namespace std;
const int MAXN = 801;
const int MAXM = 21;
int n;
int m;
int dp[MAXM][MAXN];     //dp[j][k]:取j个候选人，使其辩控差为k的所用方案中，辩控和最大的辩控和
int path[MAXM][MAXN];   //记录所选定的候选人的编号

//回溯，确认dp[j][k]方案是否曾选择过候选人i
bool select(int j, int k, int i, int* v)
{
    //对于每一个j，都没有选择i,说明前面的j个没有选择i
    while (j > 0 && path[j][k] != i)        //path[j][k]记录的是dp[i][j]中最后选的那个人的序号
    {
        k -= v[path[j][k]];                 //path[j-1][k-v(path[j][k])]为倒数第二个人的序号
        j--;
    }

    return j == 0;
}

int main()
{
    int time = 1;
    while (cin >> n >> m && n)
    {
        //Initial
        int j, k, i;
        int *p = new int[n + 1];    //每个人的控方值
        int *d = new int[n + 1];    //每个人的辩方值
        int *s = new int[n + 1];    //每个人的辩控和
        int *v = new int[n + 1];    //每个人的辩控差

        memset(dp, -1, sizeof(dp));     //初始都为-1
        memset(path, 0, sizeof(path));  //路径都为0

        //input
        for (i = 1; i <= n; ++i)
        {
            cin >> p[i] >> d[i];

            s[i] = p[i] + d[i];     //辩控和
            v[i] = p[i] - d[i];     //辩控差
        }
        int fix = m * 20;       //总修正值，

        //dp
        dp[0][fix] = 0;         //修正后dp[0][fix]才是真正的dp[0][0];
        for (j = 1; j <= m; ++j)
        {
            for (k = 0; k <= 2 * fix; ++k)      //对于每一个d-p
            {
                if (dp[j - 1][k] >= 0)          //初始化为-1，如果选择过，那么>=0。没有选择过不需要管
                {
                    for (i = 1; i <= n;++i)
                    {
                        if (dp[j][k + v[i]] < dp[j - 1][k] + s[i])      //我们选择的是最大的辩控和dp[j - 1][k] + s[i]   ，比当前的辩控和大就替换
                        {
                            if (select(j - 1, k, i, v))                 //序号i的人没有选过
                            {
                                dp[j][k + v[i]] = dp[j - 1][k] + s[i];  //符合条件
                                path[j][k + v[i]] = i;
                            }
                        }
                    }
                }
            }
        }

        //output
        for (k = 0; k <= fix; ++k)
        {
            if (dp[m][fix-k] >=0 || dp[m][fix+k] >= 0)  //中间的为最小的辩控差，从中间向两边搜索
                break;
        }
        int div = dp[m][fix - k] > dp[m][fix + k] ? fix - k : fix + k;  //最小辩控差
        //辩控差div-fix(因为整个区间右移了fix),辩控和dp[m][div]
        //div-fxi = p - d
        //dp[m][div]= p + d;
        //p = (dp[m][div] + div - fix) / 2;d = (dp[m][div] - div + fix) / 2

        cout << "Jury #" << time++ << endl;
        cout << "Best jury has value ";
        cout << (dp[m][div] + div - fix) / 2 << " for prosecution and value ";
        cout << (dp[m][div] - div + fix) / 2 << " for defence:" << endl;

        int* id = new int[m];
        for (i = 0, j = m, k = div; i < m; i++)
        {
            id[i] = path[j][k];                     //从第i个一路走找到第一个
            k -= v[id[i]];
            j--;
        }
        sort(id, id + m);   //升序输出候选人编号  
        for (i = 0; i < m; i++)
            cout << ' ' << id[i];
        cout << endl ;

        /*Relax*/

        delete p;
        delete d;
        delete s;
        delete v;
        delete id;
    }
    return 0;
}