LeetCode刷题 --- 两个关联数组的排序技巧

刷题的过程中，经常会遇到一些题目中给了关联数组，即 int[] values1 ，int[] values2，解题过程中需要根据某个数组的值进行排序，但是要同时保证另外一个关联数组也按照同样规则排序。

原来的做法：

构造二元数组，然后排序，后续取值的时候，从二元数组中取值。

如下：根据values的进行从大到小排序

    public static void main(String[] args) {
        int[] values = new int[] {5, 6, 3, 2, 1};
        int[] labels = new int[] {1, 1, 2, 2, 3};

        int[][] sss = new int[values.length][2];
        for (int i = 0; i < sss.length; i++) {
            sss[i][0] = values[i];
            sss[i][1] = labels[i];
        }
        // Arrays.sort(sss, new Comparator<int[]>() {
        //     @Override
        //     public int compare(int[] o1, int[] o2) {
        //         return o2[0] - o1[0];
        //     }
        // });

        Arrays.sort(sss, (a, b) -> b[0] - a[0]);

        for (int i = 0; i < sss.length; i++) {
            System.out.print(sss[i][0]);
        }
    }

小技巧：

构建一个一维数组，存储数组的坐标，然后根据排序规则新数组，取值根据坐标取就OK了

如下：根据values的进行从大到小排序

    public static void main(String[] args) {
        int[] values = new int[] {5, 6, 3, 2, 1};
        int[] labels = new int[] {1, 1, 2, 2, 3};

        Integer[] id = new Integer[values.length];
        for (int i = 0; i < id.length; i++) {
            id[i] = i;
        }
        Arrays.sort(id, (a, b) -> values[b] - values[a]);

        for (int i = 0; i < id.length; i++) {
            System.out.print(values[id[i]]);
        }
    }

1090. 受标签影响的最大值

解题思路：

给定的两个数组按照value值进行关联排序，后面按照题意解题即可。

排序+哈希

class Solution {
    public int largestValsFromLabels(int[] values, int[] labels, int numWanted, int useLimit) {
        Integer[] id = new Integer[values.length];
        for (int i = 0; i < id.length; i++) {
            id[i] = i;
        }
        Arrays.sort(id, (a, b) -> values[b] - values[a]);

        int selectCount = 0;
        int sum = 0;
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < id.length; i++) {
            int value = values[id[i]];
            int label = labels[id[i]];
            if (selectCount >= numWanted) {
                break;
            }
            if (!map.containsKey(label)) {
                map.put(label, 1);
                sum += value;
                selectCount++;
            } else if (map.get(label) < useLimit) {
                map.put(label, map.get(label) + 1);
                sum += value;
                selectCount++;
            } else {
                continue;
            }
        }
        return sum;
    }
}