奥卡姆剃刀定律在Java代码中的体现——记一次LeetCode刷题心得

最近在看西瓜书和黑客军团，了解到了一个名词，叫做奥卡姆剃刀定律

奥卡姆剃刀定律（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);
    }
}

这或许给我们一种启发，在编码过程中，往往简单的方法会更加的行之有效，而简单的方法需要我们将基础知识灵活运用，所以在刚开始学习的过程中打好基础是非常有必要的。