2022년 2월 17일 목요일 - 오늘은 조금 일이 많아따


오늘 올려볼 문제는 39번 Combination Sum 이라는 문제이다.


사진을 클릭하면 해당 문제로 이동합니다.

leetcode 문제 사진

오늘도 LeetCode 사이트 오늘의 문제를 가지고 왔다.

안풀릴 줄 알았는데 풀려서 놀람.. 이게 왜 풀리지?


입력


사진에서도 볼 수 있듯이 int 배열 하나와 int 값 하나가 입력으로 들어온다.



풀이 및 코드


주어진 int 배열의 원소들의 합이 target이 되는 값들의 집합을 리턴하는 문제다.

이 때 각 집합은 순서가 상관없이 원소의 개수들이 같으면 같은 집합이라고 생각한다.

위를 규칙을 통해 중복없이 모든 원소들의 집합을 구하는 문제다.


오늘은 처음부터 정답을 생각해냈지만 풀릴 줄 몰랐다.

Time Limit Exceed 가 날 줄 알았지만 풀려서 좀 놀랐다.


백트래킹을 사용해서 원소들을 고르고, index도 파라매터로 같이 넘겨서 중복이 없게끔 해서 문제를 풀었다.


이제 코드를 봐보자!


풀이코드

class Solution {
    int find;
    int[] arr;
    Stack<Integer> s = new Stack<Integer>();
    List<List<Integer>> result = new ArrayList<List<Integer>>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        arr = candidates;
        find = target;

        solve(0, 0);

        return result;
    }

    public void solve(int sum, int index)
    {
        if(sum == find)
        {
            result.add(new ArrayList(s));
            return;
        }

        if(sum > find)
            return;

        for(int i = index; i < arr.length; i++)
        {
            s.push(arr[i]);
            solve(sum + arr[i], i);
            s.pop();
        }
    }
}



제출 화면

leetcode 문제 맞았습니다


오늘은 이게 왜 풀리지 의문을 가졌던 문제다.

아마 제약조건이 더 깐깐했다면 틀렸을 것 같은데 어쨌든 풀려서 기분은 좋았다.


내일도 문제를 풀어서 블로그에 글을 쓸 수 있으면 좋겠다.

2022년 2월 16일 수요일 - 아니 날씨 버그 걸린듯 핫픽스 필요함


오늘 올려볼 문제는 24번 Swap Nodes in Pairs 이라는 문제이다.


사진을 클릭하면 해당 문제로 이동합니다.

leetcode 문제 사진

오늘도 LeetCode 사이트 오늘의 문제를 가지고 왔다.

오늘은 살짝 귀찮은 문제였다..


입력


사진에서도 볼 수 있듯이 Linked List 하나가 입력으로 주어진다.



풀이 및 코드


주어진 Linked List에서 인접해 있는 2개의 노드의 위치를 바꾸는 문제이다.


오늘은 처음부터 정답을 생각해냈지만 시행착오를 겪었다.

사실 링크드리스트를 다루는 것이기에 연결만 잘해주면 되는 문제이다.

하지만 바꾼 후 연결을 제대로 하지 못했어서 시행착오를 겪었지만 금방 틀린 부분을 찾아서 문제를 풀었다.


이제 코드를 봐보자!


풀이코드

class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null)
            return head;

        ListNode result;

        ListNode first = head, second = head.next;
        first.next = second.next;
        second.next = first;

        result = second;

        head = first;

        while(head != null)
        {
            try
            {
                first = head.next;
                second = head.next.next;
                first.next = second.next;
                second.next = first;

                head.next = second;

                head = first;
            }
            catch(Exception e)
            {
                break;
            }
        }

        return result;
    }
}



제출 화면

leetcode 문제 맞았습니다


오늘은 살짝 귀찮았던 문제였다.

그래도 이런 문제도 풀어야 익숙해지기 때문에 금방 풀었던 것 같다.


내일도 문제를 풀어서 블로그에 글을 쓸 수 있으면 좋겠다.

2022년 2월 15일 화요일 - 아니 오늘 왤케 추운데


오늘 올려볼 문제는 136번 Single Number 이라는 문제이다.


사진을 클릭하면 해당 문제로 이동합니다.

leetcode 문제 사진

오늘도 LeetCode 사이트 오늘의 문제를 가지고 왔다.

오늘은 1분 컷


입력


사진에서도 볼 수 있듯이 int 배열 하나가 입력으로 주어진다.



풀이 및 코드


주어진 배열에서 단 한 개만 존재하는 원소를 찾는 문제이다.


오늘은 처음부터 정답을 생각해냈다.

xor 연산을 사용한 방법이다.

1개의 원소를 제외하고 다른 모든 원소는 정확히 2개씩 존재하므로 1개만 있는 원소만 남는 방법이다.

위와 같은 풀이가 가능한게 이해가 힘들다면 xor 연산 방법을 찾아보자.


이제 코드를 봐보자!


풀이코드

class Solution {
    public int singleNumber(int[] nums) {
        int result = 0;
        for(int num : nums) result ^= num;

        return result;
    }
}



제출 화면

leetcode 문제 맞았습니다


오늘은 전에 봤던 풀이를 기반으로 풀었던 문제이다.

아마 이 풀이를 몰랐다면 우리의 영원한 구세주 "HashMap"을 사용해서 문제를 풀지 않았을까 생각된다.


내일도 문제를 풀어서 블로그에 글을 쓸 수 있으면 좋겠다.

2022년 2월 14일 월요일 - 언제 주말이 오는거죠?


오늘 올려볼 문제는 104번 Maximum Depth of Binary Tree 이라는 문제이다.


사진을 클릭하면 해당 문제로 이동합니다.

leetcode 문제 사진

오늘도 LeetCode 사이트 오늘의 문제를 가지고 왔다.

팀원 분이 굉장히 짧은 코드로 풀어서 오오 했다


입력


사진에서도 볼 수 있듯이 Tree를 이루고 있는 rootNode 하나가 입력으로 주어진다.



풀이 및 코드


주어진 트리의 최대 깊이를 찾는 문제이다.


오늘은 처음부터 정답을 생각해냈다.

BFS를 사용해서 트리의 최대 깊이를 찾았다.

하지만 주어진 함수를 사용하는 방법도 알게되어서 이도 같이 적겠다.


이제 코드를 봐보자!


풀이코드

class Solution {
    int result = 0;
    public int maxDepth(TreeNode root) {
        Queue<TreeNode> q = new LinkedList<TreeNode>();
        q.add(root);

        solve(q, -1);

        return result;
    }

    public void solve(Queue<TreeNode> q, int level)
    {
        if(q.isEmpty())
        {
            result = level;
            return;
        }

        Queue<TreeNode> next = new LinkedList<TreeNode>();

        while(!q.isEmpty())
        {
            TreeNode temp = q.poll();

            if(temp == null)
                continue;

            next.add(temp.left);
            next.add(temp.right);
        }

        solve(next, level + 1);
    }
}

짧은 코드

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null)
            return 0;
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}



제출 화면

leetcode 문제 맞았습니다


오늘은 생각보다 더 간단하게 풀 수 있는 문제를 조금 복잡하게 푼 것에 대해서 아쉬웠다.

그래도 쉽게 풀 수 있어서 다행이다.


내일도 문제를 풀어서 블로그에 글을 쓸 수 있으면 좋겠다.

2022년 2월 13일 일요일 - 오늘은 데이트~


오늘 올려볼 문제는 78번 Subsets 이라는 문제이다.


사진을 클릭하면 해당 문제로 이동합니다.

leetcode 문제 사진

오늘도 LeetCode 사이트 오늘의 문제를 가지고 왔다.

아니 List 작동 방식 이상해...


입력


사진에서도 볼 수 있듯이 int 배열 하나가 주어진다.



풀이 및 코드


int 배열의 subsets들을 모두 구하는 문제이다.


오늘은 처음부터 정답을 생각해냈다.

전형적인 백트래킹 문제여서 별다른 설명은 하지 않겠다.


이제 코드를 봐보자!


풀이코드

class Solution {
    List<List<Integer>> result = new ArrayList<List<Integer>>();
    Stack<Integer> arr = new Stack<Integer>();
    public List<List<Integer>> subsets(int[] nums) {
        solve(nums, 0);

        return result;
    }

    public void solve(int[] nums, int index)
    {
        if(index == nums.length)
        {
            result.add(new ArrayList(arr));
            return;
        }

        solve(nums, index + 1);

        arr.push(nums[index]);

        solve(nums, index + 1);

        arr.pop();
    }
}



제출 화면

leetcode 문제 맞았습니다


오늘은 java의 List가 이상하게 동작하는 바람에 조금 시간이 걸렸던 문제였다.

그래도 쉽게 문제를 풀어서 다행이었다.


내일도 문제를 풀어서 블로그에 글을 쓸 수 있으면 좋겠다.

2022년 2월 12일 토요일 - 주말은 최고야!


오늘 올려볼 문제는 127번 Word Ladder 이라는 문제이다.


사진을 클릭하면 해당 문제로 이동합니다.

leetcode 문제 사진

오늘도 LeetCode 사이트 오늘의 문제를 가지고 왔다.

와 오늘 진짜 못푸는줄 알았다...


입력


사진에서도 볼 수 있듯이 String 2개와 String 리스트 하나가 주어진다.



풀이 및 코드


문제를 설명하기가 조금 어렵긴 한데 beginWord를 endWord로 wordList를 사용해서 변환할 수 있는지, 있다면 가장 짧은 변환 횟수는 몇인지 구하는 문제이다.

이 때 변환하는 규칙은 String을 구성하는 문자들 중 하나만 다른 String으로만 변환이 가능하다.


오늘은 정말 어려웠다.

일단 String으로 주어지기에 HashMap을 써야한다는 것을 알았다.

HashMap에 문자가 1개만 차이나는 String ArrayList를 저장하고 또한 Visit을 저장하는 HashMap도 만든다.

이를 모두 저장하고 재귀를 사용하여 순회하는 방식으로 문제를 풀었다.

하지만 DFS로 푸는 바람에 Time Limit Exceeded가 났다.

그래서 다른 풀이를 생각해봤다.


BFS가 최소 길이를 찾는다는 것을 생각해냈고 이를 사용해서 문제를 풀었다.


이제 코드를 봐보자!


풀이코드

class Solution {
    // key와 문자 1개만 차이나는 String들을 담고있는 HashMap
    HashMap<String, ArrayList<String>> map = new HashMap<String, ArrayList<String>>();
    // visit 했는지 판단
    HashMap<String, Boolean> visit = new HashMap<String, Boolean>();

    // endWord 파라매터로 넘기기 싫어서 글로벌
    String end;

    // wordList의 길이가 최대 5000이므로 10000으로 설정
    int result = 10000;

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        // HashMap에 value로 들어있는 ArrayList를 받기 위한 변수
        ArrayList temp;

        end = endWord;

        // beginWord는 wordList에 없을 수 있기 때문에 beginWord에 대해서 초기화
        map.put(beginWord, new ArrayList<String>());
        visit.put(beginWord, false);

        // endWord가 wordList에 포함되어 있는지 판단하는 변수
        boolean hasEnd = false;

        // wordList에 들어있는 String에 대한 초기화 과정
        // 또한 begin에 대한 것도 처리해줌
        for(int i = 0; i < wordList.size(); i++)
        {
            map.put(wordList.get(i), new ArrayList<String>());
            visit.put(wordList.get(i), false);

            if(check(beginWord, wordList.get(i)))
            {
                // HashMap에서 get해서 바로 Add 하면 put이 안돼서 temp로 받아서 add 하는 과정
                temp = map.get(beginWord);
                temp.add(wordList.get(i));
                map.put(beginWord, temp);
            }

            if(wordList.get(i).equals(endWord))
                hasEnd = true;
        }

        // endWord가 wordList에 없다면
        if(!hasEnd)
            return 0;

        // String끼리 문자 차이가 1개만 나는 String 들을 HashMap에 저장하는 과정
        for(int i = 0; i < wordList.size(); i++)
        {
            // beginWord가 wordList에 들어있을 경우 2번 저장되게 되므로 그거 막아주는 역할
            if(wordList.get(i).equals(beginWord))
                continue;

            for(int j = i + 1; j < wordList.size(); j++)
            {
                if(check(wordList.get(i), wordList.get(j)))
                {
                    temp = map.get(wordList.get(i));
                    temp.add(wordList.get(j));
                    map.put(wordList.get(i), temp);

                    temp = map.get(wordList.get(j));
                    temp.add(wordList.get(i));
                    map.put(wordList.get(j), temp);
                }
            }
        }

        // BFS를 위한 큐
        Queue<String> q = new LinkedList<String>();
        q.add(beginWord);

        solve(q, 1);

        return result == 10000 ? 0 : result;
    }

    // 이 메소드는 평범한 BFS와 로직이 같다.
    public void solve(Queue<String> q, int level)
    {
        Queue<String> next = new LinkedList<String>();
        ArrayList<String> arr;

        while(!q.isEmpty())
        {
            arr = map.get(q.poll());

            for(int i = 0; i < arr.size(); i++)
            {
                if(!visit.get(arr.get(i)))
                {
                    visit.put(arr.get(i), true);
                    next.add(arr.get(i));
                }

                if(arr.get(i).equals(end))
                {
                    result = level + 1;
                    return;
                }
            }
        }

        if(!next.isEmpty())
            solve(next, level + 1);
    }

    // 문자 1개만 차이나는지 판단하는 메소드
    public boolean check(String s1, String s2)
    {
        if(s1.length() != s2.length())
            return false;

        int diff = 0;

        for(int i = 0; i < s1.length(); i++)
        {
            if(s1.charAt(i) != s2.charAt(i))
                diff++;
        }

        return diff == 1;
    }
}



제출 화면

leetcode 문제 맞았습니다


오늘은 진짜 못푸는줄 알았다.

푸는데 1시간 30분 걸렸으니 말 다 했다...

그래도 풀어서 블로그에 글 쓸 수 있어서 다행이다!


내일도 문제를 풀어서 블로그에 글을 쓸 수 있으면 좋겠다.

2022년 2월 11일 금요일 - 오늘은 FLEX


오늘 올려볼 문제는 567번 Permutation in String 이라는 문제이다.


사진을 클릭하면 해당 문제로 이동합니다.

leetcode 문제 사진

오늘도 LeetCode 사이트 오늘의 문제를 가지고 왔다.

아니 왜 permutation이라고 써서 헷갈리게 하냐고!!@!!@@!!


입력


사진에서도 볼 수 있듯이 String 2개가 주어진다.



풀이 및 코드


s1의 순열 중 하나가 s2에 포함되어 있는지를 판단하는 알고리즘이다.


오늘은 문제에서 permutation이라고 써서 헷갈린 것 때문에 해맨것을 제외한다면 처음부터 정답을 생각해냈다.

기본적으로 전에 풀었던 438번 문제 Find All Anagrams in a String 문제와 거의 같은 알고리즘을 쓴다.

그렇기에 설명은 여기에서 대신하겠다.

그래서 다른 풀이를 생각해봤다.


일단 누적합마다 해쉬맵에 저장한다.

이 때 해쉬맵에 현재 누적합 - k 가 존재한다면 결과값에 해당 해쉬맵에 들어있는 값을 더한다.

이런식으로 시간복잡도 O(N)에 풀 수 있는 방법을 생각해냈다.

이제 코드를 봐보자!


풀이코드

class Solution {
    int[] arr = new int[30];
    public boolean checkInclusion(String s1, String s2) {
        if(s2.length() < s1.length())
            return false;

        for(int i = 0; i < s1.length(); i++)
        {
            arr[s1.charAt(i) - 'a']++;
            arr[s2.charAt(i) - 'a']--;
        }

        for(int i = s1.length(); i < s2.length(); i++)
        {
            if(check())
                return true;

            arr[s2.charAt(i) - 'a']--;
            arr[s2.charAt(i - s1.length()) - 'a']++;
        }

        if(check())
            return true;

        return false;
    }

    public boolean check()
    {
        for(int i = 0; i < arr.length; i++)
        {
            if(arr[i] != 0)
                return false;
        }

        return true;
    }
}



제출 화면

leetcode 문제 맞았습니다


오늘은 문제에 permutation이라는 말에 꽂혀서 빨리 못 풀었던 문제였다.

그래도 뜻을 이해하고 풀어서 다행이다.


내일도 문제를 풀어서 블로그에 글을 쓸 수 있으면 좋겠다.

2022년 2월 10일 목요일 - 으아아아악 첫월급!!!!


오늘 올려볼 문제는 560번 Subarray Sum Equals K 이라는 문제이다.


사진을 클릭하면 해당 문제로 이동합니다.

leetcode 문제 사진

오늘도 LeetCode 사이트 오늘의 문제를 가지고 왔다.

오늘은 조금 까다로워서 시행착오 한 3번정도 거쳤다..


입력


사진에서도 볼 수 있듯이 int 배열 1개와 int 1개가 주어진다.



풀이 및 코드


배열의 subarray의 합이 k와 같은 subarray가 몇개 있는지 구하는 문제이다.


처음에는 k에 대해서 생각하지 못하고 누적합의 차가 0인 경우만 생각했었다.

하지만 역시나 이는 제대로된 풀이가 아니었다.

그래서 다른 풀이를 생각해봤다.


일단 누적합마다 해쉬맵에 저장한다.

이 때 해쉬맵에 현재 누적합 - k 가 존재한다면 결과값에 해당 해쉬맵에 들어있는 값을 더한다.

이런식으로 시간복잡도 O(N)에 풀 수 있는 방법을 생각해냈다.

이제 코드를 봐보자!


풀이코드

class Solution {
    public int subarraySum(int[] nums, int k) {
        int sum = 0;
        int result = 0;
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();

        map.put(0, 1);

        for(int i = 0; i < nums.length; i++)
        {
            sum += nums[i];

            if(!map.containsKey(sum))
                map.put(sum, 0);

            if(map.containsKey(sum - k))
            {
                result += map.get(sum - k);
            }

            map.put(sum, map.get(sum) + 1);
        }

        return result;
    }

}



제출 화면

leetcode 문제 맞았습니다


오늘은 조금 까다로웠던 문제였다.

그래도 조금의 시행착오만으로 문제를 풀 수 있어서 다행인 것 같다.


내일도 문제를 풀어서 블로그에 글을 쓸 수 있으면 좋겠다.

+ Recent posts