关注我们，每天更新大厂最新笔试题解析
前言
文末给大家推荐一下我们的活动，针对校招笔面试全覆盖的全程真一对一的提高，参加活动前会给你安排一个全面的摸底，摸底后会针对你的情况进行分析和对于参加活动的介绍，然后你再决定是否参加!
在线做题链接：https://niumacode.com/
整体侧重考察贪心策略的灵活运用以及复杂工程逻辑的模拟能力。
- 特点： 基础签到题。将双方战力升序排序后，用双指针进行策略匹配。核心思想是用己方最弱的战力去尽可能兑掉敌方较弱的战力，若打不过则直接作为“炮灰”消耗掉敌方的高战力，保证己方精锐的胜率。
- 特点： 典型的游戏背包空间分配业务题。没有复杂的算法，难点在于工程实现：一是准确无误地实现“类型 > 品质 > ID”的多级比较逻辑；二是严谨地在二维网格中按从左到右、从上到下的顺序扫描空闲区块并完成填入。
- 特点： 进阶算法题。炮弹发射次数越多越容易清场，这种明显的“单调性”直接指向了二分答案框架。解题难点在于
check(k) 函数的设计：需要采用极限贪心思维，将前面的所有推力假设为单向的最坏情况，以此来判定是否需要增加开火次数。
- 第四题：贴图流式加载（复杂系统模拟 / LRU 变种）
- 考点： 面向对象状态建模、多条件缓存驱逐机制（优先过期时间、其次 ID）。
- 特点： 压轴大模拟题。不涉及高级算法，但极度考验代码的组织架构和对繁杂业务边界的处理能力。需要完美模拟游戏引擎底层的内存管理细节，包括多级资源依赖、精确到时刻的过期判定以及空间不足时的强制驱逐逻辑。
沙场点兵
在线做题链接：https://niumacode.com/
在网易旗舰级武侠游戏《逆水寒》的“宋辽边境”战场玩法中，宋辽两军正隔河对峙。
辽军统帅为了挫败我方士气，摆下了“连环阵”：他们派出了 支精锐的先锋小队，并公开了这 支小队出战的先后顺序以及每一支小队的“战力值”。
作为宋军的战术指挥官，你手下同样拥有 支蓄势待发的铁骑小队，每支小队的“战力值”你也了如指掌。根据战场规则，两军将进行 轮一对一的“阵前对决”：
每一轮，双方各派出一支小队进行厮杀； 战力值较高的小队将全歼对手并获胜（积 分）； 若战力值相同，由于辽军占据地利，判定辽军获胜（宋军积 分，辽军积 分）。
战国时，齐威王与田忌赛马的故事广为人知，你也想成为如田忌一般的智将，带领你麾下的将士赢得胜利。请判断，是否存在一种排兵布阵的策略，使得我军最终的胜场数严格大于辽军的胜场数？
输入描述
每个测试文件均包含多组测试数据。第一行输入一个整数 () 表示演练的数据组数。每组测试数据描述如下：
第一行一个整数 (， 为奇数)，表示双方派出的小队数量。
第二行包含 个整数 ()，表示我军（宋军）每支小队的战力值。
第三行包含 个整数 ()，表示敌军（辽军）的出战顺序及其战力值。
保证所有测试中 的总和不超过 。
输出描述
输出 行。对每组数据，若通过合理排兵布阵能使得我军 胜场数 败场数，输出 YES；否则输出 NO。
示例 1
输入
2
5
2 5 7 1 6
3 5 6 2 7
3
3 3 3
3 3 3
输出
YES
NO
说明
对于第一组测试数据，一种最佳出兵顺序如下： 第一阵：派战力 迎战辽军 （胜）； 第二阵：派战力 迎战辽军 （胜）； 第三阵：派战力 迎战辽军 （胜）； 第四阵：派战力 迎战辽军 （败）； 第五阵：派战力 迎战辽军 （败）； 最终 胜 负，大破辽军，输出 YES。
思路与代码
该问题本质上是“田忌赛马”贪心策略的变体。为了获得尽可能多的胜场，首先将双方的战力值数组进行升序排序。通过双指针贪心法，尝试用我方当前最弱的兵力去对抗敌方最弱的兵力：如果能赢，则匹配这对组合并增加胜场；如果不能赢（即我方最弱兵力小于或等于敌方最弱兵力），则该兵力无法战胜敌方任何剩余兵力，应将其消耗掉，转而使用我方后续更强的兵力尝试匹配。
由于题目给出 为奇数，且要求胜场数严格大于败场数，因此最终只需判断最大胜场数是否超过 （即至少达到 场）即可判定为 YES。
import java.util.*;
import java.io.*;
publicclassMain{
publicstaticvoidmain(String[] args)throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String firstLine = reader.readLine();
if (firstLine == null) return;
int testCases = Integer.parseInt(firstLine.trim());
PrintWriter out = new PrintWriter(System.out);
while (testCases-- > 0) {
int totalCount = Integer.parseInt(reader.readLine().trim());
long[] songArmy = newlong[totalCount];
long[] liaoArmy = newlong[totalCount];
StringTokenizer st1 = new StringTokenizer(reader.readLine());
for (int i = 0; i < totalCount; i++) {
songArmy[i] = Long.parseLong(st1.nextToken());
}
StringTokenizer st2 = new StringTokenizer(reader.readLine());
for (int i = 0; i < totalCount; i++) {
liaoArmy[i] = Long.parseLong(st2.nextToken());
}
Arrays.sort(songArmy);
Arrays.sort(liaoArmy);
int victories = 0;
int ourPtr = 0;
int enemyPtr = 0;
for (; ourPtr < totalCount; ourPtr++) {
if (songArmy[ourPtr] > liaoArmy[enemyPtr]) {
victories++;
enemyPtr++;
}
}
if (victories > totalCount / 2) {
out.println("YES");
} else {
out.println("NO");
}
}
out.flush();
}
}
背包排序
在线做题链接：https://niumacode.com/
玩家小A现在有一个 个格子的背包（ 为高， 为宽），有 个物品，先按排序算法把物品进行排序，然后根据排序后的物品——放入背包。
在放入背包时，优先选择行数最小的位置进行放置，其次选择列数最小的位置。如果当前行无法容纳物品，则继续查找下一行。如果整个背包都无法放下该物品，则跳过该物品。
最后输出背包是否放的下所有物品。并输出当前背包状态，用 id 表示当前背包格子是什么物品，如果当前格子没有物品输出 。
每个物品都包含以下这些属性： id：物品唯一 ID，每个物品各不相同。 height width：物品占用的格子数。（height为高，width为宽）物品不可以旋转放入背包。 quality：物品的品质。数值越大品质越高。 type：物品的种类。
排序规则如下：、优先按照 type 排序，"equip" "weapon" "item" "other"。、品质高的优先。、id 小的优先。
输入描述
第一行包含三个整数 ()， ()， ()，分别表示背包的高，背包的宽，物品的数量。
接下来 行，每行包含四个整数，id ()，height ()，width ()，quality ()，一个字符串 type (type {"equip", "weapon", "item", "other"})，为物品包含的属性。
输出描述
第一行包含一个字符串 "YES" 表示为背包可以放下所有物品。"NO" 表示为有的物品放不进去背包。
接下来 行，每行包含 个整数，表示当前格子放着的物品 id，如果当前格子没有物品则输出 。
示例 1
输入
4 3 3
1 1 3 7 other
2 3 1 2 equip
3 2 2 4 other
输出
YES
2 3 3
2 3 3
2 0 0
1 1 1
说明
排序后顺序：。按顺序放入即可。
示例 2
输入
4 4 6
6 2 1 3 weapon
1 2 3 1 equip
3 2 1 4 item
5 3 3 3 weapon
2 2 2 3 other
4 2 1 3 item
输出
NO
1 1 1 6
1 1 1 6
3 4 2 2
3 4 2 2
思路与代码
该程序采用了贪心算法结合自定义排序规则。首先根据题目要求的优先级（种类权重 > 品质降序 > ID升序）对所有物品进行预排序。随后遍历排序后的物品列表，在二维网格中按照“从上到下、从左到右”的顺序寻找第一个能够容纳该物品尺寸的空置区域。一旦找到合法位置，立即将其放置并填充 ID，若遍历整个网格均无法放置，则跳过该物品并标记最终状态为失败（NO）。
import java.util.*;
import java.io.*;
publicclassMain{
staticclassProductimplementsComparable<Product> {
int sn, rLen, cLen, score, level;
String category;
publicProduct(int sn, int rLen, int cLen, int score, String category){
this.sn = sn;
this.rLen = rLen;
this.cLen = cLen;
this.score = score;
this.category = category;
// 映射类型权重
switch (category) {
case"equip": this.level = 1; break;
case"weapon": this.level = 2; break;
case"item": this.level = 3; break;
default: this.level = 4; break;
}
}
@Override
publicintcompareTo(Product other){
if (this.level != other.level) return Integer.compare(this.level, other.level);
if (this.score != other.score) return Integer.compare(other.score, this.score);
return Integer.compare(this.sn, other.sn);
}
}
publicstaticvoidmain(String[] args)throws IOException {
Scanner cin = new Scanner(System.in);
if (!cin.hasNextInt()) return;
int rowMax = cin.nextInt();
int colMax = cin.nextInt();
int total = cin.nextInt();
List<Product> cargoList = new ArrayList<>();
for (int i = 0; i < total; i++) {
cargoList.add(new Product(cin.nextInt(), cin.nextInt(), cin.nextInt(), cin.nextInt(), cin.next()));
}
Collections.sort(cargoList);
int[][] mat = newint[rowMax][colMax];
boolean success = true;
for (Product p : cargoList) {
boolean isPlaced = false;
// 优先遍历行，其次遍历列
for (int i = 0; i <= rowMax - p.rLen; i++) {
for (int j = 0; j <= colMax - p.cLen; j++) {
if (checkSpace(mat, i, j, p.rLen, p.cLen)) {
markMatrix(mat, i, j, p.rLen, p.cLen, p.sn);
isPlaced = true;
break;
}
}
if (isPlaced) break;
}
if (!isPlaced) success = false;
}
System.out.println(success ? "YES" : "NO");
StringBuilder sb = new StringBuilder();
for (int i = 0; i < rowMax; i++) {
for (int j = 0; j < colMax; j++) {
sb.append(mat[i][j]).append(j == colMax - 1 ? "" : " ");
}
sb.append("\n");
}
System.out.print(sb.toString());
}
privatestaticbooleancheckSpace(int[][] board, int x, int y, int h, int w){
for (int i = x; i < x + h; i++) {
for (int j = y; j < y + w; j++) {
if (board[i][j] != 0) returnfalse;
}
}
returntrue;
}
privatestaticvoidmarkMatrix(int[][] board, int x, int y, int h, int w, int val){
for (int i = x; i < x + h; i++) {
for (int j = y; j < y + w; j++) {
board[i][j] = val;
}
}
}
}
不朽荣光
在线做题链接：https://niumacode.com/
在《永劫无间》的决赛圈中，作为仅存的侠客之一，你正处于“聚窟洲”的一处狭长索桥上与其余敌方侠客对峙。
此时“暗域”（毒圈）已经严重蔓延，索桥的左端（坐标 ）与右端（坐标 ）均已被高浓度的暗域覆盖，任何侠客一旦进入暗域范围就会因体力耗尽被瞬间淘汰。
令索桥的安全区域左侧边缘对应坐标 ，右侧边缘对应坐标 。当前桥上还有 名敌方侠客，其初始坐标为 ，同一位置上可能有多名侠客，但均满足 ()，即暂时处于安全区内。
你捡到了一把金色品质的“火炮”，并装备了稀有魂玉“连珠·反弹”。你可以向索桥上任意一个整数坐标点 发射一枚具有强力冲击波的炮弹，产生如下效果：. 命中：如果某名敌方侠客当前坐标恰好为 ，则被炮弹直接命中造成巨额伤害淘汰；. 左击退：如果某名敌方侠客当前坐标为 且 ，则会被爆炸气浪向左震飞 个单位，变为坐标 ；. 右击退：如果某名敌方侠客当前坐标为 且 ，则会被爆炸气浪向右震飞 个单位，变为坐标 。
当敌方侠客的坐标被震飞至 或 时，就会跌入暗域被淘汰。
为了拿下“不朽荣光”成就（在另外两名队友已经阵亡的情况下，独自存活至少 分钟并最终获胜），你需要计算至少发射多少次炮弹，才能将所有敌方侠客淘汰？每次开火前，你都可以根据当前幸存敌人的位置，重新选择最优的落点 。
输入描述
第一行输入三个整数 ()，分别表示敌方侠客数量、索桥安全区长度与震飞距离； 第二行输入 个整数 ()，表示初始时每名敌方侠客的坐标。
示例 1
输入
3 10 2
3 5 9
输出
2
说明
在这个样例中，一种最优策略是： 第一次瞄准 处开火，直接淘汰坐标 的敌人，其余敌人被震飞至坐标 （存活）和 （掉入暗域淘汰）； 第二次瞄准 处开火，淘汰剩余敌人。
示例 2
输入
5 20 3
2 6 9 12 17
输出
2
说明
在这个样例中，一种最优策略是： 第一次瞄准 处开火，直接淘汰坐标 的敌人，其余被震飞至 ，其中 和 触发暗域淘汰； 第二次瞄准 处开火，直接淘汰坐标 的敌人，另一名被震飞至 （掉入暗域淘汰）。
思路与代码
本题采用排序去重 + 二分答案的算法思路。因为发射的炮弹越多，越容易淘汰所有敌人（结果具有单调性），所以我们可以通过二分查找来确定最少的射击次数 。同一位置的敌人受气浪影响完全一致，因此预先进行去重处理。
在验证 次射击是否足够时，采用贪心策略：从左到右遍历敌人，对于当前敌人，贪心地假设前面已经不得不消耗的 次射击都在其左侧（产生向右的推力），而剩余的 次射击全在其右侧（产生向左的推力）。如果在这种最有利于将其向左震飞的极限情况下，该敌人仍留在安全区内（），则说明必须额外消耗一次射击来处理他，令 加一。若中途 超过了 ，则说明 发炮弹不够。
import java.io.*;
import java.util.*;
publicclassMain{
// 快速 I/O 类，用于处理大数据量输入
staticclassFastScanner{
privatefinal InputStream in = System.in;
privatefinalbyte[] buffer = newbyte[1 << 16];
privateint head = 0, tail = 0;
privateintread()throws IOException {
if (head >= tail) {
head = 0;
tail = in.read(buffer, 0, buffer.length);
if (tail <= 0) return -1;
}
return buffer[head++];
}
publiclongnextLong()throws IOException {
int c = read();
while (c <= 32) {
if (c == -1) return -1;
c = read();
}
boolean negative = false;
if (c == '-') {
negative = true;
c = read();
}
long res = 0;
while (c > 32) {
res = res * 10 + (c - '0');
c = read();
}
return negative ? -res : res;
}
}
staticlong L, r;
staticlong[] a;
// 检查给定的射击总次数 k 是否足够
staticbooleancheck(long k){
long need = 0; // 记录必须使用的直接/左侧射击次数
for (long x : a) {
// 假设已用的 need 次射击都在左侧，剩下的 (k - need) 次都在右侧
long pos = x + (2L * need - k) * r;
// 如果在此极限情况下仍处于安全区内，则必须额外开一炮
if (pos > 0 && pos < L) {
need++;
// 如果需要的炮弹数超过了给定的 k，说明 k 次不够
if (need > k) returnfalse;
}
}
returntrue;
}
publicstaticvoidmain(String[] args)throws Exception {
FastScanner fs = new FastScanner();
long n_raw = fs.nextLong();
if (n_raw == -1) return; // 处理可能的无输入情况
int n = (int) n_raw;
L = fs.nextLong();
r = fs.nextLong();
long[] raw_a = newlong[n];
for (int i = 0; i < n; i++) {
raw_a[i] = fs.nextLong();
}
// 1. 排序
Arrays.sort(raw_a);
// 2. 去重（相同坐标的敌人无论怎么炸受到的影响均相同，视作一个单位即可）
long[] temp = newlong[n];
int m = 0;
for (int i = 0; i < n; i++) {
if (i == 0 || raw_a[i] != raw_a[i-1]) {
temp[m++] = raw_a[i];
}
}
a = Arrays.copyOf(temp, m);
// 3. 二分查找最小炮弹数
long lo = 1, hi = m;
while (lo < hi) {
long mid = (lo + hi) >>> 1;
if (check(mid)) {
hi = mid; // 当前次数可行，尝试更小的次数
} else {
lo = mid + 1; // 当前次数不可行，必须增加次数
}
}
// 输出最少需要发射的炮弹次数
System.out.println(lo);
}
}
贴图流式加载
在线做题链接：https://niumacode.com/
在游戏引擎中，为了在有限的显存 (VRAM) 中获得最佳画质，系统采用贴图流式加载 (Texture Streaming) 技术管理贴图。例如，当渲染系统需要用到某贴图的 mip1 时，系统会从硬盘中读取此贴图的 mip1、mip2、mip3...，并把它们加载到显存；在一段固定时间 后，这些 mip 才允许被卸载以腾出宝贵的显存（称为过期）。
时间 请求加载的 mip 的过期时间为 ；加载时间为闭区间， 时不允许卸载； 注意：同一张贴图的不同 mip 可以具有不同的过期时间；每次请求加载时，mip 的过期时间都会被更新；
系统会设置一个贴图占用显存大小的上限 ，为了避免贴图 mip 的频繁加卸载，系统会尽可能将经常使用的 mip 驻留在显存中。当显存不足以容纳新加载请求的数据时，系统会触发 LRU 回收机制，依次卸载已过期的 mip 资源，直至能够加载新数据。如果所有过期资源都被卸载，显存依旧不足，此时系统会放弃本次加载（放弃加载时，不更新过期时间）。
每个贴图会有一个唯一的编号 ，LRU 回收时，相同过期时间的贴图按照从小到大依次卸载；相同过期时间的 mip 必须一次性卸载；不同过期时间的 mip 必须依次卸载（这关系到下面的日志输出）。
注意：如果新加载某张贴图请求依赖某级 mip，这级 mip 缓存即使过期了也不能被 LRU 回收（如：贴图 目前已加载 mip2 并已过期，当前想加载贴图 的 mip0，触发显存不足需要 LRU 卸载贴图，mip0 依赖 mip2，所以 mip2 虽过期但无法卸载）。
系统也可以接收主动清理信号，此时系统会卸载所有已过期的资源（与 LRU 回收不同，主动清理时，仅按照贴图编号从小到大依次卸载所有过期 mip，不再按照过期时间顺序）。
你需要编写一个程序来模拟这一过程，并输出贴图加载状态变更的日志。每条日志需要包含时间、贴图编号、状态变更后该贴图的最小加载 mip、状态变更后系统当前的贴图显存总占用。
注意：、仅当贴图加载状态改变时才需要输出日志，贴图加载状态不变时不需要输出日志。、依次卸载的贴图或 mip 需要有独立的日志。、一次性卸载的 mip 仅输出一条日志。
输入描述
首行： ()
接下来 行，每行为以下二者之一：
. 加载请求： 表示在时间 时渲染系统需要用到贴图 的 mipX（如 ，请求加载的就是 mip1）。贴图 的 mip0 占用显存为 ，mip 数量为 。题目保证保证相同输入 的 和 均相同。 请注意：贴图的每一级 mip 占用显存是前一级 mip 的 ，保证每一级 mip 占用显存大小均为整数 (如 mip1，它的显存占用大小应该是 )。
. 主动清理请求： 表示在时间 时接收到主动清理信号。题目保证： 非递减。 ()
输出描述
每一行代表一条日志，格式为 表示在时间 时贴图 的 mip 加载级别发生了变化，变化后此贴图的最小加载 mip 为 mipX，变化后系统当前的贴图显存总占用为 （如果此贴图的所有 mip 均被卸载，输出的 为 ）
示例 1
输入
120 4 7
1 3 0 20 1
1 2 0 40 2
1 1 0 40 2
1 4 0 20 1
5 4 0 20 1
6 4 0 20 1
99 -1
输出
1 3 0 20
1 2 0 70
1 1 0 120
6 1 -1 70
6 4 0 90
99 2 -1 40
99 3 -1 20
99 4 -1 0
说明
依次加载贴图 、、，占用 ，输出 条日志；随后加载贴图 ，由于显存不足而失败，不输出日志。 再次请求贴图 ， 加载的资源过期时间为 ；由于加载时间为闭区间， 时仍未过期，不能回收，因此加载失败，不输出日志。 再次请求贴图 ，贴图 、、 已可回收。它们过期时间相同，按贴图编号从小到大回收，先卸载贴图 ；此时空间足够，再加载贴图 ，共输出 条日志。 主动清理，按贴图编号 、、 依次卸载所有已过期资源，共输出 条日志。
示例 2
输入
341 4 10
1 1 1 256 5
2 2 0 40 2
3 3 0 40 2
4 1 0 256 5
5 1 0 256 5
6 1 0 256 5
7 1 0 256 5
8 1 0 256 5
9 1 0 256 5
10 1 0 256 5
输出
1 1 1 85
2 2 0 135
3 3 0 185
7 2 -1 135
8 3 -1 85
8 1 0 341
说明
请求贴图 的 mip1，加载 mip1~，占用 。、 依次加载贴图 、，总占用分别为 、。 多次请求贴图 的 mip0，需要补载 mip0=，但显存不足，均失败。 注意 时贴图 的 mip1 过期，但由于贴图 的 mip0 依赖 mip1，因此不能够回收。 贴图 过期，被回收后占用变为 ，仍不足以补载 mip0。 贴图 过期，被回收后占用变为 ，此时空间足够，补载贴图 的 mip0，总占用变为 。
思路与代码
这段代码的核心思路是模拟一个具备过期清理和空间驱逐机制的显存（VRAM）纹理管理系统。它通过维护每个纹理及其多级渐远纹理（Mipmaps）的加载状态、大小和过期时间，处理两种主要操作：
- 清理操作（ID=-1）：遍历所有纹理，将当前时间已过期的 Mipmaps 卸载，并按 ID 升序依次输出卸载后的状态。
- 加载/更新操作：当需要加载或更新纹理时，程序首先计算所需空间；若显存不足，则按过期时间（Expire Time）升序（时间相同则按 ID 升序）的优先级，强制驱逐其他已过期的 Mipmaps 直到空间足够。加载成功后，会更新对应层级的过期时间并按需输出显存变化。
整个逻辑严密遵循了“先按过期时间清理、空间不足再强制驱逐、最后更新状态”的流程，确保了显存利用的高效性与数据的一致性。
import java.io.*;
import java.util.*;
publicclassMain{
staticclassTexture{
int id;
int c;
long[] sizes;
boolean[] loaded;
long[] expire;
publicTexture(int id, long s, int c){
this.id = id;
this.c = c;
this.sizes = newlong[c];
this.loaded = newboolean[c];
this.expire = newlong[c];
sizes[0] = s;
for (int i = 1; i < c; i++) {
sizes[i] = sizes[i - 1] / 4;
}
}
publicintgetMinLoadedMip(){
for (int i = 0; i < c; i++) {
if (loaded[i]) return i;
}
return -1;
}
}
staticclassEvictGroupimplementsComparable<EvictGroup> {
int texId;
long expire;
List<Integer> mips = new ArrayList<>();
boolean isClean;
publicEvictGroup(int texId, long expire, boolean isClean){
this.texId = texId;
this.expire = expire;
this.isClean = isClean;
}
@Override
publicintcompareTo(EvictGroup o){
if (isClean) {
return Integer.compare(this.texId, o.texId);
} else {
if (this.expire != o.expire) return Long.compare(this.expire, o.expire);
return Integer.compare(this.texId, o.texId);
}
}
}
publicstaticvoidmain(String[] args)throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line = br.readLine();
if (line == null) return;
StringTokenizer st = new StringTokenizer(line);
long M = Long.parseLong(st.nextToken());
long D = Long.parseLong(st.nextToken());
int N = Integer.parseInt(st.nextToken());
Map<Integer, Texture> textures = new HashMap<>();
long usedVram = 0;
for (int k = 0; k < N; k++) {
line = br.readLine();
if (line == null) break;
st = new StringTokenizer(line);
long t = Long.parseLong(st.nextToken());
int typeOrId = Integer.parseInt(st.nextToken());
if (typeOrId == -1) {
Map<Integer, EvictGroup> groupMap = new HashMap<>();
for (Texture tex : textures.values()) {
for (int m = 0; m < tex.c; m++) {
if (tex.loaded[m] && tex.expire[m] < t) {
if (!groupMap.containsKey(tex.id)) {
groupMap.put(tex.id, new EvictGroup(tex.id, 0, true));
}
groupMap.get(tex.id).mips.add(m);
}
}
}
List<EvictGroup> groups = new ArrayList<>(groupMap.values());
Collections.sort(groups);
for (EvictGroup g : groups) {
Texture tex = textures.get(g.texId);
for (int m : g.mips) {
tex.loaded[m] = false;
usedVram -= tex.sizes[m];
}
System.out.println(t + " " + g.texId + " " + tex.getMinLoadedMip() + " " + usedVram);
}
} else {
int id = typeOrId;
int X = Integer.parseInt(st.nextToken());
long s = Long.parseLong(st.nextToken());
int c = Integer.parseInt(st.nextToken());
if (!textures.containsKey(id)) {
textures.put(id, new Texture(id, s, c));
}
Texture tex = textures.get(id);
long reqSpace = 0;
for (int m = X; m < c; m++) {
if (!tex.loaded[m]) {
reqSpace += tex.sizes[m];
}
}
if (M - usedVram < reqSpace) {
Map<String, EvictGroup> groupMap = new HashMap<>();
for (Texture t_i : textures.values()) {
for (int m = 0; m < t_i.c; m++) {
if (t_i.loaded[m] && t_i.expire[m] < t) {
if (t_i.id == id && m >= X) continue;
String key = t_i.id + "_" + t_i.expire[m];
if (!groupMap.containsKey(key)) {
groupMap.put(key, new EvictGroup(t_i.id, t_i.expire[m], false));
}
groupMap.get(key).mips.add(m);
}
}
}
List<EvictGroup> groups = new ArrayList<>(groupMap.values());
Collections.sort(groups);
for (EvictGroup g : groups) {
Texture g_tex = textures.get(g.texId);
for (int m : g.mips) {
g_tex.loaded[m] = false;
usedVram -= g_tex.sizes[m];
}
System.out.println(t + " " + g.texId + " " + g_tex.getMinLoadedMip() + " " + usedVram);
if (M - usedVram >= reqSpace) break;
}
}
if (M - usedVram >= reqSpace) {
boolean changed = false;
for (int m = X; m < c; m++) {
if (!tex.loaded[m]) {
tex.loaded[m] = true;
usedVram += tex.sizes[m];
changed = true;
}
tex.expire[m] = t + D;
}
if (changed) {
System.out.println(t + " " + id + " " + tex.getMinLoadedMip() + " " + usedVram);
}
}
}
}
}
}
10个月宝宝每天需要喝多少奶粉？
