使用Java实现给绳子或线段描颜色的算法，基于时间轴的考勤计算算法

最新推荐文章于 2024-04-30 07:55:52 发布
最新推荐文章于 2024-04-30 07:55:52 发布
阅读量387 收藏 1
点赞数
分类专栏： java基础 笔记 中控考勤机 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011783999/article/details/120708087
版权

场景 要实现一个绳子染色的功能的算法
如图：

img

一开始是一个红色线段，两端坐标分别为0和100，画上一个蓝色线段后，红色线段被截断，变成红蓝红三个线段，可以重复染色，后来者覆盖，有多种颜色可以染色
线段集合是List ，要求尽可能用Java stream实现画新颜色的draw函数

这里我直接用时间线段进行演示，画图逻辑类似
实现方式如下
声明一个存储时间线段单元的类TeacherAttUnit ，并声明时间的类型枚举AttType


public class TeacherAttUnit {
	//考勤类型
	enum  AttType{

		WEI_CHU_QIN("未出勤","weichuqin",1),
		CHU_QIN("出勤","chuqin",2),
		NIAN_JIA("年假","nianjia",3),
		HUN_JIA("婚假","hunjia",4),
		SHI_JIA("事假","shijia",5);
		public final String name;  //此时段的考勤类型
		public final String attType;  //此时段的考勤类型
		public final int  sort;  //此时段的考勤类型
		AttType(String name,String attType,int sort) {
			this.name = name;
			this.attType = attType;
			this.sort = sort;
		}
		
		
	}
	
	public  Date startTime;  //开始时间
	public  Date endTime;   //结束时间
	public  AttType attType;  //此时段的考勤类型
	public  List<AttType> attTypeList =new ArrayList<>();//所有出现的考勤类型
	public  String leaveType;//  假单类型
	public Date getStartTime() {
		return startTime;
	}
	public void setStartTime(Date startTime) {
		this.startTime = startTime;
	}
	public Date getEndTime() {
		return endTime;
	}
	public void setEndTime(Date endTime) {
		this.endTime = endTime;
	}
	public AttType getAttType() {
		return attType;
	}
	public void setAttType(AttType attType) {
		this.attType = attType;
	}
	public List<AttType> getAttTypeList() {
		return attTypeList;
	}
	public void setAttTypeList(List<AttType> attTypeList) {
		this.attTypeList = attTypeList;
	}
	public String getLeaveType() {
		return leaveType;
	}
	public void setLeaveType(String leaveType) {
		this.leaveType = leaveType;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "\n"+ JSONObject.toJSONString(this);
	}
}

再声明一个实现算法的核心计算类，构造函数声明覆盖的时间轴和时间轴的初始化类型
每增加一个新的类型时间段，只需要调用insert方法插入即可

/**
 * 考勤计算过程
 * @author chenlinhui
 *
 */
public class TeacherAttCalculationPress  {
	//这里防止调用者修改计算过程，声明为私有
	private List<TeacherAttUnit>  attList; //每个时段的集合
	/**
	 * 初始化计算过程
	 * @param startTime   时间轴开始时间
	 * @param endTime     时间轴结束时间
	 * @param attType     时间轴默认考勤状态
	 * @param leaveType   时间轴默认请假状态
	 */
	public TeacherAttCalculationPress(Date startTime,Date endTime,AttType attType, String leaveType){
		attList = new LinkedList<TeacherAttUnit>();
		TeacherAttUnit attTeacherAttUnit = new TeacherAttUnit();
		attTeacherAttUnit.setStartTime(startTime);
		attTeacherAttUnit.setEndTime(endTime);
		attTeacherAttUnit.setAttType(attType);
		attTeacherAttUnit.setLeaveType(leaveType);
		attTeacherAttUnit.attTypeList.add(attType);
		attList.add(attTeacherAttUnit);
	}
	//原有数据  2021年9月01日 到2021年9月29日  出勤
	//插入数据  2021年9月09日 到 2021年9月19日  类型请假
	//结果      2021年9月01日 到2021年9月29日  出勤，  2021年9月29日  到   2021年9月09日  请假，  2021年9月09日 到 2021年9月19日  出勤
	/**
	 * 添加一个假单，第一个添加的假单时间区间是最大需要处理的时间区间
	 * @param attUnitNew  新加的考勤单元或者假单
	 */
	public void insert(TeacherAttUnit attUnitNew) {
		if (attList == null) {
			attList = new LinkedList<TeacherAttUnit>();
		}
		if (attList.size() == 0) {
			attList.add(attUnitNew);
			return;
		}
		//步骤1. 进行线段染色，染色后会出现相邻线段相同颜色情况，下一步需要合并
		attList = attList.stream().flatMap((attNode)->{

			SimpleDateFormat format = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss" );
			List<TeacherAttUnit>  flatList =  new  ArrayList<>();
			//以下处理只保留attNode覆盖的时段，所以要求alllist中第一个节点是覆盖全天的
			/**
			 * att		                          ------------
			 * 情况一    └───────────────────────┘
			 * 互相无交叉
	    	 *   */
			if (attNode.getStartTime().compareTo(attUnitNew.getEndTime()) >= 0
					||attNode.getEndTime().compareTo(attUnitNew.getStartTime()) <= 0) {
				flatList.add(attNode);
			}
			/**
			 * att	     ------------
			 * 情况二    └───────────────────────┘
			 * 新的包含已有的
	    	 *   */
			else if (attUnitNew.getStartTime().compareTo(attNode.getStartTime()) <= 0
					&& attUnitNew.getEndTime().compareTo(attNode.getEndTime()) >= 0) {
				attNode.getAttTypeList().add(attUnitNew.attType);
				if (attNode.getAttType().sort < attUnitNew.getAttType().sort) {
					attNode.setAttType(attUnitNew.attType);
				}
				flatList.add(attNode);
			}
			/**
			 * att    ------------------------------
			 * 情况三               └──────────────┘
			 * 已有的包含新的
	    	 *   */
			else if (attUnitNew.getStartTime().compareTo(attNode.getStartTime()) > 0
					&& attUnitNew.getEndTime().compareTo(attNode.getEndTime()) < 0) {

				if (attNode.getAttType().sort < attUnitNew.getAttType().sort) {
					//新插入优先级高，时间段被分割成三个时间段
					TeacherAttUnit attNew_1 = new TeacherAttUnit();
					attNew_1.setStartTime(attNode.getStartTime());
					attNew_1.setEndTime(attUnitNew.getStartTime());
					attNew_1.setAttType(attNode.getAttType());
					attNew_1.getAttTypeList().addAll(attNode.attTypeList);
					
					TeacherAttUnit attNew_2 = new TeacherAttUnit();
					attNew_2.setStartTime(attUnitNew.getStartTime());
					attNew_2.setEndTime(attUnitNew.getEndTime());
					attNew_2.setAttType(attUnitNew.getAttType());
					attNew_2.getAttTypeList().addAll(attNode.attTypeList);
					attNew_2.getAttTypeList().add(attUnitNew.attType);
					
					TeacherAttUnit attNew_3 = new TeacherAttUnit();
					attNew_3.setStartTime(attUnitNew.getEndTime());
					attNew_3.setEndTime(attNode.getEndTime());
					attNew_3.setAttType(attNode.getAttType());
					attNew_3.getAttTypeList().addAll(attNode.attTypeList);

					flatList.add(attNew_1);
					flatList.add(attNew_2);
					flatList.add(attNew_3);
				}else {
					//保持不变
					attNode.getAttTypeList().add(attUnitNew.attType);
					flatList.add(attNode);
				}
				
			}
			/**
			 * att		         ------------------------------
			 * 情况四    └───────────────────────┘
			 * 交叉一
	    	 *   */
			else if (attUnitNew.startTime.compareTo(attNode.startTime) <= 0
					 && attUnitNew.endTime.compareTo(attNode.startTime) > 0
					 && attUnitNew.endTime.compareTo(attNode.endTime) < 0) {

				if (attNode.getAttType().sort < attUnitNew.getAttType().sort) {
					//新插入优先级高，时间段被分割成两个时间段
					
					TeacherAttUnit attNew_2 = new TeacherAttUnit();
					attNew_2.setStartTime(attNode.getStartTime());
					attNew_2.setEndTime(attUnitNew.getEndTime());
					attNew_2.setAttType(attUnitNew.getAttType());
					attNew_2.getAttTypeList().addAll(attNode.attTypeList);
					attNew_2.getAttTypeList().add(attUnitNew.attType);
					
					TeacherAttUnit attNew_3 = new TeacherAttUnit();
					attNew_3.setStartTime(attUnitNew.getEndTime());
					attNew_3.setEndTime(attNode.getEndTime());
					attNew_3.setAttType(attNode.getAttType());
					attNew_3.getAttTypeList().addAll(attNode.attTypeList);

					flatList.add(attNew_2);
					flatList.add(attNew_3);
				}else {
					//保持不变
					attNode.getAttTypeList().add(attUnitNew.attType);
					flatList.add(attNode);
				}
				
			}
			/**
			 * att    ------------------------------
			 * 情况五                                      └───────────────────────┘
			 * 交叉二
	    	 *   */
			else if (attUnitNew.startTime.compareTo(attNode.startTime) > 0
					&& attUnitNew.startTime.compareTo(attNode.endTime) < 0
					&& attUnitNew.endTime.compareTo(attNode.endTime) >= 0) {

				if (attNode.getAttType().sort < attUnitNew.getAttType().sort) {
					//新插入优先级高，时间段被分割成两个时间段

					TeacherAttUnit attNew_3 = new TeacherAttUnit();
					attNew_3.setStartTime(attNode.getStartTime());
					attNew_3.setEndTime(attUnitNew.getStartTime());
					attNew_3.setAttType(attNode.getAttType());
					attNew_3.getAttTypeList().addAll(attNode.attTypeList);
					
					TeacherAttUnit attNew_2 = new TeacherAttUnit();
					attNew_2.setStartTime(attUnitNew.getStartTime());
					attNew_2.setEndTime(attNode.getEndTime());
					attNew_2.setAttType(attUnitNew.getAttType());
					attNew_2.getAttTypeList().addAll(attNode.attTypeList);
					attNew_2.getAttTypeList().add(attUnitNew.attType);
					

					flatList.add(attNew_2);
					flatList.add(attNew_3);
				}else {
					//保持不变
					attNode.getAttTypeList().add(attUnitNew.attType);
					flatList.add(attNode);
				}
			}
			return flatList.stream();
		})
		
		//步骤2.排序，为 合并相邻的相同颜色的线段 做准备
		.sorted((sortNode1,sortNode2) -> {
				//按时间排序
				return sortNode1.getStartTime().compareTo(sortNode2.getStartTime());
			})
		//步骤3：使用规约方法，比较相邻元素，进行合并操作
		.reduce(new ArrayList<TeacherAttUnit>(),  (result,attNode)->{
				//跟最后一个元素相同就合并，不同就添加
				if (result.size() >0 && result.get(result.size() - 1).attType.sort == attNode.attType.sort) {
					//合并操作，也就是修改最后一个节点结束时间,
					result.get(result.size() - 1).setEndTime(attNode.getEndTime());
				}else {
					result.add(attNode);
				}
				
				return result;
			},(a,b) -> a);
	}
	/**
	 * 统计每个线段，计算并返回考勤结果，这里没有实现，直接用的tostring方法
	 * @return  计算完的考勤结果 如 出勤几小时，旷工几小时
	 */
	public String  calculationResult() {
		
		return attList.toString();
	}
}

声明main函数进行测试


	public static void main(String[] args) throws ParseException {
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date startDate = format.parse("2021-10-11 00:00:00");
		Date endTime = format.parse("2021-10-12 00:00:00");
		TeacherAttCalculationPress press = new TeacherAttCalculationPress(startDate, endTime, AttType.WEI_CHU_QIN, "");

		System.err.println("初始化时间轴》》" + press.attList);
		TeacherAttUnit attUnitNew1 = new TeacherAttUnit();
		attUnitNew1.setStartTime(format.parse("2021-10-11 09:00:00"));
		attUnitNew1.setEndTime(format.parse("2021-10-11 15:00:00"));
		attUnitNew1.setAttType(AttType.CHU_QIN);
		attUnitNew1.setLeaveType("");
		press.insert(attUnitNew1);
		System.err.println("增加出勤》》" + press.attList);
		TeacherAttUnit attUnitNew = new TeacherAttUnit();
		attUnitNew.setStartTime(format.parse("2021-10-11 12:00:00"));
		attUnitNew.setEndTime(format.parse("2021-10-11 18:00:00"));
		attUnitNew.setAttType(AttType.CHU_QIN);
		attUnitNew.setLeaveType("");
		press.insert(attUnitNew);
		System.err.println("增加交叉出勤》》" + press.attList);
		TeacherAttUnit attUnitNew2 = new TeacherAttUnit();
		attUnitNew2.setStartTime(format.parse("2021-10-11 16:00:00"));
		attUnitNew2.setEndTime(format.parse("2021-10-11 17:00:00"));
		attUnitNew2.setAttType(AttType.NIAN_JIA);
		attUnitNew2.setLeaveType("");
		press.insert(attUnitNew2);
		System.err.println("增加年假》》" + press.attList);
	}

测试结果

初始化时间轴》》[
{"attType":"WEI_CHU_QIN","attTypeList":["WEI_CHU_QIN"],"endTime":1633968000000,"leaveType":"","startTime":1633881600000}]
增加出勤》》[
{"attType":"WEI_CHU_QIN","attTypeList":["WEI_CHU_QIN"],"endTime":1633914000000,"startTime":1633881600000}, 
{"attType":"CHU_QIN","attTypeList":["WEI_CHU_QIN","CHU_QIN"],"endTime":1633935600000,"startTime":1633914000000}, 
{"attType":"WEI_CHU_QIN","attTypeList":["WEI_CHU_QIN"],"endTime":1633968000000,"startTime":1633935600000}]
增加交叉出勤》》[
{"attType":"WEI_CHU_QIN","attTypeList":["WEI_CHU_QIN"],"endTime":1633914000000,"startTime":1633881600000}, 
{"attType":"CHU_QIN","attTypeList":["WEI_CHU_QIN","CHU_QIN","CHU_QIN"],"endTime":1633946400000,"startTime":1633914000000}, 
{"attType":"WEI_CHU_QIN","attTypeList":["WEI_CHU_QIN"],"endTime":1633968000000,"startTime":1633946400000}]
增加年假》》[
{"attType":"WEI_CHU_QIN","attTypeList":["WEI_CHU_QIN"],"endTime":1633914000000,"startTime":1633881600000}, 
{"attType":"CHU_QIN","attTypeList":["WEI_CHU_QIN","CHU_QIN","CHU_QIN"],"endTime":1633939200000,"startTime":1633914000000}, 
{"attType":"NIAN_JIA","attTypeList":["WEI_CHU_QIN","CHU_QIN","CHU_QIN","NIAN_JIA"],"endTime":1633942800000,"startTime":1633939200000}, 
{"attType":"CHU_QIN","attTypeList":["WEI_CHU_QIN","CHU_QIN","CHU_QIN"],"endTime":1633946400000,"startTime":1633942800000}, 
{"attType":"WEI_CHU_QIN","attTypeList":["WEI_CHU_QIN"],"endTime":1633968000000,"startTime":1633946400000}]
huihttp
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
面试必刷的算法题 - 剑指offer题集Java实现
clonechen
04-12 2379
本文的题目均来自LeetCode的剑指offer题库 文章目录基础知识数据结构面试题03.数组中重复的数字面试题04.二维数组中的查找面试题05.替换空格面试题06.从尾到头打印链表面试题07.重建二叉树面试题09.用两个栈实现队列算法与数据操作面试题10-I.斐波那契数列面试题11.旋转数组的最小数字面试题12.矩阵中的路径面试题13.机器人的运动范围[面试题14-I. 剪绳子](https:/...
JAVA算法：贪心算法典型题目详解 （JAVA版本 共6题）
梅森上校的博客 业精于勤荒于嬉，形成于思毁于随。
05-28 8020
JAVA算法：贪心算法典型题目详解（JAVA版本） 题目一：最优装载问题 一条小船用来运输古董到河对岸。假设船的最大载重量为MAXWEIGHT，每件古董的重量为，怎么能够装载最多数量的古董到船上呢？ 样例数据： MAXWEIGHT 为 30 给定8个古董，重量分别为：[4, 10, 7, 11, 3, 5, 14, 2] 算法分析 这个问题是一个典型的可以使用贪心算法解决的问题。 ...
算法-剪绳子问题的数学解释以及Java实现
qq_23594799的博客
01-21 1259
剪绳子问题的数学解释以及Java实现 本问题来源于剑指Offer的最后一题，问题描述如下 给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1），每段绳子的长度记为k[0],k[1],…,k[m]。请问k[0]xk[1]x…xk[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。 数学...
贪心算法经典题目java实现-版本
纵横的博客
12-16 1022
1，最优装载问题 问题描述： 有一批集装箱要装上一艘载重量为c的轮船。其中集装箱i的重 量为wi最优装载问题要求确定在装载体积不受限制的情况下，将尽可能多的集装箱装上轮船。 样例数据： MAXWEIGHT 为 30 给定8个集装箱，重量分别为：[4, 10, 7, 11, 3, 5, 14, 2]。 算法分析 这是典型使用贪心算法解决的问题。 通过分析题目可以看到，小船的载重量（MAXWEIGHT...
剪绳子（动态规划、贪心算法）
行走
04-27 3545
一、前言 《剑指Offer》中题14 二、题目 给你一根长度为n的绳子，请把绳子剪成m段(m、n都是整数，n>1并且m>1)，每段绳子的长度记为k[0]，k[1]，...，k[m]。请问k[0] X k[1] X ... X k[m]。可能的最大乘积是多少?例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。 三、思路 第一...
java 版剑指offer算法集锦(1)
最新发布
2401_84049061的博客
04-30 1019
阿里伤透我心，疯狂复习刷题，终于喜提offer 哈哈~好啦，不闲扯了1、JAVA面试核心知识整理（PDF）：包含JVMJAVA集合JAVA多线程并发，JAVA基础，Spring原理微服务，Netty与RPC，网络，日志，ZookeeperKafkaRabbitMQ，Hbase，MongoDB设计模式负载均衡数据库一致性哈希JAVA算法数据结构，加密算法，分布式缓存，Hadoop，Spark，Storm，YARN，机器学习，云计算共30个章节。2、Redis学习笔记及学习思维脑图。
题目练习：Java实现剪绳子代码（迭代实现）
XHT117的博客
04-19 867
目录 题目 分析 代码实现 题目 给你一根长度为 n 的绳子，请把绳子剪成整数长的 m 段（ m 、 n 都是整数， n > 1 并且 m > 1 ， m <= n ），每段绳子的长度记为 k[1],...,k[m] 。请问 k[1] * k[2] *...* k[m] 可能的最大乘积是多少？ 例如，当绳子的长度是 8 时，我们把它剪成长度分别为 2、3、3 的三段，此时得到的最大乘积是 18 。 数据范围：2 ≤ n...
毕业设计 - 题目：基于FP-Growth的新闻挖掘算法系统的设计与实现
HUXINY的博客
11-10 2263
1 项目背景 如今新闻泛滥，令人眼花缭乱，即使同一话题下的新闻也多得数不胜数。人们可以根据自己的职业和爱好关注专业新闻网站的不同热点要闻。因此，通过对人们关注新闻的热点问题进行分析，可以得出民众对某个领域的关切程度和社会需要解决的问题，也有利于了解当前的舆论焦点，有助于政府了解民意，便于国家对舆论进行正确引导，使我们的社会更加安定和谐。本文以财经领域为例，通过爬虫技术抓取网络上的大量财经新闻，通过对新闻内容文本进行预处理及密度聚类分析来发现热点；从发现的热点中，再进行词汇聚类分析，得出热点所涉及的人或事物，
【数据结构和算法设计】算法篇(10) 计算几何(3) 凸包问题
memcpy0的博客
04-01 1394
10.2 求解凸包问题 简单多边形分凸多边形和凹多边形两类，凸多边形是没有任何“凹陷处”的，而凹多边形至少有一个顶点处于“凹陷处”（称为凹点）。凸多边形上任意两个顶点的连线，都包含在多边形中；凹多边形中总能找到一对顶点，它们的连线有一部分在多边形外。沿着凸多边形周边移动，在每个顶点的转向都是相同的；对于凹多边形，一些是向右转，一些是向左转，在凹点的转向是相反的。图10.12所示的多边形是一个凸多边形，而图10.11所示的多边形是一个凹多边形。 点集 AAA 的凸包 Convex Hull 是指一个最小凸多边
切割绳子（C++）分治算法
m0_59850318的博客
07-15 2032
切割绳子（C++）分治算法
scratch绳子算法 scratch四级2021年3月
10-29
scratch绳子算法 实现根据输入的两根绳子的长度，可以把两根长绳截成长度相等的小段后，直接求出一共可以截成多少段，每段最长多少米就好了 案例分析：http://gg.gg/12iom3
Unity绳子/绳索效果例子
02-18
在实现绳索算法时，一种常见的方法是基于细分的线段模型，将绳索分成多个小段，每个段都是一个独立的刚体。这样可以通过调整各段之间的连接来模拟绳索的张力和弯曲。这种方法虽然计算量较大，但能够提供较高的真实感...
剑指Offer(Python多种思路实现):剪绳子
12-22
《剑指Offer(Python多种思路实现):剪绳子》 在面试中，经典的“剪绳子”问题常常被用来考察候选人的算法思维和优化能力。该问题的核心是找到一种方法，将一根给定长度的绳子剪成多段，使得这些段的乘积最大。这里...
动态规划算法笔记总结ZIP分享
12-01
动态规划的实现通常涉及递归和迭代两种方式，Java中常用ArrayList或ArrayList二维数组来存储和更新中间状态。 在学习动态规划的过程中，整理笔记是非常有益的，可以帮助我们更好地理解和记忆各种问题的解法。"动态...
算法分析与设计求绳子长度
05-28
绳子的长度 题目描述 我们有n条长度不一的绳子。现在我们想从绳子中切割出来m条长度相同的绳子，问这k条绳子最长有多长？ 输入格式 多组输入(组数据，读入以EOF结尾) 每组第一行输入两个数字，n(1)为绳子数目，m(1)...
java 百万千万级别excel数据导出问题（解决导出慢和OutOfMemoryError内存溢出的问题）
热门推荐
小兀的博客
03-19 1万+
业务场景 由于很多业务需要导出数据库里的数据，一般我们导出的数据都是要给业务部门看的，他们也会拿到做一些数据统计，所以一般都是给他们导出Excel格式的数据文件，但是当我导出五十万条数据时遇到了两个问题： 导出时一般使用POI工具包，这时很容易导致内存溢出 导出时间很慢，很容易导致超时 下面是直接导出时内存占用. 原因分析 由于Java对象是封装型对象，所以内存中对象大小是实际数据的好几倍，所以50W条的数据，最少要有50W个对象，再加上我们可能使用map对象挥着JsonObject对其进行一些数据操
百度网盘 自定义分享密码 提取码
小兀的博客
01-27 1万+
第一步: 打开对应文件页面 在浏览器中打开百度云盘，看到需要分享的文件 第二步 执行代码 然后按 F12 打开开发者工具，切换至控制台（Console），将以下代码复制粘贴到控制台，然后回车； $("body").append('<script src="https://pannss.bdstatic.com/m-static/function-widget-1/pkg/share-all_c824560.js" ></script>'); require("function-
推荐:大文件查找，快速扫描，图像分析并清理硬盘垃圾文件的绝佳好工具！
小兀的博客
10-27 9608
目录标题WizTree介绍——快速找出磁盘分区中大文件的免费工具演示使用方法大文件还有一些小文件,聚在一起的占用比例大的文件类型 我们的电脑用的时间久了，就会出现磁盘越来越满，但是又很难找不到什么文件占得这么多的磁盘，安装的软件越来越多就很难排查垃圾文件和无用的文件。 于是我找到这个软件，用了一下感觉还不错，有很多功能，多维度分析和发现垃圾文件。可以快速查看文件分类占用大小，目录占用大小，最主要的是扫描速度快，100G硬盘10S扫完。 此软件是免费的，下面是下载链接 官网链接 https://wiztree
Elasticsearch 7.4(Windows 系统) 指定单独JDK版本
小兀的博客
09-12 9563
我用的最新版本Elasticsearch 7.4,下图是官网的介绍，说解压包里已经有最合适的jdk包了，我们只需要修改指向，让它启动时用这个包就行了，网上搜出了好多文章是修改"bin/elasticsearch",可能是因为他们是linux系统，我是用的windows系统，没生效，看了下修改了另一个文件"bin/elasticsearch-env.bat"文件,成功启动。 修改bin/ela...
线段树解题实例：计算染色绳子长度
这道题目通过ZLGG给绳子染色的例子，生动地展示了如何使用线段树来跟踪染色区域，解答了求绳子染色长度的问题。理解并掌握线段树的构造和操作原理，是提高算法竞赛解决问题能力的关键步骤之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

huihttp

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值