牛客周赛 Round 23 解题报告 | 珂学家 | 构造场 + 容斥/状态 0-1背包

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量382 收藏 8
点赞数 8
分类专栏： 牛客周赛 解题报告 文章标签： java 代理模式 开发语言 算法 数据结构 贪心算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66102593/article/details/134928014
版权

前言

alt

题解

前三题都是构造类型的题，倒是D题是很典的动态规划题。

牛客还是偏思维，偏构造，偏数学，T_T.

欢迎关注

珂朵莉 牛客周赛专栏

珂朵莉 牛客小白月赛专栏

A. 小红的整数转换

a次操作+b，且a，b都是正整数

等价于 a * b = y - x

分类讨论下

  • y - x > 0

    a=1, b=y-x，是可行解

  • y - x <= 0

    无解

import java.io.BufferedInputStream;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(new BufferedInputStream(System.in));
        int t = sc.nextInt();
        while(t-- > 0) {
            int x = sc.nextInt(), y = sc.nextInt();
            if (y - x > 0) {
                System.out.printf("%d %d\n", 1, (y - x));
            } else {
                System.out.println("-1 -1");
            }
        }
    }

}

B. 小红打O

找规律，找到'*'和坐标x,y的映射关系

可以分成3部分，然后找找对称性，这样可以方便构造。

import java.io.*;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(new BufferedInputStream(System.in));
        int n = sc.nextInt();
        char[][] grid = new char[4 * n][4 * n];
        for (int i = 0; i < 4 * n; i++) Arrays.fill(grid[i], '.');

        // 头和尾巴
        for (int i = 0; i < n; i++) {
            for (int j = n - i; j < 2 * n; j++) {
                grid[i][j] = grid[i][4 * n - 1 - j] = '*';
                grid[4 * n - 1 - i][j] = grid[4 * n - 1 - i][4 * n - 1 - j] = '*';
            }
        }
        
        // 中间
        for (int i = n; i < 3 * n; i++) {
            for (int j = 0; j < n; j++) {
                grid[i][j] = grid[i][4 * n - 1 - j] = '*';
            }
        }

        for (int i = 0; i < 4 * n; i++) {
            System.out.println(new String(grid[i]));
        }
    }

}

C. 小红的完全二叉树构造

按照定义，父子之间必然有一个是偶数

对于给定的n，奇数一定不小于偶数的个数

所以，一种很自然的想法是

按树的奇偶分层，做二分图构建

根据奇数层的节点数，和偶数层的节点数的大小，来决策偶数放树的那一层。

  • 奇数层数不小于偶数层的节点数

则把偶数层优先放置偶数，其他则放剩下的

顺序不重要，奇偶是唯一关注的点。

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(new BufferedInputStream(System.in));
        int n = sc.nextInt();

        int[] depth = new int[n + 1];
        int n1 = 0, n2 = 0;
        for (int i = 1; i <= n; i++) {
            depth[i] = (depth[i / 2] + 1) %  2;
            if (depth[i] == 1) n1++;
            else n2++;
        }

        Deque<Integer> arr1 = new ArrayDeque<>();
        Deque<Integer> arr2 = new ArrayDeque<>();
        for (int i = 1; i <= n; i++) {
            if (i % 2 == 1) arr1.add(i);
            else arr2.add(i);
        }

        int[] res = new int[n + 1];
        if (n1 >= n2) {
            // 偶数层先放偶数
            for (int i = 1; i <= n; i++) {
                if (depth[i] == 0) {
                    res[i] = !arr2.isEmpty() ? arr2.pop() : arr1.pop();
                }
            }

            // 奇数层再放剩下的
            for (int i = 1; i <= n; i++) {
                if (depth[i] == 1) {
                    res[i] = !arr2.isEmpty() ? arr2.pop() : arr1.pop();
                }
            }
        } else {
            // 奇数层先放偶数
            for (int i = 1; i <= n; i++) {
                if (depth[i] == 1) {
                    res[i] = !arr2.isEmpty() ? arr2.pop() : arr1.pop();
                }
            }

            // 偶数层再放剩下的
            for (int i = 1; i <= n; i++) {
                if (depth[i] == 0) {
                    res[i] = !arr2.isEmpty() ? arr2.pop() : arr1.pop();
                }
            }
        }

        System.out.println(
                IntStream.range(1, n + 1)
                    .mapToObj(x -> String.valueOf(res[x]))
                    .collect(Collectors.joining(" "))
        );
    }

}

D. 小红的红蓝硬币

这题有两个思路

  • 状态 + 0-1背包
  • 容斥 + 0-1背包

两者皆以0-1背包为基础，区别在于，一个正向求解, 一个是正难则反。

1. 状态 + 0-1背包

正向求解，引入3个状态

  • 0, 只包含红色的币
  • 1，只包含蓝色的币
  • 2，同时包含了红色和蓝色

把状态迁移整合进0-1背包的迭代求解过程中

令 opt[i][j][s], 前i项金币中，当前总价值为j，状态为s的方案数

第一维，可以借助滚动数组来优化，这样空间复杂度为O(3*k)

时间复杂度为O(3 *k * n)

import java.io.BufferedInputStream;
import java.util.Scanner;


public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(new BufferedInputStream(System.in));
        int n = sc.nextInt(), p = sc.nextInt();
        char[] str = sc.next().toCharArray();

        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }

        long mod = (long)1e9 + 7;
        long[][] dp = new long[3][p + 1];

        for (int i = 0; i < n; i++) {
            // 这是不选择带来的转移
            long[][] dp2 =new long[][] {
                    dp[0].clone(), dp[1].clone(), dp[2].clone()
            };

            char c = str[i];
            int v = arr[i];
            // 选择带来的转移
            if (c == 'B') {
                for (int j = 0; j <= p - v; j++) {
                    dp2[0][j + v] = (dp2[0][j + v] + dp[0][j]) % mod;
                }

                for (int j = 0; j <= p - v; j++) {
                    dp2[2][j + v] = (dp2[2][j + v] + dp[1][j] + dp[2][j]) % mod;
                }

                // 从空集中转移而来
                dp2[0][v] = (dp2[0][v] + 1) % mod;
            } else {
                for (int j = 0; j <= p - v; j++) {
                    dp2[1][j + v] = (dp2[1][j + v] + dp[1][j]) % mod;
                }

                for (int j = 0; j <= p - v; j++) {
                    dp2[2][j + v] = (dp2[2][j + v] + dp[0][j] + dp[2][j]) % mod;
                }

                // 从空集中转移而来
                dp2[1][v] = (dp2[1][v] + 1) % mod;
            }

            dp = dp2;
        }

        System.out.println(dp[2][p]);

    }

}

2. 容斥 + 0-1背包

红色/蓝色金币至少都有一个的方案数

总的方案 - 只含红色 - 只含蓝色

而3部分的独立计算，就是简单的0-1背包

import java.io.BufferedInputStream;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(new BufferedInputStream(System.in));
        int n = sc.nextInt(), p = sc.nextInt();
        char[] str = sc.next().toCharArray();

        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }

        long mod = (long)1e9 + 7;
        long[] dp1 = new long[p + 1];
        long[] dp2 = new long[p + 1];
        long[] dp3 = new long[p + 1];

        // 只有红色的金币
        dp1[0] = 1;
        for (int i = 0; i < n; i++) {
            int v = arr[i];
            if (str[i] == 'R') {
                for (int j = p - v; j >= 0; j--) {
                    dp1[j + v] = (dp1[j + v] + dp1[j]) % mod;
                }
            }
        }

        // 只有蓝色的金币
        dp2[0] = 1;
        for (int i = 0; i < n; i++) {
            int v = arr[i];
            if (str[i] == 'B') {
                for (int j = p - v; j >= 0; j--) {
                    dp2[j + v] = (dp2[j + v] + dp2[j]) % mod;
                }
            }
        }

        // 所有金币的方案数
        dp3[0] = 1;
        for (int i = 0; i < n; i++) {
            int v = arr[i];
            for (int j = p - v; j >= 0; j--) {
                dp3[j + v] = (dp3[j + v] + dp3[j]) % mod;
            }
        }

        // 容斥
        long res = ((dp3[p] - dp2[p] - dp1[p]) % mod + mod) % mod;
        System.out.println(res);
    }

}

写在最后

alt

珂朵莉酱
关注
  • 8
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
牛客周赛 Round 11 解题报告 | 珂学家 | 线性dp+大剪枝
2301_79125431的博客
09-10 145
评测系统依托史，写是都能写出来了，看到通过的就2个，有点恶心昂不算题解的题解：A. 裸的dfs，略B. 从正面做很麻烦，反着来很方便，反正每次操作的元素是确定的。/** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * * @param array int整型一维数组 * @ret。/** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * * @param str string字符串 * @return。
网络基础-牛客学习！！
05-02
网络基础-牛客学习！！
牛客周赛 Round 18 解题报告 | 珂学家 | 分类讨论计数 + 状态DP
每天多一点干货
11-06 173
欢迎关注珂朵莉 牛客周赛。周六睡到十二点多，起来迷迷糊糊的清游戏，突然想到昨天想着出门呢，但是地方都还没找好，连忙找地方，找到合适的出门已经一点多了，吃过饭去坐了贼挤的西郊线，深夜emo时间到，本科毕业去工作了一段时间后考研上岸的，现在27，明年28岁毕业，本科四非，自己水平也比较一般，专业热门，可我不中用，还是女生，只有一段暑期实习。博士，两个薪资都差不多也都是光伏，比亚迪在深圳，晶科能源在嘉兴，比亚迪公司大但是光伏不强，晶科能源组件出货量第一但是公司不如笛子，牛客大佬们帮忙选一选，真的很纠。
牛客周赛 Round 31 解题报告 | 珂学家 | 设计 + 组合
m0_66102593的博客
02-04 691
D题出的蛮好的，其实做过LruCache题的同学，基本都会，即Map+双向链表技巧。E题典型的DP题，负数可以引入偏移来解决。F题是道数学题，组合+乘法原理。
牛客SQ练习题及答案（1-61题）
04-20
牛客SQ练习题及答案（1-61题）
C++面试--牛客(1).pdf
03-21
C++面试--牛客(1).pdf
牛客-js45题-代码
03-08
包含完整代码
leetcode题库-algorithm:剑指Offer+LeetCodeTop-100-Liked-Questions+CyC2018Lee
06-29
希望各位能理解我的思路，从这个仓库学到同一道算法题的多种解法，以及类似题目的解法。 更重要的是学习到题目背后算法的思想，能够用来解决实际问题。 部分方法只给了思路没有代码，说明我认为这种方法思想可以，但...
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 890
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 892
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1203
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 490
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 225
【代码】Java手动启动jar包。
java多线程创建方式
weixin_57763462的博客
05-28 1043
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
Redis学习笔记【基础篇】
qq_42192253的博客
05-30 769
这样以来，我们就可以把不同类型的数据区分开了。从而避免了key的冲突问题。HSET key field value：添加或者修改hash类型key的field的值。获取sorted set 中的指定元素的排名：ZRANK key member。HGET key field：获取一个hash类型key的field的值。通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范。HMSET：批量添加多个hash类型key的field的值。HMGET：批量获取多个hash类型key的field的值。
C语言基础——数组
2302_80177460的博客
05-27 1048
C语言基础——字符串与数组及部分操作符-CSDN博客），这里再简单说明一下吧。我们都知道，如果我们在C语言中想要创建很多个变量，如果是一个一个创建的话那效率太低下了，这个时候或许会有人想到用循环来搞定，但是我们再细想想，如果用循环来表示的话我们应该把这组数据储存在哪里呢，如果只是创建一个变量的话那么后一次循环会覆盖掉前一次循环，但是如果创建很多个变量的话又不好在循环之中插入，这个时候我们便可以使用我们心心念念的数组啦。我们这一章节就来具体看看数组到底是什么吧。
Java入门基础教程-字面量、变量、关键字与标识符
码客笔记
05-27 153
变量是存储数据值的容器，其值可以在程序执行过程中被修改。变量有一个名字（即标识符），并且总是与特定的数据类型相关联。在Java中，变量的声明和初始化是分开的，但也可以同时进行。大家不要被这个词搞晕了，它其实很简单，我们知道计算机是来处理数据的，字面量其实就是告诉程序员数据在程序中的书写格式。所谓标志符其实就是我们自己取的名字。像前面我们取的类名，变量名其实都是标志符。如何识别那些单词是关键字？
继承与无参构造器
2301_79842503的博客
05-30 218
在Java中，当你创建一个子类的实例时，如果子类构造函数没有显式地调用父类的构造函数，那么编译器会自动插入一个对父类无参构造函数的调用（如果父类中存在这样的构造函数）。这是Java中构造函数链式调用的一个基本规则，确保父类在子类之前被正确初始化。这个过程是Java中对象初始化的一个重要部分，确保在子类访问或修改从父类继承的任何状态之前，父类已经完成了其自己的初始化。的构造函数内部，你输出了"Student()无参构造器后执行了"，这是在。的构造函数执行之后发生的。的构造函数执行之前，编译器会自动先调用。
牛客+1008+爱因斯坦的名言
12-15
以下是输出爱因斯坦名言的C++代码： ```cpp #include using namespace std; int main() { cout << "\"Genius is 1% ... return 0; } ``` 输出结果为： ``` "Genius is 1% inspiration and 99% perspiration." ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值