一、最小查询成本
文件序列：a1、a2 ... an 非限定有序、重复
加载成本：l1、l2 ... ln
缓存成本：c
文件查询可以直接加载或则从缓存里获取。
代码语言：javascript复制/**
*
* @param f 文件序列
* @param lc 加载成本序列
* @param c 单个文件缓存成本
*/
public static void minCost(int[] f, int[] lc, int c) {
Map<Integer, Integer> flc = new HashMap<>(); //加载成本映射
Map<Integer, Integer> fls = new HashMap<>(); //文件数统计
for (int i = 0; i < f.length; i ) {
flc.put(f[i], lc[i]);
fls.put(f[i], fls.getOrDefault(f[i], 0) 1);
}
int sumCost = 0;
for (Map.Entry<Integer, Integer> entry: flc.entrySet()) {
int slc = entry.getValue() * fls.get(entry.getKey());
int scc = fls.get(entry.getKey()) c;
sumCost = Math.min(slc, scc);
}
System.out.println(sumCost);
} 测试数据：
文件序列：1, 2, 3, 4, 3, 2, 2
加载成本：1, 1, 1, 1, 1, 1, 1
缓存成本：5
测试结果：7
二、和目标数差最小的数列
数列：a1、a2 ... an 非限定有序
目标数：t
结果数列个数：m
代码语言：javascript复制import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
/**
*
* @param arr 数序列
* @param target 目标数
* @param count 结果数个数
*/
public static void shortDiffArr(int[] arr, int target, int count) {
Arrays.sort(arr);
Map<Integer, Integer> indexAndDiff = new HashMap<>();
for (int i = 0; i < arr.length; i ) {
indexAndDiff.put(i, Math.abs(arr[i] - target));
}
String result = indexAndDiff.entrySet().stream()
.sorted(Comparator.comparingInt(Map.Entry::getValue)).limit(count)
.sorted(Comparator.comparingInt(Map.Entry::getKey))
.map(value -> String.valueOf(arr[value.getKey()]))
.collect(Collectors.joining(" "));
System.out.println(result);
}测试数据：
3, 4, 8, 6, 7, 5, 10
6
5
输出结果：
4 5 6 7 8
三、差异值和相似值差值
两个正整数的二进制标示：
差异值：同一个二进制位不同，则结果取 1，相同则取 0
相似值：同一个二进制位都为 1 则取 1，其它取 0
判断差异值和相似值差值是否大于某个值
代码语言：javascript复制/**
*
* @param a
* @param b
*/
public static void difAndFam(int a, int b) {
String ba = Integer.toBinaryString(a);
String bb = Integer.toBinaryString(b);
ba = String.format("%0" (31 - ba.length()) "d", 0) ba;
bb = String.format("%0" (31 - bb.length()) "d", 0) bb;
StringBuilder sbd = new StringBuilder();
StringBuilder sbf = new StringBuilder();
for (int i = 0; i < ba.length(); i ) {
sbd.append(ba.charAt(i) != bb.charAt(i) ? 1 : 0);
sbf.append(ba.charAt(i) - '0' == 1 && bb.charAt(i) - '0' == 1 ? 1 : 0);
}
int result = Integer.parseInt(sbd.toString(), 2) - Integer.parseInt(sbf.toString(), 2);
System.out.println(result);
}测试数据：234551 43434
测试结果：179579
