洛古 P1926 小书童——刷题大军

最新推荐文章于 2024-07-26 12:42:30 发布

一个老蒟蒻

最新推荐文章于 2024-07-26 12:42:30 发布

阅读量444

点赞数 1

分类专栏：蓝桥杯文章标签：动态规划算法贪心算法

本文链接：https://blog.csdn.net/qq_30347475/article/details/122984567

版权

蓝桥杯专栏收录该内容

14 篇文章 7 订阅

订阅专栏

P1926、小书童——刷题大军

题目

题目背景

数学是火，点亮物理的灯；物理是灯，照亮化学的路；化学是路，通向生物的坑；生物是坑，埋葬学理的人。文言是火，点亮历史宫灯；历史是灯，照亮社会之路；社会是路，通向哲学大坑；哲学是坑，埋葬文科生。——小A

题目描述

小A“刷题”十分猖狂，明目张胆地“刷题”。他现在在小书童里发现了n样他喜欢的“题目”，每“题”都有他的需要时间，而老师布置了m项作业，每项作业都有它的需要时间及分值，老师规定k分以上算及格。小A只剩r个单位时间，他想在及格的基础上更多地“刷题”。

输入格式

第一行：n m k r。第二行：n个数，代表每“题”他的需要时间。第三行：m个数。表示每项作业它的需要时间。第四行：m个数。代表每项作业它的分值。

输出格式

一个数，代表小A能刷几道题

输入输出样例

输入 #1复制

3 4 20 100
15 20 50
10 15 40 40
5 5 10 15

输出 #1复制

说明/提示

没有不能及格的情况

对于100%的数据， $n\le 10,m\le 10,k\le 50,r\le 150$

思路

这其实就是一道很平常的01背包问题，但是他不太一样的地方是他要进行两次背包。

第一次背包过程中，一旦当前情况的分值已经大于及格分，那么我们就对当前所需时间进行判断，在多次循环后我们求出的就是及格最少要花的时间

那么接下来，我们减去及格要花的最少时间，那么剩下的时间就是允许我们自由刷题的时间了

接着就是最平常的背包了

这里数据范围不大，所以二维 $d p$ 应该也是没有问题的

但是我的代码用的是一维 $d p$ ，所以能花更少的空间复杂度

大家也最好学一学 $d p$ 的状态压缩，以防比赛卡数据呢？

$t i p s :$ 一维 $d p$ 要注意内循环要反向遍历，而且遍历范围不一样！！！！

代码

package com.lanqiao;

import java.util.Scanner;

/**
 * @author 王宇哲
 **/
public class P1926 {

    /**
     * 小A喜欢的题目数量
     */
    static int n;

    /**
     * 老师布置的题目数量
     */
    static int m;

    /**
     * 老师规定的及格分数
     */
    static int k;

    /**
     * 小A剩余的时间
     */
    static int r;

    /**
     * 他想要刷的题总共需要的时间
     */
    static int[] requireTimeForLike;

    /**
     * 老师规定的作业所需时间
     */
    static int[] requireTimeForOrder;

    /**
     * 老师规定的作业的分值
     */
    static int[] scoreForOrder;

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        n = scanner.nextInt();
        m = scanner.nextInt();
        k = scanner.nextInt();
        r = scanner.nextInt();

        requireTimeForLike = new int[n+1];
        requireTimeForOrder = new int[m+1];
        scoreForOrder = new int[m+1];

        for (int i = 1;i <= n;i ++){
            requireTimeForLike[i] = scanner.nextInt();
        }
        for (int i = 1;i <= m;i ++){
            requireTimeForOrder[i] = scanner.nextInt();
        }
        for (int i = 1;i <= m;i ++){
            scoreForOrder[i] = scanner.nextInt();
        }
        //*************求及格的情况下还剩多少时间***************
        int[] dp = new int[r+1];

        int minRequireTime = 0xfffffff;

        for(int i = 1;i<=m;i++){
            for(int j = r;j>=requireTimeForOrder[i];j--){
                dp[j] = Math.max(dp[j],dp[j-requireTimeForOrder[i]]+scoreForOrder[i]);

                //如果花这么久已经及格了，就更新最少需要的时间
                if(dp[j] > k){
                    minRequireTime = Math.min(minRequireTime,j);
                }
            }
        }

        //现在开始，剩下的时间都是小A的啦
        r -= minRequireTime;

        //*************求最多完成的题目数量********************

        dp = new int[r+1];

        for(int i = 1;i <=n ;i++){
            for(int j=r;j>=requireTimeForLike[i];j--){
                dp[j] = Math.max(dp[j],dp[j-requireTimeForLike[i]]+1);
            }
        }

        System.out.println(dp[r]);

    }

}