最近在看西瓜书和黑客军团，了解到了一个名词，叫做奥卡姆剃刀定律
奥卡姆剃刀定律（Occam's Razor, Ockham's Razor）又称“奥康的剃刀”，它是由14世纪英格兰的逻辑学家、圣方济各会修士奥卡姆的威廉（William of Occam，约1285年至1349年）提出。这个原理称为“如无必要，勿增实体”，即“简单有效原理”。正如他在《箴言书注》2卷15题说“切勿浪费较多东西去做，用较少的东西，同样可以做好的事情。”
在刷题的过程中，我发现同一个题目，用“高级”的方法执行代码的速度往往比“低级”的方法慢很多，而且还需要了解比“低级”的方法更多的知识和细节。这不免让我突然意识到这可能便是奥卡姆剃刀定律。
从代码中可以看出，从第一个方法到第四个方法用的数据结构和方法越来越简单，而执行效率也越来越高。那些相对高级的数据结构和方法需要大量的基础代码支撑，会用到更多更深的类，导致从起始到终点的路径更长更复杂。
package leetcode.daily.y20.m7.d10;
import java.util.*;
import java.util.stream.Collectors;
/**
* 760. 找出变位映射
* 给定两个列表 Aand B，并且 B 是 A 的变位（即 B 是由 A 中的元素随机排列后组成的新列表）。
* <p>
* 我们希望找出一个从 A 到 B 的索引映射 P 。一个映射 P[i] = j 指的是列表 A 中的第 i 个元素出现于列表 B 中的第 j 个元素上。
* <p>
* 列表 A 和 B 可能出现重复元素。如果有多于一种答案，输出任意一种。
* <p>
* 例如，给定
* <p>
* A = [12, 28, 46, 32, 50]
* B = [50, 12, 32, 46, 28]
* <p>
* <p>
* 需要返回
* <p>
* [1, 4, 3, 2, 0]
* P[0] = 1 ，因为 A 中的第 0 个元素出现于 B[1]，而且 P[1] = 4 因为 A 中第 1 个元素出现于 B[4]，以此类推。
* <p>
* <p>
* <p>
* 注：
* <p>
* A, B 有相同的长度，范围为 [1, 100]。
* A[i], B[i] 都是范围在 [0, 10^5] 的整数。
*/
public class FindAnagramMappings {
public static void main(String[] args) {
// 4 ms 38.1 MB
System.out.println(Arrays.toString(new Solution() {
@Override
public int[] anagramMappings(int[] A, int[] B) {
int[] res = new int[A.length];
List<Integer> listA = Arrays.stream(A).boxed().collect(Collectors.toList());
List<Integer> listB = Arrays.stream(B).boxed().collect(Collectors.toList());
for (int i = 0; i < res.length; i++) {
res[i] = listB.indexOf(listA.get(i));
listB.set(res[i], -1);
}
return res;
}
}.anagramMappings(new int[]{12, 28, 46, 32, 50}, new int[]{50, 12, 32, 46, 28})));
// 2 ms 38.5 MB
System.out.println(Arrays.toString(new Solution() {
@Override
public int[] anagramMappings(int[] A, int[] B) {
int len = A.length;
int[] res = new int[len];
Integer[] integerA = new Integer[len];
Integer[] integerB = new Integer[len];
for (int i = 0; i < len; i++) {
integerA[i] = A[i];
integerB[i] = B[i];
}
List<Integer> listA = new ArrayList<>(Arrays.asList(integerA));
List<Integer> listB = new ArrayList<>(Arrays.asList(integerB));
for (int i = 0; i < len; i++) {
res[i] = listB.indexOf(listA.get(i));
listB.set(res[i], -1);
}
return res;
}
}.anagramMappings(new int[]{12, 28, 46, 32, 50}, new int[]{50, 12, 32, 46, 28})));
// 1 ms 38.2 MB
System.out.println(Arrays.toString(new Solution() {
@Override
public int[] anagramMappings(int[] A, int[] B) {
int len = A.length;
int[] res = new int[len];
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < len; i++) {
map.put(B[i], i);
}
for (int i = 0; i < len; i++) {
res[i] = map.get(A[i]);
}
return res;
}
}.anagramMappings(new int[]{12, 28, 46, 32, 50}, new int[]{50, 12, 32, 46, 28})));
// 1 ms 37.9 MB
System.out.println(Arrays.toString(new Solution() {
@Override
public int[] anagramMappings(int[] A, int[] B) {
int len = A.length;
int[] res = new int[len];
for (int i = 0; i < len; i++) {
for (int j = 0; j < len; j++) {
if (A[i] == B[j]) {
res[i] = j;
B[j] = -1;
break;
}
}
}
return res;
}
}.anagramMappings(new int[]{12, 28, 46, 32, 50}, new int[]{50, 12, 32, 46, 28})));
}
private interface Solution {
int[] anagramMappings(int[] A, int[] B);
}
}
这或许给我们一种启发，在编码过程中，往往简单的方法会更加的行之有效，而简单的方法需要我们将基础知识灵活运用，所以在刚开始学习的过程中打好基础是非常有必要的。
