1주차 1차 2 - LeetCode-Study-Team/solutions GitHub Wiki

class Solution {
    private final static int[] caseStore = new int[46];
    public int climbStairs(int n) {
        if(n==0 || n==1 || n==2){
            caseStore[n] = n;
            return caseStore[n];
        }
        if(caseStore[n] > 2) {
            return caseStore[n];
        }
        caseStore[n] = climbStairs(n-1) + climbStairs(n-2);
        return caseStore[n];
    }
}

public Node cloneGraph(Node root) {  //root : 복제 대상 노드
    if (root == null) return null;

    // use a queue to help BFS
    Queue<Node> queue = new LinkedList<Node>();
    queue.add(root);

    // use a map to save cloned nodes
    Map<Node, Node> map = new HashMap<Node, Node>();

    // clone the root
    map.put(root, new Node(root.val));

    while (!queue.isEmpty()) {
        Node node = queue.poll();  //poll() : 첫번째 값을 반환, 비어있다면 null 반환

        // handle the neighbors
        for (Node neighbor : node.neighbors) {
            if (!map.containsKey(neighbor)) {
                // clone the neighbor
                map.put(neighbor, new Node(neighbor.val));
                // add it to the next level
                queue.add(neighbor);
            }

            // copy the neighbor
            map.get(node).neighbors.add(map.get(neighbor));
        }
    }

    return map.get(root);
}

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {

        int len = intervals.length;
        int newLen = newInterval.length;
        if(len == 0 && newLen == 0) { return new int[][]{}; }
        if(len == 0 && newLen != 0) { return new int[][]{newInterval}; }
        if(len != 0 && newLen == 0) { return intervals; }

        List<int[]> store = new ArrayList<>();

        int start = newInterval[0];
        int end = newInterval[1];

        int index = 0;
        while (index < len && start > intervals[index][1]) {
            store.add(new int[]{intervals[index][0], intervals[index][1]});
            index++;
        }        

        int left = newInterval[0];
        int right = newInterval[1];
        while (index < len && end >= intervals[index][0]) {
            left = Math.min(left, intervals[index][0]);
            right = Math.max(right, intervals[index][1]);            
            index++;
        }        
        store.add(new int[]{left, right});

        while (index < len) {
            store.add(new int[]{intervals[index][0], intervals[index][1]});
            index++;
        }

        int[][] new_intervals = new int[store.size()][2];        
        for(int i=0; i<store.size(); i++){
            new_intervals[i] = store.get(i);
        }

        return new_intervals;
    }
}