计算数组连续值的移动距离

/**
     * 计算数组连续值的移动距离
     * 给定一个乱序的整数数组，数组中值为1~n，请计算出所有数字移动到比其大1的数字位置的距离和。
     * 比如数组：[2,4,1,3,7,9,5,10,6,8]
     * 1->2 距离为1
     * 2->3 距离为2
     * 3->4 距离为1
     * ....
     * 9->10 距离为1
     */
    public static int getNumDistance1(int[] nums) {
        // 思路1：直接双重for循环遍历，判断两者差值为1时候，计算两者索引距离之和
        int distance = 0;
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (Math.abs(nums[j] - nums[i]) == 1) {
                    distance += Math.abs(j - i);
                }
            }
        }
        return distance;
    }

    public static int getNumDistance2(int[] nums) {
        // 思路2：先将数组中的每个元素与其下标一一对应，存入一个hashmap中，其中元素作为key,下标作为value
        // 从1~n-1遍历数组，计算相邻的元素直接的距离，将距离累加
        int distance = 0;
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], i);
        }
        for (int i = 1; i < nums.length; i++) {
            distance += Math.abs(map.get(i + 1) - map.get(i));
        }
        return distance;
    }

计算遥控器按键总次数

字母排列如下

遥控器按键

 /**
     * 计算遥控器按键总次数
     * 遥控器按键有上下左右和确认键，给定一个节目单（比如“9AA”）,
     * 从第一个字母A出发，计算需要按键的次数，不可回走已经走过路线。
     * 每找到一个字母，需要按一次确认键。
     * 输入一个节目单字符串(字符均为合法字符，且均在遥控器字母表中)，请输出总计按键次数。
     */
    public int minKeyDownCnt1(String nameStr) {
        String[][] array = {
                {"A", "B", "C", "D", "E", "F"},
                {"G", "H", "I", "J", "K", "L"},
                {"M", "N", "O", "P", "Q", "R"},
                {"S", "T", "U", "V", "W", "X"},
                {"Y", "Z", "0", "1", "2", "3"},
                {"4", "5", "6", "7", "8", "9"},
        };
        int count = 0;
        int[] index = new int[2];
        for (int i = 0; i < nameStr.length(); i++) {
            String tempStr = String.valueOf(nameStr.charAt(i));
            int tempCount = 0;
            for (int j = 0; j < array.length; j++) {
                for (int k = 0; k < array[0].length; k++) {
                    if (tempStr.equals(array[j][k])) {
                        tempCount = Math.abs(j - index[0]) + Math.abs(k - index[1]);
                        index = new int[]{j, k};
                        tempCount++;
                    }
                }
            }
            count += tempCount;
        }
        return count;
    }

    public int minKeyDownCnt2(String nameStr) {
        Map<Integer, List<String>> map = new HashMap<>();
        List<String> listOne = new ArrayList<>(Arrays.asList("A", "B", "C", "D", "E", "F"));
        List<String> listTwo = new ArrayList<>(Arrays.asList("G", "H", "I", "J", "K", "L"));
        List<String> listThree = new ArrayList<>(Arrays.asList("M", "N", "O", "P", "Q", "R"));
        List<String> listFour = new ArrayList<>(Arrays.asList("S", "T", "U", "V", "W", "X"));
        List<String> listFive = new ArrayList<>(Arrays.asList("Y", "Z", "0", "1", "2", "3"));
        List<String> listSix = new ArrayList<>(Arrays.asList("4", "5", "6", "7", "8", "9"));
        map.put(1, listOne);
        map.put(2, listTwo);
        map.put(3, listThree);
        map.put(4, listFour);
        map.put(5, listFive);
        map.put(6, listSix);
        int result = 0;
        String lastStr = "A";
        int lastIndex = 1;
        for (int i = 0; i < nameStr.length(); i++) {
            String str = String.valueOf(nameStr.charAt(i));
            for (Map.Entry<Integer, List<String>> entry : map.entrySet()) {
                List<String> value = entry.getValue();
                Integer curIndex = entry.getKey();
                if (value.contains(str)) {
                    result += Math.abs(value.indexOf(str) - map.get(lastIndex).indexOf(lastStr))
                            + Math.abs(curIndex - lastIndex) + 1;
                    lastStr = str;
                    lastIndex = curIndex;
                    break;
                }
            }
        }
        return result;
    }