【JAVA】每类各选一个后求最大最小值差值的最小值（Pro20210802）（优先级队列 / IndexTree）

最新推荐文章于 2025-02-12 15:44:59 发布
最新推荐文章于 2025-02-12 15:44:59 发布
阅读量394 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： IndexTree 算法技巧 算法 文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/March0305/article/details/119348986
本文介绍了如何帮助Lin计算在不同建造方法下，N个便利设施的最大最小值差值的最小值问题。利用优先级队列和索引树的算法思路，解决大规模数据的高效计算，给出具体代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

【JAVA】每类各选一个后求最大最小值差值的最小值（Pro20210802）（优先级队列 / IndexTree

题目：

Lin 打算在自己住的村子里建 N 个不同的便利设施。每个便利设施有 K 种建造方法，设施的便利性因建造方法而异。因此，Lin 尝试从 K 种方法中各选择一种来建造这 N 个便利设施。
当 N 个便利设施中便利性最高和最低的差值越小，便利设施越便于使用。Lin 希望算出最小的差值。

[图]

假设便利设施数量 N 为 3，各设施的建造方法数量 K 为 4（如上 [图] 中所示）。如果便利设施 ① 和 ③ 的建成便利性为 1，设施 ② 的便利性为 5，那么上文所述的便利性差值便为 4。如果便利设施 ① 建成便利性为 15，设施 ② 便利性为 17，设施 ③ 便利性为 18，则差值为 3，这是差值最小的情况。

请帮助 Lin 算出上述的最小差值。

[限制条件]

  1. 便利设施数量 N 和建造方法数量 K 均为介于 2 到 100,000 之间的整数。
  2. N * K 不得超过 1,000,000。
  3. 各设施的便利性值为介于 1 到 1,000,000,000 之间的整数。
  4. 同一便利设施的建造方法（便利性值）不会重复。

[输入]
首先，给定测试用例数量 T，后面接着输入 T 种测试用例。在每个测试用例的第一行，给定便利设施类型数量 N 和建造方式数量 K，以空格分隔。接下来的 N 行，每行以升序给定 K 个便利性数值，以空格分隔。
[输出]
每个测试用例输出一行。首先，输出 “#x”（x 为测试用例编号，从 1 开始），加一个空格，然后输出文中提到的最小差值。

[输入和输出示例]
(输入)
3
3 4
1 10 15 24
5 8 17 20
1 6 12 18
3 5
1 6 12 26 35
3 9 28 33 35
10 25 29 30 31
3 5
1 20 37 46 1000000000
1 10 30 59 999999992
10 20 28 41 1000000000

(输出)
#1 3
#2 3
#3 8

思路：

暴力求解的话，从最左侧开始，需要计算每一种可能性。
但对于 ASW = MAX - MIN 来说，想要ASW 更小，只有两种操作，即：MAX减小，或MIN增大。
从最左侧开始的话，MAX不可能再减小了，就只能MIN增大。
对于每一行来说，已经是升序的了，那就是对于MIN所在的行，取下一个，再在每行所选的元素中取最大值和最小值。

代码（优先级队列）：

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Main {
	static int T, N, K, ASW;
	static int[][] DATA; // 原始数据

	public static void main(String[] args) throws Exception {
		System.setIn(new FileInputStream("D:\\SW\\TestCase\\sample_input_20210802.txt"));
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

		StringTokenizer st = new StringTokenizer(bf.readLine());
		T = Integer.parseInt(st.nextToken());

		for (int testcase = 1; testcase <= T; testcase++) {
			st = new StringTokenizer(bf.readLine());
			N = Integer.parseInt(st.nextToken());
			K = Integer.parseInt(st.nextToken());

			DATA = new int[N][K];
			ASW = Integer.MAX_VALUE;

			// 读取数据
			for (int row = 0; row < N; row++) {
				st = new StringTokenizer(bf.readLine());

				for (int column = 0; column < K; column++)
					DATA[row][column] = Integer.parseInt(st.nextToken());
			}

			doCalc();

			System.out.println("#" + testcase + " " + ASW);
		}
	}

	public static void doCalc() {
		PriorityQueue<Installations> pqMax = new PriorityQueue<Installations>(new Comparator<Installations>() {
			@Override
			public int compare(Installations o1, Installations o2) {
				return o2.cost - o1.cost;
			}
		});

		PriorityQueue<Installations> pqMin = new PriorityQueue<Installations>(new Comparator<Installations>() {
			@Override
			public int compare(Installations o1, Installations o2) {
				return o1.cost - o2.cost;
			}
		});

		// 从最左侧（最小值）开始
		for (int row = 0; row < N; row++) {
			pqMax.add(new Installations(DATA[row][0], row, 0));
			pqMin.add(new Installations(DATA[row][0], row, 0));
		}

		// 不断移动最小值的指针求局部最优解
		while (!pqMin.isEmpty()) {
			Installations max = pqMax.peek(); // 最小值移动指针时，新添加的值，对求最大值没有影响
			Installations min = pqMin.poll(); // 最小值移动指针时，最小值要更新（此处为删除）

			ASW = Math.min(ASW, max.cost - min.cost);

			if (min.column == K - 1)
				break;

			// 移动指针
			pqMax.add(new Installations(DATA[min.row][min.column + 1], min.row, min.column + 1));
			pqMin.add(new Installations(DATA[min.row][min.column + 1], min.row, min.column + 1));
		}
	}
}

class Installations {
	int cost, row, column;

	public Installations(int cost, int row, int column) {
		this.row = row;
		this.column = column;
		this.cost = cost;
	}
}

代码（IndexTree）：

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
	static int T, N, K, ASW, IDX;
	static int[][] DATA; // 原始数据
	static Installations[] MAX_TREE, MIN_TREE;

	public static void main(String[] args) throws Exception {
		System.setIn(new FileInputStream("D:\\SW\\TestCase\\sample_input_20210802.txt"));
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

		StringTokenizer st = new StringTokenizer(bf.readLine());
		T = Integer.parseInt(st.nextToken());

		for (int testcase = 1; testcase <= T; testcase++) {
			st = new StringTokenizer(bf.readLine());
			N = Integer.parseInt(st.nextToken());
			K = Integer.parseInt(st.nextToken());

			IDX = 1;
			while (IDX < N)
				IDX *= 2;

			DATA = new int[N][K];
			ASW = Integer.MAX_VALUE;
			MAX_TREE = new Installations[IDX * 2];
			MIN_TREE = new Installations[IDX * 2];

			// 读取数据
			for (int row = 0; row < N; row++) {
				st = new StringTokenizer(bf.readLine());

				for (int column = 0; column < K; column++)
					DATA[row][column] = Integer.parseInt(st.nextToken());
			}

			// 初始化Tree
			for (int index = 1; index < 2 * IDX; index++) {
				MAX_TREE[index] = new Installations(0, 0, 0);
				MIN_TREE[index] = new Installations(-1000000001, 0, 0);
			}

			// 计算起点为每行选择最左侧的数
			for (int row = 0; row < N; row++) {
				update(MAX_TREE, row + IDX, new Installations(DATA[row][0], row, 0));
				update(MIN_TREE, row + IDX, new Installations(-DATA[row][0], row, 0));
			}

			while (true) {
				ASW = Math.min(ASW, MAX_TREE[1].cost + MIN_TREE[1].cost);

				int row = MIN_TREE[1].row;
				int column = MIN_TREE[1].column + 1;

				if (column == K)
					break;

				// 更新最小值（移动最小值指针）
				update(MAX_TREE, row + IDX, new Installations(DATA[row][column], row, column));
				update(MIN_TREE, row + IDX, new Installations(-DATA[row][column], row, column));
			}

			System.out.println("#" + testcase + " " + ASW);
		}
	}

	private static void update(Installations[] tree, int index, Installations obj) {
		tree[index] = obj;
		index /= 2;

		while (index > 0) {
			obj = tree[index * 2].cost > tree[index * 2 + 1].cost ? tree[index * 2] : tree[index * 2 + 1];
			tree[index] = new Installations(obj.cost, obj.row, obj.column);

			index /= 2;
		}
	}

	static class Installations {
		int cost, row, column;

		public Installations(int cost, int row, int column) {
			this.row = row;
			this.column = column;
			this.cost = cost;
		}
	}
}
Java 求解滑动窗口最大值
南淮北安的博客
05-19 616
文章目录一、题目二、单调队列解析三、代码四、总结 一、题目 给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回滑动窗口中的最大值。 二、单调队列解析 题目让求随着滑动窗口的滑动，返回窗口覆盖范围的最大值 该题不适合优先级队列，因为采用大顶堆存放k个数字，可以知道此时的最大值，但是窗口是滑动的，大顶堆每次只能弹出最大值，无法移除其他值，即无法用大顶堆维护滑动窗口里的值。 所以采用队列维护，随着窗
华为OD机试2025C卷统一考试题库清单（持续收录中）以及考点说明
热门推荐
学Java，找哪吒
07-14 6万+
每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。
Java计算整型数组中的最大值和最小值的差
m0_56245143的博客
02-18 599
【代码】Java计算整型数组中的最大值和最小值的差。
最小差值（java）
lianggege88的博客
04-30 861
问题描述： 样例输入： 代码如下： package leetcode; import java.util.Arrays; import java.util.Scanner; public class SmallestRangeI { public int smallestRangeI(int[] nums, int k) { if (nums.length==1) return 0;//数组长度为1，直接返回0 Arrays.sort(nums);
index Tree
xiaolu567的博客
06-16 256
1）支持区间查询 2）没有线段树那么强，但是非常容易改成一维、二维、三维的结构 3）只支持单点更新 1)假设某一个index二进制形式 01100(12),管理了那些值? 最后一个1拆开的第一个数开始01001(9)~它自己(12) 2)求1到i的累加和,哪些数从Tree数组里面拿出来才能得到1到i所有范围的累加和? 在help数组中先拿原位置累加上把最后一个1抹去的值在Tree数组中的位置+上一步把最后一个1抹掉的这个数在Tree数组中位置的数…一直到没有1可以抹(index变成0),所有东西累加起来 例
树状数组Binary Indexed Trees详解与Java实现
BrilliantEagle的专栏
07-09 4491
WiKi树状数组是由Peter Fenwick在1994年提出的，所以又称为Fenwick Tree。数组的区间求和的复杂度是O(n)，树状数组可以将数组区间求和的复杂度降低到O(lg n)。这对于长数组的高频率区间求和的应用场景来讲，可以提高效率。参考树状数组(Binary Indexed Trees) 搞懂树状数组详解这里从上面的参考中总结我的思路。 树状数组通过树形结构对原始数组进行预处理
POJ2533（Index tree）
上官凝轩
07-18 156
import java.io.*; import java.util.*; /** * index tree * @author XAGDC * */ public class POJ2533_2 { static int tree[]; public static void main(String[] args) throws Exception { BufferedReader br = new BufferedReader(new InputStreamReader(Sys...
【JAVA】求数组连续区间内最大值与最小值的差不大于K的最大区间长度 Pro20210705 (双指针+优先级队列 / 双指针+IndexTree)
March0305的博客
07-14 1357
求数组连续区间内最大值与最小值的差不大于K的最大区间长度 Pro20210705题目方法一：双指针+优先级队列方法二：双指针+IndexTree 题目 给定数组，求在数组的连续区间内最大值与最小值的差不大于K的最大区间长度。 输入： 测试用例数量T 第1个测试用例数组长度N 差值K 第1个测试用例数组 第2个测试用例数组长度N 差值K 第2个测试用例数组 … 方法一：双指针+优先级队列 思路： 既然是连续区间，那么在下标left和下标right区间内，元素都是计算范围内的，所以用双指针指定连续区
【专项刷题】— 优先级队列（堆）
weixin_62678196的博客
09-09 905
思路：利用堆来解决 TopK问题。
2025最新华为OD机试真题目录A+B+C+D+E卷(持续收录中)-Java版
最新发布
**My Coding Family**
02-12 2845
🔔本文收录于「最新最全华为OD机试真题(Java版)」专栏，手把手带你零基础教学华为OD机试。本题集提供最优题解思路，解题步骤，代码解析，复杂度分析及最优题解源码等，支持多语言题解，助你轻松拿捏OD机考，一举上岸！安利大家关注&&收藏&&订阅！题库正在疯狂收录中，up！up！up！！ 🚫提醒：拒绝一切代考/替考，违法必究！专栏所写题库均搜集于互联网，经过精心筛选和整理，结合数位十多年大厂实战经验资深大佬经验所撰，欢迎订阅。    💗订阅福利：一次订阅，可永久免费阅读，提供在线答疑解惑，后续题库更新皆可
【小5聊】java基础之判断最大值和最小值差值是否在数组中
小5聊的博客
03-22 379
判断数组中最大值和最小值差值是否在数组中，存在则输出下标值，不存则输出-1 import java.io.*; import java.util.*; import java.util.Arrays; class test { public static void main (String[] args) throws java.lang.Exception { //定义一个5个元素的整数数组 int arrLength=5; List<In.
力扣——最小绝对差（Java）
weixin_58140823的博客
07-04 931
力扣——最小绝对差（Java）
JAVA获取二维数组中每一列的最小值
qq_38846242的博客
09-24 4253
思路1 行列互换，然后直接获取行的最小值 分列，列数=二维数组中长度最长的一维数组的长度 循环嵌套，进行行列转换 依次获取行中最小值 public static void main(String[] args) throws Exception { int[][] array = { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7 }, { 8, 9, 10 }}; ...
java 数组中差值最大数对_在一个数组中找 差值最大的两个数 差值最小的两个数 推广到 点对...
weixin_31032795的博客
02-25 843
先求差值最大的：1、找出最大值和最小值 然后做差， 每次比较相邻的两个数(比如先0,1 然后2,3)，然后每次比较记录下最大和最小的差值，可以比较1.5N次得到结果，和分为奇数偶数位比较一样的复杂度2、由于抽屉原来，设最大的值和最小的值为maxV和minV，那么最大差值不会超过delta = (maxV-minV)/(N-1)， 用反证法可以证明，编程之美p171，然后根据delta的值分为...
CCF201712-1最小差值Java解法
龙大
03-05 357
问题描述 　　给定n个数，请找出其中相差（差的绝对值）最小的两个数，输出它们的差值的绝对值。 输入格式 　　输入第一行包含一个整数n。 　　第二行包含n个正整数，相邻整数之间使用一个空格分隔。 输出格式 　　输出一个整数，表示答案。 样例输入 5 1 5 4 8 20 样例输出 1 样例说明 　　相差最小的两个数是5和4，它们之间的差值是1。 样例输入 5 9 3 6 1 3 样例输出 0 样例说...
LeetCode 1509. 三次操作后最大值与最小值的最小差
荔枝的FM
08-06 412
给你一个数组nums，每次操作你可以选择nums中的任意一个元素并将它改成任意值。 请你返回三次操作后， nums中最大值与最小值的差的最小值。 示例 1： 输入：nums = [5,3,2,4] 输出：0 解释：将数组 [5,3,2,4] 变成 [2,2,2,2]. 最大值与最小值的差为 2-2 = 0 。 示例 2： 输入：nums = [1,5,0,10,14] 输出：1 解释：将数组 [1,5,0,10,14] 变成 [1,1,0,1,1] 。 最大值与最小值的差为 1-0 ...
算法小记-IndexTree
darkness0604的博客
01-11 524
前言 在对一个数据集进行一些例如区间【L,R】求和的问题的时候，想通过一个比较快的数据结构来完成，可以使用indexTree，它可以达到O（logN）的时间复杂度。 时间复杂度 O（logN） 算法思想 构建一个help数组 作为一个help数组，有如下特点： 1、help数组的有效位置从1位置开始 2、采用“配对”的方式在位置上存放值，因此以图上为例，我们来描述一个这个过程： 1：1位置上只有自己，因此只存放1位置的值 2：之前有一个1位置，所以与2位置配对，组成一对，所以此位置存放1,2位置的值 3:
Java求极差
weixin_62069241的博客
06-25 1072
求极差给定一个数组长度n，以及n个数，求数组中最大值与最小值之差输入用例：输出用例：输入用例：输出用例：输入用例：输出用例：
Index Tree特点及适用范围
March0305的博客
09-16 635
Index Tree特点及适用范围特点：适用范围： 个人总结，仅供参考！ 特点： 空间复杂度：[2N, 4N] 时间复杂度： Update：logN（单点更新） Query：2logN（一次区间查询） Index Tree是完美二叉树； Index Tree一定存在空间浪费（至少Tree[0]未使用）； Index Tree的使用，仅仅是为了提升效率： 只使用Index Tree的叶节点，就可以解决问题，但效率较低； 一次区间查询：O(N) --> O(logN)（效率提升了）； 一次更新：O
Java编程实现数组最大最小值与平均值计算
下面是一个简单的Java程序，演示了如何计算一个整型数组的最大值、最小值和平均值。 ```java public class Main { public static void main(String[] args) { int[] numbers = {1, 5, 3, 7, 4, 6, 2}; // 示例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值