每日一题 LeetCode 1743. 从相邻元素对还原数组 java题解

是真的烦。想要永久的躺平。但只有现在卷死才可能实现。

题目

https://leetcode-cn.com/problems/restore-the-array-from-adjacent-pairs/

代码

class Solution {
    public int[] restoreArray(int[][] adjacentPairs) {
        Map<Integer, List<Integer>> map = new HashMap<Integer, List<Integer>>();//<元素，相邻元素>
        for (int[] adjacentPair : adjacentPairs) {
            map.putIfAbsent(adjacentPair[0], new ArrayList<Integer>());
            map.putIfAbsent(adjacentPair[1], new ArrayList<Integer>());
            map.get(adjacentPair[0]).add(adjacentPair[1]);
            map.get(adjacentPair[1]).add(adjacentPair[0]);
        }

        int n = adjacentPairs.length + 1;//元素数目=对数+1
        int[] ret = new int[n];
        for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
            int e = entry.getKey();
            List<Integer> adj = entry.getValue();
            if (adj.size() == 1) {//找到第一个只有一个相邻元素的，作为第一个元素
                ret[0] = e;
                ret[1] = map.get(ret[0]).get(0);//获取第一个元素的相邻元素，作为第二个元素
                break;
            }
        }

        for (int i = 2; i < n; i++) {
            List<Integer> adj = map.get(ret[i - 1]);//获取前一个元素的相邻元素列表
            ret[i] = ret[i - 2] == adj.get(0) ? adj.get(1) : adj.get(0);//前一个元素和前前元素相邻，取另一个相邻的
        }
        return ret;
    }
}

class Solution {
    public int[] restoreArray(int[][] adjacentPairs) {
        HashMap<Integer,List<Integer>> map=new HashMap<Integer,List<Integer>>();
        int len=adjacentPairs.length;
        //初始化map
        for(int i=0;i<len;i++){
            map.putIfAbsent(adjacentPairs[i][0],new ArrayList<Integer>());
            map.putIfAbsent(adjacentPairs[i][1],new ArrayList<Integer>());
            map.get(adjacentPairs[i][0]).add(adjacentPairs[i][1]);
            map.get(adjacentPairs[i][1]).add(adjacentPairs[i][0]);
        }
        int[] ret=new int[len+1];
        //找到第一个
        for(Map.Entry<Integer,List<Integer>> entry:map.entrySet()){
            List<Integer> list=entry.getValue();
            if(list.size()==1){
                ret[0]=entry.getKey();
                ret[1]=list.get(0);
                break;
            }
        }
        //还原数组
        for(int i=2;i<ret.length;i++){
            List<Integer> list=map.get(ret[i-1]);
            if(list.get(0)==ret[i-2]){
                ret[i]=list.get(1);
            }
            else{
                ret[i]=list.get(0);
            }
        }
        return ret;
    }
}