POJ #1015 - Jury Compromise - TODO: POJ website issue

(poj.org issue. Not submitted yet)

This is a 2D DP problem, very classic too. Since I'm just learning, so I took this link as reference:

http://blog.csdn.net/lyy289065406/article/details/6671105

1. It is a little tricky to pick dependent values for this DP. Again, just think about how you are going to expand this reel gradually. We pick number of chosen persons and min|D-P|

2. Back-tracing is used to trace paths.

3. Take care of details.

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <algorithm>

#define MAX_NUM 400
#define MAX_CNT 20

//    info per candidate
int pdiff[MAX_CNT + ];
int  psum[MAX_CNT + ];
int rpath[MAX_CNT];

//    runtime
int   dp[MAX_CNT + ][MAX_NUM *  + ];    // with offset
int path[MAX_CNT + ][MAX_NUM *  + ];    // with offset

void Reset()
{
    memset(  dp, -, sizeof(int) * ((MAX_NUM *  + ) * (MAX_CNT + )));
    memset(path, -, sizeof(int) * ((MAX_NUM *  + ) * (MAX_CNT + )));
    memset(rpath, -, sizeof(int) * MAX_CNT);
}

//    Backtrace: is i selected in dp[p][k]?
bool select(int i, int p, int k)
{
    while (p >  && path[p][k] != i)
    {
        k -= pdiff[path[p][k]];
        p--;
    }
    return p ? true : false;
}

void best_jury(int n, int m, int cnt, int *pd, int *ps)
{
    Reset();

    int fix = m * ;
    dp[][fix] = ;

    for (int p = ; p <= m; p ++)        // each selected m of dp
    for (int k = ; k <= fix * ; k ++)    // each hit sum(v) of dp
    {
        if (dp[p-][k] < ) continue;

        for (int i = ; i < n; i ++)    // each one
        {
            //    Remember: value of dp[][] is sum(sum)
            int newk = dp[p - ][k] + psum[i];
            if (newk > dp[p][k + pdiff[i]])
            {
                if (!select(i, p - , k))
                {
                    // Remember:
                    //    p -> candicate index
                    //    k.. -> current sum(diff)
                      dp[p][k + pdiff[i]] = newk;
                    path[p][k + pdiff[i]] = i;
//                    printf("- put %d @ %d, %ds\n", i, p, k + pdiff[i]);
                }
            }
        }
    }

    //    Get min sum(diff)
    int k = -;
    for (int i = ; i < fix; i++)
    {
        int v0 = dp[m][fix - i];
        int v1 = dp[m][fix + i];
        if (v0 >  || v1 > )
        {
            k = i;
            break;
        }
    }

    int minSumDiff = dp[m][fix - k] > dp[m][fix + k] ? (fix - k) : (fix + k);    // pick the bigger sum one

    int ttlDiff = (dp[m][minSumDiff] + minSumDiff - fix) / ;
    int ttlSum = (dp[m][minSumDiff] - minSumDiff + fix) / ;

    //
    printf("Jury #%d\n", cnt);
    printf("Best jury has value %d for prosecution and value %d for defence:\n", ttlDiff, ttlSum);

    //    Output selected in order
    int tmpk = minSumDiff;
    int id_inx = ;
    while (m >  && path[m][tmpk] >= )
    {
        rpath[id_inx++] = path[m][tmpk];
        tmpk -= pdiff[path[m][tmpk]];
        m--;
    }
    std::sort(rpath, rpath + id_inx);
    for (int i = ; i < id_inx; i ++)
    {
        printf(" %d", rpath[i] + ); // real inx starting from 1
    }
    printf("\n\n");
}

int main()
{
    int m, n, cnt = ;
    int pi[MAX_NUM];
    int di[MAX_NUM];

    while (    scanf("%d", &n), scanf("%d", &m), cnt ++,
            (m != ) && (n != ) )
    {
        //    Get Input
        for (int i = ; i < n; i ++)
        {
            scanf("%d%d", pi + i, di + i);
            pdiff[i] = pi[i] - di[i];
            psum[i]  = pi[i] + di[i];
        }

        //
        Reset();
        best_jury(n, m, cnt, pdiff, psum);
    }

    return ;
}