poj-1015

最新推荐文章于 2020-06-09 20:18:16 发布
最新推荐文章于 2020-06-09 20:18:16 发布
阅读量1k 收藏
点赞数
分类专栏： POJ 文章标签： poj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fyfcauc/article/details/28436263
版权 
#include <stdio.h>
#include <math.h>
#include <malloc.h>

struct candicate {
    int D;
    int P;
};

struct DPstatus {
    short maxSum;
};

typedef struct candicate candicate;
typedef struct DPstatus DPstatus;

void getJury(candicate * candicateInfo, int candicateNum, int juryNum) {

    DPstatus DPmatrix[201][21][801] = {0};

    for (int i = 0; i < 201; i++) {
        for (int j = 0; j < 21; j++) {
            for (int k = 0; k < 801; k++) {
                DPmatrix[i][j][k].maxSum = -1;
            }
        }
    }

    for (int i = candicateNum; i >= 0; i--) {
        for (int j = 0; j <= juryNum; j++) {
            for (int k = -20*juryNum; k <= 20*juryNum; k++) {
                // printf("%d %d %d\n", i, j, k);
                int kPlus = 20*juryNum;
                if (j == 0 && k == 0) {   // no choose any jury member, just 0.
                    DPmatrix[i][j][k + kPlus].maxSum = 0;
                    // printf("E %d %d %d 0\n", i, j, k);
                    continue;
                } else if (j == 0 && k != 0) { // no choose one,
                    DPmatrix[i][j][k + kPlus].maxSum = -1;
                    continue;
                } else if (i == candicateNum && j == 0 && k != 0) {
                    DPmatrix[i][j][k + kPlus].maxSum = -1;
                    continue;
                } else if (i == candicateNum && j == 0 && k == 0) {
                    DPmatrix[i][j][k + kPlus].maxSum = 0;
                    // printf("E %d %d %d 0\n", i, j, k);
                    continue;
                } else if (i == candicateNum && j > 0) {
                    DPmatrix[i][j][k + kPlus].maxSum = -1;
                    continue;
                } else if (k == -20*juryNum && j < juryNum) {
                    DPmatrix[i][j][k + kPlus].maxSum = -1;
                    // printf("F1 %d %d %d 0\n", i, j, k);
                    continue;
                } else if (k == 20*juryNum && j < juryNum) {
                    DPmatrix[i][j][k + kPlus].maxSum = -1;
                    // printf("F2 %d %d %d 0\n", i, j, k);
                    continue;
                } else {
                    if (DPmatrix[i+1][j][k + kPlus].maxSum == -1 &&
                        DPmatrix[i+1][j-1][k - ((candicateInfo[i].D - candicateInfo[i].P)) +kPlus].maxSum == -1) {
                        // printf("A %d %d %d -1\n", i, j, k);
                        DPmatrix[i][j][k+kPlus].maxSum = -1;
                    } else if (DPmatrix[i+1][j][k+kPlus].maxSum == -1) { //choose this one.
                        DPmatrix[i][j][k+kPlus].maxSum = (candicateInfo[i].D + candicateInfo[i].P) + DPmatrix[i+1][j-1][k - ((candicateInfo[i].D - candicateInfo[i].P)) + kPlus].maxSum;
                        // printf("B choose %d %d %d %d  D %d P %d \n", i, j, k, DPmatrix[i][j][k+kPlus].maxSum, candicateInfo[i].D, candicateInfo[i].P);
                    } else if (DPmatrix[i+1][j-1][k - ((candicateInfo[i].D - candicateInfo[i].P)) + kPlus].maxSum == -1) {
                        DPmatrix[i][j][k+kPlus].maxSum = DPmatrix[i+1][j][k + kPlus].maxSum;
                        // printf("C no choose %d %d %d %d\n", i, j, k, DPmatrix[i][j][k+kPlus].maxSum);
                    } else {
                        int chooseSum = (candicateInfo[i].D + candicateInfo[i].P) + DPmatrix[i+1][j-1][k - ((candicateInfo[i].D - candicateInfo[i].P)) +kPlus].maxSum;
                        int noChooseSum = DPmatrix[i+1][j][k +kPlus].maxSum;
                        if (chooseSum >= noChooseSum) { // choose
                            DPmatrix[i][j][k+kPlus].maxSum = chooseSum;
                            // printf("D choose %d %d %d %d\n", i, j, k, DPmatrix[i][j][k+kPlus].maxSum);
                        } else {
                            DPmatrix[i][j][k+kPlus].maxSum = noChooseSum;
                            // printf("D no choose %d %d %d %d\n", i, j, k, DPmatrix[i][j][k+kPlus].maxSum);
                        }
                    }
                }
            }
        }
    }



    int middleZero = 20*juryNum;
    int bigEnd = 40*juryNum;

    int i = 0;
    int finalRes = 402;
    while(1) {
        if (middleZero - i == -1 || middleZero + i == bigEnd + 1) {
            break;
        }
        int left = DPmatrix[0][juryNum][middleZero - i].maxSum;
        int right = DPmatrix[0][juryNum][middleZero + i].maxSum;
        if (left >= 0 && right >= 0) {
            if (left >= right) {
                // printf("V %d %d\n", -i, left);
                finalRes = -i;
                break;
            } else {
                // printf("V %d %d\n", i, right);
                finalRes = i;
                break;
            }
        } else if (left >= 0) {
            // printf("V %d %d\n", -i, left);
            finalRes = -i;
            break;
        } else if (right >= 0) {
            // printf("V %d %d\n", i, right);
            finalRes = i;
            break;
        }
        i++;
    }

    i = 0;
    int j = juryNum;
    int k = middleZero + finalRes;
    // printf("%d\n", DPmatrix[i][j][k].maxSum);
    int DSum = 0;
    int PSum = 0;
    int chooseArray[20] = {0};
    while(1) {
        if (j == 0 || i == candicateNum) {
            break;
        }
        if (DPmatrix[i][j][k].maxSum == DPmatrix[i+1][j][k].maxSum) { // no choose this one
            // printf("%d is not choosed: D: %d P: %d  %d\n", i, candicateInfo[i].D, candicateInfo[i].P, DPmatrix[i+1][j][k].maxSum);
        } else if (DPmatrix[i][j][k].maxSum ==
                    (candicateInfo[i].D + candicateInfo[i].P) + DPmatrix[i+1][j-1][k - (candicateInfo[i].D - candicateInfo[i].P)].maxSum) { // choose this
            // printf("%d is choosed: D: %d P: %d\n", i, candicateInfo[i].D, candicateInfo[i].P);
            // printf("%d ", i + 1);
            chooseArray[juryNum-j] = i + 1;
            DSum += candicateInfo[i].D;
            PSum += candicateInfo[i].P;
            j--;
            k -= (candicateInfo[i].D - candicateInfo[i].P);
        }
        i++;
    }
    printf("Best jury has value %d for prosecution and value %d for defence:\n", DSum, PSum);
    for (int i = 0; i < juryNum; i++) {
        printf(" %d", chooseArray[i]);
    }
    printf("\n");
}

int main() {
    int JuryId = 1;
    while(1) {
        int candicateNum;
        int juryNum;
        scanf("%d %d", &candicateNum, &juryNum);
        if (candicateNum == 0 && juryNum == 0) {
            return 0;
        }
        candicate * candicateInfo = (candicate *)malloc(sizeof(candicate) * candicateNum);
        int min = 100;
        for (int i = 0; i < candicateNum; i++) {
            int D, P;
            scanf("%d %d", &((candicateInfo+i)->D), &((candicateInfo+i)->P));
        }

        printf("Jury #%d\n", JuryId);
        getJury(candicateInfo, candicateNum, juryNum);
        JuryId++;
    }

}



该题其实本质上是一个背包问题， 只不过题目描述上让人不会向那方面想， 并且， 跟DP的学术派描述也不是很直接的对应，

在这道题上阻了挺长时间的， 最后用了最基本的三维数组干过去了（其实可能降为二维的， 以后要再搞一遍二维的）。

因为是三维数组, 所以里面存maxsum的是short， 变成int就直接栈溢出了。

上面解法的出发点是对于每一个可能的DP差进行处理， 题目给了限制条件， 可选者最多200个， 最多20个陪审团员， 每个人的DP差在-20 ~ 20， 那么对于所有情况而言，

DP差的范围在 -20 * 20 ~ 20*20， 而为了用数组进行保存， 那么就需要把 ~400 ~ 400 全部加上 400 变为非负数（一个常用办法）。

那么可以定义 MAXSUM[i][j][k]  为 从candidate的第 i个位置开始 选取 j 个 陪审团员， 是的 辩控差等于k的情况下， 能得到的最大辩控和.

一开始， 要将这个三维数组全部初始化为 -1（-1 代表着 这种条件下无解， 能用-1表示是因为我们会为每个k的取值加上400， 所以只要有解， 那么必然是>=0

（=0 可能是没有选取 或者是 本身D和P就是0）的）

对于这种数组解法， 最重要的有两个：

1. 确定边界值：

<1> j == 0, k == 0, 及不选取任何的陪审团成员（简称J）， 而且辩控差是0， 这种情况下， 因为没有选取任何的陪审团， 因此辩控差自然为0， 而辩控和也为0.

<2> j ==0 , k !=0, 不选取任何的陪审团成员， 但是辩控差却不是0， 这种情况下， 产生了矛盾， 因此该项为-1， 代表无解。

<3> i == candidateNum, j == 0, k == 0,  已经将备选者全部筛选完了， 其他同<1>

<4> i == candidateNum, j == 0, k != 0, 已经将备选者全部筛选完了， 其他同<2>

<5> i == candidateNum, j > 0, 已经将备选者筛选完了，但是陪审团没凑齐， 那么无解.

<6> k < -20*juryNum,  j <= juryNum,  这种情况下， 因为在j <= juryNum的情况下， 能拿到的最小的DP控辩差就是 20*juryNum, 因此无解

<7> k >20*juryNum, j <= juryNum 同<7>, 不过换成了最大的控辩差. 无解


2. 确定递推关系：

MAXSUM[i][j][k] 由两个值决定 ：

<1> MAXSUM[i+1][j][k]: 第 i 个候选者不被选入陪审团， 那么控辩和就等于 从第 i+1个候选者开始进行选择， 选取 j 个人， 并且辩控差等于k.

<2> MAXSUM[i+1][j-1][k - (A[i].D - A[i].P)], 选择第i个候选者进入陪审团， 那么控辩和就等于 A[i].D + A[i].P, 再加上， 从第i个候选者开始选择， 选取 j-1个人， 并且控辩差为

k - (A[i].D - A[i].P).


如果上面两个值都是 -1（无解）， 那么本值也无解， 如果只有一个有解， 那么就只能选择有效的解。

如果两个都有解， 那么从中选择最大的（因为题要求控辩和最大）。


根据这个关系， 也可以推导出三重循环（i，j  ,k）的遍历顺序， 因为 i 由 i+1 影响， j 由 j-1 影响， 而 k 由 k - (A[i].D - A[i].P) 影响，

那么 i 就从 最大的开始， j 从最小的开始， 而k 则无所谓， 因为虽然k 会被 k - (A[i].D - A[i].P)影响， 但是被其影响的前提是选择了 j -1， 而j-1（因为j 从最小的开始）

则在j的上一轮中已经全部得到了， 因此大小无关。


这道题最直观的递推式应该是这样的:

MINABS[i][j][k]   从第i个候选者开始选择j个人， 使得其DP辩控差的绝对值 是以 k为中心的 最小值.

但是这样就搞不出递推关系了. 


这道题难不在于动态规划， 而在于能想到以背包问题的思路来求解， 一般的直观反应可能是求最小的辩控差绝对值的子问题，

而想不到其实是在某一个辩控差为前提下， 求解可能的最大辩控和. （这样就和背包问题一样了， 有了两个约束条件， 选择人数 和 辩控差）。

如果题目要求的是辩控差（不是绝对值）最大 或者 最小， 那么等于约束条件只有一个， 就不再需要按照背包问题的思路来求，按照学术派的动规来求即可。

而再引入绝对值最小以后， 父问题与子问题之间的联系被断开了， 及按照常规思路的最优子结构被破坏了。（这一段有待商榷）


还有有时候正确的解可能由多组， 随便输出一组就可以AC。

fyfcauc
关注
专栏目录
poj1015
a479778594的博客
07-19 592
思路： 刚开始想的是用bfs来解决，但是要选多少人，就要有深入多少层，且重复的部分较多，所以，在数据量较小的情况下可以使用。 因此考虑另一种办法：也是网上大部分的dp方法，记录下每个人的控诉值和辩护值之间的 差值a[i] 和 和值b[i]，用f[i][j]记录前i个人的总的差值之和为j时总的和值之和，用path[i][j]保存前i个人总的差值之和为j时第i个人的编号,由path[i][j]可知...
题解POJ - 1651 Multiplication Puzzle (区间DP)
Wolfgang_baozi
02-06 264
题目传送门 The multiplication puzzle is played with a row of cards, each containing a single positive integer. During the move player takes one card out of the row and scores the number of points equal to ...
POJ 1015
一只菜鸟夹
07-25 875
Jury Compromise Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 31585   Accepted: 8513   Special Judge Description In Frobnia, a far-away country, the verdicts in ...
POJ1015-Jury Compromise【动态规划DP】
08-09
【标题】"POJ1015-Jury Compromise" 是一个编程竞赛题目，主要涉及的是动态规划（Dynamic Programming, 简称DP）的算法应用。动态规划是一种解决复杂问题的有效方法，它通过将问题分解成子问题，并存储子问题的解来...
POJ ACM 1015 Jury Compromise
01-09
《POJ ACM 1015 Jury Compromise：双解法深度解析》 在编程竞赛的世界里，ACM（国际大学生程序设计竞赛）是检验学子编程能力的重要舞台，而POJ（在线判题系统）是其中的一个热门平台。本文将深入探讨一道经典的POJ...
POJ 1015 动态规划
12-15
POJ上的一道题目，自己写的代码，因为想下载别人的， 所以就放上了。
ACM POJ1011-1020问题解答集及C语言实战项目源码
文件名称列表中的数字1012、1019、1020、1011、1016、1018、1014、1017、1015、1013分别对应POJ上的题目编号。这些题目的解答和源码文件可用于学习和参考，是实战项目案例的重要组成部分，对于学习和练习C语言及算法...
POJ 1015 （巨难的DP）
CHAI_NIAOJINJE的博客
06-09 572
题目：poj1015 中文描述 在遥远的国家佛罗布尼亚，嫌犯是否有罪，须由陪审团决定。陪审团是由法官从公众中挑选的。先随机挑选n个人作为陪审团的候选人，然后再从这n个人中选m人组成陪审团。选m人的办法是： 控方和辩方会根据对候选人的喜欢程度，给所有候选人打分，分值从0到20。为了公平起见，法官选出陪审团的原则是：选出的m个人，必须满足辩方总分和控方总分的差的绝对值最小。如果有多种选择方案的辩方总分和控方总分的之差的绝对值相同，那么选辩控双方总分之和最大的方案即可。 输入 输入包含多组数据。每组数据的第一行是
POJ1015
auiayo82822的博客
11-28 96
题意 现有两方， 给出n个人，每方分别给n个人两个分数分别为a[i]，b[i]，现要选出m个人，使得m个人两方的和的差的绝对值最小，如果多组解，输出双方和最大的解（1<=n<=200, 1<=m<=20， 0 <= a[i]，b[i]<= 20） 分析 贪心显然不可解 错的思路：dp[i]表示n个人选出i个人的的最佳方案（即绝对值最小），但显...
POJ 1015 Jury Compromise
cmonkey
02-13 672
Jury Compromise Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 19548   Accepted: 4886   Special Judge Description In Frobnia, a far-away country, the ve
poj 1015
jinjiahao5299的专栏
03-13 430
#include #include int dp[210][25][420],sd[210][25][410]={0},sp[210][25][410]={0},path[25]; int p[210],d[210],s[210],r[210]; int ab(int i) { return i>0?i:-i; } int main() { //freopen("in.txt","r",s
题解：POJ1015 Jury Compromise 【DP】
子衿君的博客
03-06 404
传送门 描述 在遥远的国家佛罗布尼亚，嫌犯是否有罪，须由陪审团决定。陪审团是由法官从公众中挑选的。先随机挑选n个人作为陪审团的候选人，然后再从这n个人中选m人组成陪审团。选m人的办法是： 控方和辩方会根据对候选人的喜欢程度，给所有候选人打分，分值从0到20。为了公平起见，法官选出陪审团的原则是：选出的m个人，必须满足辩方总分和控方总分的差的绝对值最小。如果有多种选择方案的辩方总分和控方总分的之差...
动态规划POJ-1170题解及交流讨论
资源摘要信息:"POJ-1170 动态规划问题的详细解析与编程实现" 知识点1：动态规划概念 动态规划是解决优化问题的一种方法，它的核心思想是将复杂问题分解为更小的子问题，并存储这些子问题的解（称为记忆化），避免...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值