package com.zy.asrs.utils;
|
|
import com.zy.asrs.entity.BasDevpPosition;
|
import com.zy.asrs.entity.WrkMast;
|
import com.zy.core.enums.RouteCollectCountType;
|
|
import java.util.*;
|
|
public class SortTheExecutionOfTheCarUtil {
|
//排序
|
public static int[][] ReorderSteId(int[][] steList,int steNoStart){
|
int[][] ints = new int[steList.length][2];
|
int Difference = 0;
|
for (int[] steNo : steList){
|
if (steNo[0] == steNoStart){
|
Difference = steNo[1] - 1;
|
break;
|
}
|
}
|
for (int[] steNo : steList){
|
int i = steNo[1];
|
if (i > Difference){
|
steNo[1] = i - Difference;
|
} else {
|
steNo[1] = steList.length + i-Difference;
|
}
|
ints[steNo[0]-1] = steNo;
|
}
|
return ints;
|
}
|
|
// //获取最近并在当前位置前边的位置1000000===>10000==>0==>1000000
|
// public static Integer LatelyAndLessThan(List<BasDevpPosition> devpPosition, long nowPosition,long perimeter){
|
// Integer result = 0;
|
// long Difference = perimeter;
|
// for (BasDevpPosition positions : devpPosition){
|
// Long position = positions.getPlcPosition();
|
// if (position<=nowPosition){
|
// if ((nowPosition-position) < Difference){
|
// Difference = nowPosition-position;
|
// result = positions.getDevNo();
|
// }
|
// } else {
|
// if ((nowPosition-(position - perimeter)) < Difference){
|
// Difference = nowPosition-(position - perimeter);
|
// result = positions.getDevNo();
|
// }
|
// }
|
// }
|
// return result;
|
// }
|
//获取最近并在当前位置前边的位置 0==>1000===>1000000==>0
|
public static Integer LatelyAndLessThan(List<BasDevpPosition> devpPosition, long nowPosition,long perimeter){
|
Integer result = 0;
|
long Difference = perimeter;
|
for (BasDevpPosition positions : devpPosition){
|
Long position = positions.getPlcPosition();
|
if (position >= nowPosition){
|
if ((position-nowPosition) < Difference){
|
Difference = position-nowPosition;
|
result = positions.getDevNo();
|
}
|
} else {
|
if (perimeter - (nowPosition - position) < Difference){
|
Difference = perimeter - (nowPosition - position);
|
result = positions.getDevNo();
|
}
|
}
|
}
|
return result;
|
}
|
|
// //获取最近并在当前位置后边的位置 1000000===>10000==>0==>1000000
|
// public static Integer LatelyAndLessThanWcs(List<BasDevpPosition> devpPosition, long nowPosition,long perimeter){
|
// Integer result = 0;
|
// Integer integer = LatelyAndLessThan(devpPosition, nowPosition,perimeter);
|
// for (BasDevpPosition basDevpPosition:devpPosition){
|
// if (basDevpPosition.getDevNo().equals(integer)){
|
// if (basDevpPosition.getDevNo() == 101){
|
// result = 133;
|
// }
|
// break;
|
// }
|
// result = basDevpPosition.getDevNo();
|
// }
|
// return result;
|
// }
|
//获取最近并在当前位置后边的位置 0==>1000===>1000000==>0
|
public static Integer LatelyAndLessThanWcs(List<BasDevpPosition> devpPosition, long nowPosition,long perimeter){
|
Integer result = -1;
|
Integer integer = LatelyAndLessThan(devpPosition, nowPosition,perimeter);
|
for (BasDevpPosition basDevpPosition:devpPosition){
|
if (basDevpPosition.getDevNo().equals(integer)){
|
if (basDevpPosition.getDevNo() == 134){
|
result = 101;
|
}
|
break;
|
}
|
result = basDevpPosition.getDevNo();
|
}
|
return result == -1? 101 : result;
|
}
|
// //获取最近并在当前位置前边的位置
|
// public static Long LatelyAndLessThan(long[] devpPosition,long nowPosition){
|
// long result = 0L;
|
// long Difference = 1737000L;
|
// for (long position : devpPosition){
|
// if (position<=nowPosition){
|
// if ((nowPosition-position) < Difference){
|
// Difference = nowPosition-position;
|
// result = position;
|
// }
|
// } else {
|
// if ((nowPosition-(position - 1737000L)) < Difference){
|
// Difference = nowPosition-(position - 1737000L);
|
// result = position;
|
// }
|
// }
|
// }
|
// return result;
|
// }
|
|
// //获取最近并在当前位置后边的位置 1000000===>10000==>0==>1000000
|
// public static Integer LatelyAndGreaterThan(List<List<Long>> sitePosition, long nowPosition ,long perimeter){
|
// int result = 0;
|
// long Difference = perimeter;
|
// for (List<Long> rgvPositions: sitePosition){
|
// Long position = rgvPositions.get(1);
|
// if (position>nowPosition){
|
// if ((position - nowPosition) < Difference){
|
// Difference = position - nowPosition;
|
// result = rgvPositions.get(0).intValue();
|
// }
|
// } else {
|
// if ((perimeter - (nowPosition - position)) < Difference){
|
// Difference = perimeter - (nowPosition - position);
|
// result = rgvPositions.get(0).intValue();
|
// }
|
// }
|
// }
|
// return result;
|
// }
|
|
//获取最近并在当前位置后边的位置 0==>1000===>1000000==>0
|
public static Integer LatelyAndGreaterThan(List<List<Long>> sitePosition, long nowPosition ,long perimeter){
|
int result = -1;
|
long Difference = perimeter;
|
for (List<Long> rgvPositions: sitePosition){
|
Long position = rgvPositions.get(1);
|
if (position <= nowPosition){
|
if ((nowPosition - position) < Difference){
|
Difference = nowPosition - position;
|
result = rgvPositions.get(0).intValue();
|
}
|
} else {
|
if ((perimeter - (nowPosition - position)) < Difference){
|
Difference = perimeter - (nowPosition - position);
|
result = rgvPositions.get(0).intValue();
|
}
|
}
|
}
|
return result;
|
}
|
|
//id初始化
|
public static List<BasDevpPosition> devpNoInit(List<BasDevpPosition> devpPosition){
|
long i = 0;
|
for (BasDevpPosition basDevpPosition : devpPosition){
|
i++;
|
basDevpPosition.setId(i);
|
}
|
return devpPosition;
|
}
|
|
|
//站点排序
|
public static BasDevpPosition[] devpNoSort(List<BasDevpPosition> devpPosition1,Integer devpNo){
|
List<BasDevpPosition> devpPosition = devpNoInit(devpPosition1);
|
BasDevpPosition[] basDevpPositions = new BasDevpPosition[devpPosition.size()];
|
long Difference = 0L;
|
for (BasDevpPosition basDevpPosition : devpPosition){
|
if (basDevpPosition.getDevNo().equals(devpNo)){
|
Difference = basDevpPosition.getId() - 1L;
|
break;
|
}
|
}
|
for (BasDevpPosition basDevpPosition : devpPosition){
|
long i = basDevpPosition.getId();
|
if (i > Difference){
|
basDevpPosition.setId(i - Difference);
|
} else {
|
basDevpPosition.setId(devpPosition.size() + i - Difference);
|
}
|
basDevpPositions[basDevpPosition.getId().intValue()-1] = basDevpPosition;
|
}
|
return basDevpPositions;
|
}
|
|
//逆序排列
|
public static BasDevpPosition[] devpNoSortUN(BasDevpPosition[] devpPosition){
|
BasDevpPosition[] basDevpPositions = new BasDevpPosition[devpPosition.length];
|
for (BasDevpPosition basDevpPosition : devpPosition){
|
basDevpPositions[devpPosition.length - basDevpPosition.getId().intValue()] = basDevpPosition;
|
}
|
return basDevpPositions;
|
}
|
|
//逆序排列
|
public static boolean devpNoSortbj(BasDevpPosition[] devpPosition,Integer souDevpNo,Integer endDevpNo){
|
int sou = 0;
|
int end = 0;
|
for (int i = 0;i<devpPosition.length;i++){
|
if (devpPosition[i].getDevNo().equals(souDevpNo)){
|
sou = i;
|
}
|
if (devpPosition[i].getDevNo().equals(endDevpNo)){
|
end = i;
|
}
|
}
|
|
return sou>end;
|
}
|
|
//提取站点集合
|
public static List<Integer> WrkMastExtractSites(List<WrkMast> wrkMastList){
|
List<Integer> siteList = new ArrayList<>();
|
for (WrkMast wrkMast : wrkMastList){
|
if (!siteList.contains(wrkMast.getSourceStaNo())){
|
siteList.add(wrkMast.getSourceStaNo());
|
}
|
}
|
return siteList;
|
}
|
//提取站点集合
|
public static List<Integer> BasDevpPositionExtractSites(List<BasDevpPosition> basDevpPositions){
|
List<Integer> siteList = new ArrayList<>();
|
for (BasDevpPosition basDevpPosition : basDevpPositions){
|
if (!siteList.contains(basDevpPosition.getDevNo())){
|
siteList.add(basDevpPosition.getDevNo());
|
}
|
}
|
return siteList;
|
}
|
|
//提取站点集合X2
|
public static List<Integer> ExtractSitesComplex(List<Integer> siteList){
|
siteList.addAll(siteList);
|
return siteList;
|
}
|
|
//集合转数组
|
public static int[] SetToArrayConversion(List<Integer> siteList){
|
int[] nums = new int[siteList.size()];
|
for (int i = 0;i<siteList.size();i++){
|
nums[i] = siteList.get(i);
|
}
|
return nums;
|
}
|
|
//获取任务密集区
|
public static List<Integer> ObtainDenseAreasSite(List<Integer> siteList,List<Integer> devpList){
|
|
List<Integer> siteLists = ExtractSitesComplex(devpList);
|
int[] nums = SetToArrayConversion(siteLists);
|
|
List<Integer> champion = new ArrayList<>();
|
for (int rangeArea = 1; rangeArea<=devpList.size();rangeArea++){
|
List<List<Integer>> subsets = getConsecutiveSubsets(nums, rangeArea);
|
if (subsets != null){
|
int temporaryMaxCount = 0;
|
List<Integer> championTemporary = new ArrayList<>();
|
int championCount = 0;
|
|
for (List<Integer> one : subsets){
|
int intersectionSize = getIntersectionSize(siteList, one);
|
if (intersectionSize == temporaryMaxCount){
|
championCount++;
|
championTemporary = one;
|
} else if (intersectionSize > temporaryMaxCount){
|
championCount = 1 ;
|
temporaryMaxCount = intersectionSize;
|
championTemporary = one;
|
}
|
}
|
if (championCount == 1){
|
champion = championTemporary;
|
break;
|
}
|
continue;
|
}
|
break;
|
}
|
|
return champion;
|
}
|
|
public static Integer ObtainDenseAreasFirstPlace(List<Integer> siteList,List<Integer> devpList){
|
List<Integer> integers = ObtainDenseAreasSite(siteList, devpList);
|
if (integers==null){
|
return null;
|
}
|
return integers.get(0);
|
}
|
|
// public static void main(String[] args) {
|
//// int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
// List<Integer> siteList = new ArrayList<Integer>() {{
|
// add(1);add(2);add(3);add(4);add(5);add(6);add(7);add(8);add(9);add(10);
|
// }};
|
// List<Integer> siteLists = ExtractSitesComplex(siteList);
|
// int[] nums = SetToArrayConversion(siteLists);
|
// int subsetSize = 5; // 可以通过用户输入或者其他方式控制
|
// List<List<Integer>> subsets = getConsecutiveSubsets(nums, subsetSize);
|
// if (subsets != null){
|
// for (List<Integer> subset : subsets) {
|
// System.out.println(subset);
|
// }
|
// } else {
|
// System.out.println("子集大小必须大于0且小于等于数组长度");
|
// }
|
// }
|
|
public static List<List<Integer>> getConsecutiveSubsets(int[] nums, int size) {
|
List<List<Integer>> result = new ArrayList<>();
|
|
// 确保子集的大小合法
|
if (size > nums.length || size <= 0) {
|
// throw new IllegalArgumentException("子集大小必须大于0且小于等于数组长度");
|
return null;
|
}
|
|
// 通过滑动窗口法生成相邻的子集
|
for (int i = 0; i <= nums.length - size; i++) {
|
List<Integer> subset = new ArrayList<>();
|
for (int j = 0; j < size; j++) {
|
subset.add(nums[i + j]);
|
}
|
if (!result.contains(subset)){
|
result.add(subset);
|
}
|
}
|
|
return result;
|
}
|
|
public static int getIntersectionSize(List<Integer> listA, List<Integer> listB) {
|
// 使用集合来存储交集元素，避免重复
|
Set<Integer> intersection = new HashSet<>(listA);
|
|
// 保留集合A和集合B中的共同元素
|
intersection.retainAll(listB);
|
|
// 返回交集的大小
|
return intersection.size();
|
}
|
|
// public static void main(String[] args) {
|
// int[][] ints = new int[][]{{1,1},{3,3},{2,2},{4,4},{5,5},{6,6},{7,7},{8,8},{9,9},{10,10}};
|
//
|
// int[][] reorderSteId = ReorderSteId(ints, 2);
|
// for (int[] ste : reorderSteId){
|
// System.out.println(Arrays.toString(ste));
|
// }
|
//
|
// long[] longs = new long[]{1L,1000L,200000L,1100000L,1600000L};
|
// long l = LatelyAndLessThan(longs, 1100000L);
|
// System.out.println("l:"+l);
|
// }
|
|
|
// public static void main(String[] args) {
|
// int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
// List<List<Integer>> subsets = getSubsets(nums);
|
//
|
// for (List<Integer> subset : subsets) {
|
// System.out.println(subset);
|
// }
|
// }
|
//
|
// public static List<List<Integer>> getSubsets(int[] nums) {
|
// List<List<Integer>> result = new ArrayList<>();
|
// generateSubsets(0, nums, new ArrayList<>(), result);
|
// return result;
|
// }
|
//
|
// private static void generateSubsets(int index, int[] nums, List<Integer> current, List<List<Integer>> result) {
|
// if (index == nums.length) {
|
// result.add(new ArrayList<>(current));
|
// return;
|
// }
|
//
|
// // 不包含当前元素的子集
|
// generateSubsets(index + 1, nums, current, result);
|
//
|
// // 包含当前元素的子集
|
// current.add(nums[index]);
|
// generateSubsets(index + 1, nums, current, result);
|
//
|
// // 回溯
|
// current.remove(current.size() - 1);
|
// }
|
|
/* 好东西，做记录
|
public static void main(String[] args) {
|
int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
int subsetSize = 3; // 可以通过用户输入或者其他方式控制
|
List<List<Integer>> subsets = getConsecutiveSubsets(nums, subsetSize);
|
|
for (List<Integer> subset : subsets) {
|
System.out.println(subset);
|
}
|
}
|
|
public static List<List<Integer>> getConsecutiveSubsets(int[] nums, int size) {
|
List<List<Integer>> result = new ArrayList<>();
|
|
// 确保子集的大小合法
|
if (size > nums.length || size <= 0) {
|
throw new IllegalArgumentException("子集大小必须大于0且小于等于数组长度");
|
}
|
|
// 通过滑动窗口法生成相邻的子集
|
for (int i = 0; i <= nums.length - size; i++) {
|
List<Integer> subset = new ArrayList<>();
|
for (int j = 0; j < size; j++) {
|
subset.add(nums[i + j]);
|
}
|
result.add(subset);
|
}
|
|
return result;
|
}
|
* */
|
|
|
// public static void main(String[] args) {
|
// // 示例列表A和列表B
|
// List<Integer> listA = new ArrayList<>();
|
// List<Integer> listB = new ArrayList<>();
|
//
|
// // 初始化列表A
|
// listA.add(1);
|
// listA.add(2);
|
// listA.add(3);
|
// listA.add(4);
|
// listA.add(5);
|
//
|
// // 初始化列表B
|
// listB.add(3);
|
// listB.add(4);
|
// listB.add(5);
|
// listB.add(6);
|
// listB.add(7);
|
//
|
// // 计算交集数量
|
// int intersectionSize = getIntersectionSize(listA, listB);
|
// System.out.println("交集的数量是: " + intersectionSize);
|
// }
|
|
|
//获取最近并在当前位置前边的位置 0==>1000===>1000000==>0
|
public static Double LatelyAndLessThan(long devPosition,long rgvPosition,long perimeter){
|
long Difference = perimeter;
|
if (devPosition >= rgvPosition){
|
// if ((devPosition-rgvPosition) < Difference){
|
Difference = devPosition-rgvPosition;
|
// }
|
} else {
|
// if (perimeter - (rgvPosition - devPosition) < Difference){
|
Difference = perimeter - (rgvPosition - devPosition);
|
// }
|
}
|
return Double.valueOf(Difference);
|
}
|
|
public static int calculateShortestDistanceDistance(List<Integer> data, int a, int b) {
|
Result result = calculateShortestDistance(data, a, b);
|
return result.distance;
|
}
|
|
public static List<Integer> calculateShortestDistancePassedData(List<Integer> data, int a, int b) {
|
Result result = calculateShortestDistance(data, a, b);
|
return result.passedData;
|
}
|
|
// public static String calculateShortestDistanceDirection(List<Integer> data, int a, int b) {
|
// Result result = calculateShortestDistance(data, a, b);
|
// return result.direction;
|
// }
|
|
public static boolean calculateShortestDistanceDirection(List<Integer> data, int a, int b) {
|
Result result = calculateShortestDistance(data, a, b);
|
return result.direction.equals("向前走（顺时针）");
|
}
|
|
|
public static void main(String[] args) {
|
List<Integer> data = new ArrayList<>();
|
// 用 List<Integer> 初始化数据
|
for (int i = 1; i <= 9; i++) {
|
data.add(i);
|
}
|
|
int a = 3; // 起点
|
int b = 3; // 终点
|
|
Result result = calculateShortestDistance(data, a, b);
|
System.out.println("最近的距离是: " + result.distance);
|
System.out.println("经过的数据: " + result.passedData);
|
System.out.println("方向: " + result.direction);
|
}
|
|
public static Result calculateShortestDistance(List<Integer> data, int a, int b) {
|
int length = data.size();
|
int indexA = data.indexOf(a);
|
int indexB = data.indexOf(b);
|
|
if (indexA == -1 || indexB == -1) {
|
throw new IllegalArgumentException("列表中未找到指定的元素");
|
}
|
|
// 顺时针方向的距离及经过的数据
|
List<Integer> clockwiseData = new ArrayList<>();
|
int clockwiseDistance = (indexB - indexA + length) % length;
|
for (int i = 0; i <= clockwiseDistance; i++) {
|
clockwiseData.add(data.get((indexA + i) % length));
|
}
|
|
// 逆时针方向的距离及经过的数据
|
List<Integer> counterClockwiseData = new ArrayList<>();
|
int counterClockwiseDistance = (indexA - indexB + length) % length;
|
for (int i = 0; i <= counterClockwiseDistance; i++) {
|
counterClockwiseData.add(data.get((indexA - i + length) % length));
|
}
|
|
// 比较距离并返回结果
|
if (clockwiseDistance <= counterClockwiseDistance) {
|
return new Result(clockwiseDistance, clockwiseData, "向前走（顺时针）");
|
} else {
|
return new Result(counterClockwiseDistance, counterClockwiseData, "向后走（逆时针）");
|
}
|
}
|
|
// 用于返回结果的类
|
static class Result {
|
public int distance;
|
public List<Integer> passedData;
|
public String direction;
|
|
public Result(int distance, List<Integer> passedData, String direction) {
|
this.distance = distance;
|
this.passedData = passedData;
|
this.direction = direction;
|
}
|
}
|
|
}
|
