도전하고 기록하기

[LeetCode] 661. Image Smoother - Java

HYOJUN — Tue, 19 Dec 2023 11:20:28 +0900

https://leetcode.com/problems/image-smoother/description/

Image Smoother - LeetCode

Can you solve this real interview question? Image Smoother - An image smoother is a filter of the size 3 x 3 that can be applied to each cell of an image by rounding down the average of the cell and the eight surrounding cells (i.e., the average of the nin

leetcode.com

문제

An image smoother is a filter of the size 3 x 3 that can be applied to each cell of an image by rounding down the average of the cell and the eight surrounding cells (i.e., the average of the nine cells in the blue smoother). If one or more of the surrounding cells of a cell is not present, we do not consider it in the average (i.e., the average of the four cells in the red smoother).

Given an m x n integer matrix img representing the grayscale of an image, return the image after applying the smoother on each cell of it.

Example 1:

Input: img = [[1,1,1],[1,0,1],[1,1,1]]
Output: [[0,0,0],[0,0,0],[0,0,0]]
Explanation:
For the points (0,0), (0,2), (2,0), (2,2): floor(3/4) = floor(0.75) = 0
For the points (0,1), (1,0), (1,2), (2,1): floor(5/6) = floor(0.83333333) = 0
For the point (1,1): floor(8/9) = floor(0.88888889) = 0

Example 2:

Input: img = [[100,200,100],[200,50,200],[100,200,100]]
Output: [[137,141,137],[141,138,141],[137,141,137]]
Explanation:
For the points (0,0), (0,2), (2,0), (2,2): floor((100+200+200+50)/4) = floor(137.5) = 137
For the points (0,1), (1,0), (1,2), (2,1): floor((200+200+50+200+100+100)/6) = floor(141.666667) = 141
For the point (1,1): floor((50+200+200+200+200+100+100+100+100)/9) = floor(138.888889) = 138

풀이

풀이 과정

image smoother는 이미지의 각 셀에 대해서 자신을 포함한 주변 3x3 크기의 정사각형 영역의 값의 평균을 구하여 현재 셀에 할당하도록 하는 필터이다. 이 때 3x3 크기의 정사각형안에 셀이 존재하지 않는 경우 해당 셀은 평균에 포함되지 않는 것으로 간주한다.

m x n 사이즈의 정수 배열 img가 주어졌을 때 image smoother 필터를 적용한 결과값을 return하는 문제이다.

먼저 결과값을 배열을 선언하고 img와 같은 크기로 초기화한다.

int[][] result = new int[img.length][img[0].length];

각 셀에 대해서 주변 셀을 탐색하기 위해 각 방향의 좌표 이동값을 정의한다.
(현재 좌표 기준 앞에서 부터 차례대로 왼쪽 위, 가운데 위, 오른쪽 위, 왼쪽, 오른쪽, 왼쪽 아래, 가운데 아래, 오른쪽 아래)

// 각 방향의 좌표 이동값 ( top left, top center, top right, left, right, bottom left, bottom center, bottom right )
int directions[][] = {{-1,-1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};

반복문을 통해 img 배열의 각 셀에 대해서 탐색한다.
주변 값의 평균을 구하기 위해 주변 셀 값의 합을 담을 sum과 주변 셀 개수의 합을 담을 cnt 변수를 선언한다.
초기값은 각각 현재 탐색 중인 셀 값과 그 개수인 1로 초기화한다.

// 각 셀에 대해서 탐색
for(int row = 0; row < img.length; row++) {
    for(int col = 0; col < img[0].length; col++) {
        // 주변 셀 값의 합 ( 초기값 = 현재 탐색 중인 셀 값 )
        int sum = img[row][col];
        // 주변 셀 개수 합 ( 초기값 = 현재 탐색 중인 셀 = 1 )
        int cnt = 1;
        
        ...
    }
}

이후 각 방향에 대해 탐색하는데 만약 이동한 좌표에 해당하는 셀이 배열을 벗어나는 경우는 탐색을 제외하고, 그렇지 않은 경우에는 그 값을 sum에 더하고 cnt를 증가 시킨다.
각 방향에 대한 탐색이 끝나면 sum을 cnt로 나누어 소수점을 버린 평균 값을 구하여 result 배열에 담는다.

// 각 방향에 대해 탐색
for(int[] dir : directions) {
    int curRow = row + dir[0];
    int curCol = col + dir[1];

    // 좌표가 배열을 벗어나는 경우 탐색 제외
    if(curRow < 0 || curCol < 0 || curRow >= img.length || curCol >= img[0].length) continue;

    sum += img[curRow][curCol];
    cnt++;
}

result[row][col] = sum / cnt;

모든 셀에 대한 탐색이 끝나면 완성된 result 배열을 return한다.

return result;

최종 코드

class Solution {
    public int[][] imageSmoother(int[][] img) {
        int[][] result = new int[img.length][img[0].length];
        // 각 방향의 좌표 이동값 ( top left, top center, top right, left, right, bottom left, bottom center, bottom right )
        int directions[][] = {{-1,-1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};

        // 각 셀에 대해서 탐색
        for(int row = 0; row < img.length; row++) {
            for(int col = 0; col < img[0].length; col++) {
                // 주변 셀 값의 합 ( 초기값 = 현재 탐색 중인 셀 값 )
                int sum = img[row][col];
                // 주변 셀 개수 합 ( 초기값 = 현재 탐색 중인 셀 = 1 )
                int cnt = 1;
                // 각 방향에 대해 탐색
                for(int[] dir : directions) {
                    int curRow = row + dir[0];
                    int curCol = col + dir[1];

                    // 좌표가 배열을 벗어나는 경우 탐색 제외
                    if(curRow < 0 || curCol < 0 || curRow >= img.length || curCol >= img[0].length) continue;

                    sum += img[curRow][curCol];
                    cnt++;
                }

                result[row][col] = sum / cnt;
            }
        }

        return result;
    }
}

[LeetCode] 2483. Minimum Penalty for a Shop - Java

HYOJUN — Tue, 29 Aug 2023 14:34:04 +0900

https://leetcode.com/problems/minimum-penalty-for-a-shop/description/

Minimum Penalty for a Shop - LeetCode

Can you solve this real interview question? Minimum Penalty for a Shop - You are given the customer visit log of a shop represented by a 0-indexed string customers consisting only of characters 'N' and 'Y': * if the ith character is 'Y', it means that cust

leetcode.com

문제

You are given the customer visit log of a shop represented by a 0-indexed string customers consisting only of characters 'N' and 'Y':

if the ith character is 'Y', it means that customers come at the ith hour
whereas 'N' indicates that no customers come at the ith hour.

If the shop closes at the jth hour (0 <= j <= n), the penalty is calculated as follows:

For every hour when the shop is open and no customers come, the penalty increases by 1.
For every hour when the shop is closed and customers come, the penalty increases by 1.
Return the earliest hour at which the shop must be closed to incur a minimum penalty.

Note that if a shop closes at the jth hour, it means the shop is closed at the hour j.

Example 1:

Input: customers = "YYNY"
Output: 2
Explanation: 
- Closing the shop at the 0th hour incurs in 1+1+0+1 = 3 penalty.
- Closing the shop at the 1st hour incurs in 0+1+0+1 = 2 penalty.
- Closing the shop at the 2nd hour incurs in 0+0+0+1 = 1 penalty.
- Closing the shop at the 3rd hour incurs in 0+0+1+1 = 2 penalty.
- Closing the shop at the 4th hour incurs in 0+0+1+0 = 1 penalty.
Closing the shop at 2nd or 4th hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2.

Example 2:

Input: customers = "NNNNN"
Output: 0
Explanation: It is best to close the shop at the 0th hour as no customers arrive.

Example 3:

Input: customers = "YYYY"
Output: 4
Explanation: It is best to close the shop at the 4th hour as customers arrive at each hour.

Constraints:

1 <= customers.length <= 105
customers consists only of characters 'Y' and 'N'.

풀이

풀이 과정

'N'과 'Y'로만 이루어진 문자열 customers가 주어진다.

문자열 customers의 각 자리는 i번째 시간에 매장에 방문한 사람이 있는지 여부를 나타낸다. 즉 "YYNY"의 경우 0, 1, 3번째 시간에는 매장에 손님이 방문했고, 2번째 시간에는 손님이 방문하지 않았음을 뜻한다.

만약 특정 시간에 가게가 문을 닫는 경우 패널티가 발생 하는데 패널티는 다음과 같이 계산된다.
가게의 문이 열려있는 동안 손님이 방문하지 않는 경우 패널티가 1 증가하고, 가게의 문이 닫혀 있는 동안 손님이 방문하는 경우 역시 패널티가 1 증가한다.

이 때 패널티를 가장 적게 받을 수 있는 폐점 시간 중 가장 이른 시간을 구하는 문제이다.

먼저 각 시간대의 방문 여부를 구하기 위해 문자열을 배열로 분리한다.

// 방문 로그를 분리
char[] visited = customers.toCharArray();

그리고 각 시간대의 패널티, 최소 패널티, 최적 폐점 시간을 저장할 변수를 선언한다.

// 패널티
int penalty = 0;
// 최소 패널티
int minPenalty = 0;
// 최적 폐점 시간
int optimalClosingTime = 0;

각각의 방문 로그를 탐색하는데 i번째 시간마다 폐점을 한다고 가정하고 패널티를 계산한다.
i번째의 방문 여부가 'Y'인 경우 열려있는 동안 손님이 방문한 경우이므로 패널티를 감소하고,
i번째의 방문 여부가 'N'인 경우 열려있는 동안 손님이 방문하지 않은 경우이므로 패널티를 증가한다.
현재 패널티가 최소 패널티보다 작은 경우에는 최소 패널티와 최적 폐점 시간을 갱신해준다.
단 탐색이 0번 인덱스부터 시작하였으므로 실제 'i번째' 에 해당하는 시간은 i + 1로 계산한다.

for(int i = 0; i < visited.length; i++) {
    // i번째의 방문여부가 'Y'인 경우 패널티 감소
    if(visited[i] == 'Y') penalty--;
    // i번째의 방문여부가 'N'인 경우 패널티 증가
    else penalty++;

    // 현재 패널티가 최소 패널티보다 작은 경우
    // 최소 패널티 및 최적 폐점 시간 갱신
    if(penalty < minPenalty) {
        minPenalty = penalty;
        optimalClosingTime = i + 1;
    }
}

최종적으로 구해진 최소 패널티의 시간대를 return 한다.

// 최소 패널티의 시간을 return
return optimalClosingTime;

최종 코드

class Solution {
    public int bestClosingTime(String customers) {
        // 방문 로그를 분리
        char[] visited = customers.toCharArray();
        // 패널티
        int penalty = 0;
        // 최소 패널티
        int minPenalty = 0;
        // 최적 폐점 시간
        int optimalClosingTime = 0;
        
        for(int i = 0; i < visited.length; i++) {
            // i번째의 방문여부가 'Y'인 경우 패널티 감소
            if(visited[i] == 'Y') penalty--;
            // i번째의 방문여부가 'N'인 경우 패널티 증가
            else penalty++;
            
            // 현재 패널티가 최소 패널티보다 작은 경우
            // 최소 패널티 및 최적 폐점 시간 갱신
            if(penalty < minPenalty) {
                minPenalty = penalty;
                optimalClosingTime = i + 1;
            }
        }
        
        // 최소 패널티의 시간을 return
        return optimalClosingTime;
    }
}

[Node.js] Node.js + express를 사용한 서버 구성 시작하기

HYOJUN — Sat, 26 Aug 2023 19:47:14 +0900

Node.js 프로젝트 생성

express를 설치하고 사용하기 앞서 우선 Node.js를 설치하고 Node.js 프로젝트를 생성해야한다.

Node.js 사이트에서 운영체제에 맞는 원하는 버전의 Node.js를 다운로드 받을 수 있다.

Node.js

Node.js® is a JavaScript runtime built on Chrome's V8 JavaScript engine.

nodejs.org

다음으로 프로젝트 대상 폴더에서 터미널에 아래 명령어를 입력하여 package.json 파일을 생성한다.

npm init

명령어를 입력하면 다음과 같은 기본적인 설정 정보들을 입력한다

혹은 -y 옵션을 통해 모든 항목을 기본값으로 설치한다.

npm init -y

정상적으로 package.json 파일이 생성되었다면 서버 구성을 위해 express 설치를 진행한다.

express 설치

express는 Node.js에서 서버 구성을 좀 더 쉽게 할 수 있도록 해주는 프레임워크이다.
아래 명령어를 통해 express를 설치한다.

npm i express

node_modules 폴더 아래에 모듈이 설치되며 package.json 파일의 dependencies 항목에 express 모듈이 추가된다.

express 사용

서버 구동을 위한 코드를 작성할 js파일을 하나 생성하고 express 홈페이지에 나와있는 Hello World 예제를 통해 서버 구동을 테스트한다.

Express "Hello World" 예제

Hello world 예제 기본적으로 이 앱은 여러분이 작성할 수 있는 가장 간단한 Express 앱일 것입니다. 이 앱은 하나의 파일로 된 앱이며 Express 생성기를 통해 얻게 되는 앱과는 같지 않습니다. (이 예제

expressjs.com

// express 불러오기
const express = require('express');
// express 인스턴스 생성
const app = express();
// 포트 정보
const port = 3000;

// 라우트 설정
// HTTP GET 방식으로 '/' 경로를 요청하였을 때
// Hello World!라는 문자열을 결과값으로 보냄
app.get('/', (req, res) => {
  res.send('Hello World!');
});

// 서버 실행
app.listen(port, () => {
  console.log(`App running on port ${port}...`);
});

node 명령어를 통해 해당 파일을 실행하면 서버가 실행되고 localhost:3000에서 실행중인 서버를 확인할 수 있다.

[LeetCode] 215. Kth Largest Element in an Array - Java

HYOJUN — Mon, 14 Aug 2023 16:30:31 +0900

https://leetcode.com/problems/kth-largest-element-in-an-array/description/

Kth Largest Element in an Array - LeetCode

Can you solve this real interview question? Kth Largest Element in an Array - Given an integer array nums and an integer k, return the kth largest element in the array. Note that it is the kth largest element in the sorted order, not the kth distinct eleme

leetcode.com

문제

Given an integer array nums and an integer k, return the kth largest element in the array.

Note that it is the kth largest element in the sorted order, not the kth distinct element.

Can you solve it without sorting?

Example 1:

Input: nums = [3,2,1,5,6,4], k = 2
Output: 5

Example 2:

Input: nums = [3,2,3,1,2,4,5,5,6], k = 4
Output: 4

Constraints:

1 <= k <= nums.length <= 105
-104 <= nums[i] <= 104

풀이

풀이 과정

정수 배열 nums와 정수 k가 주어질 때 nums배열안에서 k번째로 큰 요소를 찾아 return하는 문제이다.
nums에는 중복된 요소가 존재할 수 있으며 정렬을 사용하지 않고 풀이하는 것이 이 문제의 과제이다.

해당 조건으로 문제를 풀이하기 위하여 우선순위큐를 사용한다.

PriorityQueue<Integer> pq = new PriorityQueue<>();

배열의 요소를 처음부터 탐색하며 우선순위큐에 넣어주고 만약 우선순위 큐의 사이즈가 k보다 커지게 된다면 우선순위큐의 요소를 하나 제거한다. 그러면 우선순위큐에는 우선순위가 가장 높은 수(= 제일 작은 수)가 제거되므로 최종적으로 우선순위 큐에는 가장 큰 수부터 k번째 큰 수 까지만 남게된다.

for(int i : nums) {
    // num배열의 각 수를 우선순위큐에 넣음
    pq.offer(i);
    // 우선순위큐의 사이즈가 k보다 커지는 경우 원소를 하나 제거
    // 우선순위큐에는 가장 큰 수부터 k번째 큰 수 까지만 남게됨
    if(pq.size() > k) pq.poll();
}

따라서 모든 탐색이 종료된 후 우선순위큐에 남아있는 요소를 하나 뽑아 return하면 k번째 큰 수를 구할 수 있다.

// 우선순위 큐에 남아있는 k번째 큰 수를 return
return pq.poll();

최종 코드

class Solution {
    public int findKthLargest(int[] nums, int k) {
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        
        for(int i : nums) {
            // num배열의 각 수를 우선순위큐에 넣음
            pq.offer(i);
            // 우선순위큐의 사이즈가 k보다 커지는 경우 원소를 하나 제거
            // 우선순위큐에는 가장 큰 수부터 k번째 큰 수 까지만 남게됨
            if(pq.size() > k) pq.poll();
        }
        
        // 우선순위 큐에 남아있는 k번째 큰 수를 return
        return pq.poll();
    }
}

[JavaScript] 콜백 지옥(Callback Hell) 탈출을 위한 코드작성 - promise, async/await

HYOJUN — Sun, 13 Aug 2023 00:05:17 +0900

❓ 콜백 함수 (callback function)

콜백(callback) 또는 콜백 함수(callback function)는 다른 코드의 인수로서 넘겨주는 실행 가능한 코드를 말한다.
콜백을 넘겨받는 코드는 이 콜백을 필요에 따라 즉시 실행할 수도 있고, 아니면 나중에 실행할 수도 있다.

function sum(a, b, callback) {
  callback(a + b);
}

sum(2, 5, (result) => {
  console.log(result);
});

위 코드는 sum이라는 함수의 인자로 정수 a,b 와 콜백 함수를 넘겨 주며 콜백 함수에서는 두 정수 a와 b를 합한 결과인 result를 콘솔로 출력한다.

❓ 콜백 지옥 (callback hell)

콜백 지옥이란 JavaScript에서 비동기 프로그래밍시 흔히 발생하는 문제로 여러개의 콜백함수가 연속적으로 사용되어 반복되는 들여쓰기로 인해 코드의 가독성이 떨어지는 현상을 의미한다. 코드의 들여쓰기가 마치 피라미드 모양과도 같아 운명의 피라미드(Pyramid of doom)라고 불리기도 하며 이러한 형태의 코드는 유지보수에도 어려움을 주게 된다.

a((resultA) => {
    b(resultA, (resultB) => {
        c(resultB, (resultC) => {
            d(resultC, (resultD) => {
                e(resultD, (resultE) => {
                    f(resultE, (resultF) => {
                        g(resultF, (resultG) => {
                            console.log(resultG);
                        });
                    });
                });
            });
        });
    });
});

아래 코드는 콜백 지옥의 간단한 예시이다. 알파벳 소문자로 작성된 hello.txt 파일을 읽고 해당 문자열을 대문자로 변환한 후 다시 텍스트 파일로 저장하는 코드이다.

const fs = require('fs');

function convert(data, callback) {
    // 알파벳 문자열을 대문자로 변환
    const converted = data.toUpperCase();
    // 1초 후에 콜백 함수 실행
    setTimeout(() => {
        callback(converted);
    }, 1000);
}

// 텍스트 파일 읽기
fs.readFile('hello.txt', 'utf-8', (err, data) => {
    if (err) {
        console.log('Could not read file!');
    } else {
        // 대문자 변환 함수 실행
        convert(data, (result) => {
            // 변환된 문자열을 파일로 저장
            fs.writeFile('output.txt', result, (err) => {
                if (err) {
                    console.log('Could not write file!');
                } else {
                    console.log('File successfully written');
                }
            });
        });
    }
});

콜백 지옥 탈출을 위한 promise

콜백 지옥을 탈출하기 위한 첫 번째 방법으로 promise의 사용이 있다.
promise는 어떤 연산에 대한 결과값을 반환하는데 이 결과값은 최종 결과 값이 아니고, 미래의 어떤 시점에 결과를 제공하겠다는 '약속'(프로미스)를 반환한다.
promise를 지원하지 않는 함수에서 promise를 사용하기 위해서는 먼저 new Promise 생성자를 이용하여 새로운 promise객체를 생성하고 resolve와 reject를 매개변수로 받는 함수를 작성한다.
이 때 resolve는 주어진 값으로 이행되는 promise 객체를 반환하며 then 메서드에서 최종 상태를 결정한다.
reject의 경우 주어진 사유로 인해 거부하는 promise 객체를 반환하며 catch 메서드에서 거부된 결과에 대한 후 처리 작업을 진행한다.
위의 예시를 promise를 이용하여 리팩토링 하기 위해서는 우선 convert함수, 파일을 읽는 함수, 파일을 저장하는 함수를 promise화 해야한다. 각각의 함수를 promise화한 결과는 아래와 같다.

const fs = require('fs');

function convert(data, callback) {
    return new Promise((resolve) => {
        // 알파벳 문자열을 대문자로 변환
        const converted = data.toUpperCase();
        // 1초 후에 콜백 함수 실행
        setTimeout(() => {
            resolve(converted);
        }, 1000);
    });
}

// 텍스트 파일 읽기
function readFilePromise(fileName) {
    return new Promise((resolve, reject) => {
        fs.readFile(fileName, 'utf-8', (err, data) => {
            if (err) reject('Could not read file!');
            else resolve(data);
        });
    });
}

// 텍스트 파일 쓰기
function writeFilePromise(fileName, data) {
    return new Promise((resolve, reject) => {
        fs.writeFile(fileName, data, (err) => {
            if (err) reject('Could not write file!');
            else resolve(data);
        });
    });
}

promise화 된 함수를 바탕으로 코드를 리팩토링하게 되면 다음과 같이 코드가 간결해지고 가독성이 높아지게 된다.
함수가 추가되더라도 들여쓰기의 깊이는 더 이상 깊어지지 않고 마치 열차처럼 연결된 형태로 확장이 가능해진다.

// Promise를 이용한 코드 리팩토링
readFilePromise('hello.txt')
    .then((data) => convert(data))
    .then((converted) => writeFilePromise('output.txt', converted))
    .then(() => console.log('File successfully written'))
    .catch((err) => console.log(err));

콜백 지옥 탈출을 위한 async / await

JavaScript ES8버전부터는 promise를 이용한 비동기 코드를 더 쉽게 작성하고 관리할 수 있도록 도와주는 async와 await의 사용이 가능해졌다.
함수 앞에 async를 선언하여 async함수를 정의할 수 있으며 해당 함수는 결과값으로 항상 promise를 반환한다.
await 키워드는 async 함수 내에서만 사용이 가능하며 await 뒤에오는 promise가 처리될 때까지 현재 함수의 실행을 일시 중지하며 promise의 결과값을 기다린다.
promise가 처리되면 해당 promise의 결과값을 반환받을 수 있다.
promise의 then, catch 대신 try catch 구문으로 함수의 이행과 오류를 구분하여 처리할 수 있고 promise의 then 체인을 사용하지 않아도 보다 직관적인 비동기 코드 작성이 가능하다.

// async&await를 이용한 코드 리팩토링
(async () => {
    try {
        const data = await readFilePromise('hello.txt');
        const converted = await convert(data);
        await writeFilePromise('output.txt', converted);
        console.log('File successfully written');
    } catch (err) {
        console.log(err);
    }
})();

참고

[LeetCode] 518. Coin Change II - Java, JavaScript

HYOJUN — Fri, 11 Aug 2023 15:25:47 +0900

https://leetcode.com/problems/coin-change-ii/description/

Coin Change II - LeetCode

Can you solve this real interview question? Coin Change II - You are given an integer array coins representing coins of different denominations and an integer amount representing a total amount of money. Return the number of combinations that make up that

leetcode.com

문제

You are given an integer array coins representing coins of different denominations and an integer amount representing a total amount of money.

Return the number of combinations that make up that amount. If that amount of money cannot be made up by any combination of the coins, return 0.

You may assume that you have an infinite number of each kind of coin.

The answer is guaranteed to fit into a signed 32-bit integer.

풀이

풀이 과정

DP를 이용하여 0부터 amount원까지 각 금액을 만들 수 있는 경우의 수를 구해나간다.

우선 memoization을 위해 amount + 1길이 만큼의 배열을 선언하고 0번째 인덱스는 1로 초기화 한다.(0원을 만들 수 있는 경우의 수는 항상 1가지 이므로)

int[] dp = new int[amount + 1];
dp[0] = 1;

그리고 각 동전의 종류에 대해서 동전의 금액부터 amount까지 반복 탐색한다.
탐색하는 각 금액을 i라고 했을 때 i원이 될 수 있는 경우의 수는 i원에서 coin을 뺀 금액의 경우의 수와 같다고 할 수 있다.
그렇기 때문에 각 동전 별로 i - coin의 경우의 수를 i의 경우의 수에 합산하여 최종적으로 amount의 경우의 수를 return 한다.

for(int coin : coins) {
    for(int i = coin; i <= amount; i++) {
        // i원이 될 수 있는 경우의 수는
        // i원에서 coin만큼 뺀금액의 경우의 수
        // 따라서 i - coin의 경우의 수를 i의 경우의 수에 추가
        dp[i] += dp[i - coin];
    }
}

return dp[amount];

최종 코드

Java

class Solution {
    public int change(int amount, int[] coins) {
        int[] dp = new int[amount + 1];
        dp[0] = 1;
        
        for(int coin : coins) {
            for(int i = coin; i <= amount; i++) {
                // i원이 될 수 있는 경우의 수는
                // i원에서 coin만큼 뺀금액의 경우의 수
                // 따라서 i - coin의 경우의 수를 i의 경우의 수에 추가
                dp[i] += dp[i - coin];
            }
        }

        return dp[amount];
    }
}

JavaScript

/**
 * @param {number} amount
 * @param {number[]} coins
 * @return {number}
 */
var change = function(amount, coins) {
    const dp = Array(amount + 1).fill(0);
  dp[0] = 1;

  for (const coin of coins) {
    for (let i = coin; i <= amount; i++) {
      dp[i] += dp[i - coin];
    }
  }

  return dp[amount];
};

[LeetCode] 74. Search a 2D Matrix - Java

HYOJUN — Mon, 7 Aug 2023 22:39:33 +0900

https://leetcode.com/problems/search-a-2d-matrix/description/

Search a 2D Matrix - LeetCode

Can you solve this real interview question? Search a 2D Matrix - You are given an m x n integer matrix matrix with the following two properties: * Each row is sorted in non-decreasing order. * The first integer of each row is greater than the last integer

leetcode.com

문제

You are given an m x n integer matrix matrix with the following two properties:

Each row is sorted in non-decreasing order.
The first integer of each row is greater than the last integer of the previous row.

Given an integer target, return true if target is in matrix or false otherwise.

You must write a solution in O(log(m * n)) time complexity.

Example 1:

Input: matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
Output: true

Example 2:

Input: matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
Output: false

Constraints:

m == matrix.length
n == matrix[i].length
1 <= m, n <= 100
-104 <= matrix[i][j], target <= 104

풀이

풀이 과정

m x n크기의 2차원 배열 matrix가 주어지고 다음과 같은 성질을 가진다.
배열의 각 행은 오름차순 정렬되어 있으며, 각 행의 첫 번째 요소는 이전 행의 마지막 요소보다 큰 값을 가진다.

정수 target이 주어질 때 target이 배열 내에 존재하는 경우 true, 그렇지 않은 경우 false를 return 해야한다.
단, O(log(m x n))의 시간 복잡도로 풀이해야 한다.

이진탐색을 2차원 배열에 적용하여 풀이하였다.

먼저 탐색을 시작할 행의 인덱스를 0으로 초기화하고 열의 인덱스는 마지막 값으로 초기화한다.

int row = 0;
int col = matrix[0].length - 1;

행의 인덱스가 배열의 길이를 넘지 않고 열의 인덱스가 0 이상인 경우 반복하여 다음 조건을 탐색한다.

현재 행,열의 값이 target과 일치하는 경우 true를 return한다.
현재 행,열의 값이 target보다 작은 경우, 즉 각 행의 마지막 값이 target보다 커질 때 까지 row를 증가시킨다.
현재 행, 열의 값이 target보다 큰 경우, 즉 현재 행이 target이 속할 수 있는 범위 내 인경우 col을 감소시킨다.

while(row < matrix.length && col >= 0) {
    // target과 일치하는 경우
    if(matrix[row][col] == target) return true;
    // 현재 row의 col 값이 target보다 작은 경우 row 증가
    if(matrix[row][col] < target) row++;
    // 현재 row의 col 값이 target보다 큰 경우 col 감소
    else col--;
}

모든 탐색이 종료되는 경우에는 target과 일치하는 요소가 없으므로 false를 return 한다.

// 반복 탐색이 모두 끝난 경우 target이 포함되지 않으므로 false를 return
return false;

최종 코드

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int row = 0;
        int col = matrix[0].length - 1;
        
        while(row < matrix.length && col >= 0) {
            // target과 일치하는 경우
            if(matrix[row][col] == target) return true;
            // 현재 row의 col 값이 target보다 작은 경우 row 증가
            if(matrix[row][col] < target) row++;
            // 현재 row의 col 값이 target보다 큰 경우 col 감소
            else col--;
        }
        
        // 반복 탐색이 모두 끝난 경우 target이 포함되지 않으므로 false를 return
        return false;
    }
}

[LeetCode] 735. Asteroid Collision - Java

HYOJUN — Sat, 22 Jul 2023 15:44:27 +0900

https://leetcode.com/problems/asteroid-collision/

Asteroid Collision - LeetCode

Can you solve this real interview question? Asteroid Collision - We are given an array asteroids of integers representing asteroids in a row. For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning

leetcode.com

문제

We are given an array asteroids of integers representing asteroids in a row.

For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.

Find out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction will never meet.

Example 1:

Input: asteroids = [5,10,-5]
Output: [5,10]
Explanation: The 10 and -5 collide resulting in 10. The 5 and 10 never collide.

Example 2:

Input: asteroids = [8,-8]
Output: []
Explanation: The 8 and -8 collide exploding each other.

Example 3:

Input: asteroids = [10,2,-5]
Output: [10]
Explanation: The 2 and -5 collide resulting in -5. The 10 and -5 collide resulting in 10.

Constraints:

2 <= asteroids.length <= 104
-1000 <= asteroids[i] <= 1000
asteroids[i] != 0

풀이

풀이 과정

주어진 정수배열 asteroids 에서 양수값과 음수값은 각각 오른쪽으로 움직이는 소행성, 왼쪽으로 움직이는 소행성을 나타내고 각 요소의 절대값은 소행성의 크기를 나타낸다.
각 소행성들은 모두 같은 속도로 움직이고 소행성끼리 부딫히게 되었을 때 크기가 같으면 모두 파괴되고 크기가 다른 경우 크기가 작은 소행성이 파괴된다.
이 때 파괴될 수 있는 모든 소행성이 파괴된 후 남은 소행성을 구하는 문제이다.

각 소행성 간의 비교를 위해 Stack을 사용한다.

Stack<Integer> stack = new Stack<>();

소행성 배열의 각 요소를 차례대로 탐색하며 각 값에 따라 처리한다.

우선 소행성 값이 양수인 경우에는 stack에 값을 추가한다.

반대로 소행성 값이 음수인 경우에는 stack에 값이 남아있지 않거나 현재 소행성의 크기가 stack의 가장 마지막 소행성의 크기 이하가 될 때 까지 stack에서 값을 꺼내어 소행성이 파괴되었음을 처리한다.

첫 번째 처리 과정을 거친 후 stack이 비어있거나 stack의 마지막 값이 음수값인 경우에는 현재 소행성 값을 stack에 추가한다.
만약 stack에 양수값이 남아있고 비교할 두 소행성의 크기가 같은 경우에는 두 소행성을 모두 파괴 처리한다.

// 모든 소행성 탐색
for(int asteroid : asteroids) {
    // 소행성 값이 양수인 경우(= 오른쪽으로 움직이는 소행성)
    if(asteroid > 0) {
        // stack에 값 추가
        stack.push(asteroid);
    }
    // 소행성 값이 음수인 경우(= 왼쪽으로 움직이는 소행성)
    else {
        // stack에 비교할 양수 값이 남아있고
        // stack의 가장 위에 있는 소행성의 크기 이하가 될 때까지 소행성 파괴
        while(!stack.isEmpty() && stack.peek() > 0 && stack.peek() < -asteroid) {
            stack.pop();
        }
        // 더 이상 stack에 비교할 양수 값이 남아있지 않은 경우
        if(stack.isEmpty() || stack.peek() < 0) {
            // stack에 값 추가
            stack.push(asteroid);
        }
        // 비교할 두 소행성의 사이즈가 같은 경우
        else if(stack.peek() == -asteroid) {
            // 두 소행성 모두 파괴
            stack.pop();
        }
    }
}

최종적으로 stack을 배열로 변환하여 반환한다.

// Array 형태로 return
return stack.stream().mapToInt(Integer::intValue).toArray();

최종 코드

class Solution {
    public int[] asteroidCollision(int[] asteroids) {
        Stack<Integer> stack = new Stack<>();
        
        // 모든 소행성 탐색
        for(int asteroid : asteroids) {
            // 소행성 값이 양수인 경우(= 오른쪽으로 움직이는 소행성)
            if(asteroid > 0) {
                // stack에 값 추가
                stack.push(asteroid);
            }
            // 소행성 값이 음수인 경우(= 왼쪽으로 움직이는 소행성)
            else {
                // stack에 비교할 양수 값이 남아있고
                // stack의 가장 위에 있는 소행성의 크기보다 작아질 때까지 소행성 파괴
                while(!stack.isEmpty() && stack.peek() > 0 && stack.peek() < -asteroid) {
                    stack.pop();
                }
                // 더 이상 stack에 비교할 양수 값이 남아있지 않은 경우
                if(stack.isEmpty() || stack.peek() < 0) {
                    // stack에 값 추가
                    stack.push(asteroid);
                }
                // 비교할 두 소행성의 사이즈가 같은 경우
                else if(stack.peek() == -asteroid) {
                    // 두 소행성 모두 파괴
                    stack.pop();
                }
            }
        }
        
        // Array 형태로 return
        return stack.stream().mapToInt(Integer::intValue).toArray();
    }

}

[Flutter] 첫 번째 토이프로젝트 - 앱개발부터 배포까지 회고

HYOJUN — Sat, 1 Jul 2023 17:00:48 +0900

유튜브에 올라온 강의들과 유데미의 강의로 플러터를 공부하면서 기본적이고 핵심적인 내용들을 다 학습하고 나면 간단한 앱을 만들어서 스토어에 게시까지 해보리라 다짐했었다.

그러다가 이번에 어느정도 목표한 부분까지 학습이 끝나게 되어서 토이프로젝트를 진행하게 되었고 스토어에 게시까지 성공하게 되었다.
비록 정말 단순한 앱이지만 플러터 개발의 첫 시작이 되는 이번 토이프로젝트를 기록으로 남기고자 한다.

1. 토이프로젝트의 목표

이번 토이프로젝트로 이루고자 했던 목표는 다음 세 가지였다.

앱 개발부터 배포까지 해보기
- 이번 토이프로젝트의 가장 큰 목표이다. 우선 간단한 프로젝트로 앱 개발의 전체적인 흐름을 경험함으로써 겪을 수 있는 많은 문제들을 미리 핸들링해보고, 추후에 더욱 복잡한 앱을 만들어 배포하게 될 때 더욱 효율적으로 개발을 하고자 한다.
핵심기능만 빠르게 완성해보기
- 개인 프로젝트를 진행하다가 실패하게되는 가장 큰 이유중 하나가 너무 많은 기능을 기획하고 개발하려다가 지치게 되고 포기하게 되는 경우라고 한다. 이번 토이프로젝트의 가장 큰 목표는 앱 개발부터 배포까지 전체적인 사이클을 경험해 보는 것으로 핵심기능만 집중하여 개발하고 나중에 추가, 수정등을 통해 업데이트 해보기로 하였다.
내가 꾸준히 사용 할 앱을 만들어보기
- Todo 앱이나 뽀모도로 앱과 같이 토이프로젝트 하면 흔히 볼 수 있는 프로젝트 주제들이 있지만, 아무래도 내가 실제로 필요로 하고 자주 사용하는 앱을 만들어야 문제점을 개선하고 기능을 추가하는데 더욱 도움이 되지 않을까 생각했다.
  평소에 집 지하주차장에 차를 대고 다음에 차를 타러 갈 때 몇 층에 댔는지 자주 잊어버려 층을 왔다갔다 한 경험이 많다. 집 뿐만 아니라 마트등에 갈 때도 주차한 층을 자주 잊어버리곤 하는데 간단하게 주차한 층을 기록하는 앱 정도면 빠르게 만들어 볼 수 있겠다 싶어 이번 프로젝트의 주제로 결정하였다.

2. 개발 환경

언어 - Dart

프레임워크 - Flutter

IDE - Android studio Flamingo

형상관리 - Git, GitHub

디자인 - Figma

3. 화면 설계

화면은 간단한 싱글페이지 구성으로 주차 위치가 지상인지 지하인지 구분하는 버튼과 층을 선택할 수 있는 버튼, 그리고 저장 버튼으로 구성했다.

사실상 일상에서 주차하는 건물에는 지상이든 지하이든 10층 이상으로는 가는 경우가 거의 없기 때문에 층 버튼은 숫자 키패드와 비슷하게 1층에서 9층까지만 두었고 이 내용을 바탕으로 간단하게 틀을 잡고 개발을 시작했다.

4. 화면 및 기능 개발

설계한 내용을 바탕으로 화면 레이아웃을 만들고 기능들을 추가했다.

한번 저장한 데이터는 다음에 앱을 다시 실행하더라도 유지가 되어야 하므로 DB와의 연결이 필요했는데 저장할 데이터가 단순하고 양이 적었기 때문에 별도 서버구성은 하지않고 기기내에서 저장할 수 있도록 shared_preferences 패키지를 사용하여 저장기능을 구현하였다. 또한 저장시 저장 완료 알림을 위해 fluttertoast 패키지로 토스트 알림창을 적용하였다.

5. 배포 준비

앱 배포를 위해서 피그마를 이용하여 앱 실행 아이콘을 디자인 해주었다. 앱 실행 아이콘을 개발하면서 앱 실행시 초기에 보여지는 스플래시 화면과 스토어 등록할 때 필요한 그래픽 이미지와 스크린샷 등도 같이 만들어 주었다.
스크린샷 이미지 역시 피그마를 통해 만들었고 커뮤니티에서 템플릿을 받아 제작하였다.

플레이 스토어에 출시할 앱의 버전 지정과 서명등은 안드로이드 개발자 사이트에 정리가 잘 되어있어 참고하여 진행하였다.

https://developer.android.com/studio/publish/app-signing?hl=ko

앱 서명 | Android 스튜디오 | Android Developers

앱 서명 및 보안과 관련된 중요한 개념을 알아보고, Android 스튜디오를 사용하여 Google Play에 출시하기 위해 앱에 서명하는 방법과 Play 앱 서명을 선택하는 방법을 알아보세요.

developer.android.com

마지막으로 안드로이드 스튜디오 개발자 계정을 등록하여 앱 배포 준비를 완료 하였다.
안드로이드 개발자 계정의 경우에는 25달러를 한번 결제하면 개발자 계정을 사용할 수 있지만 애플같은 경우에는 1년마다 129,000 원의 멤버십을 연장하며 사용해야한다고 한다.
지금 진행하는 프로젝트는 수익이 발생하는 앱도 아니고 멤버십에 들어가는 비용이 적지는 않은 비용이라 이번에는 안드로이드로만 진행을 하였다.

6. 배포

지금까지 준비한 소스와 이미지들로 스토어 정보들을 등록하고 앱을 게시하였다.

프로젝트는 2023.06.19 ~ 2023.06.23 까지 총 5일이 소요되었으며 등록한 앱은 검토를 거쳐서 이틀 뒤인 6월 25일에 스토어에 프로덕션 상태로 등록되게되었다.

https://play.google.com/store/apps/details?id=com.hyojun.where_is_my_car

내차어딨지? - 주차 위치 기록하기 - Google Play 앱

내 차 몇층에 있더라..? 이제 간편하게 기록하세요!

play.google.com

7. 개선 방향

가장 먼저 상태관리 패키지인 Provider를 이용하여 소스코드 전체를 리팩토링 할 예정이다. 지금은 화면 하나에 기능도 몇 개 없어서 크게 문제가 없지만 나중에 기능이 추가되고 화면이 늘어나게 되었을 때 관리를 쉽게 하기 위해서는 필수적인 작업이라고 생각된다.

기능적으로는 우선 저장을 누른 순간부터 주차한 시간이 얼마나 지났는지를 표시해주는 화면을 하나 더 만들어서 추가해볼 예정이다. 이외에도 사용해보다가 추가되면 유용할 것 같은 기능들은 계속해서 수정해보려고한다.

현재는 한 페이지 짜리 실험용 앱이지만 지속적으로 업데이트 하여 단순한 토이프로젝트를 넘어 실제로 사람들이 사용하는 앱으로 발전하기를 기대해본다.

[LeetCode] 1091. Shortest Path in Binary Matrix - Java

HYOJUN — Thu, 1 Jun 2023 15:36:05 +0900

https://leetcode.com/problems/shortest-path-in-binary-matrix/description/

Shortest Path in Binary Matrix - LeetCode

Can you solve this real interview question? Shortest Path in Binary Matrix - Given an n x n binary matrix grid, return the length of the shortest clear path in the matrix. If there is no clear path, return -1. A clear path in a binary matrix is a path from

leetcode.com

문제

Given an n x n binary matrix grid, return the length of the shortest clear path in the matrix. If there is no clear path, return -1.

A clear path in a binary matrix is a path from the top-left cell (i.e., (0, 0)) to the bottom-right cell (i.e., (n - 1, n - 1)) such that:

All the visited cells of the path are 0.
All the adjacent cells of the path are 8-directionally connected (i.e., they are different and they share an edge or a corner).

The length of a clear path is the number of visited cells of this path.

Example 1:

Input: grid = [[0,1],[1,0]]
Output: 2

Example 2:

Input: grid = [[0,0,0],[1,1,0],[1,1,0]]
Output: 4

Example 3:

Input: grid = [[1,0,0],[1,1,0],[1,1,0]]
Output: -1

Constraints:

n == grid.length
n == grid[i].length
1 <= n <= 100
grid[i][j] is 0 or 1

풀이

풀이 과정

길이가 n이고 값이 0과 1로 이루어진 정사각형 모양의 2차원배열 grid가 주어지고 0은 이동을 했던 지점, 1은 이동을 하지 않았던 지점을 나타낸다.

왼쪽 상단에서 출발하여 오른쪽 하단에 도착하려고 할 때 최단 거리를 구하는 문제이다.

이동은 대각선을 포함한 8방향 모두 이동이 가능하고 출발점에서 도착점으로 가는 최단 경로가 존재하지 않는 경우 -1을 return한다.

먼저 최단 경로가 1이거나 구할 수 없는 경우를 먼저 제외한다.
배열의 길이를 n이라고 할 때 출발점의 값이 0이고 배열의 길이 n이 1인 경우는 항상 그 자체로 최단거리이므로 바로 1을 return 한다.
만약 출발점이나 도착점의 값이 0이 아닌 경우는 출발점에서 도착점으로 이어지는 경로를 구할 수 없으므로 -1을 return한다.

// 배열의 길이
int n = grid.length;

// 배열이 한 칸이고 이동가능한 경우 최단거리 1을 return
if(grid[0][0] == 0 && n == 1) return 1;
// 출발점이나 도착점이 이동 불가능한 지점인 경우 경로탐색이 불가능 하므로 -1을 return
if(grid[0][0] == 1 || grid[n - 1][n - 1] == 1) return -1;

이외의 경우에는 큐를 이용한 BFS탐색을 이용하기로 한다.
우선 현재 좌표를 기준으로 왼쪽 위, 중앙 위, 오른쪽 위, 왼쪽, 오른쪽, 왼쪽 아래, 중앙 아래, 오른쪽 아래 순서대로 탐색할 방향을 지정한다.

// 탐색할 방향 (왼쪽 위, 중앙 위, 오른쪽 위, 왼쪽, 오른쪽, 왼쪽 아래, 중앙 아래, 오른쪽 아래)
int[][] dirs = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};

다음으로 탐색에 사용할 큐를 선언해주고 출발점인 (0,0) 좌표를 삽입한다.

// 탐색에 사용할 큐 선언
Queue<int[]> q = new LinkedList<>();
// 큐에 출발점 삽입
q.offer(new int[] {0, 0});

너비우선탐색을 위해서는 특정 지점의 방문 여부를 알 필요가 있는데 방문한 지점의 값을 -1로 바꾸어 방문 여부를 표시해준다.

// 출발점값을 -1로 방문여부 표시
grid[0][0] = -1;

정답 카운트를 0부터 시작하여 큐가 빌 때까지 반복하여 탐색을 한다.
먼저 정답 카운트를 하나 증가 시키고 현재 큐에 있는 모든 값을 반복 하여 탐색한다.
현재 탐색중인 지점이 도착점인 경우 정답값을 return 해준다.

그렇지 않은 경우에는 나머지 8방향 탐색을 계속한다.
처음에 선언해준 탐색 방향대로 새로운 행 좌표와 열 좌표를 각각 구하고

새로운 좌표가 배열을 벗어나는 경우
방문 가능한 좌표가 아닌 경우( 값이 1인 경우 )
이미 방문한 경우 ( 값이 -1인 경우 )

이러한 경우에는 탐색에서 제외한다.
탐색이 가능한 경우에는 새로운 좌표의 값을 -1로 변경하여 방문 표시를 하고, 큐에 새로운 좌표값을 추가한다.

// 큐가 빌 때까지 반복
while(!q.isEmpty()) {
    // 정답 카운트 증가
    answer++;
    // 현재 큐에 있는 모든 요소 탐색
    for(int i = q.size(); i > 0; i--) {
        // 현재 탐색중인 지점
        int[] point = q.poll();
        // 현재 탐색중인 지점의 행 좌표
        int row = point[0];
        // 현재 탐색중인 지점의 열 좌표
        int col = point[1];

        // 도착점에 도착한 경우 정답 카운트를 return
        if(row == n - 1 && col == n - 1) return answer;

        // 8방향 탐색
        for(int[] dir : dirs) {
            // 새로운 행 좌표
            int newRow = row + dir[0];
            // 새로운 열 좌표
            int newCol = col + dir[1];
            // 새로운 좌표가 배열을 벗어나는 경우 탐색 제외
            if(newRow < 0 || newRow == n || newCol < 0 || newCol == n) continue;
            // 새로운 좌표가 방문 가능한 좌표가 아니거나 이미 방문한 경우 탐색 제외
            if(grid[newRow][newCol] != 0) continue;

            // 현재 좌표 -1로 방문 표시
            grid[newRow][newCol] = -1;
            // 큐에 새로운 좌표값 주가
            q.offer(new int[] {newRow, newCol});
        }
    }
}

최종 코드

class Solution {
    public int shortestPathBinaryMatrix(int[][] grid) {
        // 배열의 길이
        int n = grid.length;
        
        // 배열이 한 칸이고 이동가능한 경우 최단거리 1을 return
        if(grid[0][0] == 0 && n == 1) return 1;
        // 출발점이나 도착점이 이동 불가능한 지점인 경우 경로탐색이 불가능 하므로 -1을 return
        if(grid[0][0] == 1 || grid[n - 1][n - 1] == 1) return -1;
        
        // 탐색할 방향 (왼쪽 위, 중앙 위, 오른쪽 위, 왼쪽, 오른쪽, 왼쪽 아래, 중앙 아래, 오른쪽 아래)
        int[][] dirs = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};
        // 탐색에 사용할 큐 선언
        Queue<int[]> q = new LinkedList<>();
        // 큐에 출발점 삽입
        q.offer(new int[] {0, 0});
        // 출발점값을 -1로 방문여부 표시
        grid[0][0] = -1;
        
        // 정답 카운트
        int answer = 0;
        
        // 큐가 빌 때까지 반복
        while(!q.isEmpty()) {
            // 정답 카운트 증가
            answer++;
            // 현재 큐에 있는 모든 요소 탐색
            for(int i = q.size(); i > 0; i--) {
                // 현재 탐색중인 지점
                int[] point = q.poll();
                // 현재 탐색중인 지점의 행 좌표
                int row = point[0];
                // 현재 탐색중인 지점의 열 좌표
                int col = point[1];
                
                // 도착점에 도착한 경우 정답 카운트를 return
                if(row == n - 1 && col == n - 1) return answer;
                
                // 8방향 탐색
                for(int[] dir : dirs) {
                    // 새로운 행 좌표
                    int newRow = row + dir[0];
                    // 새로운 열 좌표
                    int newCol = col + dir[1];
                    // 새로운 좌표가 배열을 벗어나는 경우 탐색 제외
                    if(newRow < 0 || newRow == n || newCol < 0 || newCol == n) continue;
                    // 새로운 좌표가 방문 가능한 좌표가 아니거나 이미 방문한 경우 탐색 제외
                    if(grid[newRow][newCol] != 0) continue;
                    
                    // 현재 좌표 -1로 방문 표시
                    grid[newRow][newCol] = -1;
                    // 큐에 새로운 좌표값 주가
                    q.offer(new int[] {newRow, newCol});
                }
            }
        }

        return -1;
    }
}

[Flutter] 어플리케이션 실행 아이콘 변경하기 2 - 플러그인 이용

HYOJUN — Thu, 25 May 2023 15:26:17 +0900

[Flutter] 어플리케이션 실행 아이콘 변경하기

플러터로 새로운 프로젝트를 만들고 실행하면 아래와 같은 플러터 아이콘이 기본 어플리케이션 아이콘으로 생성된다. 어플리케이션의 실행 아이콘으로 사용하고자 하는 이미지를 준비하여 다

hyojun.tistory.com

위 글에서 플러그인 없이 앱 실행 아이콘 변경하는 법을 정리하였는데 플러그인을 이용해서 해당 과정을 간단하게 처리하는 방법도 존재한다.

flutter_launcher_icons라는 플러그인을 이용하는 것인데 아래의 플러그인 문서를 참고하여 pubspec.yaml 파일에 dependencies를 추가한다.

flutter_launcher_icons | Dart Package

A package which simplifies the task of updating your Flutter app's launcher icon.

pub.dev

그 후 pubspec.yaml 파일과 같은 경로에 flutter_launcher_icons.yaml 파일을 생성하여 아래와 같이 작성한다.

flutter_icons:
  android: "launcher_icon"
  ios: true
  image_path: "images/i_am_rich_app_icon.png"

image_path에는 앱 실행아이콘으로 사용할 이미지를 넣어놓은 경로를 작성해주면 된다.

설정이 끝난 후 터미널에서 아래의 명령어를 실행해주면 실행 아이콘을 생성하고 변경해주는 작업이 자동으로 진행된다.

flutter pub run flutter_launcher_icons:main

모든 작업이 완료된 후 프로젝트 빌드를 다시 진행하면 수동 작업과 마찬가지로 변경된 앱 아이콘을 확인할 수 있다.

[Flutter] 어플리케이션 실행 아이콘 변경하기

HYOJUN — Thu, 25 May 2023 00:05:46 +0900

플러터로 새로운 프로젝트를 만들고 실행하면 아래와 같은 플러터 아이콘이 기본 어플리케이션 아이콘으로 생성된다.

어플리케이션의 실행 아이콘으로 사용하고자 하는 이미지를 준비하여 다음 사이트로 이동한다.
이 사이트에서는 각 기기 환경에 맞는 어플리케이션 아이콘을 자동으로 생성해준다.

https://www.appicon.co/

App Icon Generator

www.appicon.co

사이트에 접속하여 왼쪽에 사용하고자 하는 이미지를 드래그 하고 오른쪽에서 생성하고자 하는 기기 종류를 선택하여 Generate 버튼을 클릭한다.

그러면 압축파일을 하나 다운로드하게 되는데 압축을 해제하면 선택한 환경에 맞게 생성된 아이콘 파일들을 확인할 수 있다.

이제 안드로이드와 ios 각각의 앱 아이콘 경로를 찾아 파일을 교체 해준다.

1. 안드로이드

android > app > src > main > res 경로에서 우클릭하여 파일 탐색기에 표시한다.

탐색기에서 아래와 같은 5개의 폴더를 사이트에서 생성한 폴더로 교체해준다.

2. ios

ios 역시 안드로이드와 과정은 같다.
ios > Runner Assets.xcassets 폴더를 파일 탐색기에 표시하고 Assets.xcassets 폴더를 사이트에서 생성한 폴더로 교체해준다.

설정을 마치고 나면 다음과 같이 어플리케이션의 아이콘이 변경된 것을 확인할 수 있다.

* 플러그인을 이용하여 실행 아이콘 변경하기

[Flutter] 어플리케이션 실행 아이콘 변경하기 2 - 플러그인 이용

[Flutter] 어플리케이션 실행 아이콘 변경하기 플러터로 새로운 프로젝트를 만들고 실행하면 아래와 같은 플러터 아이콘이 기본 어플리케이션 아이콘으로 생성된다. 어플리케이션의 실행 아이콘

hyojun.tistory.com

[LeetCode] 703. Kth Largest Element in a Stream - Java

HYOJUN — Tue, 23 May 2023 15:08:06 +0900

https://leetcode.com/problems/kth-largest-element-in-a-stream/

Kth Largest Element in a Stream - LeetCode

Can you solve this real interview question? Kth Largest Element in a Stream - Design a class to find the kth largest element in a stream. Note that it is the kth largest element in the sorted order, not the kth distinct element. Implement KthLargest class:

leetcode.com

문제

Design a class to find the kth largest element in a stream. Note that it is the kth largest element in the sorted order, not the kth distinct element.

Implement KthLargest class:

KthLargest(int k, int[] nums) Initializes the object with the integer k and the stream of integers nums.
int add(int val) Appends the integer val to the stream and returns the element representing the kth largest element in the stream.

Example 1:

Input
["KthLargest", "add", "add", "add", "add", "add"]
[[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]
Output
[null, 4, 5, 5, 8, 8]

Explanation
KthLargest kthLargest = new KthLargest(3, [4, 5, 8, 2]);
kthLargest.add(3);   // return 4
kthLargest.add(5);   // return 5
kthLargest.add(10);  // return 5
kthLargest.add(9);   // return 8
kthLargest.add(4);   // return 8

Constraints:

1 <= k <= 104
0 <= nums.length <= 104
-104 <= nums[i] <= 104
-104 <= val <= 104
At most 104 calls will be made to add.
It is guaranteed that there will be at least k elements in the array when you search for the kth element.

풀이

풀이 과정

정수 k와 정수 배열 nums 배열이 주어지고 정수들을 추가할 때 k번째로 큰 숫자를 찾아내는 클래스를 구현해야 하는 문제이다.
클래스에서 구현해야하는 함수는 인스턴스를 초기화하는 함수 KthLargest와 값을 추가해주는 add이다.

해당 클래스를 구현하기 위해서 우선순위큐를 사용하도록 한다.

nums의 모든 요소와 추가되는 정수들을 우선순위큐에 담고 큐의 사이즈가 k를 초과하는 경우 마지막 요소를 제거하며 항상 k번째 큰 수가 다음에 나오도록 하는 방향으로 풀이한다.

먼저 우선순위큐와 큐의 최대 사이즈가 될 변수를 전역변수로 선언한다,

// 크기 순으로 저장할 우선순위큐 선언
PriorityQueue<Integer> pq = new PriorityQueue<>();
// 큐에 저장할 최대 길이
int size;

인스턴스를 초기화 하는 함수에서는 전역변수 size에 k의 값을 저장해주고 nums 배열의 모든 요소를 큐에 저장한다.
이 때 큐의 크기가 k보다 커지게 되는 경우에는 마지막 요소를 하나 제거한다.

 public KthLargest(int k, int[] nums) {
    size = k;

    // nums 배열의 요소들을 큐에 저장
    for(int i : nums) {
        pq.offer(i);
        // 큐의 크기가 k보다 큰 경우 마지막 요소 제거
        if(pq.size() > k) pq.poll();
    }
}

수를 추가하는 add 함수에서는 전달받은 val값을 큐에 추가하고 마찬 가지로 길이 k를 초과하게 되는 경우에는 마지막 요소를 제거한다. 그 후 마지막에 있는 요소 값을 return 해준다.

public int add(int val) {
    // val 값을 큐에 추가
    pq.offer(val);
    // k길이를 초과하게되는 마지막 요소 제거
    if(pq.size() > size) pq.poll();

    // 마지막에 있는 요소를 return
    return pq.peek();
}

최종 코드

class KthLargest {
    // 크기 순으로 저장할 우선순위큐 선언
    PriorityQueue<Integer> pq = new PriorityQueue<>();
    // 큐에 저장할 최대 길이
    int size;

    public KthLargest(int k, int[] nums) {
        size = k;
        
        // nums 배열의 요소들을 큐에 저장
        for(int i : nums) {
            pq.offer(i);
            // 큐의 크기가 k보다 큰 경우 마지막 요소 제거
            if(pq.size() > k) pq.poll();
        }
    }
    
    public int add(int val) {
        // val 값을 큐에 추가
        pq.offer(val);
        // k길이를 초과하게되는 마지막 요소 제거
        if(pq.size() > size) pq.poll();
        
        // 마지막에 있는 요소를 return
        return pq.peek();
    }
}

/**
 * Your KthLargest object will be instantiated and called as such:
 * KthLargest obj = new KthLargest(k, nums);
 * int param_1 = obj.add(val);
 */

[LeetCode] 2466. Count Ways To Build Good Strings

HYOJUN — Sun, 14 May 2023 02:09:15 +0900

https://leetcode.com/problems/count-ways-to-build-good-strings/description/

문제

Given the integers zero, one, low, and high, we can construct a string by starting with an empty string, and then at each step perform either of the following:

Append the character '0' zero times.
Append the character '1' one times.

This can be performed any number of times.

A good string is a string constructed by the above process having a length between low and high (inclusive).

Return the number of different good strings that can be constructed satisfying these properties. Since the answer can be large, return it modulo 10^9 + 7.

Example 1:

Input: low = 3, high = 3, zero = 1, one = 1
Output: 8
Explanation: 
One possible valid good string is "011". 
It can be constructed as follows: "" -> "0" -> "01" -> "011". 
All binary strings from "000" to "111" are good strings in this example.

Example 2:

Input: low = 2, high = 3, zero = 1, one = 2
Output: 5
Explanation: The good strings are "00", "11", "000", "110", and "011".

Constraints:

1 <= low <= high <= 105
1 <= zero, one <= low

풀이

풀이 과정

zero, one, low, high 4개의 정수 변수가 주어진다.

아래 두 개의 조건에 따라 문자열을 만들어 나간다.

'0'을 zero번 붙인다.
'1'을 one번 붙인다.

이렇게 만들 수 있는 문자열 중 문자열의 길이가 low이상 high이하인 문자열을 good string으로 정의하며 good string의 총 개수를 구하는 문제이다.

정답이 매우 큰 수 일 수 있으므로 10^9 + 7로 나눈 나머지를 return한다.

dp를 이용하여 각 자리수마다 만들 수 있는 문자열의 경우의 수를 구하고 그 길이가 low이상 high이하인 경우의 수를 더한 값을 return하는 방식으로 풀이한다.

각 자리수마다 만들어질 수 있는 경우의 수를 저장할 배열을 선언하고 첫 번째값을 1로 세팅한다.

// 각 자리수마다 만들어질 수 있는 경우의 수를 저장할 배열
int[] dp = new int[high + 1];
// 아무것도 만들수 없는 경우의 수 1
dp[0] = 1;

단어를 만들 수 있는 최소한의 길이는 zero와 one중 작은 값이다. 단어를 만들 수 있는 최소한의 길이보다 작은 경우에는 만들 수 있는 경우의 수가 존재하지 않으므로 이 최소 길이부터 탐색을 시작한다.

현재 탐색중인 문자열 자리수가 0이 들어갈 개수 이상인 경우 zero만큼 이전 자리수의 경우의 수 만큼의 개수를 현재 인덱스 값에 추가한다.
1이 들어갈 경우에 대해서도 같은 방법으로 탐색한다.

만약 현재 탐색중인 문자열 자리수가 good string이 되는 길이인 경우에는 정답에 현재 인덱스의 값을 추가한다.
모든 탐색이 종료된 후 최종적으로 구해진 정답을 return한다.

int answer = 0;
// 단어를 만들 수 있는 최소 길이
int minLength = Math.min(zero, one);
// 나머지 계산을 위한 수
int mod = 1000000007;

// 단어를 만들 수 있는 최소 길이부터 탐색
for(int i = minLength; i <= high; i++) {
    // 현재 탐색중인 문자열 자리수가 0이 들어갈 개수 이상인 경우
    if(i >= zero) {
        // 0의 개수 이전 자리수의 경우의 수 만큼 추가
        dp[i] = (dp[i] + dp[i - zero]) % mod;
    }
    // 현재 탐색중인 문자열 자리수가 1이 들어갈 개수 이상인 경우
    if(i >= one) {
        // 1의 개수 이전 자리수의 경우의 수 만큼 추가
        dp[i] = (dp[i] + dp[i - one]) % mod;
    }
    // 현재 탐색중인 문자열 자리수가 good string이 되는 길이인 경우
    if(i >= low) {
        // 정답 개수 추가
        answer = (answer + dp[i]) % mod;
    }
}

return answer;

최종 코드

class Solution {
    public int countGoodStrings(int low, int high, int zero, int one) {
        int answer = 0;
        
        // 단어를 만들 수 있는 최소 길이
        int minLength = Math.min(zero, one);
        // 나머지 계산을 위한 수
        int mod = 1000000007;
        // 각 자리수마다 만들어질 수 있는 경우의 수를 저장할 배열
        int[] dp = new int[high + 1];
        // 아무것도 만들수 없는 경우의 수 1
        dp[0] = 1;
        
        // 단어를 만들 수 있는 최소 길이부터 탐색
        for(int i = minLength; i <= high; i++) {
            // 현재 탐색중인 문자열 자리수가 0이 들어갈 개수 이상인 경우
            if(i >= zero) {
                // 0의 개수 이전 자리수의 경우의 수 만큼 추가
                dp[i] = (dp[i] + dp[i - zero]) % mod;
            }
            // 현재 탐색중인 문자열 자리수가 1이 들어갈 개수 이상인 경우
            if(i >= one) {
                // 1의 개수 이전 자리수의 경우의 수 만큼 추가
                dp[i] = (dp[i] + dp[i - one]) % mod;
            }
            // 현재 탐색중인 문자열 자리수가 good string이 되는 길이인 경우
            if(i >= low) {
                // 정답 개수 추가
                answer = (answer + dp[i]) % mod;
            }
        }

        return answer;
    }
}

[LeetCode] 59. Spiral Matrix II - Java

HYOJUN — Wed, 10 May 2023 13:36:13 +0900

https://leetcode.com/problems/spiral-matrix-ii/description/

Spiral Matrix II - LeetCode

Can you solve this real interview question? Spiral Matrix II - Given a positive integer n, generate an n x n matrix filled with elements from 1 to n2 in spiral order. Example 1: [https://assets.leetcode.com/uploads/2020/11/13/spiraln.jpg] Input: n = 3 O

leetcode.com

문제

Given a positive integer n, generate an n x n matrix filled with elements from 1 to n^2 in spiral order.

Example 1:

Input: n = 3
Output: [[1,2,3],[8,9,4],[7,6,5]]

Example 2:

Input: n = 1
Output: [[1]]

Constraints:

1 <= n <= 20

풀이

풀이 과정

정수 n이 주어질 때 n x x크기의 이차원배열을 1부터 n^2까지 나선형으로 채워야하는 문제이다

풀이하는 과정은 54. Sprial Matrix와 같다.
두 문제의 차이점은 Sprial Matrix는 이미 채워진 배열의 요소를 구하는 문제이고 Sprial Matrix II는 빈 배열을 처음부터 채워나가야 하는 것이다.

먼저 최종적으로 return할 2차원 배열을 생성한다.

// 정답 배열
int[][] answer = new int[n][n];

다음으로 각 요소들의 위치를 판단하기 위한 변수들을 선언한다.

정수 dir은 현재 이동방향을 나타내는 변수이며 0, 1, 2, 3 순서대로 오른쪽, 아래, 왼쪽, 위를 나타낸다.
정수 배열 dirR과 dirC는 각각 현재 이동방향에 대해서 행과 열의 이동 방향을 나타낸다.
마지막으로 정수 row와 col은 현재 탐색중인 행과 열의 좌표를 나타낸다. 시작점은 0, 0으로 설정한다.

// 현재 이동방향 (오른쪽, 아래, 왼쪽, 위)
int dir = 0;
// Row의 이동방향
int[] dirR = {0, 1, 0, -1};
// Column의 이동방향
int[] dirC = {1, 0, -1, 0};
// 시작 Row
int row = 0;
// 시작 Col
int col = 0;

해당 변수들을 가지고 정답 배열의 길이만큼 반복하며 탐색을 진행한다.
현재 행과 열에 1부터 차례대로 삽입하고 다음 이동할 좌표에 대해서 조건을 판단하여 이동방향을 변경해야한다.
이동방향을 변경해야하는 경우는 다음 두 가지이다.

다음으로 이동할 좌표가 배열을 벗어난 경우
이미 방문한 좌표인 경우

해당 조건에 해당하는 경우 이동방향을 변경하고 최종적으로 행과 열의 좌표값을 갱신한다.

// 정답 배열의 길이만큼 반복
for(int i = 0; i < n * n; i++) {
    answer[row][col] = i + 1;

    // 다음으로 이동할 좌표가 배열을 벗어나거나 이미 방문한 요소인 경우 이동방향을 변경
    if(row + dirR[dir] < 0 || row + dirR[dir] >= n ||
       col + dirC[dir] < 0 || col + dirC[dir] >= n ||
       answer[row + dirR[dir]][col + dirC[dir]] != 0) {
        dir = (dir + 1) % 4;
    }

    // 현재 좌표를 갱신
    row += dirR[dir];
    col += dirC[dir];
}

구해진 2차원 배열을 return한다.

return answer;

최종 코드

class Solution {
    public int[][] generateMatrix(int n) {
        // 정답 배열
        int[][] answer = new int[n][n];
        // 현재 이동방향 (오른쪽, 아래, 왼쪽, 위)
        int dir = 0;
        // Row의 이동방향
        int[] dirR = {0, 1, 0, -1};
        // Column의 이동방향
        int[] dirC = {1, 0, -1, 0};
        // 시작 Row
        int row = 0;
        // 시작 Col
        int col = 0;
        
        // 정답 배열의 길이만큼 반복
        for(int i = 0; i < n * n; i++) {
            answer[row][col] = i + 1;
            
            // 다음으로 이동할 좌표가 배열을 벗어나거나 이미 방문한 요소인 경우 이동방향을 변경
            if(row + dirR[dir] < 0 || row + dirR[dir] >= n ||
               col + dirC[dir] < 0 || col + dirC[dir] >= n ||
               answer[row + dirR[dir]][col + dirC[dir]] != 0) {
                dir = (dir + 1) % 4;
            }
            
            // 현재 좌표를 갱신
            row += dirR[dir];
            col += dirC[dir];
        }

        return answer;
    }
}

[LeetCode] 1572. Matrix Diagonal Sum - Java

HYOJUN — Mon, 8 May 2023 21:46:44 +0900

https://leetcode.com/problems/matrix-diagonal-sum/description/

Matrix Diagonal Sum - LeetCode

Can you solve this real interview question? Matrix Diagonal Sum - Given a square matrix mat, return the sum of the matrix diagonals. Only include the sum of all the elements on the primary diagonal and all the elements on the secondary diagonal that are

leetcode.com

문제

Given a square matrix mat, return the sum of the matrix diagonals.

Only include the sum of all the elements on the primary diagonal and all the elements on the secondary diagonal that are not part of the primary diagonal.

Example 1:

Input: mat = [[1,2,3],
              [4,5,6],
              [7,8,9]]
Output: 25
Explanation: Diagonals sum: 1 + 5 + 9 + 3 + 7 = 25
Notice that element mat[1][1] = 5 is counted only once.

Example 2:

Input: mat = [[1,1,1,1],
              [1,1,1,1],
              [1,1,1,1],
              [1,1,1,1]]
Output: 8

Example 3:

Input: mat = [[5]]
Output: 5

Constraints:

n == mat.length == mat[i].length
1 <= n <= 100
1 <= mat[i][j] <= 100

풀이

풀이 과정

길이가 n인 정사각형 모양의 2차원 배열 mat가 주어질 때 왼쪽 위부터 오른쪽 아래로 향하는 대각선상에 위치한 요소들과 오른쪽 위부터 왼쪽 아래로 향하는 대각선상에 위치한 요소들의 총합을 구하는 문제이다.
단 두 대각선상에서 중복되는 요소는 한 번만 더하도록 한다.

우선 총 합계를 저장할 변수와 배열의 길이를 저장할 변수를 선언하고 초기화한다.

// 대각선 요소의 총 합계
int sum = 0;

// 배열의 길이
int length = mat.length;

우선 배열의 길이가 1인 경우 요소는 하나만 존재하고 대각선으로 나타낼 경우 중복되어 한 번만 합계에 추가해야하기 때문에 해당 요소를 바로 return한다.

// 배열의 길이가 1인 경우 요소를 바로 return
if(length == 1) return mat[0][0];

배열의 길이가 1보다 큰 경우에는 배열의 길이만큼 반복하며 각 행의 요소를 탐색한다.

현재 탐색중인 행이 n번째 행이라고 할 때 왼쪽 위에서 오른쪽 아래로 향하는 대각선에 해당하는 요소는 mat[n][n] 으로 나타낼 수 있다. 따라서 합계에 mat[n][n]을 더해준다.

다음으로 오른쪽 위에서 왼쪽 아래로 향하는 대각선에 해당하는 요소는 mat[n][배열의 길이 - n - 1]로 나타낼 수 있다.
해당 요소 역시 합계에 더해주는데 두 대각선에서 중복되는 요소인 경우에는 더하지 않는다.
배열의 길이가 홀수이면서 현재 탐색중인 행의 인덱스가 배열의 절반인 경우 중복되는 요소가 된다.

// 배열의 길이만큼 반복
for(int i = 0; i < length; i++){
    // primary diagonal
    sum += mat[i][i];

    // secondary diagonal
    // 배열의 길이가 홀수 이면서 길이의 절반에 해당하는 인덱스인 경우
    // 중복된 요소가 선택되므로 탐색제외
    if(length % 2 == 1 && i == length / 2) continue;
    // 이외의 경우 합계에 더함
    sum += mat[i][length - i - 1];
}

최종적으로 구해진 합계를 return한다.

return sum;

최종 코드

class Solution {
    public int diagonalSum(int[][] mat) {
        // 대각선 요소의 총 합계
        int sum = 0;

        // 배열의 길이
        int length = mat.length;

        // 배열의 길이가 1인 경우 요소를 바로 return
        if(length == 1) return mat[0][0];

        // 배열의 길이만큼 반복
        for(int i = 0; i < length; i++){
            // primary diagonal
            sum += mat[i][i];

            // secondary diagonal
            // 배열의 길이가 홀수 이면서 길이의 절반에 해당하는 인덱스인 경우
            // 중복된 요소가 선택되므로 탐색제외
            if(length % 2 == 1 && i == length / 2) continue;
            // 이외의 경우 합계에 더함
            sum += mat[i][length - i - 1];
        }

        return sum;
    }
}

[LeetCode] 1046. Last Stone Weight - Java

HYOJUN — Mon, 24 Apr 2023 23:15:20 +0900

https://leetcode.com/problems/last-stone-weight/description/

Last Stone Weight - LeetCode

Can you solve this real interview question? Last Stone Weight - You are given an array of integers stones where stones[i] is the weight of the ith stone. We are playing a game with the stones. On each turn, we choose the heaviest two stones and smash them

leetcode.com

문제

You are given an array of integers stones where stones[i] is the weight of the ith stone.

We are playing a game with the stones. On each turn, we choose the heaviest two stones and smash them together. Suppose the heaviest two stones have weights x and y with x <= y. The result of this smash is:

If x == y, both stones are destroyed, and
If x != y, the stone of weight x is destroyed, and the stone of weight y has new weight y - x.

At the end of the game, there is at most one stone left.

Return the weight of the last remaining stone. If there are no stones left, return 0.

Example 1:

Input: stones = [2,7,4,1,8,1]
Output: 1
Explanation: 
We combine 7 and 8 to get 1 so the array converts to [2,4,1,1,1] then,
we combine 2 and 4 to get 2 so the array converts to [2,1,1,1] then,
we combine 2 and 1 to get 1 so the array converts to [1,1,1] then,
we combine 1 and 1 to get 0 so the array converts to [1] then that's the value of the last stone.

Example 2:

Input: stones = [1]
Output: 1

Constraints:

1 <= stones.length <= 30
1 <= stones[i] <= 1000

풀이

풀이 과정

1~30개 사이의 돌들의 무게가 담겨있는 배열 stones가 주어지고 주어진 돌들을 이용하여 게임을 진행한다.

주어진 돌들의 배열에서 가장 무거운 돌 두개를 선택하며 다음 과정을 반복한다.

두 개의 돌을 각각 x, y라고 할 때 x <= y 이다.
x와 y의 무게 같은 경우 두 개의 돌을 모두 파괴한다.
만약 x와 y의 무게가 같지 않은 경우 x를 파괴하고 y - x무게 만큼의 새로운 돌의 무게를 배열에 다시 추가한다.
마지막 남은 돌의 무게를 return 한다, 남은 돌이 없는 경우에는 0을 return한다.

우선 배열의 길이가 1인 경우에는 해당 돌의 무게값을 바로 return한다.

// 돌의 개수가 한 개인 경우 해당 돌의 무게를 바로 return
if(stones.length == 1) return stones[0];

무게별로 순차적으로 탐색하고 새로운 돌의 무게가 추가되는 경우가 있으므로 우선순위 큐를 이용한다.
가장 무거운 돌을 비교하므로 높은 값이 우선순위를 갖도록 큐를 선언해준다.

// 돌의 무게를 무거운 순으로 저장할 우선순위 큐
PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());

배열에 있는 모든 값을 큐에 삽입한다.

// 모든 돌을 우선순위 큐에 삽입
for(int i : stones) pq.offer(i);

큐에 남은 값이 1개 이하가 될 때까지 탐색을 반복한다.

조건에 맞도록 우선순위가 높은 두 개의 값을 각각 x, y로 큐에서 추출하고 두 값이 같지 않은 경우 y - x의 값을 다시 우선순위 큐에 삽입한다.

// 우선순위큐에 남은 돌의 개수가 한 개 이하가 될 때까지 반복
while(pq.size() > 1){
    // 가장 무거운 돌 두 개 꺼냄
    int y = pq.poll();
    int x = pq.poll();

    // x와 y의 무게가 같지 않은 경우 y-x의 무게를 다시 우선순위 큐에 삽입
    if(x != y) pq.offer(y - x);
}

큐에 남아있는 값이 있는 경우 해당 값을 return 하고 남아있는 값이 없는 경우에는 0을 return 한다.

// 우선순위큐에 남은 값이 있는 경우 해당 값을 return
// 남은 값이 없는 경우 0을 return
return pq.size() == 0 ? 0 : pq.poll();

최종 코드

class Solution {
    public int lastStoneWeight(int[] stones) {
        // 돌의 개수가 한 개인 경우 해당 돌의 무게를 바로 return
        if(stones.length == 1) return stones[0];

        // 돌의 무게를 무거운 순으로 저장할 우선순위 큐
        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());

        // 모든 돌을 우선순위 큐에 삽입
        for(int i : stones) pq.offer(i);

        // 우선순위큐에 남은 돌의 개수가 한 개 이하가 될 때까지 반복
        while(pq.size() > 1){
            // 가장 무거운 돌 두 개 꺼냄
            int y = pq.poll();
            int x = pq.poll();

            // x와 y의 무게가 같지 않은 경우 y-x의 무게를 다시 우선순위 큐에 삽입
            if(x != y) pq.offer(y - x);
        }

        // 우선순위큐에 남은 값이 있는 경우 해당 값을 return
        // 남은 값이 없는 경우 0을 return
        return pq.size() == 0 ? 0 : pq.poll();
    }
}

[LeetCode] 2390. Removing Stars From a String - Java

HYOJUN — Tue, 11 Apr 2023 13:45:53 +0900

https://leetcode.com/problems/removing-stars-from-a-string/description/

Removing Stars From a String - LeetCode

Can you solve this real interview question? Removing Stars From a String - You are given a string s, which contains stars *. In one operation, you can: * Choose a star in s. * Remove the closest non-star character to its left, as well as remove the star it

leetcode.com

문제

You are given a string s, which contains stars *.

In one operation, you can:

Choose a star in s.
Remove the closest non-star character to its left, as well as remove the star itself.

Return the string after all stars have been removed.

Note:

The input will be generated such that the operation is always possible.
It can be shown that the resulting string will always be unique.

Example 1:

Input: s = "leet**cod*e"
Output: "lecoe"
Explanation: Performing the removals from left to right:
- The closest character to the 1st star is 't' in "leet**cod*e". s becomes "lee*cod*e".
- The closest character to the 2nd star is 'e' in "lee*cod*e". s becomes "lecod*e".
- The closest character to the 3rd star is 'd' in "lecod*e". s becomes "lecoe".
There are no more stars, so we return "lecoe".

Example 2:

Input: s = "erase*****"
Output: ""
Explanation: The entire string is removed, so we return an empty string.

Constraints:

1 <= s.length <= 105
s consists of lowercase English letters and stars *.
The operation above can be performed on s.

풀이

풀이 과정

알파벳 소문자와 '*'로 이루어진 문자열 s가 주어질 때 다음 과정을 거쳐서 만들어지는 문자열을 구하는 문제이다.

문자열 내의 '*' 하나를 선택한다.
선택한 '*'의 왼쪽에 있는 알파벳 중 가장 가까운 알파벳 하나와 선택한 '*'을 제거한다.

문자열의 글자들을 처음부터 탐색하면서 스택에 저장해두고 '*'이 나올 때 스택의 가장 위에 있는 문자가 선택한 '*'의 가장 왼쪽에 있는 문자이므로 스택에서 제거해 나가는 식으로 풀이한다.

Stack<Character> stack = new Stack<>();

// 문자열의 모든 글자 탐색
for(int i = 0; i < s.length(); i++){
    // 현재 탐색중인 글자
    char c = s.charAt(i);

    // 현재 탐색중인 글자가 '*'인 경우 스택의 가장 마지막 글자를 제거
    if(c == '*') stack.pop();
    // 현재 탐색중인 글자가 알파벳인 경우 스택에 추가
    else stack.push(c);
}

모든 제거 과정이 끝나고 남은 문자열을 return하면 되는데 stack에서 꺼내는 순서는 문자열의 역순이 되므로 앞쪽에서부터 문자를 삽입하여 정답 문자열을 만들어 return해준다.

// 정답 문자열을 만들기 위한 stringBuilder
StringBuilder sb = new StringBuilder();

// 스택에 남아있는 모든 글자 탐색
while(stack.size() > 0){
    // 스택에서 꺼낸 문자열을 앞쪽에 삽입
    sb.insert(0, stack.pop());
}

return sb.toString();

최종 코드

class Solution {
    public String removeStars(String s) {
        Stack<Character> stack = new Stack<>();

        // 문자열의 모든 글자 탐색
        for(int i = 0; i < s.length(); i++){
            // 현재 탐색중인 글자
            char c = s.charAt(i);

            // 현재 탐색중인 글자가 '*'인 경우 스택의 가장 마지막 글자를 제거
            if(c == '*') stack.pop();
            // 현재 탐색중인 글자가 알파벳인 경우 스택에 추가
            else stack.push(c);
        }

        // 정답 문자열을 만들기 위한 stringBuilder
        StringBuilder sb = new StringBuilder();

        // 스택에 남아있는 모든 글자 탐색
        while(stack.size() > 0){
            // 스택에서 꺼낸 문자열을 앞쪽에 삽입
            sb.insert(0, stack.pop());
        }

        return sb.toString();
    }
}

[Flutter] flutter windows version 이슈 해결하기

HYOJUN — Mon, 10 Apr 2023 13:03:47 +0900

오랜만에 플러터 공부를 위해 플러터 환경설정을 확인하던 중 flutter doctor 에서 아래와 같이 windows version에서 문제가 발생하였다.

해당 이슈는 명령어 세 줄만으로 간단하게 해결이 가능했다.

1. 플러터가 최신 버전이 아닌 경우 플러터 업그레이드

flutter upgrade

2. 플러터 채널을 master로 변경

flutter channel master

3. 다시 한번 flutter doctor를 실행하여 환경설정을 확인하면 모든 항목이 초록색 체크로 표시되어있는 편안한 화면을 볼 수 있다.

flutter doctor -v

[LeetCode] 1020. Number of Enclaves - Java

HYOJUN — Fri, 7 Apr 2023 14:00:45 +0900

https://leetcode.com/problems/number-of-enclaves/

Number of Enclaves - LeetCode

Can you solve this real interview question? Number of Enclaves - You are given an m x n binary matrix grid, where 0 represents a sea cell and 1 represents a land cell. A move consists of walking from one land cell to another adjacent (4-directionally) land

leetcode.com

문제

You are given an m x n binary matrix grid, where 0 represents a sea cell and 1 represents a land cell.

A move consists of walking from one land cell to another adjacent (4-directionally) land cell or walking off the boundary of the grid.

Return the number of land cells in grid for which we cannot walk off the boundary of the grid in any number of moves.

Example 1:

Input: grid = [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
Output: 3
Explanation: There are three 1s that are enclosed by 0s, and one 1 that is not enclosed because its on the boundary.

Example 2:

Input: grid = [[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
Output: 0
Explanation: All 1s are either on the boundary or can reach the boundary.

Constraints:

m == grid.length
n == grid[i].length
1 <= m, n <= 500
grid[i][j] is either 0 or 1.

풀이

풀이 과정

각 셀이 바다(0)와 땅(1)으로 이루어진 m x n 크기의 2차원 배열 grid가 주어질 때 사방이 바다로 둘러 쌓인 땅 타일의 개수를 구하는 문제이다.

각 타일을 탐색할 때에 사용할 함수를 먼저 생성한다.

탐색 대상 그리드와 행과 열의 인덱스, 그리고 현재 탐색중인 타일이 바다로 쌓여있는지 여부를 전달받는다.
우선 탐색 대상 좌표가 그리드를 벗어나는 경우에는 바로 탐색을 종료한다.
탐색 대상 좌표가 그리드 내에 있는 경우에는 현재 타일이 땅 타일인지 여부를 판단한다.
땅 타일인 경우에는 현재 타일을 바다로 변경하고 바다로 쌓여 있는지 여부에 따라 정답카운트를 증가시킨다.
그 후 상하좌우에 연결되어있는 타일을 탐색하며 모든 인접한 땅타일을 바다로 변경하며 같은 과정을 반복한다.

/**
 * @param grid  탐색 대상 그리드
 * @param row   현재 탐색중인 행의 인덱스
 * @param col   현재 탐색중인 열의 인덱스
 * @param inEnclosed 현재 탐색중인 타일이 물로 쌓여있는지 여부
 * @return
 */
public void dfs(int[][] grid, int row, int col, boolean isEnclosed){
    // 좌표가 그리드를 벗어나는 경우 탐색 종료
    if(row < 0 || col < 0 || row >= grid.length || col >= grid[0].length) return;
    // 방문한 타일이 땅(1)인 경우 물(0)로 변경
    // 물로 둘러 쌓여있는 땅 타일인 경우 정답 카운트 증가
    // 상하좌우 타일 탐색하며 모든 인접한 땅타일을 물로 변경
    if(grid[row][col] == 1){
        grid[row][col] = 0;
        if(isEnclosed) answer++;
        dfs(grid, row, col+1, isEnclosed);
        dfs(grid, row, col-1, isEnclosed);
        dfs(grid, row+1, col, isEnclosed);
        dfs(grid, row-1, col, isEnclosed);
    }
}

해당 함수를 사용하여 그리드의 모든 셀을 탐색하는데 땅타일이 그리드의 가장자리까지 연결되어있는 경우 연결된 땅 타일들은 바다로 둘러쌓여있지 않는것으로 간주되므로 우선 그리드의 가장자리부터 isEnclosed를 false로 탐색하여 바다로 둘러쌓여있지 않은 경우들을 제거한다.

// 그리드의 가장자리에 땅이 있는 경우 해당 타일과 연결된 땅은 물에 둘러쌓여있지 않게되므로
// 가장자리를 우선 탐색하여 연결된 모든 땅 타일을 물 타일로 변경
for(int i = 0; i < n; i++){
    // 가장 윗줄 탐색
    dfs(grid, 0, i, false);
    // 가장 아랫줄 탐색
    dfs(grid, m - 1, i, false);
}
for(int i = 1; i < m - 1; i++){
    // 가장 왼쪽줄 탐색
    dfs(grid, i, 0, false);
    // 가장 오른쪽줄 탐색
    dfs(grid, i, n - 1, false);
}

그 후 남아있는 안쪽 셀을 대상으로 탐색을 하게 되면 이때 남아있는 땅 타일들은 모두 바다로 둘러 쌓여있는 타일들이므로 isEnclosed를 true로 탐색하며 땅타일들에 대한 개수를 탐색한다.

// 나머지 안쪽 셀들을 탐색
for(int i = 1; i < m - 1; i++){
    for(int j = 1; j < n - 1; j++){
        dfs(grid, i, j, true);
    }
}

탐색이 종료된 후 구해진 정답을 return한다.

return answer;

최종 코드

class Solution {
    int answer = 0;

    public int numEnclaves(int[][] grid) {
        // 그리드 행 개수
        int m = grid.length;
        // 그리드 열 개수
        int n = grid[0].length;

        // 그리드의 가장자리에 땅이 있는 경우 해당 타일과 연결된 땅은 물에 둘러쌓여있지 않게되므로
        // 가장자리를 우선 탐색하여 연결된 모든 땅 타일을 물 타일로 변경
        for(int i = 0; i < n; i++){
            // 가장 윗줄 탐색
            dfs(grid, 0, i, false);
            // 가장 아랫줄 탐색
            dfs(grid, m - 1, i, false);
        }
        for(int i = 1; i < m - 1; i++){
            // 가장 왼쪽줄 탐색
            dfs(grid, i, 0, false);
            // 가장 오른쪽줄 탐색
            dfs(grid, i, n - 1, false);
        }
        // 나머지 안쪽 셀들을 탐색
        for(int i = 1; i < m - 1; i++){
            for(int j = 1; j < n - 1; j++){
                dfs(grid, i, j, true);
            }
        }

        return answer;
    }

    /**
     * @param grid  탐색 대상 그리드
     * @param row   현재 탐색중인 행의 인덱스
     * @param col   현재 탐색중인 열의 인덱스
     * @param inEnclosed 현재 탐색중인 타일이 물로 쌓여있는지 여부
     * @return
     */
    public void dfs(int[][] grid, int row, int col, boolean isEnclosed){
        // 좌표가 그리드를 벗어나는 경우 탐색 종료
        if(row < 0 || col < 0 || row >= grid.length || col >= grid[0].length) return;
        // 방문한 타일이 땅(1)인 경우 물(0)로 변경
        // 물로 둘러 쌓여있는 땅 타일인 경우 정답 카운트 증가
        // 상하좌우 타일 탐색하며 모든 인접한 땅타일을 물로 변경
        if(grid[row][col] == 1){
            grid[row][col] = 0;
            if(isEnclosed) answer++;
            dfs(grid, row, col+1, isEnclosed);
            dfs(grid, row, col-1, isEnclosed);
            dfs(grid, row+1, col, isEnclosed);
            dfs(grid, row-1, col, isEnclosed);
        }
    }
}

[LeetCode] 2405. Optimal Partition of String - Java

HYOJUN — Tue, 4 Apr 2023 13:15:49 +0900

https://leetcode.com/problems/optimal-partition-of-string/description/

Optimal Partition of String - LeetCode

Can you solve this real interview question? Optimal Partition of String - Given a string s, partition the string into one or more substrings such that the characters in each substring are unique. That is, no letter appears in a single substring more than o

leetcode.com

문제

Given a string s, partition the string into one or more substrings such that the characters in each substring are unique. That is, no letter appears in a single substring more than once.

Return the minimum number of substrings in such a partition.

Note that each character should belong to exactly one substring in a partition.

Example 1:

Input: s = "abacaba"
Output: 4
Explanation:
Two possible partitions are ("a","ba","cab","a") and ("ab","a","ca","ba").
It can be shown that 4 is the minimum number of substrings needed.

Example 2:

Input: s = "ssssss"
Output: 6
Explanation:
The only valid partition is ("s","s","s","s","s","s").

Constraints:

1 <= s.length <= 105
s consists of only English lowercase letters.

풀이

풀이 과정

알파벳 소문자로 이루어진 문자열 s가 주어질 때 문자열을 부분문자열들로 나누어 각 부분문자열에 중복된 글자가 존재하지 않는 부분문자열의 최소 개수를 구하는 문제이다.

정답을 저장할 변수를 선언하고 문자열의 길이가 최소 1이상이므로 1로 초기화한다.

// 최소 부분 문자열의 개수
// 문자열의 길이가 1이상이므로 1로 초기화
int answer = 1;

문자열을 부분문자열로 나눌 때 중복 사용된 글자를 판단하기 위해 Map을 사용한다.

// 문자열 탐색중 사용된 글자를 저장할 Map
Map<Character, Boolean> used = new HashMap<>();

문자열을 처음부터 탐색하며 각 글자를 Map에다 저장하고 Map에 저장된 글자가 사용된 경우, 즉 중복된 글자가 사용되는 경우에 그 부분에서 문자열을 나누고 정답 카운트를 증가시킨다.
모든 탐색이 종료된 후 구해진 정답을 return 한다.

// 문자열의 모든 글자를 탐색
for(int i = 0; i < s.length(); i++) {
    char c = s.charAt(i);
    // 현재 탐색중인 글자가 Map에 포함되어 있는 경우 
    if(used.containsKey(c)){
        // 정답 카운트 증가
        answer++;
        // Map을 초기화 하고 현재 글자 추가
        used.clear();
        used.put(c, true);
    }
    // 현재 탐색중인 글자가 Map에 포함되어 있는 경우 
    else {
        // Map에 현재 글자 추가
        used.put(c, true);
    }
}

return answer;

최종 코드

class Solution {
    public int partitionString(String s) {
        // 최소 부분 문자열의 개수
        // 문자열의 길이가 1이상이므로 1로 초기화
        int answer = 1;
        // 문자열 탐색중 사용된 글자를 저장할 Map
        Map<Character, Boolean> used = new HashMap<>();
        
        // 문자열의 모든 글자를 탐색
        for(int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            // 현재 탐색중인 글자가 Map에 포함되어 있는 경우 
            if(used.containsKey(c)){
                // 정답 카운트 증가
                answer++;
                // Map을 초기화 하고 현재 글자 추가
                used.clear();
                used.put(c, true);
            }
            // 현재 탐색중인 글자가 Map에 포함되어 있는 경우 
            else {
                // Map에 현재 글자 추가
                used.put(c, true);
            }
        }

        return answer;
    }
}

[LeetCode] 881. Boats to Save People - Java

HYOJUN — Mon, 3 Apr 2023 23:06:53 +0900

https://leetcode.com/problems/boats-to-save-people/description/

Boats to Save People - LeetCode

Can you solve this real interview question? Boats to Save People - You are given an array people where people[i] is the weight of the ith person, and an infinite number of boats where each boat can carry a maximum weight of limit. Each boat carries at most

leetcode.com

문제

You are given an array people where people[i] is the weight of the ith person, and an infinite number of boats where each boat can carry a maximum weight of limit. Each boat carries at most two people at the same time, provided the sum of the weight of those people is at most limit.

Return the minimum number of boats to carry every given person.

Example 1:

Input: people = [1,2], limit = 3
Output: 1
Explanation: 1 boat (1, 2)

Example 2:

Input: people = [3,2,2,1], limit = 3
Output: 3
Explanation: 3 boats (1, 2), (2) and (3)

Example 3:

Input: people = [3,5,3,4], limit = 5
Output: 4
Explanation: 4 boats (3), (3), (4), (5)

Constraints:

1 <= people.length <= 5 * 104
1 <= people[i] <= limit <= 3 * 104

풀이

풀이 과정

사람들의 몸무게가 담긴 배열 people과 보트에 한번에 탈 수 있는 최대 무게 limit가 주어질 때 모든 사람이 타기위해 필요한 보트의 최소 개수를 구하는 문제이다.
보트에는 동시에 두 사람까지 탑승할 수 있다.

가장 적은 보트를 사용하기 위해서는 사람들을 몸무게 순으로 정렬하여 몸무게가 많이 나가는 사람이 탑승할 때 가능한 경우 가벼운 사람이 함께 탑승하는 것이 가장 효율적이다.
따라서 사람들을 먼저 무게순으로 정렬하고 양쪽끝에서 부터 비교를 하도록한다.

int answer = 0;
        
// 사람들을 무게순으로 정렬
Arrays.sort(people);

// 왼쪽 인덱스
int left = 0;
// 오른쪽 인덱스
int right = people.length - 1;

왼쪽 인덱스와 오른쪽 인덱스가 교차할 때 까지 반복하며 탐색할 때마다 보트의 수를 하나씩 증가시키고
오른쪽 사람의 무게와 왼쪽 사람의 무게 합이 limit 이하인 경우 양쪽 인덱스를 모두 안쪽으로 한 칸씩 이동,
오른쪽 사람의 무게와 왼쪽 사람의 무게 합이 limit 초과하는 경우 오른쪽 인덱스만 이동한다.
왼쪽과 오른쪽 인덱스가 같은 경우에는 남은 사람이 한 사람이므로 보트 개수를 증가시키고 탐색을 바로 종료한다.

// 왼쪽과 오른쪽 인덱스가 교차할 때까지 반복
while(left <= right) {
    answer++;

    // 왼쪽과 오른쪽 인덱스가 같은 경우 탐색 종료
    if(left == right) break;

    // 오른쪽 사람의 무게와 왼쪽 사람의 무게 합이 limit 이하인 경우 양쪽인덱스를 모두 이동
    if(people[right] + people[left] <= limit) {
        right--;
        left++;
    }
    // 오른쪽 사람의 무게와 왼쪽 사람의 무게 합이 limit 초과하는 경우 오른쪽 인덱스만 이동
    else right--;;
}

최종적으로 구해진 보트의 개수를 return 한다.

return answer;

최종 코드

class Solution {
    public int numRescueBoats(int[] people, int limit) {
        int answer = 0;
        
        // 사람들을 무게순으로 정렬
        Arrays.sort(people);
        
        // 왼쪽 인덱스
        int left = 0;
        // 오른쪽 인덱스
        int right = people.length - 1;
        
        // 왼쪽과 오른쪽 인덱스가 교차할 때까지 반복
        while(left <= right) {
            answer++;
            
            // 왼쪽과 오른쪽 인덱스가 같은 경우 탐색 종료
            if(left == right) break;
            
            // 오른쪽 사람의 무게와 왼쪽 사람의 무게 합이 limit 이하인 경우 양쪽인덱스를 모두 이동
            if(people[right] + people[left] <= limit) {
                right--;
                left++;
            }
            // 오른쪽 사람의 무게와 왼쪽 사람의 무게 합이 limit 초과하는 경우 오른쪽 인덱스만 이동
            else right--;;
        }

        return answer;
    }
}

[LeetCode] 2300. Successful Pairs of Spells and Potions - Java

HYOJUN — Sun, 2 Apr 2023 23:53:54 +0900

https://leetcode.com/problems/successful-pairs-of-spells-and-potions/description/

Successful Pairs of Spells and Potions - LeetCode

Can you solve this real interview question? Successful Pairs of Spells and Potions - You are given two positive integer arrays spells and potions, of length n and m respectively, where spells[i] represents the strength of the ith spell and potions[j] repre

leetcode.com

문제

You are given two positive integer arrays spells and potions, of length n and m respectively, where spells[i] represents the strength of the ith spell and potions[j] represents the strength of the jth potion.

You are also given an integer success. A spell and potion pair is considered successful if the product of their strengths is at least success.

Return an integer array pairs of length n where pairs[i] is the number of potions that will form a successful pair with the ith spell.

Example 1:

Input: spells = [5,1,3], potions = [1,2,3,4,5], success = 7
Output: [4,0,3]
Explanation:
- 0th spell: 5 * [1,2,3,4,5] = [5,10,15,20,25]. 4 pairs are successful.
- 1st spell: 1 * [1,2,3,4,5] = [1,2,3,4,5]. 0 pairs are successful.
- 2nd spell: 3 * [1,2,3,4,5] = [3,6,9,12,15]. 3 pairs are successful.
Thus, [4,0,3] is returned.

Example 2:

Input: spells = [3,1,2], potions = [8,5,8], success = 16
Output: [2,0,2]
Explanation:
- 0th spell: 3 * [8,5,8] = [24,15,24]. 2 pairs are successful.
- 1st spell: 1 * [8,5,8] = [8,5,8]. 0 pairs are successful. 
- 2nd spell: 2 * [8,5,8] = [16,10,16]. 2 pairs are successful. 
Thus, [2,0,2] is returned.

Constraints:

n == spells.length
m == potions.length
1 <= n, m <= 105
1 <= spells[i], potions[i] <= 105
1 <= success <= 1010

풀이

풀이 과정

두 정수 배열 spells와 potions가 주어질 때 spells의 i번째 요소와 potions배열의 값의 곱이 success 이상이 되는 개수를 구하여 배열로 return 하는 문제이다.

이분 탐색을 이용하여 풀이한다.

우선 이분탐색을 이용하기 위해 potions 배열을 오름차순으로 정렬한다.

// potions 배열 오름차순으로 정렬
Arrays.sort(potions);

spells 배열의 모든 요소를 탐색하며 이분탐색을 실행하고 spells[i]의 값과 potions 배열의 각 요소의 곱이 success 이상이 되는 개수를 구하여 spells 배열에 업데이트한다.
spells배열의 모든 요소의 탐색이 끝나면 spells 배열을 return한다.

// spells 배열의 모든 요소 탐색
for(int i = 0; i < spells.length; i++) {
    // 이진 탐색으로 개수를 구하여 spells 배열에 값 업데이트
    spells[i] = binarySearch(spells[i], potions, success);
}

// 업데이트된 spells 배열을 return
return spells;

이분탐색에 사용하는 함수는 다음과 같다.
현재 탐색중인 spells 배열의 요소와 potions 배열, 그리고 구하고자 하는 값의 기준이 되는 target 변수를 인자로 받는다.

// 이분 탐색
public int binarySearch(int spell, int[] potions, long target) {

}

정렬된 potions 배열의 마지막 요소와 spell의 곱이 target보다 작은 경우 조건을 만족하는 경우가 없으므로 바로 0을 return한다.

// 정렬된 potions 배열의 마지막 요소와 spell의 곱이 target보다 작은 경우 0을 return
if((long)potions[potions.length - 1] * spell < target) return 0;

반대로 정렬된 potions 배열의 첫번째 요소와 spell의 곱이 target 이상인 경우 모든 요소가 조건을 만족하므로 potions 배열 길이를 return 한다.

// 정렬된 potions 배열의 첫번째 요소와 spell의 곱이 target 이상인 경우 potions 배열 길이를 return
if((long)potions[0] * spell >= target) return potions.length;

그리고 이분탐색에 사용할 변수들을 선언한다.

// target 이상이 되는 potions 요소의 개수
int result = 0;
// 시작지점 인덱스
int start = 0;
// 종료지점 인덱스
int end = potions.length - 1;
// 중간지점 인덱스
int mid;

중간지점의 인덱스를 계산하고 세 가지 경우로 나누어 탐색한다.

1. potions의 중간지점의 값과 spell의 곱이 target보다 크거나 같고, potions의 중간지점의 이전 값과 spell의 곱이 target보다 작은 경우

이 경우 중간지점이 문제에서 제시하는 조건을 만족하는 가장 작은값을 가진 지점이므로 중간 지점부터 배열의 끝까지의 길이를 결과값에 담고 탐색을 종료한다.

2. potions의 중간지점의 값과 spell의 곱이 target보다 작은 경우

두 번째 경우에는 문제에서 제시한 조건에 도달하기 위해서는 아직 중간지점 뒤로 이동하여야하므로 시작지점을 중간지점의 뒤로 이동한다.

3. 나머지 경우

나머지 경우에는 현재 문제에서 제시한 조건에는 도달하였지만 중간 이전 지점에도 조건을 만족하는 값들이 존재하므로 종료 지점을 중간지점 앞으로 이동한다.

위의 세가지 조건을 시작지점이 종료지점보다 커질 때까지 반복하여 탐색한다.

탐색이 종료될 때까지 조건을 만족하는 지점을 찾지 못한경우 0을 return

// 시작지점과 종료지점이 교차할 때 까지 반복
while(start <= end) {
    // 중간지점 인덱스 계산
    mid = (start + end) / 2;

    // potions의 중간지점의 값과 spell의 곱이 target보다 크거나 같고
    // potions의 중간지점의 이전 값과 spell의 곱이 target보다 작은 경우
    // 중간 지점부터 끝까지의 값을 result에 저장하고 탐색 종료
    if((long)potions[mid] * spell >= target && (long)potions[mid - 1] * spell < target) {
        result = potions.length - mid;
        break;
    }
    // potions의 중간지점의 값과 spell의 곱이 target보다 작은 경우
    // 시작지점을 중간지점 뒤로 설정
    else if((long)potions[mid] * spell < target) {
        start = mid + 1;
    }
    // 나머지 경우 종료지점을 중간지점 앞으로 설정
    else {
        end = mid - 1;
    }
}

return 0;

최종 코드

class Solution {
    public int[] successfulPairs(int[] spells, int[] potions, long success) {
        // potions 배열 오름차순으로 정렬
        Arrays.sort(potions);
        
        // spells 배열의 모든 요소 탐색
        for(int i = 0; i < spells.length; i++) {
            // 이진 탐색으로 개수를 구하여 spells 배열에 값 업데이트
            spells[i] = binarySearch(spells[i], potions, success);
        }

        // 업데이트된 spells 배열을 return
        return spells;
    }

    // 이분 탐색
    public int binarySearch(int spell, int[] potions, long target) {
        // 정렬된 potions 배열의 마지막 요소와 spell의 곱이 target보다 작은 경우 0을 return
        if((long)potions[potions.length - 1] * spell < target) return 0;
        // 정렬된 potions 배열의 첫번째 요소와 spell의 곱이 target 이상인 경우 potions 배열 길이를 return
        if((long)potions[0] * spell >= target) return potions.length;

        // target 이상이 되는 potions 요소의 개수
        int result = 0;
        // 시작지점 인덱스
        int start = 0;
        // 종료지점 인덱스
        int end = potions.length - 1;
        // 중간지점 인덱스
        int mid;
        
        // 시작지점과 종료지점이 교차할 때 까지 반복
        while(start <= end) {
            // 중간지점 인덱스 계산
            mid = (start + end) / 2;
            
            // potions의 중간지점의 값과 spell의 곱이 target보다 크거나 같고
            // potions의 중간지점의 이전 값과 spell의 곱이 target보다 작은 경우
            // 중간 지점부터 끝까지의 값을 return
            if((long)potions[mid] * spell >= target && (long)potions[mid - 1] * spell < target) {
                return potions.length - mid;
            }
            // potions의 중간지점의 값과 spell의 곱이 target보다 작은 경우
            // 시작지점을 중간지점 뒤로 설정
            else if((long)potions[mid] * spell < target) {
                start = mid + 1;
            }
            // 나머지 경우 종료지점을 중간지점 앞으로 설정
            else {
                end = mid - 1;
            }
        }
        
        return 0;
    }
}

[LeetCode] 1402. Reducing Dishes - Java/Dart

HYOJUN — Wed, 29 Mar 2023 11:16:50 +0900

https://leetcode.com/problems/reducing-dishes/description/

Reducing Dishes - LeetCode

Can you solve this real interview question? Reducing Dishes - A chef has collected data on the satisfaction level of his n dishes. Chef can cook any dish in 1 unit of time. Like-time coefficient of a dish is defined as the time taken to cook that dish incl

leetcode.com

문제

A chef has collected data on the satisfaction level of his n dishes. Chef can cook any dish in 1 unit of time.

Like-time coefficient of a dish is defined as the time taken to cook that dish including previous dishes multiplied by its satisfaction level i.e. time[i] * satisfaction[i].

Return the maximum sum of like-time coefficient that the chef can obtain after dishes preparation.

Dishes can be prepared in any order and the chef can discard some dishes to get this maximum value.

Example 1:

Input: satisfaction = [-1,-8,0,5,-9]
Output: 14
Explanation: After Removing the second and last dish, the maximum total like-time coefficient will be equal to (-1*1 + 0*2 + 5*3 = 14).
Each dish is prepared in one unit of time.

Example 2:

Input: satisfaction = [4,3,2]
Output: 20
Explanation: Dishes can be prepared in any order, (2*1 + 3*2 + 4*3 = 20)

Example 3:

Input: satisfaction = [-1,-4,-5]
Output: 0
Explanation: People do not like the dishes. No dish is prepared.

Constraints:

n == satisfaction.length
1 <= n <= 500
-1000 <= satisfaction[i] <= 1000

풀이

풀이 과정

요리사가 만드는 요리의 만족도가 담긴 배열 satisfaction이 주어지고 하나의 요리를 준비하는데 1만큼의 시간이 소요된다. 이때 요리사가 요리를 준비하는데 필요한 Like-time coefficient 값의 최대합을 구하는 문제이다.

문제에서 요구하는 Like-time coefficient는 n번째 요리를 준비할 때 현재까지 요리를 준비하는데 걸리는 시간과 현재 요리의 만족도의 곱을 의미한다. 예를 들어 3번째로 준비하는 요리의 만족도가 3이라면 이 요리의 Like-time coefficient는 3(시간) x 3(만족도) = 9가 된다. 따라서 n개의 요리를 준비할 때 각 요리의 Like-time coefficient 값의 합이 최대가 되는 값을 구하면 된다.

요리를 준비하는 순서는 상관이 없으며 최대값을 만들기 위하여 요리를 제외시키는 것도 가능하다.

풀이 과정은 다음과 같다.
먼저 요리의 만족도가 담겨있는 배열 satisfaction를 오름차순으로 정렬하여 큰 값 부터 낮은 값 순으로 탐색한다.
n번째 까지의 음식의 만족도의 합을 갱신하며 최대값에 더해나간다.
단 n번째 까지의 음식의 만족도의 합이 0 이하가 되는 경우 이 지점부터는 최대값이 줄어들게 되므로 그 지점에서의 최대값을 return한다.
탐색이 끝까지 종료되는 경우에도 마찬가지로 최대값을 return 해준다.

최종 코드

Java

class Solution {
    public int maxSatisfaction(int[] satisfaction) {
        // 최종적으로 반환할 최대값
        int maxSum = 0;
        
        // satisfaction 배열을 오름차순으로 정렬
        Arrays.sort(satisfaction);
        
        // 가장 높은 만족도 값이 음수인 경우 음식을 준비할 필요가 없으므로 0을 바로 return
        if(satisfaction[satisfaction.length - 1] < 0) return 0;
        
        // 지금까지 탐색한 각 음식의 만족도의 합
        int sum = 0;
        
        // 마지막 인덱스 부터 반대로 탐색
        for(int i = satisfaction.length -1; i >= 0; i--) {
            // 현재 음식의 만족도를 합계에 추가
            sum += satisfaction[i];
            
            // 현재까지 음식의 만족도의 합이 음수가 되는 경우
            // 이 지점부터는 최대값이 줄어들게 되므로 현재까지 탐색한 최대값을 return
            if(sum <= 0)  return maxSum;
            // 현재까지 음식의 만족도의 합이 양수가 되는 경우
            // 최대값에 만족도의 합을 추가
            else maxSum += sum;
        }

        return maxSum;
    }
}

Dart

class Solution {
  int maxSatisfaction(List<int> satisfaction) {
    // 최종적으로 반환할 최대값
    var maxSum = 0;
    
    // satisfaction 리스트를 오름차순으로 정렬
    satisfaction.sort();
    
    // 가장 높은 만족도 값이 음수인 경우 음식을 준비할 필요가 없으므로 0을 return
    if(satisfaction[satisfaction.length - 1] < 0) return 0;
    
    // 지금까지 탐색한 각 음식의 만족도의 합
    var sum = 0;
    
    for(var i = satisfaction.length - 1; i >= 0; i--){
        // 현재 음식의 만족도를 합계에 추가
        sum += satisfaction[i];
        
        if(sum <= 0) return maxSum;
        else maxSum += sum;
    }
    
    return maxSum;
  }
}

[LeetCode] 983. Minimum Cost For Tickets - Java/Dart

HYOJUN — Tue, 28 Mar 2023 13:45:22 +0900

https://leetcode.com/problems/minimum-cost-for-tickets/description/

Minimum Cost For Tickets - LeetCode

Can you solve this real interview question? Minimum Cost For Tickets - You have planned some train traveling one year in advance. The days of the year in which you will travel are given as an integer array days. Each day is an integer from 1 to 365. Train

leetcode.com

문제

You have planned some train traveling one year in advance. The days of the year in which you will travel are given as an integer array days. Each day is an integer from 1 to 365.

Train tickets are sold in three different ways:

a 1-day pass is sold for costs[0] dollars,
a 7-day pass is sold for costs[1] dollars, and
a 30-day pass is sold for costs[2] dollars.

The passes allow that many days of consecutive travel.

For example, if we get a 7-day pass on day 2, then we can travel for 7 days: 2, 3, 4, 5, 6, 7, and 8.

Return the minimum number of dollars you need to travel every day in the given list of days.

Example 1:

Input: days = [1,4,6,7,8,20], costs = [2,7,15]
Output: 11
Explanation: For example, here is one way to buy passes that lets you travel your travel plan:
On day 1, you bought a 1-day pass for costs[0] = $2, which covered day 1.
On day 3, you bought a 7-day pass for costs[1] = $7, which covered days 3, 4, ..., 9.
On day 20, you bought a 1-day pass for costs[0] = $2, which covered day 20.
In total, you spent $11 and covered all the days of your travel.

Example 2:

Input: days = [1,2,3,4,5,6,7,8,9,10,30,31], costs = [2,7,15]
Output: 17
Explanation: For example, here is one way to buy passes that lets you travel your travel plan:
On day 1, you bought a 30-day pass for costs[2] = $15 which covered days 1, 2, ..., 30.
On day 31, you bought a 1-day pass for costs[0] = $2 which covered day 31.
In total, you spent $17 and covered all the days of your travel.

Constraints:

1 <= days.length <= 365
1 <= days[i] <= 365
days is in strictly increasing order.
costs.length == 3
1 <= costs[i] <= 1000

풀이

풀이 과정

여행일이 담긴 배열 days 와 1-day pass, 7-day pass, 30-day pass의 가격이 담긴 costs 배열이 주어질 때 days 배열의 날짜를 모두 여행하기 위해 구매해야하는 pass의 최소 가격을 구하는 문제이다.

dp를 이용하여 1일 부터 마지막 날짜까지 각 날짜에 들어가는 최소 비용을 구해나가도록 풀이한다.

먼저 각 여행일의 최소 비용을 저장할 배열을 선언하고 days 배열의 마지막 날짜까지 탐색할 수 있도록 크기를 초기화한다.

// 각 여행일의 최소 비용을 저장할 배열을 선언하고
// days 배열의 마지막 날짜 + 1 크기로 초기화한다
int[] costSum = new int[days[days.length - 1] + 1];

실제 여행일에 해당하지 않는 날의 경우에는 비용이 발생하지 않으므로 전날까지의 비용을 그대로 가지고 있으면 된다.
실제 여행일을 판단하기 위해서 마찬가지로 days 배열의 마지막 날짜 + 1 크기의 boolean 배열을 선언하고 days 배열의 값에 해당하는 날짜들을 true로 세팅해준다.

// 실제 여행일에 해당하는 날짜를 저장하기위한 배열 선언 및
// days 배열에 해당하는 날짜 true로 세팅
boolean[] travelDay = new boolean[days[days.length - 1] + 1];

for(int day : days) {
    travelDay[day] = true;
}

1일부터 여행의 마지막 날까지 탐색하며 각 날짜에 필요한 최소 비용을 업데이트 한다.
현재 탐색중인 날짜가 실제 여행한 날짜에 포함되지 않는 경우는 이전 날짜의 비용을 유지하고 다음 탐색으로 넘어간다.
현재 탐색중인 날짜가 실제 여행한 날짜인 경우 다음 세 가지의 값 중 최소값으로 값을 업데이트한다.

1일 전과 1-day pass 비용의 합
7일 전과 7-day pass 비용의 합
30일 전과 30-day pass 비용의 합

for(int i = 1; i < costSum.length; i++) {
// 여행한 날짜에 포함되지 않는 경우
if(!travelDay[i]) {
    // 전일 비용을 유지하고 탐색을 계속
    costSum[i] = costSum[i - 1];
    continue;
}

// 1일 전과 1-day 패스 비용의 합
// 7일 전과 7-day 패스 비용의 합
// 30일 전과 30-day 패스 비용의 합 중 가장 작은 값을 현재 비용으로 저장 
costSum[i] = costSum[i - 1] + costs[0];
costSum[i] = Math.min(costSum[i], costSum[Math.max(0, i - 7)] + costs[1]);
costSum[i] = Math.min(costSum[i], costSum[Math.max(0, i - 30)] + costs[2]);
}

탐색이 종료된 후 여행의 마지막 날짜에 해당하는 값을 return 한다.

// 마지막 일자의 비용을 return
return costSum[costSum.length - 1];

최종 코드

Java

class Solution {
    public int mincostTickets(int[] days, int[] costs) {
        // 각 여행일의 최소 비용을 저장할 배열을 선언하고
        // days 배열의 마지막 날짜 + 1 크기로 초기화한다
        int[] costSum = new int[days[days.length - 1] + 1];
        // 실제 여행일에 해당하는 날짜를 저장하기위한 배열 선언 및
        // days 배열에 해당하는 날짜 true로 세팅
        boolean[] travelDay = new boolean[days[days.length - 1] + 1];
        
        for(int day : days) {
            travelDay[day] = true;
        }
        
        for(int i = 1; i < costSum.length; i++) {
            // 여행한 날짜에 포함되지 않는 경우
            if(!travelDay[i]) {
                // 전일 비용을 유지하고 탐색을 계속
                costSum[i] = costSum[i - 1];
                continue;
            }
            
            // 1일 전과 1-day 패스 비용의 합
            // 7일 전과 7-day 패스 비용의 합
            // 30일 전과 30-day 패스 비용의 합 중 가장 작은 값을 현재 비용으로 저장 
            costSum[i] = costSum[i - 1] + costs[0];
            costSum[i] = Math.min(costSum[i], costSum[Math.max(0, i - 7)] + costs[1]);
            costSum[i] = Math.min(costSum[i], costSum[Math.max(0, i - 30)] + costs[2]);
        }
        
        // 마지막 일자의 비용을 return
        return costSum[costSum.length - 1];
    }
}

Dart

class Solution {
  int mincostTickets(List<int> days, List<int> costs) {
    // 각 여행일의 최소 비용을 저장할 리스트를 선언하고
    // days 배열의 마지막 날짜 + 1 크기로 초기화한다
    List<int> costSum = List<int>.filled(days[days.length - 1] + 1, 0);
    // 실제 여행일에 해당하는 날짜를 저장하기위한 배열 선언 및
    // days 배열에 해당하는 날짜 true로 세팅
    List<bool> travelDay = List<bool>.filled(days[days.length - 1] + 1, false);
    
    for(var day in days){
        travelDay[day] = true;
    }
    
    for(var i = 1; i < costSum.length; i++){
        // 여행한 날짜에 포함되지 않는 경우
        if(!travelDay[i]){
        // 전일 비용을 유지하고 탐색을 계속
        costSum[i] = costSum[i - 1];
        continue;
        }
        
        // 1일 전과 1-day 패스 비용의 합
        // 7일 전과 7-day 패스 비용의 합
        // 30일 전과 30-day 패스 비용의 합 중 가장 작은 값을 현재 비용으로 저장 
        costSum[i] = costSum[i - 1] + costs[0];
        costSum[i] = min(costSum[i], costSum[max(0, i - 7)] + costs[1]);
        costSum[i] = min(costSum[i], costSum[max(0, i - 30)] + costs[2]);
    }
    
    // 마지막 일자의 비용을 return
    return costSum[costSum.length - 1];
  }
}

[LeetCode] 64. Minimum Path Sum - Java

HYOJUN — Mon, 27 Mar 2023 11:19:31 +0900

https://leetcode.com/problems/minimum-path-sum/description/

Minimum Path Sum - LeetCode

Can you solve this real interview question? Minimum Path Sum - Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum of all numbers along its path. Note: You can only move either down or rig

leetcode.com

문제

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

Example 1:

Input: grid = [[1,3,1],[1,5,1],[4,2,1]]
Output: 7
Explanation: Because the path 1 → 3 → 1 → 1 → 1 minimizes the sum.

Example 2:

Input: grid = [[1,2,3],[4,5,6]]
Output: 12

Constraints:

m == grid.length
n == grid[i].length
1 <= m, n <= 200
0 <= grid[i][j] <= 100

풀이

풀이 과정

양수값으로 이루어진 m x n 크기의 그리드가 주어졌을 때 왼쪽 상단지점에서 출발하여 오른쪽 하단에 도착하면서 지나는 지점들의 최소합을 구하는 문제이다.

다른 지점으로 이동하기 위해서는 오른쪽이나 아래쪽으로만 이동이 가능하다. 따라서 (a, b)지점으로 이동할 때의 경로 최소값은 왼쪽 지점 (a, b - 1)의 값과 위쪽 지점 (a - 1, b)의 값 중 최소값과 현재 지점의 값의 합이 된다.

다만 현재 탐색 지점이 가장 위쪽에 있는 경우에는 비교할 위쪽 지점이 없으므로 현재 지점의 값과 왼쪽 지점의 값의 합이 되고, 현재 탐색 지점이 가장 왼쪽에 있는 경우에는 비교할 왼쪽 지점이 없으므로 현재 지점의 값과 위쪽 지점의 값의 합이된다.

시작점(0, 0)부터 한 줄씩 탐색하며 값을 갱신하여 최종적으로 오른쪽 아래 지점의 값을 return 해준다.
1번 예시의 탐색과정을 그림으로 나타내면 다음과 같다.

우선 시작점은 변하지 않는 값이므로 탐색에서 제외한다.

다음으로 오른쪽 지점을 탐색한다. 현재 탐색중인 지점이 가장 위쪽에 있으므로 현재 지점의 값과 왼쪽 지점의 값의 합을 현재 지점의 값으로 저장한다.
현재 행의 나머지 지점에 대해서도 같은 탐색을 통해 값을 저장한다.

한 행에 대한 탐색이 종료되면 다음 행으로 넘어가 탐색을 계속한다.
두 번째 줄의 첫 번째 지점의 경우 가장 왼쪽에 존재하는 지점이므로 현재 지점의 값과 위쪽 지점의 값의 합을 현재 지점의 값으로 저장한다.
두 번째 지점의 경우에는 왼쪽 지점과 위쪽 지점이 모두 존재하므로 두 지점의 값 중 최소값과 현재 지점의 값을 더하여 현재 지점의 값으로 저장한다.

같은 방법으로 마지막 행까지 탐색을 마치면 가장 오른쪽 아래의 값이 경로의 최소값이 된다.

최종 코드

class Solution {
    public int minPathSum(int[][] grid) {
        // (0,0) 지점부터 오른쪽 방향으로 탐색
        for(int i = 0; i < grid.length; i++) {
            // 오른쪽 방향 탐색이 끝나면 아래쪽 방향 탐색
            for(int j = 0; j < grid[0].length; j++) {
                // (0,0) 지점은 탐색 제외
                if(i == 0 && j == 0) continue;
                
                // 가장 위쪽 지점 탐색중인 경우
                if(i == 0) {
                    // 현재 지점의 값과 왼쪽 지점의 값의 합을 현재 지점에 저장
                    grid[i][j] += grid[i][j - 1];
                }
                // 가장 왼쪽 지점를 탐색중인 경우
                else if(j == 0) {
                    // 현재 지점의 값과 위쪽 지점의 값의 합을 현재 지점에 저장
                    grid[i][j] += grid[i - 1][j];
                }
                // 그 외의 경우
                else {
                    // 왼쪽 지점의 값과 위쪽 지점의 값 중 최소값을 현재 지점의 값과 더하여 저장
                    grid[i][j] += Math.min(grid[i][j - 1], grid[i - 1][j]);
                }
            }
        }

		// 도착점의 값을 return
        return grid[grid.length - 1][grid[0].length - 1];
    }
}

[LeetCode] 105. Construct Binary Tree from Preorder and Inorder Traversal - Java

HYOJUN — Fri, 24 Mar 2023 14:12:12 +0900

https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/description/

Construct Binary Tree from Preorder and Inorder Traversal - LeetCode

Can you solve this real interview question? Construct Binary Tree from Preorder and Inorder Traversal - Given two integer arrays preorder and inorder where preorder is the preorder traversal of a binary tree and inorder is the inorder traversal of the same

leetcode.com

문제

Given two integer arrays preorder and inorder where preorder is the preorder traversal of a binary tree and inorder is the inorder traversal of the same tree, construct and return the binary tree.

Example 1:

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]

Example 2:

Input: preorder = [-1], inorder = [-1]
Output: [-1]

Constraints:

1 <= preorder.length <= 3000
inorder.length == preorder.length
-3000 <= preorder[i], inorder[i] <= 3000
preorder and inorder consist of unique values.
Each value of inorder also appears in preorder.
preorder is guaranteed to be the preorder traversal of the tree.
inorder is guaranteed to be the inorder traversal of the tree.

풀이

풀이 과정

이진 트리의 전위 순회 배열 preorder와 같은 트리의 중위 순회 배열 inorder배열이 주어졌을 때, 원래의 이진 트리를 구하는 문제이다.

우선 이진트리의 전위 순회와 중위 순회의 특징에 대해서 살펴보면
전위 순회의 경우 부모 노드 -> 왼쪽 노드 -> 오른쪽 노드 순으로 탐색을 하게 되고
중위 순회의 경위 왼쪽 노드 -> 부모 노드 -> 오른쪽 노드 순으로 탐색을 하게 된다.

따라서 전위 순회의 첫 노드는 이진트리의 root 노드가 되고 중위 순회 배열에서 이 root 노드를 기준으로 왼쪽에 있는 값들은 root 노드의 왼쪽 노드 값, 오른쪽에 있는 값들은 root 노드의 오른쪽 노드 값이 된다.
그림으로 살펴보면 아래와 같다.

이후에 왼쪽 노드와 오른쪽 노드에 대해서 같은 과정을 재귀 탐색하면 최종적으로 원래의 이진트리의 모습을 구할 수 있다.
해당 과정을 구현하는 과정과 코드는 다음과 같다.

재귀 탐색을 위한 함수를 생성한다.

/**
    * @param preorder      전위 순회 배열
    * @param inorder       중위 순회 배열
    * @param preIndex      preorder 배열에서 현재 노드의 인덱스
    * @param inStart       현재 탐색중인 inorder 배열의 시작 인덱스
    * @param inEnd         현재 탐색중인 inorder 배열의 종료 인덱스
    * @return              TreeNode
    */
    public TreeNode makeTree(int[] preorder, int[] inorder, int preIndex, int inStart, int inEnd) {
    
    }

우선 preorder 배열에서 현재 노드의 인덱스가 배열의 크기를 벗어나거나 inorder 배열의 시작 인덱스가 종료 인덱스보다 큰 경우 더 이상 하위 노드가 존재하지 않으므로 null을 return하여 탐색을 종료한다.

// preorder 배열에서 현재 노드의 인덱스가 배열의 크기를 벗어나거나
// inorder 배열의 시작 인덱스가 종료 인덱스보다 큰 경우 더 이상 노드가 존재하지 않으므로 null을 return
if(preIndex > preorder.length || inStart > inEnd) return null;

그렇지 않은 경우 preorder 배열에서 현재 노드의 인덱스 값에 해당하는 값으로 새 노드를 생성한다.

// 새로운 트리노드 생성
TreeNode node = new TreeNode(preorder[preIndex]);

현재 노드의 값을 기준으로 inorder 배열에서 현재 노드값에 해당하는 인덱스를 탐색한다. 이 인덱스를 기준으로 왼쪽과 오른쪽에 들어갈 노드를 나누게 된다.

// inorder 배열에서 현재 노드의 인덱스 탐색
// 해당 인덱스를 기준으로 노드를 좌우로 나눔
int inIndex = 0;

for(int i = inStart; i <= inEnd; i++) {
    if(node.val == inorder[i]) {
        inIndex = i;
        break;
    }
}

현재 노드의 왼쪽 오른쪽 노드에 해당하는 노드를 만들기 위해 함수를 재귀 호출하고 현재 노드를 return 한다.

// 현재 노드의 좌우 노드 추가
// 왼쪽 노드의 인덱스 = preorder 배열에서 현재 노드의 다음 인덱스
// 왼쪽 노드의 시작 인덱스 = inorder 배열의 시작 인덱스
// 왼쪽 노드의 종료 인덱스 = inorder 배열에서 현재 노드의 인덱스 - 1
node.left = makeTree(preorder, inorder, preIndex + 1, inStart, inIndex - 1);
// 오른쪽 노드의 시작 인덱스 = preorder 배열에서 현재 노드의 인덱스(preIndex) + inorder 배열에서 왼쪽 노드의 수(inIndex - inStart + 1)
// 오른쪽 노드의 시작 인덱스 = inorder 배열에서 현재 노드의 인덱스 + 1
// 오른쪽 노드의 종료 인덱스 = inorder 배열의 종료 인덱스
node.right = makeTree(preorder, inorder, preIndex + inIndex - inStart + 1, inIndex + 1, inEnd);

return node;

최종 코드

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return makeTree(preorder, inorder, 0, 0, inorder.length - 1);
    }

    /**
    * @param preorder      전위 순회 배열
    * @param inorder       중위 순회 배열
    * @param preIndex      preorder 배열에서 현재 노드의 인덱스
    * @param inStart       현재 탐색중인 inorder 배열의 시작 인덱스
    * @param inEnd         현재 탐색중인 inorder 배열의 종료 인덱스
    * @return              TreeNode
    */
    public TreeNode makeTree(int[] preorder, int[] inorder, int preIndex, int inStart, int inEnd) {
        
        // preorder 배열에서 현재 노드의 인덱스가 배열의 크기를 벗어나거나
        // inorder 배열의 시작 인덱스가 종료 인덱스보다 큰 경우 더 이상 하위 노드가 존재하지 않으므로 null을 return
        if(preIndex > preorder.length || inStart > inEnd) return null;
        
        // 새로운 트리노드 생성
        TreeNode node = new TreeNode(preorder[preIndex]);
        
        // inorder 배열에서 현재 노드의 인덱스 탐색
        // 해당 인덱스를 기준으로 노드를 좌우로 나눔
        int inIndex = 0;
        
        for(int i = inStart; i <= inEnd; i++) {
            if(node.val == inorder[i]) {
                inIndex = i;
                break;
            }
        }
        
        // 현재 노드의 좌우 노드 추가
        // 왼쪽 노드의 인덱스 = preorder 배열에서 현재 노드의 다음 인덱스
        // 왼쪽 노드의 시작 인덱스 = inorder 배열의 시작 인덱스
        // 왼쪽 노드의 종료 인덱스 = inorder 배열에서 현재 노드의 인덱스 - 1
        node.left = makeTree(preorder, inorder, preIndex + 1, inStart, inIndex - 1);
        // 오른쪽 노드의 시작 인덱스 = preorder 배열에서 현재 노드의 인덱스(preIndex) + inorder 배열에서 왼쪽 노드의 수(inIndex - inStart + 1)
        // 오른쪽 노드의 시작 인덱스 = inorder 배열에서 현재 노드의 인덱스 + 1
        // 오른쪽 노드의 종료 인덱스 = inorder 배열의 종료 인덱스
        node.right = makeTree(preorder, inorder, preIndex + inIndex - inStart + 1, inIndex + 1, inEnd);
        
        return node;
    }
}

[LeetCode] 1319. Number of Operations to Make Network Connected - Java

HYOJUN — Fri, 24 Mar 2023 09:58:04 +0900

https://leetcode.com/problems/number-of-operations-to-make-network-connected/description/

Number of Operations to Make Network Connected - LeetCode

Can you solve this real interview question? Number of Operations to Make Network Connected - There are n computers numbered from 0 to n - 1 connected by ethernet cables connections forming a network where connections[i] = [ai, bi] represents a connection b

leetcode.com

문제

There are n computers numbered from 0 to n - 1 connected by ethernet cables connections forming a network where connections[i] = [ai, bi] represents a connection between computers ai and bi. Any computer can reach any other computer directly or indirectly through the network.

You are given an initial computer network connections. You can extract certain cables between two directly connected computers, and place them between any pair of disconnected computers to make them directly connected.

Return the minimum number of times you need to do this in order to make all the computers connected. If it is not possible, return -1.

Example 1:

Input: n = 4, connections = [[0,1],[0,2],[1,2]]
Output: 1
Explanation: Remove cable between computer 1 and 2 and place between computers 1 and 3.

Example 2:

Input: n = 6, connections = [[0,1],[0,2],[0,3],[1,2],[1,3]]
Output: 2

Example 3:

Input: n = 6, connections = [[0,1],[0,2],[0,3],[1,2]]
Output: -1
Explanation: There are not enough cables.

Constraints:

1 <= n <= 105
1 <= connections.length <= min(n * (n - 1) / 2, 105)
connections[i].length == 2
0 <= ai, bi < n
ai != bi
There are no repeated connections.
No two computers are connected by more than one cable.

풀이

풀이 과정

0부터 n번까지의 컴퓨터가 있고 각 컴퓨터간의 연결 관계를 나타내는 2차원 배열 connections가 주어질 때 모든 컴퓨터가 연결 되기 위해서 케이블을 옮기는 과정의 최소 횟수를 구하는 문제이다. 만약 모든 컴퓨터를 연결하는 것이 불가능하다면 -1를 return한다.

이 문제에서 어떤 케이블을 어디에서 어디로 옮겨야 하는지는 크게 중요하지 않다.
n개의 노드를 모두 연결 시키기 위해서는 최소 n - 1개의 간선이 필요하다. 그렇기 때문에 만약 케이블의 개수를 나타내는 connections 배열의 길이가 n - 1보다 작은 경우에는 모든 컴퓨터를 연결하는 것이 불가능하다.

만약 케이블의 개수가 n - 1개 이상이라면 모든 컴퓨터를 연결하는 것이 가능하고 몇 번의 케이블 이동이 필요한지는 연결되어있지 않은 노드들의 개수만 파악하면 된다. 즉 비연결 그래프안에서 연결 그래프가 몇개나 있는지 탐색하는 것으로 생각하면 쉽게 풀이할 수 있다.

우선 탐색을 위해 사용할 변수를 선언해준다.
graph는 각 노드간의 연결관계를 저장할 리스트 변수이고 visited는 특정 노드에 방문을 했는지 여부를 저장하기 위한 배열이다.

List<ArrayList<Integer>> graph = new ArrayList<>();
boolean[] visited;

케이블의 개수가 n - 1개보다 적다면 연결이 불가능하므로 바로 -1을 return 해준다.

// n개의 컴퓨터를 모두 연결하기 위한 케이블의 최소 개수는 n - 1개
// 케이블의 개수가 n - 1개보다 적다면 연결이 불가하므로 -1을 return
if(connections.length < n - 1) return answer;

visited와 graph 변수를 각각 초기화 해준다.

// 각 노드의 방문 여부를 저장할 배열
visited = new boolean[n];

// 각 컴퓨터별 노드 생성
for(int i = 0; i < n; i++) {
    graph.add(new ArrayList<>());
}

// 각 케이블의 연결 관계를 저장
for(int[] connection : connections) {
    graph.get(connection[0]).add(connection[1]);
    graph.get(connection[1]).add(connection[0]);
}

각 노드를 순회하며 방문 여부를 탐색하고 현재 노드와 연결된 모든 노드를 방문하며 방문 여부를 업데이트 한다.
만약 현재 노드가 처음 방문한 노드인 경우에는 다른 노드와 연결되어있지 않았던 경우이므로 정답 카운트를 증가시켜준다. 단. 최초 탐색인 경우에는 항상 방문 여부가 false로 시작하므로 정답 카운트 변수는 -1부터 시작한다.

int answer = -1;

// 각 노드를 탐색
for(int i = 0; i < n; i++) {
    // 처음 방문 한 노드인 경우 다른 노드와 연결되어 있지 않았던 경우이므로 정답 카운트 증가
    // 단, 최초 탐색인 경우 항상 방문 여부가 false이므로 정답 카운트는 -1부터 시작
    // 현재 노드는 방문 처리하고 현재 노드와 연결된 모든 노드 탐색
    if(!visited[i]) {
        answer++;
        visited[i] = true;
        dfs(i);
    }
}

현재 노드와 연결되어있는 다른 노드들을 탐색하는데는 다음 함수를 사용한다.

public void dfs(int node) {
    // 현재 노드와 연결되어 있는 이웃 노드 탐색
    for(int neighbor : graph.get(node)) {
        // 처음 방문하는 노드인 경우 방문여부를 true로 바꾸고 다음 노드 탐색
        if(!visited[neighbor]) {
            visited[neighbor] = true;
            dfs(neighbor);
        }
    }
}

최종적으로 구해진 정답을 return 한다.

return answer;

최종 코드

class Solution {
    List<ArrayList<Integer>> graph = new ArrayList<>();
    boolean[] visited;

    public int makeConnected(int n, int[][] connections) {
        int answer = -1;

        // n개의 컴퓨터를 모두 연결하기 위한 케이블의 최소 개수는 n - 1개
        // 케이블의 개수가 n - 1개보다 적다면 연결이 불가하므로 -1을 return
        if(connections.length < n - 1) return answer;

        // 각 노드의 방문 여부를 저장할 배열
        visited = new boolean[n];
        
        // 각 컴퓨터별 노드 생성
        for(int i = 0; i < n; i++) {
            graph.add(new ArrayList<>());
        }
        
        // 각 케이블의 연결 관계를 저장
        for(int[] connection : connections) {
            graph.get(connection[0]).add(connection[1]);
            graph.get(connection[1]).add(connection[0]);
        }
        
        // 각 노드를 탐색
        for(int i = 0; i < n; i++) {
            // 처음 방문 한 노드인 경우 다른 노드와 연결되어 있지 않았던 경우이므로 정답 카운트 증가
            // 단, 최초 탐색인 경우 항상 방문 여부가 false이므로 정답 카운트는 -1부터 시작
            // 현재 노드는 방문 처리하고 현재 노드와 연결된 모든 노드 탐색
            if(!visited[i]) {
                answer++;
                visited[i] = true;
                dfs(i);
            }
        }

        return answer;
    }

    public void dfs(int node) {
        // 현재 노드와 연결되어 있는 이웃 노드 탐색
        for(int neighbor : graph.get(node)) {
            // 처음 방문하는 노드인 경우 방문여부를 true로 바꾸고 다음 노드 탐색
            if(!visited[neighbor]) {
                visited[neighbor] = true;
                dfs(neighbor);
            }
        }
    }
}

[LeetCode] 2348. Number of Zero-Filled Subarrays - Java

HYOJUN — Tue, 21 Mar 2023 13:36:51 +0900

https://leetcode.com/problems/number-of-zero-filled-subarrays/description/

Number of Zero-Filled Subarrays - LeetCode

Can you solve this real interview question? Number of Zero-Filled Subarrays - Given an integer array nums, return the number of subarrays filled with 0. A subarray is a contiguous non-empty sequence of elements within an array. Example 1: Input: nums =

leetcode.com

문제

Given an integer array nums, return the number of subarrays filled with 0.

A subarray is a contiguous non-empty sequence of elements within an array.

Example 1:

Input: nums = [1,3,0,0,2,0,0,4]
Output: 6
Explanation: 
There are 4 occurrences of [0] as a subarray.
There are 2 occurrences of [0,0] as a subarray.
There is no occurrence of a subarray with a size more than 2 filled with 0. Therefore, we return 6.

Example 2:

Input: nums = [0,0,0,2,0,0]
Output: 9
Explanation:
There are 5 occurrences of [0] as a subarray.
There are 3 occurrences of [0,0] as a subarray.
There is 1 occurrence of [0,0,0] as a subarray.
There is no occurrence of a subarray with a size more than 3 filled with 0. Therefore, we return 9.

Example 3:

Input: nums = [2,10,2019]
Output: 0
Explanation: There is no subarray filled with 0. Therefore, we return 0.

Constraints:

1 <= nums.length <= 105
-109 <= nums[i] <= 109

풀이

풀이 과정

-109 부터 109 까지의 정수로 이루어진 배열 nums가 주어질 때 0으로 채워진 부분배열의 총 개수를 구하는 문제이다.

길이가 N인 배열의 부분배열의 개수는 1부터 N까지의 합을 구하는 것과 같다.

배열	부분배열의 개수
[0]	1
[0, 0]	3
[0, 0, 0]	6
[0, 0, 0, 0]	10

따라서 nums 배열의 요소를 순차적으로 탐색하며 0으로 이루어진 부분배열의 길이를 구해가며 그 길이를 정답에 계속 더해나간다.

최종 코드

class Solution {
    public long zeroFilledSubarray(int[] nums) {
        long answer = 0;

        // 0으로 채워진 배열의 길이
        long length = 0;
        
        // nums 배열의 모든 요소 탐색
        for(int i = 0; i < nums.length; i++) {
            // 현재 탐색 요소가 0인 경우
            // 0으로 채워진 배열의 길이 증가 및 길이만큼 정답 카운트 증가
            if(nums[i] == 0) {
                length++;
                answer += length;
            }
            // 현재 탐색 요소가 0이 아닌 경우 0으로 채워진 배열의 길이 초기화
            else length = 0;
        }

        return answer;
    }
}

[LeetCode] 605. Can Place Flowers - Java

HYOJUN — Mon, 20 Mar 2023 22:27:12 +0900

https://leetcode.com/problems/can-place-flowers/description/

문제

You have a long flowerbed in which some of the plots are planted, and some are not. However, flowers cannot be planted in adjacent plots.

Given an integer array flowerbed containing 0's and 1's, where 0 means empty and 1 means not empty, and an integer n, return if n new flowers can be planted in the flowerbed without violating the no-adjacent-flowers rule.

Example 1:

Input: flowerbed = [1,0,0,0,1], n = 1
Output: true

Example 2:

Input: flowerbed = [1,0,0,0,1], n = 2
Output: false

Constraints:

1 <= flowerbed.length <= 2 * 104
flowerbed[i] is 0 or 1.
There are no two adjacent flowers in flowerbed.
0 <= n <= flowerbed.length

풀이

풀이 과정

꽃이 심어져 있거나 비어있는 화단의 배열 flowerbed와 심어야할 꽃의 개수 n이 주어진다.

연속한 화단에 꽃을 심을 수 없다고 할 때 현재 화단에 주어진 개수 만큼의 꽃을 심을 수 있는지 구하는 문제이다.

먼저 심어야 할 꽃이 없는 경우에는 바로 true를 return해 준다.

// 심어야 할 꽃이 없는 경우 바로 true를 return
if(n == 0) return true;

이후 화단을 차례대로 탐색한다.
현재 화단이 비어있는 경우는 다음 세가지 경우에 따라 꽃을 심을 수 있는지 없는지 체크한다.

1. 첫 번째 화단인 경우
flowerbed의 길이가 1이거나 오른쪽 화단이 비어있는 경우 꽃을 심을 수 있다.

// 첫 화단인 경우
if(i == 0) {
    // flowerbed의 길이가 1이거나 오른쪽 화단이 비어있는 경우
    if(flowerbed.length == 1 || flowerbed[i + 1] == 0) {
        // 현재 화단에 꽃을 심음
        flowerbed[i] = 1;
        // 심어야할 꽃의 수 감소
        n--;
    }
}

2. 마지막 화단인 경우
왼쪽 화단이 비어있는 겨웅 꽃을 심을 수 있다.

// 마지막 화단인 경우
else if(i == flowerbed.length - 1) {
    // 왼쪽 화단이 비어있는 경우
    if(flowerbed[i - 1] == 0) {
    /// 현재 화단에 꽃을 심음
        flowerbed[i] = 1;
        // 심어야할 꽃의 수 감소
        n--;
    }
}

3. 나머지 화단인 경우
좌우의 화단이 모두 비어있는 경우 꽃을 심을 수 있다.

// 나머지 화단인 경우
else {
    // 좌우의 화단이 모두 비어있는경우
    if(flowerbed[i - 1] == 0 && flowerbed[i + 1] == 0) {
        // 현재 화단에 꽃을 심음
        flowerbed[i] = 1;
        // 심어야할 꽃의 수 감소
        n--;
    }
}

현재 화단을 탐색한 후 심어야 할 꽃의 수가 0이 되는 경우 true를 return한다.

// 심어야할 꽃의 수가 0이 되는 경우 true를 return
if(n == 0) return true;

모든 탐색이 종료된 후 남은 꽃의 수가 0인 경우에는 true, 0보다 큰 경우에는 false를 return 한다.

// 남은 꽃의 수가 0인 경우 true, 0보다 큰 경우 false를 return
return (n == 0) ? true : false;

최종 코드

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        // 심어야 할 꽃이 없는 경우 바로 true를 return
        if(n == 0) return true;

        for(int i = 0; i < flowerbed.length; i++) {
            // 현재 화단이 비어있는 경우
            if(flowerbed[i] == 0){
                // 첫 화단인 경우
                if(i == 0) {
                    // flowerbed의 길이가 1이거나 오른쪽 화단이 비어있는 경우
                    if(flowerbed.length == 1 || flowerbed[i + 1] == 0) {
                        // 현재 화단에 꽃을 심음
                        flowerbed[i] = 1;
                        // 심어야할 꽃의 수 감소
                        n--;
                    }
                }
                // 마지막 화단인 경우
                else if(i == flowerbed.length - 1) {
                    // 왼쪽 화단이 비어있는 경우
                    if(flowerbed[i - 1] == 0) {
                    /// 현재 화단에 꽃을 심음
                        flowerbed[i] = 1;
                        // 심어야할 꽃의 수 감소
                        n--;
                    }
                }
                // 나머지 화단인 경우
                else {
                    // 좌우의 화단이 모두 비어있는경우
                    if(flowerbed[i - 1] == 0 && flowerbed[i + 1] == 0) {
                        // 현재 화단에 꽃을 심음
                        flowerbed[i] = 1;
                        // 심어야할 꽃의 수 감소
                        n--;
                    }
                }
            }
            // 심어야할 꽃의 수가 0이 되는 경우 true를 return
            if(n == 0) return true;
        }

        // 남은 꽃의 수가 0인 경우 true, 0보다 큰 경우 false를 return
        return (n == 0) ? true : false;
    }
}

[Programmers] 점프와 순간 이동 - Java

HYOJUN — Fri, 17 Mar 2023 09:58:13 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/12980

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

문제

문제 설명
OO 연구소는 한 번에 K 칸을 앞으로 점프하거나, (현재까지 온 거리) x 2 에 해당하는 위치로 순간이동을 할 수 있는 특수한 기능을 가진 아이언 슈트를 개발하여 판매하고 있습니다. 이 아이언 슈트는 건전지로 작동되는데, 순간이동을 하면 건전지 사용량이 줄지 않지만, 앞으로 K 칸을 점프하면 K 만큼의 건전지 사용량이 듭니다. 그러므로 아이언 슈트를 착용하고 이동할 때는 순간 이동을 하는 것이 더 효율적입니다. 아이언 슈트 구매자는 아이언 슈트를 착용하고 거리가 N 만큼 떨어져 있는 장소로 가려고 합니다. 단, 건전지 사용량을 줄이기 위해 점프로 이동하는 것은 최소로 하려고 합니다. 아이언 슈트 구매자가 이동하려는 거리 N이 주어졌을 때, 사용해야 하는 건전지 사용량의 최솟값을 return하는 solution 함수를 만들어 주세요.

예를 들어 거리가 5만큼 떨어져 있는 장소로 가려고 합니다.
아이언 슈트를 입고 거리가 5만큼 떨어져 있는 장소로 갈 수 있는 경우의 수는 여러 가지입니다.

처음 위치 0 에서 5 칸을 앞으로 점프하면 바로 도착하지만, 건전지 사용량이 5 만큼 듭니다.
처음 위치 0 에서 2 칸을 앞으로 점프한 다음 순간이동 하면 (현재까지 온 거리 : 2) x 2에 해당하는 위치로 이동할 수 있으므로 위치 4로 이동합니다. 이때 1 칸을 앞으로 점프하면 도착하므로 건전지 사용량이 3 만큼 듭니다.
처음 위치 0 에서 1 칸을 앞으로 점프한 다음 순간이동 하면 (현재까지 온 거리 : 1) x 2에 해당하는 위치로 이동할 수 있으므로 위치 2로 이동됩니다. 이때 다시 순간이동 하면 (현재까지 온 거리 : 2) x 2 만큼 이동할 수 있으므로 위치 4로 이동합니다. 이때 1 칸을 앞으로 점프하면 도착하므로 건전지 사용량이 2 만큼 듭니다.

위의 3가지 경우 거리가 5만큼 떨어져 있는 장소로 가기 위해서 3번째 경우가 건전지 사용량이 가장 적으므로 답은 2가 됩니다.

제한 사항

숫자 N: 1 이상 10억 이하의 자연수
숫자 K: 1 이상의 자연수

입출력 예

N	Result
5	2
6	2
5000	5

입출력 예 설명

입출력 예 #1
위의 예시와 같습니다.

입출력 예 #2
처음 위치 0 에서 1 칸을 앞으로 점프한 다음 순간이동 하면 (현재까지 온 거리 : 1) x 2에 해당하는 위치로 이동할 수 있으므로 위치 2로 이동합니다. 이때 1 칸을 앞으로 점프하면 위치3으로 이동합니다. 이때 다시 순간이동 하면 (현재까지 온 거리 : 3) x 2 이동할 수 있으므로 위치 6에 도착합니다. 이 경우가 건전지 사용량이 가장 적으므로 2를 반환해주면 됩니다.

입출력 예 #3
위와 같은 방식으로 합니다.

풀이

풀이 과정

점프를 하여 이동하는 경우에만 건전지를 사용하므로 최대한 점프를 하지 않고 순간이동으로만 이동을 하면 된다.

순간이동을 하는 경우에는 현재 거리의 두 배만큼 이동을 하기 때문에 순간이동을 하면 항상 짝수위치에만 도착하게 된다.
따라서 도착 지점부터 반대로 탐색하며 현재 위치가 짝수인 경우 그 절반의 위치로 순간이동 하고 홀수인 경우에는 한 칸만 점프로 이동하여 거리가 0이 될 때까지 반복하며 탐색한다.

최종 코드

public class Solution {
    public int solution(int n) {
        int ans = 0;

        // 도착 지점부터 반대로 탐색
        // 거리가 0이 될 때까지 반복
        while(n > 0) {
            // 현재 위치가 짝수인 경우 절반위치로 순간이동
            if(n % 2 == 0) {
                n /= 2;
            }
            // 현재 위치가 홀수인 경우 한 칸 전으로 점프, 건전지 사용량 1 증가
            else {
                n--;
                ans++;
            }
        }

        return ans;
    }
}

[LeetCode] 211. Design Add and Search Words Data Structure - Java

HYOJUN — Sun, 26 Feb 2023 23:37:58 +0900

https://leetcode.com/problems/design-add-and-search-words-data-structure/description/

Design Add and Search Words Data Structure - LeetCode

Can you solve this real interview question? Design Add and Search Words Data Structure - Design a data structure that supports adding new words and finding if a string matches any previously added string. Implement the WordDictionary class: * WordDictionar

leetcode.com

문제

Design a data structure that supports adding new words and finding if a string matches any previously added string.

Implement the WordDictionary class:

WordDictionary() Initializes the object.
void addWord(word) Adds word to the data structure, it can be matched later.
bool search(word) Returns true if there is any string in the data structure that matches word or false otherwise. word may contain dots '.' where dots can be matched with any letter.

Example:

Input
["WordDictionary","addWord","addWord","addWord","search","search","search","search"]
[[],["bad"],["dad"],["mad"],["pad"],["bad"],[".ad"],["b.."]]
Output
[null,null,null,null,false,true,true,true]

Explanation
WordDictionary wordDictionary = new WordDictionary();
wordDictionary.addWord("bad");
wordDictionary.addWord("dad");
wordDictionary.addWord("mad");
wordDictionary.search("pad"); // return False
wordDictionary.search("bad"); // return True
wordDictionary.search(".ad"); // return True
wordDictionary.search("b.."); // return True

Constraints:

1 <= word.length <= 25
word in addWord consists of lowercase English letters.
word in search consist of '.' or lowercase English letters.
There will be at most 3 dots in word for search queries.
At most 104 calls will be made to addWord and search.

풀이

풀이 과정

문제에서 주어진 조건에 따라 단어를 저장하고 단어를 찾아내는 사전 프로그램을 작성하는 문제이다.
바로 이전에 풀이했던 208. Implement Trie (Prefix Tree) 와 유사한 문제이다.

https://hyojun.tistory.com/entry/LeetCode-208-Implement-Trie-Prefix-Tree-Java-%EC%9E%91%EC%84%B1%EC%A4%91

[LeetCode] 208. Implement Trie (Prefix Tree) - Java

https://leetcode.com/problems/implement-trie-prefix-tree/ Implement Trie (Prefix Tree) - LeetCode Can you solve this real interview question? Implement Trie (Prefix Tree) - A trie [https://en.wikipedia.org/wiki/Trie] (pronounced as "try") or prefix tree is

hyojun.tistory.com

우선 객체를 생성하고 단어를 추가하는 과정은 Implement Trie를 구현하는 과정과 동일하다.

public class Node {
    // 현재 노드까지가 단어인지 아닌지 판단할 변수
    boolean isWord;
    // 현재 노드의 자식노드를 저장할 Map
    Map<Character, Node> children = new HashMap<>();
}

class WordDictionary {
    // 노드 변수 선언
    Node root;
    
    public WordDictionary() {
        // 새로운 루트 노드 생성
        root = new Node();
    }
    
    public void addWord(String word) {
        // 트리 최상위 노드
        Node node = root;

        // 문자열 끝까지 탐색
        for(int i = 0; i < word.length(); i++){
            // 현재 탐색중인 문자
            Character c = word.charAt(i);
            // 자식 노드에 현재 탐색중인 문자가 없는 경우
            if(!node.children.containsKey(c)){
                // 노드를 새로 생성하고 자식노드에 삽입
                node.children.put(c, new Node());
            } 

            // 노드를 갱신
            node = node.children.get(c);
            // 문자열을 끝까지 탐색한 경우 단어 여부 업데이트
            if(i == word.length() - 1){
                node.isWord = true;
            }
        }
    }

Implement Trie와 다른 점은 문자를 찾는 search 함수에서 문자가 알파벳이 아닌 '.' 이 주어질 수 있다는 점인데 '.'은 모든 알파벳에 대응될 수 있는 것으로 간주한다.

그렇기 때문에 '.'이 오는 경우 DFS를 통하여 모든 자식 노드들을 탐색해 볼수 있도록 search 함수만 약간의 수정을 해주도록 한다.

DFS 탐색을 할 수 있도록 함수를 하나 생성해주고 현재 탐색중인 노드와, 찾고자 하는 단어, 그리고 현재 탐색중인 인덱스를 파라미터로 전달한다.

 public boolean dfs(Node root, String word, int idx) {
 
 }

문자열을 끝까지 탐색한 경우 단어 여부에 따라 결과값을 return한다.

// 문자열을 끝까지 탐색한 경우 단어 여부에 따라 결과값을 return
if(idx == word.length()) return root.isWord;

그 후 현재 탐색중인 문자에 따라 두 가지 경우로 나누어 탐색을 진행한다.
먼저 현재 탐색중인 문자가 '.'인 경우, 현재 노드의 자식노드들을 인덱스를 증가시키며 재귀탐색하여 true가 되는 경우가 존재한다면 true를 return한다.

// 현재 탐색중인 문자
Character c = word.charAt(idx);

// 현재 탐색중인 문자가 '.'인 경우
if(c == '.') {
    // 현재 노드의 자식노드들을 탐색하여 true가 되는 경우 true를 return
    for(Character key : root.children.keySet()) {
       if(dfs(root.children.get(key), word, idx + 1)) return true;
    }
}

다음으로 현재 탐색중인 문자가 알파벳인 경우, 자식노드에 현재 탐색중인 문자가 존재하는지 여부를 확인한다.
만약 현재 탐색중인 문자가 존재하지 않는다면 false를 return하고, 탐색중인 문자가 존재한다면 마찬가지로 인덱스를 증가시키며 자식노드를 탐색한다.

// 현재 탐색중인 문자가 알파벳인 경우
else {
    // 자식노드에 현재 탐색중인 문자가 존재하지 않는 경우 false를 return
    if(root.children.get(c) == null) return false;
    // 자식노드에 현재 탐색중인 문자가 존재하는 경우 다음 레벨을 탐색
    return dfs(root.children.get(c), word, idx + 1);
}

최종 코드

public class Node {
    // 현재 노드까지가 단어인지 아닌지 판단할 변수
    boolean isWord;
    // 현재 노드의 자식노드를 저장할 Map
    Map<Character, Node> children = new HashMap<>();
}

class WordDictionary {
    // 노드 변수 선언
    Node root;
    
    public WordDictionary() {
        // 새로운 루트 노드 생성
        root = new Node();
    }
    
    public void addWord(String word) {
        // 트리 최상위 노드
        Node node = root;

        // 문자열 끝까지 탐색
        for(int i = 0; i < word.length(); i++){
            // 현재 탐색중인 문자
            Character c = word.charAt(i);
            // 자식 노드에 현재 탐색중인 문자가 없는 경우
            if(!node.children.containsKey(c)){
                // 노드를 새로 생성하고 자식노드에 삽입
                node.children.put(c, new Node());
            } 

            // 노드를 갱신
            node = node.children.get(c);
            // 문자열을 끝까지 탐색한 경우 단어 여부 업데이트
            if(i == word.length() - 1){
                node.isWord = true;
            }
        }
    }
    
    public boolean search(String word) {
        return dfs(root, word, 0);
    }
    
    public boolean dfs(Node root, String word, int idx) {
        // 문자열을 끝까지 탐색한 경우 단어 여부에 따라 결과값을 return
        if(idx == word.length()) return root.isWord;
        
        // 현재 탐색중인 문자
        Character c = word.charAt(idx);
        
        // 현재 탐색중인 문자가 '.'인 경우
        if(c == '.') {
            // 현재 노드의 자식노드들을 탐색하여 true가 되는 경우 true를 return
            for(Character key : root.children.keySet()) {
               if(dfs(root.children.get(key), word, idx + 1)) return true;
            }
        }
        // 현재 탐색중인 문자가 알파벳인 경우
        else {
            // 자식노드에 현재 탐색중인 문자가 존재하지 않는 경우 false를 return
            if(root.children.get(c) == null) return false;
            // 자식노드에 현재 탐색중인 문자가 존재하는 경우 다음 레벨을 탐색
            return dfs(root.children.get(c), word, idx + 1);
        }
        
        return false;
    }
}

/**
 * Your WordDictionary object will be instantiated and called as such:
 * WordDictionary obj = new WordDictionary();
 * obj.addWord(word);
 * boolean param_2 = obj.search(word);
 */

[LeetCode] 208. Implement Trie (Prefix Tree) - Java

HYOJUN — Wed, 15 Feb 2023 16:59:31 +0900

https://leetcode.com/problems/implement-trie-prefix-tree/

Implement Trie (Prefix Tree) - LeetCode

Can you solve this real interview question? Implement Trie (Prefix Tree) - A trie [https://en.wikipedia.org/wiki/Trie] (pronounced as "try") or prefix tree is a tree data structure used to efficiently store and retrieve keys in a dataset of strings. There

leetcode.com

문제

A trie (pronounced as "try") or prefix tree is a tree data structure used to efficiently store and retrieve keys in a dataset of strings. There are various applications of this data structure, such as autocomplete and spellchecker.

Implement the Trie class:

Trie() Initializes the trie object.
void insert(String word) Inserts the string word into the trie.
boolean search(String word) Returns true if the string word is in the trie (i.e., was inserted before), and false otherwise.
boolean startsWith(String prefix) Returns true if there is a previously inserted string word that has the prefix prefix, and false otherwise.

Example 1:

Input
["Trie", "insert", "search", "search", "startsWith", "insert", "search"]
[[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
Output
[null, null, true, false, true, null, true]

Explanation
Trie trie = new Trie();
trie.insert("apple");
trie.search("apple");   // return True
trie.search("app");     // return False
trie.startsWith("app"); // return True
trie.insert("app");
trie.search("app");     // return True

Constraints:

1 <= word.length, prefix.length <= 2000
word and prefix consist only of lowercase English letters.
At most 3 * 104 calls in total will be made to insert, search, and startsWith.

풀이

풀이 과정

Trie ( prefix tree ) 자료구조는 문자열 데이터를 효율적으로 저장하고 찾는데 사용하는 트리 데이터 구조의 한 종류이다. 때문에 자동완성이나 맞춤법 검사등의 프로그램에 사용된다.

주어진 조건에 따라서 Trie 구조를 이용한 문자열 검색기능을 만들어야하는 문제이다.
구현 해야하는 클래스는 새로운 Trie를 생성하기위한 클래스 Trie, 단어 저장을 위한 insert, 단어 탐색을 위한 search, 주어진 문자로 시작하는 단어 탐색을 위한 startsWith이다.

먼저 구현하고자 하는 Trie의 구조를 그림으로 표현해보면 아래와 같다.

다음 구조는 "catch", "cake", "cafe" 3개의 단어를 저장하고 있는 Trie 트리이다.
파란색 바탕으로 칠해진 노드는 해당노드가 단어의 마지막 문자가 될 수 있다는 의미이다.
예를 들어 3개의 단어가 저장되어 있을 때 단어 "cat"을 찾고자 한다면 왼쪽 노드를 따라 "cat"이라는 단어가 연결되어 존재한다. 하지만 t가 단어의 끝이 아니기 때문에 "cat"이라는 단어는 현재 트리에 존재하지 않는다고 할 수 있다.

이러한 구조를 코드로 구현하기 위해 우선 트리의 노드가 될 클래스를 구현한다.
노드 클래스는 현재 노드가 단어의 끝인지 아닌지 판단할 변수와 현재 노드의 자식노드를 저장할 Map으로 구성한다.

// 트리 노드
class Node {
    // 현재 노드까지가 단어인지 아닌지 판단할 변수
    boolean isWord;
    // 현재 노드의 자식노드를 저장할 Map
    Map<Character, Node> children = new HashMap<>();
}

본격적으로 문제에서 주어진 조건을 구현하기 위해 만들어둔 트리 노드를 변수로 선언하고 Trie 클래스에서 새로운 노드를 생성하여 노드 변수에 저장한다.

class Trie {
    // 노드 변수 선언
    Node root;

    public Trie() {
        // 새로운 루트 노드 생성
        root = new Node();
    }
    ...

다음으로 단어를 저장하는 insert 함수를 작성한다.
insert 함수 안에서는 선언한 노드 변수를 새로운 변수에 담고 주어진 단어를 각 문자별로 반복하여 탐색한다.
만약 현재 탐색중인 문자가 현재 노드의 자식 노드에 존재하지 않는 경우 노드를 새로 생성하여 자식 노드에 추가한다.
그 후 현재 노드를 현재 탐색중인 문자에 해당하는 자식노드로 갱신한다.
반복하여 탐색하고 문자열을 끝까지 탐색한 경우에는 현재 노드에 단어인지 아닌지의 여부를 업데이트한다.

public void insert(String word) {
    // 트리 최상위 노드
    Node node = root;

    // 문자열 끝까지 탐색
    for(int i = 0; i < word.length(); i++){
        // 현재 탐색중인 문자
        Character c = word.charAt(i);
        // 자식 노드에 현재 탐색중인 문자가 없는 경우
        if(!node.children.containsKey(c)){
            // 노드를 새로 생성하고 자식노드에 삽입
            node.children.put(c, new Node());
        } 

        // 노드를 갱신
        node = node.children.get(c);
        // 문자열을 끝까지 탐색한 경우 단어 여부 업데이트
        if(i == word.length() - 1){
            node.isWord = true;
        }
    }
}

주어진 단어를 탐색하는 search와 주어진 단어로 시작하는 문자를 탐색하는 startsWith를 구현하는 과정은 거의 똑같다고 할 수 있다.
마찬가지로 주어진 문자를 처음부터 끝까지 탐색하며 자식 노드에 해당 문자가 존재하면 노드를 갱신해가며 자식노드를 따라가면 된다. 만약 문자열을 끝까지 탐색하기전에 자식 노드에 현재 탐색하는 문자가 존재하지 않는다면 주어진 단어는 존재하지 않는 단어이므로 바로 false를 return해주면 된다.

public boolean search(String word) {
    // 트리 최상위 노드
    Node node = root;

    // 문자열 끝까지 탐색
    for(int i = 0; i < word.length(); i++){
        // 현재 탐색중인 문자
        Character c = word.charAt(i);
        // 자식 노드에 현재 탐색중인 문자가 존재하는 경우
        // 해당 자식노드로 노드 갱신
        if(node.children.containsKey(c)) node = node.children.get(c);
        // 자식 노드에 현재 탐색중인 문자가 존재하지 않는 경우 false를 return
        else return false;
    }

    // 마지막까지 탐색 후 현재 노드까지 단어가 존재하면 true 존재하지않으면 false를 return
    return node.isWord? true : false;
}

search 함수와 startsWith 함수의 유일한 차이점은 마지막 return 조건이다.
search 함수 같은 경우에는 현재 노드가 단어가 될 수 있는 마지막 노드인지 여부를 체크해야하지만 startsWith 함수 같은 경우에는 단어 앞에 해당 문자만 포함이 되어있으면 되기 때문에 마지막 노드가 단어의 마지막이여도 되고 마지막이 아니여도 상관없이 true를 return할 수 있다.

public boolean startsWith(String prefix) {
    // 트리 최상위 노드
    Node node = root;

    // 문자열 끝까지 탐색
    for(int i = 0; i < prefix.length(); i++){
        // 현재 탐색중인 문자
        Character c = prefix.charAt(i);
        // 자식 노드에 현재 탐색중인 문자가 존재하는 경우
        // 해당 자식노드로 노드 갱신
        if(node.children.containsKey(c)) node = node.children.get(c);
        // 자식 노드에 현재 탐색중인 문자가 존재하지 않는 경우 false를 return
        else return false;
    }

    // prefix 마지막 까지 탐색을 했다면 해당 prefix로 시작하는 단어 존재
    return true;
}

최종 코드

// 트리 노드
class Node {
    // 현재 노드까지가 단어인지 아닌지 판단할 변수
    boolean isWord;
    // 현재 노드의 자식노드를 저장할 Map
    Map<Character, Node> children = new HashMap<>();
}

class Trie {
    // 노드 변수 선언
    Node root;

    public Trie() {
        // 새로운 루트 노드 생성
        root = new Node();
    }
    
    public void insert(String word) {
        // 트리 최상위 노드
        Node node = root;

        // 문자열 끝까지 탐색
        for(int i = 0; i < word.length(); i++){
            // 현재 탐색중인 문자
            Character c = word.charAt(i);
            // 자식 노드에 현재 탐색중인 문자가 없는 경우
            if(!node.children.containsKey(c)){
                // 노드를 새로 생성하고 자식노드에 삽입
                node.children.put(c, new Node());
            } 

            // 노드를 갱신
            node = node.children.get(c);
            // 문자열을 끝까지 탐색한 경우 단어 여부 업데이트
            if(i == word.length() - 1){
                node.isWord = true;
            }
        }
    }
    
    public boolean search(String word) {
        // 트리 최상위 노드
        Node node = root;

        // 문자열 끝까지 탐색
        for(int i = 0; i < word.length(); i++){
            // 현재 탐색중인 문자
            Character c = word.charAt(i);
            // 자식 노드에 현재 탐색중인 문자가 존재하는 경우
            // 해당 자식노드로 노드 갱신
            if(node.children.containsKey(c)) node = node.children.get(c);
            // 자식 노드에 현재 탐색중인 문자가 존재하지 않는 경우 false를 return
            else return false;
        }
        
        // 마지막까지 탐색 후 현재 노드까지 단어가 존재하면 true 존재하지않으면 false를 return
        return node.isWord? true : false;
    }
    
    public boolean startsWith(String prefix) {
        // 트리 최상위 노드
        Node node = root;

        // 문자열 끝까지 탐색
        for(int i = 0; i < prefix.length(); i++){
            // 현재 탐색중인 문자
            Character c = prefix.charAt(i);
            // 자식 노드에 현재 탐색중인 문자가 존재하는 경우
            // 해당 자식노드로 노드 갱신
            if(node.children.containsKey(c)) node = node.children.get(c);
            // 자식 노드에 현재 탐색중인 문자가 존재하지 않는 경우 false를 return
            else return false;
        }
        
        // prefix 마지막 까지 탐색을 했다면 해당 prefix로 시작하는 단어 존재
        return true;
    }
}

/**
 * Your Trie object will be instantiated and called as such:
 * Trie obj = new Trie();
 * obj.insert(word);
 * boolean param_2 = obj.search(word);
 * boolean param_3 = obj.startsWith(prefix);
 */

[LeetCode] 76. Minimum Window Substring - Java

HYOJUN — Tue, 14 Feb 2023 11:46:58 +0900

https://leetcode.com/problems/minimum-window-substring/description/

Minimum Window Substring - LeetCode

Can you solve this real interview question? Minimum Window Substring - Given two strings s and t of lengths m and n respectively, return the minimum window substring of s such that every character in t (including duplicates) is included in the window. If t

leetcode.com

문제

Given two strings s and t of lengths m and n respectively, return the minimum window substring of s such that every character in t (including duplicates) is included in the window. If there is no such substring, return the empty string "".

The testcases will be generated such that the answer is unique.

Example 1:

Input: s = "ADOBECODEBANC", t = "ABC"
Output: "BANC"
Explanation: The minimum window substring "BANC" includes 'A', 'B', and 'C' from string t.

Example 2:

Input: s = "a", t = "a"
Output: "a"
Explanation: The entire string s is the minimum window.

Example 3:

Input: s = "a", t = "aa"
Output: ""
Explanation: Both 'a's from t must be included in the window.
Since the largest window of s only has one 'a', return empty string.

Constraints:

m == s.length
n == t.length
1 <= m, n <= 105
s and t consist of uppercase and lowercase English letters.

Follow up: Could you find an algorithm that runs in O(m + n) time?

풀이

풀이 과정

알파벳 대,소문자로 이루어진 두 문자열 s와 t가 주어졌을 때 t에 있는 모든 문자를 포함하는 s의 부분문자열 중 가장 작은 부분문자열을 구하는 문제이다. 정답에 해당하는 부분문자열이 없는 경우에는 빈 문자열을 return한다.

우선 타겟이 되는 t문자열의 길이가 s문자열의 길이보다 큰 경우 정답이 존재할 수 없으므로 바로 빈 문자열을 return 한다.

// 타겟이 되는 t문자열의 길이가 s문자열의 길이보다 큰 경우 정답이 존재할 수 없음
// 바로 빈 문자열을 return
if(t.length() > s.length()) return "";

예시 1번을 기준으로 부분문자열을 탐색하는 전체적인 과정은 다음과 같다.

1. 타겟이 되는 문자열 t의 모든 문자와 그 개수를 Map에 저장

2. 포인터 두 개를 이용하여 범위를 이동하며 탐색

3. Map에 있는 모든 문자를 포함할 때 까지 오른쪽 인덱스를 증가

4. Map에 있는 모든 문자를 포함하는 경우, 다시 Map에 있는 문자가 필요해 질 때까지 왼쪽 인덱스를 증가

5. 만들어진 범위가 최소 부분문자열의 길이보다 작은 경우 최소 부분문자열 업데이트, 단 왼쪽 인덱스는 증가 이전까지의 범위

문자열을 모두 탐색할 때 까지 위의 과정을 반복한다.

각 단계를 코드로 구현하면 다음과 같다.

먼저 필요한 문자와 그 개수를 저장할 Map을 하나 선언하고 t의 각 문자를 순회하며 Map에 저장한다.

// 필요한 문자와 개수를 저장할 Map
Map<Character, Integer> target = new HashMap<>();
// 필요한 모든 문자와 개수를 Map에 저장
for(int i = 0; i < t.length(); i++) {
    Character c = t.charAt(i);
    target.put(c, target.getOrDefault(c, 0) + 1);
}

탐색에 필요한 변수를 선언

// 최소 부분 문자열
String minSub = s;
// 탐색중인 범위의 왼쪽 인덱스
int left = 0;
// 탐색중인 범위의 오른쪽 인덱스
int right = 0;
// 필요한 문자의 총 개수
int count = t.length();
// 타겟 문자를 모두 포함한 부분문자열이 존재하는지 여부
boolean find = false;

오른쪽 인덱스가 탐색할 문자열 s의 끝에 도달할 때 까지 탐색을 반복한다.
만약 오른쪽 인덱스에 해당하는 문자가 Map에 존재하는 경우, 즉 정답이 되기 위해서 포함되어야 하는 문자인 경우 Map에서 해당 문자의 개수를 감소시키고 개수가 0이상인 경우 필요한 문자의 총 개수도 감소시킨다.
t의 모든 문자를 포함한 부분문자열을 찾았으므로 존재 여부를 업데이트한다.

개수가 0 이상인 경우에만 필요한 문자의 총 개수를 감소시키는 이유는 만약 "A"라는 문자가 1개 포함 되어야할 때 탐색중인 범위에 "A"가 두 개가 존재한다면 Map에 존재하는 "A"의 개수는 -1이 될 것이지만 실제로 필요한 문자의 총 개수는 1개만 감소해야하기 때문이다.

// 문자열의 끝까지 탐색할 때 까지 반복
while(right < s.length()) {
    // 오른쪽 인덱스의 문자 탐색
    Character end = s.charAt(right);
    // 필요한 문자인 경우
    if(target.containsKey(end)) {
        // target에서 해당 문자의 카운트 감소
        target.put(end, target.get(end) - 1);
        // 필요한 문자의 총 개수 감소
        if(target.get(end) >= 0) count--;
    }

    // 필요한 문자의 총 개수가 남아있으면 필요한 모든 문자를 포함할 때 까지 오른쪽 인덱스를 증가시키며 재탐색
    right++;
    if(count > 0) continue;
    
    // 필요한 문자를 모두 포함한 경우
    // 정답이 될 수 있는 부분 문자열 존재 여부 업데이트
	find = true;
    
    ...
}

정답이 되기위해 필요한 문자를 모두 포함할 때 까지 오른쪽 인덱스가 이동했다면, 다시 필요한 문자가 생길 때 까지 왼쪽 인덱스를 증가시키며 탐색한다.
왼쪽 인덱스에 해당하는 문자가 Map에 존재하는 경우 이번에는 반대로 Map에서 해당 문자의 개수를 증가시키고 개수가 0보다 큰 경우 필요한 문자의 총 개수도 증가시킨다.

개수가 0보다 큰 경우에만 필요한 문자의 총 개수를 증가시키는 이유도 마찬가지이다.
정답이 되기 위해서 필요한 문자 "A"의 개수가 1개인데 현재 탐색범위에 포함된 "A"가 2개라면 그 중 하나가 포함되지 않더라도 정답이 되는데는 영향이 없기 때문이다.

// 필요한 문자의 개수가 다시 0보다 커질 때 까지 왼쪽 인덱스를 증가시키며 범위를 감소시킴
while(count == 0) {
    // 왼쪽 인덱스의 문자 탐색
    Character start = s.charAt(left);
    // 필요한 문자인 경우
    if(target.containsKey(start)) {
        // target에서 해당 문자의 카운트 증가
        target.put(start, target.get(start) + 1);
        // 필요한 문자의 총 개수 증가
        if(target.get(start) > 0) count++;
    }

    // 왼쪽 인덱스 증가
    left++;
}

위의 과정을 종료했을 때 탐색 범위가 최소 부분문자열의 길이보다 작은 경우 현재 범위에 해당하는 부분문자열을 최소 부분문자열로 업데이트 한다. 이 때 왼쪽 인덱스는 증가한채로 존재하기 때문에 이전 인덱스를 포함하여 체크한다.

// 현재 탐색 범위가 최소 부분문자열 길이보다 작은 경우
if(right - (left - 1) < minSub.length()) {
    // 현재 탐색범위의 문자열을 최소 부분문자열로 저장
    minSub = s.substring(left - 1, right);
}

모든 탐색이 종료되고 정답이 될 수 있는 부분 문자열을 찾은 경우에는 최소 부분 문자열을 return 하고, 찾지 못한 경우 에는 빈 문자열을 return 한다.

// 정답이 되는 부분 문자열을 찾은 경우 최소 부분문자열을 return
// 찾지 못한 경우 빈 문자열을 return
return find ? minSub : "";

최종 코드

class Solution {
    public String minWindow(String s, String t) {
        // 타겟이 되는 t문자열의 길이가 s문자열의 길이보다 큰 경우 정답이 존재할 수 없음
        // 바로 빈 문자열을 return
        if(t.length() > s.length()) return "";
        
        // 필요한 문자와 개수를 저장할 Map
        Map<Character, Integer> target = new HashMap<>();
        // 필요한 모든 문자와 개수를 Map에 저장
        for(int i = 0; i < t.length(); i++) {
            Character c = t.charAt(i);
            target.put(c, target.getOrDefault(c, 0) + 1);
        }
        
        // 최소 부분 문자열
        String minSub = s;
        // 탐색중인 범위의 왼쪽 인덱스
        int left = 0;
        // 탐색중인 범위의 오른쪽 인덱스
        int right = 0;
        // 필요한 문자의 총 개수
        int count = t.length();
        // 타겟 문자를 모두 포함한 부분문자열이 존재하는지 여부
        boolean find = false;
        
        // 문자열의 끝까지 탐색할 때 까지 반복
        while(right < s.length()) {
            // 오른쪽 인덱스의 문자 탐색
            Character end = s.charAt(right);
            // 필요한 문자인 경우
            if(target.containsKey(end)) {
                // target에서 해당 문자의 카운트 감소
                target.put(end, target.get(end) - 1);
                // 필요한 문자의 총 개수 감소
                if(target.get(end) >= 0) count--;
            }
            
            // 필요한 문자의 총 개수가 남아있으면 필요한 모든 문자를 포함할 때 까지 오른쪽 인덱스를 증가시키며 재탐색
            right++;
            if(count > 0) continue;
            
            // 필요한 문자를 모두 포함한 경우
            // 정답이 될 수 있는 부분 문자열 존재 여부 업데이트
            find = true;
            
            // 필요한 문자의 개수가 다시 0보다 커질 때 까지 왼쪽 인덱스를 증가시키며 범위를 감소시킴
            while(count == 0) {
                // 왼쪽 인덱스의 문자 탐색
                Character start = s.charAt(left);
                // 필요한 문자인 경우
                if(target.containsKey(start)) {
                    // target에서 해당 문자의 카운트 증가
                    target.put(start, target.get(start) + 1);
                    // 필요한 문자의 총 개수 증가
                    if(target.get(start) > 0) count++;
                }
                
                // 왼쪽 인덱스 증가
                left++;
            }
            
            // 현재 탐색 범위가 최소 부분문자열 길이보다 작은 경우
            if(right - (left - 1) < minSub.length()) {
                // 현재 탐색범위의 문자열을 최소 부분문자열로 저장
                minSub = s.substring(left - 1, right);
            }
            
        }
        
        // 정답이 되는 부분 문자열을 찾은 경우 최소 부분문자열을 return
        // 찾지 못한 경우 빈 문자열을 return
        return find ? minSub : "";
    }
}

[LeetCode] 647. Palindromic Substrings - Java

HYOJUN — Sun, 12 Feb 2023 11:47:45 +0900

https://leetcode.com/problems/palindromic-substrings/

Palindromic Substrings - LeetCode

Palindromic Substrings - Given a string s, return the number of palindromic substrings in it. A string is a palindrome when it reads the same backward as forward. A substring is a contiguous sequence of characters within the string. Example 1: Input: s

leetcode.com

문제

Given a string s, return the number of palindromic substrings in it.

A string is a palindrome when it reads the same backward as forward.

A substring is a contiguous sequence of characters within the string.

Example 1:

Input: s = "abc"
Output: 3
Explanation: Three palindromic strings: "a", "b", "c".

Example 2:

Input: s = "aaa"
Output: 6
Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".

Constraints:

1 <= s.length <= 1000
s consists of lowercase English letters.

풀이

풀이 과정

전체적인 풀이 과정은 LeetCode 5.Longest Palindromic Substring와 거의 같다.

https://hyojun.tistory.com/entry/LeetCode-5-Longest-Palindromic-Substring-Java

[LeetCode] 5. Longest Palindromic Substring - Java

https://leetcode.com/problems/longest-palindromic-substring/description/ Longest Palindromic Substring - LeetCode Longest Palindromic Substring - Given a string s, return the longest palindromic substring in s. Example 1: Input: s = "babad" Output: "bab" E

hyojun.tistory.com

주어진 문자열 s의 모든 문자에 대해서 탐색하며 각각 홀수 길이인 경우, 짝수 길이인 경우의 Palindrome이 몇 개인지 누적시켜 최종 return 한다.

public int countSubstrings(String s) {
    int answer = 0;

    // s의 모든 문자에 대해서 탐색
    for(int i = 0; i < s.length(); i++) {
        // 홀수 길이인 Palindrome 개수
        answer += countPalindrome(s, i, i);
        // 짝수 길이인 Palindrome 개수
        answer += countPalindrome(s, i, i + 1);
    }

    return answer;
}

각 문자에 대해서 Palindrome이 몇 개인지 카운트하는 함수는 다음과 같다.
탐색 대상 문자열 s와 왼쪽, 오른쪽 인덱스 left, right를 전달 받아 왼쪽 인덱스와 오른쪽 인덱스가 문자열 s의 끝에 도달할 때 까지 반복한다.
만약 양쪽의 글자가 같은 경우 카운트를 증가시키고 인덱스를 한 칸씩 이동한다.
양쪽의 글자가 다른 경우에는 더 이상 Palindrome이 될 수 없으므로 탐색을 종료한다.
탐색이 종료된 후 카운트를 최종 return한다.

/**
 * @param s         탐색할 문자열
 * @param left      탐색을 시작할 왼쪽 인덱스
 * @param right     탐색을 시작할 오른쪽 인덱스
 * @return
 */
public int countPalindrome(String s, int left, int right) {
    int count = 0;

    // 왼쪽 인덱스와 오른쪽 인덱스가 끝에 도달할 때 까지 반복
    while(left >= 0 && right < s.length()) {
        // 양쪽의 글자가 같은 경우 카운트를 증가시키고 인덱스를 한칸씩 이동
        if(s.charAt(left) == s.charAt(right)) {
            count++;
            left--;
            right++;
        } 
        // 양쪽의 글자가 다른 경우 탐색 종료
        else {
            break;
        }
    }

    return count;
}

최종 코드

class Solution {
    public int countSubstrings(String s) {
        int answer = 0;
        
        // s의 모든 문자에 대해서 탐색
        for(int i = 0; i < s.length(); i++) {
            // 홀수 길이인 Palindrome 개수
            answer += countPalindrome(s, i, i);
            // 짝수 길이인 Palindrome 개수
            answer += countPalindrome(s, i, i + 1);
        }

        return answer;
    }

    /**
     * @param s         탐색할 문자열
     * @param left      탐색을 시작할 왼쪽 인덱스
     * @param right     탐색을 시작할 오른쪽 인덱스
     * @return
     */
    public int countPalindrome(String s, int left, int right) {
        int count = 0;
        
        // 왼쪽 인덱스와 오른쪽 인덱스가 끝에 도달할 때 까지 반복
        while(left >= 0 && right < s.length()) {
            // 양쪽의 글자가 같은 경우 카운트를 증가시키고 인덱스를 한칸씩 이동
            if(s.charAt(left) == s.charAt(right)) {
                count++;
                left--;
                right++;
            } 
            // 양쪽의 글자가 다른 경우 탐색 종료
            else {
                break;
            }
        }
        
        return count;
    }
}

[LeetCode] 5. Longest Palindromic Substring - Java

HYOJUN — Fri, 10 Feb 2023 00:41:26 +0900

https://leetcode.com/problems/longest-palindromic-substring/description/

Longest Palindromic Substring - LeetCode

Longest Palindromic Substring - Given a string s, return the longest palindromic substring in s. Example 1: Input: s = "babad" Output: "bab" Explanation: "aba" is also a valid answer. Example 2: Input: s = "cbbd" Output: "bb" Constraints: * 1 <= s.le

leetcode.com

문제

Given a string s, return the longest palindromic substring in s.

Example 1:

Input: s = "babad"
Output: "bab"
Explanation: "aba" is also a valid answer.

Example 2:

Input: s = "cbbd"
Output: "bb"

Constraints:

1 <= s.length <= 1000
s consist of only digits and English letters.

풀이

풀이 과정

숫자와 알파벳으로 이루어진 문자열 s가 주어질 때 s의 부분 문자열 중 가장 긴 palindrome(회문)을 구하는 문제이다.
palindrome은 거꾸로 읽어도 원래와 똑같은 문자나 문장을 의미한다.

투 포인터를 이용하여 palindrome을 판단하는 함수를 생성한다.
문자열 s와 왼쪽, 오른쪽 인덱스를 가지고 인덱스를 양쪽으로 늘려가며 해당 인덱스에 해당하는 문자가 같은지 판단하고 palindrome이 될 수 있는 최대 인덱스에서 문자열을 잘라 return 한다.

/**
     * @param s         탐색할 문자열
     * @param left      탐색을 시작할 왼쪽 인덱스
     * @param right     탐색을 시작할 오른쪽 인덱스
     * @return
     */
    public String isPalindrome(String s, int left, int right) {
        // 왼쪽 인덱스와 오른쪽 인덱스가 끝에 도달할 때 까지 반복
        while(left >= 0 && right < s.length()) {
            // 양쪽의 글자가 같은 경우 인덱스를 한칸씩 이동
            if(s.charAt(left) == s.charAt(right)) {
                left--;
                right++;
            } 
            // 양쪽의 글자가 다른 경우 탐색 종료
            else {
                break;
            }
        }
        
        // 인덱스가 이동한 상태로 탐색이 종료되었으므로 이전 인덱스까지 문자열을 잘라서 return
        return s.substring(left + 1, right);
    }
}

생성한 함수를 이용하여 주어진 문자열 s의 모든 문자에서 palindrome을 판단해야하는데 문자열의 길이가 홀수인 경우와 짝수인 경우를 나누어 생각해야한다.
문자열의 길이가 홀수인 경우에는 같은 인덱스에서 시작하여 양쪽을 비교하면 되고,
문자열의 길이가 짝수인 경우에는 인접한 두 인덱스에서 시작하여 양쪽을 비교하여야한다.
각각의 경우에서 나온 Palindrome의 길이와 Longest Palindromic Substring의 길이를 비교하여 더 큰 값으로 정답을 갱신한다.

// Longest Palindromic Substring
String lps = "";

// 문자열의 모든 문자 탐색
for(int i = 0; i < s.length(); i++) {
    // 각 문자부터 양쪽으로 늘려가며 palindrome 체크
    // 홀수인 경우 
    String oddMax = isPalindrome(s, i, i);
    lps = (lps.length() < oddMax.length())? oddMax : lps;
    // 짝수인 경우
    String evenMax = isPalindrome(s, i, i + 1);
    lps = (lps.length() < evenMax.length())? evenMax : lps;
}

모든 탐색이 종료되면 결과값을 return 한다.

return lps;

최종 코드

class Solution {
    public String longestPalindrome(String s) {
        // Longest Palindromic Substring
        String lps = "";
        
        // 문자열의 모든 문자 탐색
        for(int i = 0; i < s.length(); i++) {
            // 각 문자부터 양쪽으로 늘려가며 palindrome 체크
            // 홀수인 경우 
            String oddMax = isPalindrome(s, i, i);
            lps = (lps.length() < oddMax.length())? oddMax : lps;
            // 짝수인 경우
            String evenMax = isPalindrome(s, i, i + 1);
            lps = (lps.length() < evenMax.length())? evenMax : lps;
        }

        return lps;
    }

    /**
     * @param s         탐색할 문자열
     * @param left      탐색을 시작할 왼쪽 인덱스
     * @param right     탐색을 시작할 오른쪽 인덱스
     * @return
     */
    public String isPalindrome(String s, int left, int right) {
        // 왼쪽 인덱스와 오른쪽 인덱스가 끝에 도달할 때 까지 반복
        while(left >= 0 && right < s.length()) {
            // 양쪽의 글자가 같은 경우 인덱스를 한칸씩 이동
            if(s.charAt(left) == s.charAt(right)) {
                left--;
                right++;
            } 
            // 양쪽의 글자가 다른 경우 탐색 종료
            else {
                break;
            }
        }
        
        // 인덱스가 이동한 상태로 탐색이 종료되었으므로 이전 인덱스까지 문자열을 잘라서 return
        return s.substring(left + 1, right);
    }
}

[LeetCode] 235. Lowest Common Ancestor of a Binary Search Tree - Java

HYOJUN — Tue, 7 Feb 2023 23:40:13 +0900

https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/

Lowest Common Ancestor of a Binary Search Tree - LeetCode

Lowest Common Ancestor of a Binary Search Tree - Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the definition of LCA on Wikipedia [https://en.wikipedia.org/wiki/Lowest_common_ancest

leetcode.com

문제

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”

Example 1:

Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
Output: 6
Explanation: The LCA of nodes 2 and 8 is 6.

Example 2:

Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
Output: 2
Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.

Example 3:

Input: root = [2,1], p = 2, q = 1
Output: 2

Constraints:

The number of nodes in the tree is in the range [2, 105].
-109 <= Node.val <= 109
All Node.val are unique.
p != q
p and q will exist in the BST.

풀이

풀이 과정

이진 탐색트리 root와 노드 p, q가 주어졌을 때 노드 p와 q의 최소 공통 조상을 찾는 문제이다. (각 노드는 자신 역시 조상으로 간주한다)

이진 탐색 트리에서 세 노드에 대해서 비교할 때 크게 네가지 경우를 생각해 볼 수 있다.

p와 q의 값이 root를 기준으로 양쪽으로 나누어져 있는 경우
root의 값이 p나 q의 값 중 하나와 같은 경우
p와 q의 값이 모두 root보다 작은 경우
p와 q의 값이 모두 root보다 큰 경우

먼저 p와 q의 값이 root를 기준으로 양쪽으로 나누어져 있는 경우 왼쪽/오른쪽 서브트리에서는 공통 조상이 존재할 수 없으므로 root가 최소 공통 조상이 된다

// p와 q의 값이 root를 기준으로 양쪽으로 퍼져있을 경우 root가 최소 공통 조상이 됨
if((root.val > p.val && root.val < q.val) || (root.val > q.val && root.val < p.val)) return root;

두 번째로 root의 값이 p나 q의 값 중 하나와 같은 경우, 즉 p나 q중 하나가 그 자체로 본인의 조상으로 간주되는 경우 역시 root가 최소 공통 조상이 된다.

// root의 값이 p나 q의 값 중 하나와 같다면 역시 root가 최소 공통 조상이 됨
if(root.val == p.val || root.val == q.val) return root;

세 번째로 p와 q의 값이 모두 root보다 작은 경우 p와 q 모두 root의 왼쪽 서브트리에 존재하게 된다. 그러나 최소 공통조상이 무엇인지는 아직 알 수 없으므로 위의 두 가지 경우가 나올 때 까지 왼쪽 서브트리를 재귀 탐색한다.

// p와 q가 root보다 작은 경우 왼쪽 서브트리를 탐색
if(p.val < root.val && q.val < root.val) return lowestCommonAncestor(root.left, p, q);

마지막으로 p와 q의 값이 모두 root보다 큰 경우 p와 q모두 오른쪽 서브트리에 존재하며 역시 최소 공통 조상은 알 수 없다. 따라서 세 번째 경우와 마찬가지로 1, 2번 경우가 나올 때 까지 오른쪽 서브트리를 재귀탐색한다.

// 나머지 경우, p와 q가 root보다 큰 경우 오른쪽 서브트리를 탐색
return lowestCommonAncestor(root.right, p, q);

최종 코드

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        // p와 q의 값이 root를 기준으로 양쪽으로 퍼져있을 경우 root가 최소 공통 조상이 됨
        if((root.val > p.val && root.val < q.val) || (root.val > q.val && root.val < p.val)) return root;
        // root의 값이 p나 q의 값 중 하나와 같다면 역시 root가 최소 공통 조상이 됨
        if(root.val == p.val || root.val == q.val) return root;
        // p와 q가 root보다 작은 경우 왼쪽 서브트리를 탐색
        if(p.val < root.val && q.val < root.val) return lowestCommonAncestor(root.left, p, q);
        // 나머지 경우, p와 q가 root보다 큰 경우 오른쪽 서브트리를 탐색
        return lowestCommonAncestor(root.right, p, q);
    }
}

[LeetCode] 230. Kth Smallest Element in a BST - Java

HYOJUN — Mon, 6 Feb 2023 23:28:18 +0900

https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/

Kth Smallest Element in a BST - LeetCode

Kth Smallest Element in a BST - Given the root of a binary search tree, and an integer k, return the kth smallest value (1-indexed) of all the values of the nodes in the tree. Example 1: [https://assets.leetcode.com/uploads/2021/01/28/kthtree1.jpg] Inpu

leetcode.com

문제

Given the root of a binary search tree, and an integer k, return the kth smallest value (1-indexed) of all the values of the nodes in the tree.

Example 1:

Input: root = [3,1,4,null,2], k = 1
Output: 1

Example 2:

Input: root = [5,3,6,2,4,null,null,1], k = 3
Output: 3

Constraints:

The number of nodes in the tree is n.
1 <= k <= n <= 104
0 <= Node.val <= 104

Follow up: If the BST is modified often (i.e., we can do insert and delete operations) and you need to find the kth smallest frequently, how would you optimize?

풀이

풀이 과정

이진 탐색 트리 root와 정수 k가 주어졌을 때, 트리의 모든 노드 값 중 k번째로 작은 값을 찾는 문제이다.

트리를 순회하는 방법에는 크게 3가지가 있으며 간단하게 각 순회의 탐색 순서는 다음과 같다.

전위 순회 (Preorder Traversal) : root 노드 → 왼쪽 노드 → 오른쪽 노드
중위 순회 (Inorder Traversal) : 왼쪽 노드 → root 노드 → 오른쪽 노드
후위 순회 (Postorder Traversal) : 왼쪽 노드 → 오른쪽 노드 → root 노드

이진 탐색 트리의 특징은 왼쪽 노드의 값은 root 노드보다 작고, 오른쪽 노드의 값은 root 노드보다 큰 값으로 구성 되어 있기 때문에 (왼쪽 → root → 오른쪽) 순서대로 오름차순 정렬되어 있다고 볼 수 있다.

이번 문제에서는 제일 작은 수부터 차례대로 탐색해 k번째 노드를 찾아야 하므로 정렬된 순서대로 탐색이 가능한 중위 순회를 이용하여 풀이한다.

현재 탐색중인 노드가 몇 번째로 작은 숫자인지 저장할 변수와 정답을 저장할 변수 하나를 선언한다.

int count = 0;
int answer = 0;

다음으로 트리를 중위 순회하기위한 함수를 생성한다.
왼쪽 노드부터 재귀적으로 호출하여 가장 작은 값부터 탐색을 시작하고 현재 탐색중인 노드의 카운트와 k가 같다면 정답 변수에 현재 노드 값을 저장하고 탐색을 종료한다. 현재 카운트가 k와 같지 않은 경우 오른쪽 노드를 탐색한다.
만약 현재 노드가 null인 경우 탐색을 종료한다.

// 중위 순회
public void inorderTraversal(TreeNode node, int k){
    // 노드가 없다면 탐색 종료
    if(node == null) return;

    // 왼쪽 노드 탐색
    inorderTraversal(node.left, k);
    // 카운트를 증가시키고 그 값이 k와 같다면 현재 노드의 값을 정답으로 저장하고 탐색 종료
    if(++count == k) {
        answer = node.val;
        return;
    }
    // 오른쪽 노드 탐색
    inorderTraversal(node.right, k);
}

생성한 함수를 호출하여 결과값을 return한다.

 public int kthSmallest(TreeNode root, int k) {
    inorderTraversal(root, k);

    return answer;
}

최종 코드

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    // 몇 번째로 작은 숫자인지 카운트를 저장할 변수
    int count = 0;
    int answer = 0;
    public int kthSmallest(TreeNode root, int k) {
        inorderTraversal(root, k);

        return answer;
    }

    // 중위 순회
    public void inorderTraversal(TreeNode node, int k){
        // 노드가 없다면 탐색 종료
        if(node == null) return;

        // 왼쪽 노드 탐색
        inorderTraversal(node.left, k);
        // 카운트를 증가시키고 그 값이 k와 같다면 현재 노드의 값을 정답으로 저장하고 탐색 종료
        if(++count == k) {
            answer = node.val;
            return;
        }
        // 오른쪽 노드 탐색
        inorderTraversal(node.right, k);
    }
}

[LeetCode] 347. Top K Frequent Elements - Java

HYOJUN — Sun, 5 Feb 2023 23:10:56 +0900

https://leetcode.com/problems/top-k-frequent-elements/description/

Top K Frequent Elements - LeetCode

Top K Frequent Elements - Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order. Example 1: Input: nums = [1,1,1,2,2,3], k = 2 Output: [1,2] Example 2: Input: nums = [1], k = 1 Output:

leetcode.com

문제

Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order.

Example 1:

Input: nums = [1,1,1,2,2,3], k = 2
Output: [1,2]

Example 2:

Input: nums = [1], k = 1
Output: [1]

Constraints:

1 <= nums.length <= 105
-104 <= nums[i] <= 104
k is in the range [1, the number of unique elements in the array].
It is guaranteed that the answer is unique.

Follow up: Your algorithm's time complexity must be better than O(n log n), where n is the array's size.

풀이

풀이 과정

배열의 각 요소마다 사용된 개수를 map으로 저장하여 많이 나온 순서대로 k만큼 뽑아 결과로 return하도록 풀이한다.

우선 최종 정답을 return할 길이 k만큼의 배열을 하나 선언한다.

// 최종 return할 결과 배열
int[] answer = new int[k];

만약 nums 배열의 길이가 k와 같다면 배열의 요소가 한번씩 사용된 한가지 경우밖에 존재하지 않으므로 바로 nums 배열을 return 한다.

// 배열의 숫자의 개수와 k값이 같다면 nums자체가 정답이 됨
if(nums.length == k) return nums;

num배열의 각 요소의 개수를 저장할 map을 선언하고 반복문을 통해 개수를 카운트하여 map에 저장한다.

Map<Integer, Integer> countMap = new HashMap<>();
// num배열의 각 요소의 개수를 세며 map에 저장
for(int i : nums) {
    countMap.put(i, countMap.getOrDefault(i, 0) + 1);
}

다음으로 가장 많이 사용된 요소부터 k개만큼 추출해야 하는데 우선순위큐를 이용하여 이 방법을 구현한다.
nums 배열의 각 요소와 그 개수가 저장되어있는 countMap에서 두 번째 요소, 즉 각 요소의 개수를 기준으로 정렬하는 우선순위큐를 선언한다.

// 우선순위큐 생성
// countMap의 두 번째 요소 = 각 요소의 개수를 기준으로 정렬
PriorityQueue<Integer> pq = new PriorityQueue<>((o1, o2) -> countMap.get(o1) - countMap.get(o2));

nums 배열의 모든 요소값들을 순회하며 큐에 삽입한다. 이 때 필요한 요소의 개수는 k만큼이므로 만약 큐의 사이즈가 k를 넘어가는 경우 마지막 요소( = 우선순위가 가장 낮은 요소 = 제일 적게 사용된 요소 )를 제거한다

// nums 배열의 모든 요소 값들을 큐에 삽입
for(int i : countMap.keySet()) {
    pq.add(i);
    // 큐의 길이가 k보다 커지는 경우 마지막 요소를 제거
    if(pq.size() > k) pq.poll();
}

큐의 값을 차례대로 뽑아 결과 배열에 저장하여 최종 return한다.

// 큐의 값을 차례대로 결과 배열에 저장하여 return
for(int i = 0; i < k; i++) {
    answer[i] = pq.poll();
}

return answer;

최종 코드

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        // 최종 return할 결과 배열
        int[] answer = new int[k];
        
        // 배열의 숫자의 개수와 k값이 같다면 nums자체가 정답이 됨
        if(nums.length == k) return nums;
        
        Map<Integer, Integer> countMap = new HashMap<>();
        // num배열의 각 요소의 개수를 세며 map에 저장
        for(int i : nums) {
            countMap.put(i, countMap.getOrDefault(i, 0) + 1);
        }
        
        // 우선순위큐 생성
        // countMap의 두 번째 요소 = 각 요소의 개수를 기준으로 정렬
        PriorityQueue<Integer> pq = new PriorityQueue<>((o1, o2) -> countMap.get(o1) - countMap.get(o2));
        // nums 배열의 모든 요소 값들을 큐에 삽입
        for(int i : countMap.keySet()) {
            pq.add(i);
            // 큐의 길이가 k보다 커지는 경우 마지막 요소를 제거
            if(pq.size() > k) pq.poll();
        }
        
        // 큐의 값을 차례대로 결과 배열에 저장하여 return
        for(int i = 0; i < k; i++) {
            answer[i] = pq.poll();
        }
        
        return answer;
    }
}

[LeetCode] 49. Group Anagrams - Java

HYOJUN — Sat, 4 Feb 2023 23:13:23 +0900

https://leetcode.com/problems/group-anagrams/description/

Group Anagrams - LeetCode

Group Anagrams - Given an array of strings strs, group the anagrams together. You can return the answer in any order. An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters e

leetcode.com

문제

Given an array of strings strs, group the anagrams together. You can return the answer in any order.

An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.

Example 1:

Input: strs = ["eat","tea","tan","ate","nat","bat"]
Output: [["bat"],["nat","tan"],["ate","eat","tea"]]

Example 2:

Input: strs = [""]
Output: [[""]]

Example 3:

Input: strs = ["a"]
Output: [["a"]]

Constraints:

1 <= strs.length <= 104
0 <= strs[i].length <= 100
strs[i] consists of lowercase English letters.

풀이

풀이 과정

알파벳 소문자로 이루어진 문자열들의 배열 strs가 주어질 때 각 단어들이 anagram이 되는 단어끼리 묶어서 리스트로 반환하는 문제이다.

anagram이란 서로 다른 두 문자열의 문자 배치를 바꾸었을 때 같은 문자가 되는 문자열을 의미한다.

알파벳의 길이만큼의 배열을 하나 선언한뒤 각 문자마다 사용된 알파벳의 개수를 카운트하여 해당 결과를 해시값으로 사용한다.
같은 해시값을 가진 문자끼리 묶어서 정답리스트에 추가하도록한다.

우선 최종 반환할 결과 리스트와 각 해시그룹별 문자열 리스트를 저장할 map을 선언한다.

// 최종 결과 리스트
List<List<String>> result = new ArrayList<>();

// 각 anagram 그룹별 문자열을 저장할 map
Map<String, List<String>> map = new HashMap<>();

주어진 strs배열의 문자열을 하나씩 탐색한다.
각 문자열에서 사용된 알파벳 개수를 저장할 길이 26만큼의 정수배열을 하나 선언하고 현재 탐색중인 단어의 각 알파벳의 개수를 증가시킨다.
알파벳 배열을 그대로 문자열로 변환하여 그룹키로 사용하고 map의 해당 key의 리스트에 현재 문자열을 추가한다.

// 문자열 하나씩 탐색
for(String word : strs) {
    // 문자열에서 사용된 알파벳 개수를 저장할 정수 배열
    int[] alphabet = new int[26];
    // 현재 탐색문자의 각 알파벳 탐색
    for(char c : word.toCharArray()) {
        // 해당하는 알파벳의 값을 증가
        alphabet[c - 'a']++;
    }
    // 알파벳 map을 문자열로 변환하여 그룹키로 사용
    String groupKey = Arrays.toString(alphabet);

    // map에 그룹키가 존재하지 않는다면 키를 추가
    if(!map.containsKey(groupKey)) {
        map.put(groupKey, new ArrayList<>());
    }

    // 해당 그룹키에 현재 문자열 추가
    map.get(groupKey).add(word);
}

map에 담긴 값들을 정답 리스트에 모두 추가하여 최종 return한다.

// map의 값들을 정답 리스트에 추가
for(String key : map.keySet()) {
    result.add(map.get(key));
}

// 결과 리스트 return
return result;

최종 코드

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        // 최종 결과 리스트
        List<List<String>> result = new ArrayList<>();
        
        // 각 anagram 그룹별 문자열을 저장할 map
        Map<String, List<String>> map = new HashMap<>();
        // 문자열 하나씩 탐색
        for(String word : strs) {
            // 문자열에서 사용된 알파벳 개수를 저장할 정수 배열
            int[] alphabet = new int[26];
            // 현재 탐색문자의 각 알파벳 탐색
            for(char c : word.toCharArray()) {
                // 해당하는 알파벳의 값을 증가
                alphabet[c - 'a']++;
            }
            // 알파벳 map을 문자열로 변환하여 그룹키로 사용
            String groupKey = Arrays.toString(alphabet);
            
            // map에 그룹키가 존재하지 않는다면 키를 추가
            if(!map.containsKey(groupKey)) {
                map.put(groupKey, new ArrayList<>());
            }
            
            // 해당 그룹키에 현재 문자열 추가
            map.get(groupKey).add(word);
        }
        
        // map의 값들을 정답 리스트에 추가
        for(String key : map.keySet()) {
            result.add(map.get(key));
        }

        // 결과 리스트 return
        return result;
    }
}

[LeetCode] 424. Longest Repeating Character Replacement - Java

HYOJUN — Sat, 4 Feb 2023 18:49:06 +0900

https://leetcode.com/problems/longest-repeating-character-replacement/submissions/

Longest Repeating Character Replacement - LeetCode

Longest Repeating Character Replacement - You are given a string s and an integer k. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most k times. Return the length of the

leetcode.com

문제

You are given a string s and an integer k. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most k times.

Return the length of the longest substring containing the same letter you can get after performing the above operations.

Example 1:

Input: s = "ABAB", k = 2
Output: 4
Explanation: Replace the two 'A's with two 'B's or vice versa.

Example 2:

Input: s = "AABABBA", k = 1
Output: 4
Explanation: Replace the one 'A' in the middle with 'B' and form "AABBBBA".
The substring "BBBB" has the longest repeating letters, which is 4.

Constraints:

1 <= s.length <= 105
s consists of only uppercase English letters.
0 <= k <= s.length

풀이

풀이 과정

알파벳 대문자로만 이루이진 문자열 s와 바꿀수 있는 알파벳의 개수 k가 주어질 때 만들 수 있는 가장 긴 반복되는 문자열의 길이를 구하는 문제이다.

문자열을 범위를 늘려가며 탐색하여 범위내에서 가장 많이 사용된 알파벳이 무엇인지 구하고 범위에서 가장 많이 사용된 알파벳의 개수를 뺀 나머지, 즉 바꿔야할 알파벳의 개수가 k보다 큰 지 비교한다.
k보다 작거나 같다면 탐색 범위의 종료지점을 증가시켜 탐색하고, 크다면 시작 지점과 종료 지점을 같이 증가시켜 최대 길이를 유지한채 탐색 범위를 이동한다.

우선 탐색 범위내에서 사용된 알파벳의 개수를 카운팅하기 위해 알파벳의 개수 만큼의 배열을 생성한다.

// 알파벳의 개수를 카운팅할 배열
int[] alphabet = new int[26];

사용된 알파벳 중 가장 많이 사용된 알파벳의 개수를 구하기 위한 함수도 하나 아래와 같이 생성한다.

// 현재 탐색중인 범위내에서 가장 많이 사용된 알파벳의 개수를 반환
public int mostFreqVal() {
    int result = 0;

    for(int i : alphabet) {
        result = Math.max(result, i);
    }

    return result;
}

탐색 범위 내 가장 많이 나온 알파벳 개수를 저장할 변수와 탐색 시작지점 변수를 생성하고, 문자열 s의 첫 번째 알파벳의 개수를 증가시킨 상태로 탐색을 시작한다.

// 탐색 범위 내 가장 많이 나온 문자 개수
int max = 0;
// 첫 번째 문자 개수를 증가
alphabet[s.charAt(0) - 'A']++;
// 탐색중인 문자 범위의 왼쪽 인덱스값
int left = 0;

두 번째 문자부터 시작하여 문자열 s의 길이만큼 반복하여 탐색한다.
현재 탐색중인 문자의 사용 개수를 1 증가시키고 가장 많이 사용된 알파벳의 개수 max를 구한다.
이때 현재 탐색중인 범위에서 max를 뺀 개수, 즉 바꿔야할 알파벳의 개수가 k보다 큰 경우 왼쪽 인덱스에 해당하는 알파벳의 사용개수는 감소시키고 왼쪽 인덱스를 증가시킨다.

// 두 번째 문자부터 문자열의 길이만큼 탐색
for(int i = 1; i < s.length(); i++) {
    // 현재 탐색중인 문자의 사용 개수 증가
    alphabet[s.charAt(i) - 'A']++;
    max = mostFreqVal();

    // 현재 탐색중인 범위에서 가장 많이 사용된 알파벳을 뺀 개수,
    // 즉 바꿔야할 알파벳의 개수가 k보다 큰 경우
    if(i - left + 1 - max > k) {
        // 왼쪽 인덱스에 해당하는 알파벳 사용 개수를 감소
        alphabet[s.charAt(left) - 'A']--;
        // 탐색할 왼쪽 인덱스를 증가시킴
        left++;
    }
}

문자열의 길이에서 왼쪽 인덱스를 뺀 길이를 최종 return 한다.
이 때 해당 범위의 문자열이 가장 긴 반복된 문자열은 아니며 단순히 길이만을 알 수 있다.

// 문자열의 길이에서 왼쪽 인덱스를 뺀 값을 return
return s.length() - left;

최종 코드

class Solution {
    // 알파벳의 개수를 카운팅할 배열
    int[] alphabet = new int[26];

    public int characterReplacement(String s, int k) {
        // 탐색 범위 내 가장 많이 나온 문자 개수
        int max = 0;
        // 첫 번째 문자 개수를 증가
        alphabet[s.charAt(0) - 'A']++;
        // 탐색중인 문자 범위의 왼쪽 인덱스값
        int left = 0;
        
        // 두 번째 문자부터 문자열의 길이만큼 탐색
        for(int i = 1; i < s.length(); i++) {
            // 현재 탐색중인 문자의 사용 개수 증가
            alphabet[s.charAt(i) - 'A']++;
            max = mostFreqVal();
            
            // 현재 탐색중인 범위에서 가장 많이 사용된 알파벳을 뺀 개수,
            // 즉 바꿔야할 알파벳의 개수가 k보다 큰 경우
            if(i - left + 1 - max > k) {
                // 왼쪽 인덱스에 해당하는 알파벳 사용 개수를 감소
                alphabet[s.charAt(left) - 'A']--;
                // 탐색할 왼쪽 인덱스를 증가시킴
                left++;
            }
        }
        
        // 문자열의 길이에서 왼쪽 인덱스를 뺀 값을 return
        return s.length() - left;
    }

    // 현재 탐색중인 범위내에서 가장 많이 사용된 알파벳의 개수를 반환
    public int mostFreqVal() {
        int result = 0;
        
        for(int i : alphabet) {
            result = Math.max(result, i);
        }
        
        return result;
    }
}

[LeetCode] 98. Validate Binary Search Tree - Java

HYOJUN — Mon, 30 Jan 2023 22:56:37 +0900

https://leetcode.com/problems/validate-binary-search-tree/description/

Validate Binary Search Tree - LeetCode

Validate Binary Search Tree - Given the root of a binary tree, determine if it is a valid binary search tree (BST). A valid BST is defined as follows: * The left subtree of a node contains only nodes with keys less than the node's key. * The right subtree

leetcode.com

문제

Given the root of a binary tree, determine if it is a valid binary search tree (BST).

A valid BST is defined as follows:

The left

subtree

of a node contains only nodes with keys less than the node's key.
The right subtree of a node contains only nodes with keys greater than the node's key.
Both the left and right subtrees must also be binary search trees.

Example 1:

Input: root = [2,1,3]
Output: true

Example 2:

Input: root = [5,1,4,null,null,3,6]
Output: false
Explanation: The root node's value is 5 but its right child's value is 4.

Constraints:

The number of nodes in the tree is in the range [1, 104].
-231 <= Node.val <= 231 - 1

풀이

풀이 과정

이진 트리 root가 주어졌을 때 주어진 트리가 이진 탐색 트리인지 여부를 판단하는 문제이다.

이때 이진탐색트리의 정의는 다음과 같다

노드의 왼쪽 서브트리는 모두 노드의 값보다 작은 값으로만 이루어진다.
노드의 오른쪽 서브트리는 모두 노드의 값보다 큰 값으로만 이루어진다.
왼쪽과 오른쪽 서브트리 역시 모두 이진탐색트리이다.

재귀를 통하여 풀이한다.

우선 재귀에 사용할 함수를 생성한다. 함수는 현재 노드와 현재 노드가 유효한 노드가 되는 최소값, 최대값을 인자로 받는다.
현재 노드가 null인 경우 모든 유효성 체크를 통과하고 마지막에 도달한 것이므로 true를 return한다.
현재 노드가 유효한 노드가 되는 최소값 이하인 경우 1번 정의에 어긋나므로 false를 return하고 반대로 최대값 이상인 경우에도 2번 정의에 어긋나므로 false를 return한다.
이후 왼쪽과 오른쪽 노드에 대해서 재귀적으로 탐색한다.
이 때 왼쪽노드를 탐색하는 경우 최대값을 현재 노드값으로 설정하고 오른쪽노드를 탐색하는 경우 최소값을 현재 노드값으로 설정한다.

public boolean isValid(TreeNode root, Integer min, Integer max){
    // 현재 노드가 null 이면 모든 유효성 체크를 통과해 마지막에 도달한 것이므로 true를 return
    if(root == null) return true;
    // 현재 노드가 유효한 노드가 되는 최소값 이하인 경우 false를 return
    if(min != null && root.val <= min) return false;
    // 현재 노드가 유효한 노드가 되는 최대값 이상인 경우 false를 return
    if(max != null && root.val >= max) return false;

    // 왼쪽, 오른쪽 노드에 대해 탐색
    return isValid(root.left, min, root.val) && isValid(root.right, root.val, max);
}

생성한 함수를 호출하여 정답을 return한다. 최초 root 노드를 호출할 때에는 최소값과 최대값을 각각 null로 설정한다.

public boolean isValidBST(TreeNode root) {
    return isValid(root, null, null);
}

최종 코드

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isValidBST(TreeNode root) {
        return isValid(root, null, null);
    }

    /**
     * @param root  트리의 root 노드
     * @param min   현재 노드가 유효한 노드가 되는 최소값
     * @param max   현재 노드가 유효한 노드가 되는 최대값
     * @return
     */
    public boolean isValid(TreeNode root, Integer min, Integer max){
        // 현재 노드가 null 이면 모든 유효성 체크를 통과해 마지막에 도달한 것이므로 true를 return
        if(root == null) return true;
        // 현재 노드가 유효한 노드가 되는 최소값 이하인 경우 false를 return
        if(min != null && root.val <= min) return false;
        // 현재 노드가 유효한 노드가 되는 최대값 이상인 경우 false를 return
        if(max != null && root.val >= max) return false;

        // 왼쪽, 오른쪽 노드에 대해 탐색
        return isValid(root.left, min, root.val) && isValid(root.right, root.val, max);
    }
}

[LeetCode] 79. Word Search - Java

HYOJUN — Sun, 29 Jan 2023 22:41:51 +0900

https://leetcode.com/problems/word-search/

Word Search - LeetCode

Word Search - Given an m x n grid of characters board and a string word, return true if word exists in the grid. The word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The s

leetcode.com

문제

Given an m x n grid of characters board and a string word, return true if word exists in the grid.

The word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once.

Example 1:

Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
Output: true

Example 2:

Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
Output: true

Example 3:

Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
Output: false

Constraints:

m == board.length
n = board[i].length
1 <= m, n <= 6
1 <= word.length <= 15
board and word consists of only lowercase and uppercase English letters.

풀이

풀이 과정

m x n 사이즈의 2차원 배열이 주어지고 각 셀에는 알파벳이 들어있다. 찾아야하는 단어 word가 주어질 때 word가 이어진 셀로 존재한다면 true를 return한다.
이 때 동일한 셀은 중복해서 사용할 수 없다.

dfs를 사용하여 풀이한다.

우선 탐색에 사용할 함수를 생성한다.
탐색에 사용할 파라미터는 문자를 탐색할 대상 배열, 찾을 대상 단어, 단어 중 현재 탐색할 알파벳의 인덱스, 배열의 x좌표, 배열의 y좌표로 구성한다.
탐색 결과에 따라 true 혹은 false를 반환하도록 한다

/**
 * @param board         : 문자를 탐색할 대상 배열
 * @param word          : 찾을 대상 단어
 * @param wordIndex     : 현재 탐색중인 단어의 인덱스
 * @param x             : 배열의 x좌표
 * @param y             : 배열의 y좌표
 * @return
 */
public boolean wordSearch(char[][] board, String word, int wordIndex, int x, int y) {

}

함수 내에서는 아래의 조건들을 판단한다.

1. 현재 탐색중인 단어의 인덱스가 찾을 대상 단어의 인덱스와 같다면, 즉 단어의 길이만큼 탐색한 경우 word의 모든 알파벳을 비교한 것이므로 글자가 존재한다고 볼 수 있다. 따라서 true를 return 한다.

boolean result = false;
// 단어의 길이만큼 탐색했다면 글자가 존재하므로 true를 return
if(wordIndex == word.length()) return true;

2. x,y의 좌표가 배열을 벗어난다면 탐색이 불가능하므로 false를 return한다.

// 좌표가 배열을 벗어난다면 false를 return
if(x < 0 || y < 0 || x >= board.length || y >= board[0].length) return false;

3. 이미 방문한 좌표를 재방문하는 경우 중복된 셀을 사용할 수 없으므로 false를 return한다.
이때 방문한 좌표의 값은 '*'로 변경하여 판단하기로 한다.

// 이미 방문했다면 false를 return
if(board[x][y] == '*') return false;

4. 현재 좌표값과 탐색 중인 문자가 일치하지 않는 경우 더 이상 탐색이 불필요하므로 false를 return한다.

// 문자가 일치하지 않는 경우 false를 return
if(board[x][y] != word.charAt(wordIndex)) return false;

5. 이외의 경우는 현재 좌표의 값과 탐색 중인 문자가 일치하는 경우이다.
이 경우에는 현재 좌표 값을 방문의 의미로 '*'로 세팅하고 상, 하, 좌, 우에 대해 단어 인덱스를 증가시켜 재탐색한다.
상하좌우를 탐색하기 위해 x,y좌표에 대한 이동 방향을 전역변수로 세팅하여 사용한다.
상하좌우에 대해 탐색한 결과값이 true가 나오는 경우 탐색을 중단한다. 해당 좌표에서 탐색이 종료되면 방문 표시 해두었던 '*' 값을 다시 원래의 값으로 되돌리고 결과값을 return한다.

class Solution {
    // 좌표의 이동 방향 ( 상, 하, 좌, 우 )
    int[] dx = {-1, 1, 0, 0};
    int[] dy = {0, 0, -1, 1};
    
    ...
    
    // 방문 표시
    board[x][y] = '*';
    // 상하좌우 탐색
    for(int i = 0; i < 4; i++) {
        result = wordSearch(board, word, wordIndex + 1, x + dx[i], y + dy[i]);
        if(result) break;
    }
    // 방문 표시 해제
    board[x][y] = word.charAt(wordIndex);
    
    // 결과값 return
    return result;

생성한 함수를 이용하여 배열의 모든 요소에 대해서 탐색한다.
탐색 중 true값이 return되는 경우 탐색을 중지하고 true를 최종 결과로 return한다.

public boolean exist(char[][] board, String word) {
    boolean result = false;
    int m = board.length;
    int n = board[0].length;

    // 배열의 요소 탐색
    for(int i = 0; i < m; i ++) {
        for(int j = 0; j < n; j++) {
            // 찾고자 하는 단어가 존재하는 경우 true를 return
            if(wordSearch(board, word, 0, i, j)) return true;
        }
    }

    return result;
}

최종 코드

class Solution {
    // 좌표의 이동 방향 ( 상, 하, 좌, 우 )
    int[] dx = {-1, 1, 0, 0};
    int[] dy = {0, 0, -1, 1};

    public boolean exist(char[][] board, String word) {
        boolean result = false;
        int m = board.length;
        int n = board[0].length;
        
        // 배열의 요소 탐색
        for(int i = 0; i < m; i ++) {
            for(int j = 0; j < n; j++) {
                // 찾고자 하는 단어가 존재하는 경우 true를 return
                if(wordSearch(board, word, 0, i, j)) return true;
            }
        }

        return result;
    }

    /**
     * @param board         : 문자를 탐색할 대상 배열
     * @param word          : 찾을 대상 단어
     * @param wordIndex     : 현재 탐색중인 단어의 인덱스
     * @param x             : 배열의 x좌표
     * @param y             : 배열의 y좌표
     * @return
     */
    public boolean wordSearch(char[][] board, String word, int wordIndex, int x, int y) {
        boolean result = false;
        // 단어의 길이만큼 탐색했다면 글자가 존재하므로 true를 return
        if(wordIndex == word.length()) return true;
        // 좌표가 배열을 벗어난다면 false를 return
        if(x < 0 || y < 0 || x >= board.length || y >= board[0].length) return false;
        // 이미 방문했다면 false를 return
        if(board[x][y] == '*') return false;
        // 문자가 일치하지 않는 경우 false를 return
        if(board[x][y] != word.charAt(wordIndex)) return false;
        
        // 방문 표시
        board[x][y] = '*';
        // 상하좌우 탐색
        for(int i = 0; i < 4; i++) {
            result = wordSearch(board, word, wordIndex + 1, x + dx[i], y + dy[i]);
            if(result) break;
        }
        // 방문 표시 해제
        board[x][y] = word.charAt(wordIndex);
        
        // 결과값 return
        return result;
    }
}

[LeetCode] 48. Rotate Image - Java

HYOJUN — Sat, 28 Jan 2023 23:03:38 +0900

https://leetcode.com/problems/rotate-image/description/

Rotate Image - LeetCode

Rotate Image - You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise). You have to rotate the image in-place [https://en.wikipedia.org/wiki/In-place_algorithm], which means you have to modify the input 2D matrix

leetcode.com

문제

You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise).

You have to rotate the image in-place, which means you have to modify the input 2D matrix directly. DO NOT allocate another 2D matrix and do the rotation.

Example 1:

Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
Output: [[7,4,1],[8,5,2],[9,6,3]]

Example 2:

Input: matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
Output: [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]

Constraints:

n == matrix.length == matrix[i].length
1 <= n <= 20
-1000 <= matrix[i][j] <= 1000

풀이

풀이 과정

n x n 사이즈의 정사각형 모양 2차원 배열이 주어질 때 시계방향으로 90도 회전한 배열을 구해야한다.
다만 완성된 배열은 새로 만들어진 다른 2차원 배열이 아닌 주어진 배열안에서만 값을 변경하여야한다.

가운데 행을 기준으로 위아래 요소들을 반전시키고 왼쪽 위부터 오른쪽 아래를 잇는 선을 기준으로 요소들을 반전시키면 시계방향으로 90도 회전시킨 모양을 얻을 수 있다.

최종 코드

class Solution {
    public void rotate(int[][] matrix) {
        int length = matrix.length;
        // 배열의 값을 교체할 때 사용할 임시 변수
        int temp  = 0;
        
        // 가운데 행을 기준으로 위아래를 반전
        for(int i = 0; i < length/2; i++) {
            for(int j = 0; j < length; j++) {
                temp = matrix[i][j];
                matrix[i][j] = matrix[length - i - 1][j];
                matrix[length - i - 1][j] = temp;
            }
        }
        
        // 왼쪽위부터 오른쪽아래를 잇는 선을 기준으로 반전
        for(int i = 0; i < length; i++) {
            for(int j = i; j < length; j++) {
                temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
        }
    }
}

[LeetCode] 54. Spiral Matrix - Java

HYOJUN — Fri, 27 Jan 2023 00:01:24 +0900

https://leetcode.com/problems/spiral-matrix/

Spiral Matrix - LeetCode

Spiral Matrix - Given an m x n matrix, return all elements of the matrix in spiral order. Example 1: [https://assets.leetcode.com/uploads/2020/11/13/spiral1.jpg] Input: matrix = [[1,2,3],[4,5,6],[7,8,9]] Output: [1,2,3,6,9,8,7,4,5] Example 2: [https://a

leetcode.com

문제

Given an m x n matrix, return all elements of the matrix in spiral order.

Example 1:

Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
Output: [1,2,3,6,9,8,7,4,5]

Example 2:

Input: matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
Output: [1,2,3,4,8,12,11,10,9,5,6,7]

Constraints:

m == matrix.length
n == matrix[i].length
1 <= m, n <= 10
-100 <= matrix[i][j] <= 100

풀이

풀이 과정

m*n 크기의 2차원 배열 matrix가 주어질 때 배열의 요소들을 나선방향으로 돌면서 구하는 문제이다.

우선 풀이에 필요한 변수들을 선언한다.

// 행의 길이
int m = matrix.length;
// 열의 길이
int n = matrix[0].length;
// matrix 배열의 요소 개수 크기만큼의 정답 배열 선언
List<Integer> answer = new ArrayList<>();
// 방향에 따라 이동할 x,y좌표 값
// 오른쪽, 아래, 왼쪽, 위
int[] dirX = {0, 1, 0, -1};
int[] dirY = {1, 0, -1, 0};
// 방향을 나타낼 포인터
int dir = 0;
// 시작 x좌표
int x = 0;
// 시작 y좌표
int y = 0;

matrix 배열 요소의 길이만큼 반복하며 탐색 한다.
현재 탐색중인 좌표의 값을 정답 리스트에 추가하고 방문 여부를 체크하기위해 배열요소의 최대값인 100보다 큰 값으로 현재 요소 값을 변경한다.
그 후 이동할 방향에 따라 이동한 x,y 좌표가 배열을 벗어나거나 이미 방문한 요소인 경우에는 방향을 변경한다.
방향이 결정된 후에 x와 y좌표를 갱신한다.

// matrix 배열 요소의 길이만큼 탐색
for(int i = 0; i < m * n; i++) {
    // 현재 좌표의 값을 정답 리스트에 추가
    answer.add(matrix[x][y]);
    // 방문 여부를 체크하기위해 배열요소의 최대값인 100보다 큰 값으로 현재 요소값 변경 
    matrix[x][y] = 101;

    // 이동한 좌표가 배열을 벗어났거나 이미 방문한 요소인 경우
    if(x + dirX[dir] < 0 || x + dirX[dir] >= m || y + dirY[dir] < 0 || y + dirY[dir] >= n || matrix[x + dirX[dir]][y + dirY[dir]] > 100) {
        // 방향을 변경
        dir = (dir + 1) % 4;
    }

    // 좌표 갱신
    x = x + dirX[dir];
    y = y + dirY[dir];
}

최종적으로 구한 정답 리스트를 return한다.

return answer;

최종 코드

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        // 행의 길이
        int m = matrix.length;
        // 열의 길이
        int n = matrix[0].length;
        // matrix 배열의 요소 개수 크기만큼의 정답 배열 선언
        List<Integer> answer = new ArrayList<>();
        // 방향에 따라 이동할 x,y좌표 값
        // 오른쪽, 아래, 왼쪽, 위
        int[] dirX = {0, 1, 0, -1};
        int[] dirY = {1, 0, -1, 0};
        // 방향을 나타낼 포인터
        int dir = 0;
        // 시작 x좌표
        int x = 0;
        // 시작 y좌표
        int y = 0;
        
        // matrix 배열 요소의 길이만큼 탐색
        for(int i = 0; i < m * n; i++) {
            // 현재 좌표의 값을 정답 리스트에 추가
            answer.add(matrix[x][y]);
            // 방문 여부를 체크하기위해 배열요소의 최대값인 100보다 큰 값으로 현재 요소값 변경 
            matrix[x][y] = 101;
            
            // 이동한 좌표가 배열을 벗어났거나 이미 방문한 요소인 경우
            if(x + dirX[dir] < 0 || x + dirX[dir] >= m || y + dirY[dir] < 0 || y + dirY[dir] >= n || matrix[x + dirX[dir]][y + dirY[dir]] > 100) {
                // 방향을 변경
                dir = (dir + 1) % 4;
            }
            
            // 좌표 갱신
            x = x + dirX[dir];
            y = y + dirY[dir];
        }

        return answer;
    }
}

[LeetCode] 73. Set Matrix Zeroes - Java

HYOJUN — Thu, 26 Jan 2023 00:16:01 +0900

https://leetcode.com/problems/set-matrix-zeroes/description/

Set Matrix Zeroes - LeetCode

Set Matrix Zeroes - Given an m x n integer matrix matrix, if an element is 0, set its entire row and column to 0's. You must do it in place [https://en.wikipedia.org/wiki/In-place_algorithm]. Example 1: [https://assets.leetcode.com/uploads/2020/08/17/ma

leetcode.com

문제

Given an m x n integer matrix matrix, if an element is 0, set its entire row and column to 0's.

You must do it in place.

Example 1:

Input: matrix = [[1,1,1],[1,0,1],[1,1,1]]
Output: [[1,0,1],[0,0,0],[1,0,1]]

Example 2:

Input: matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
Output: [[0,0,0,0],[0,4,5,0],[0,3,1,0]]

Constraints:

m == matrix.length
n == matrix[0].length
1 <= m, n <= 200
-231 <= matrix[i][j] <= 231 - 1

Follow up:

A straightforward solution using O(mn) space is probably a bad idea.
A simple improvement uses O(m + n) space, but still not the best solution.
Could you devise a constant space solution?

풀이

풀이 과정

2차원 배열 matrix가 주어질 때 셀의 값이 0인 행과 열은 모두 0으로 치환해야하는 문제이다.

방법은 크게 세 가지로 나눌 수 있다.

공간복잡도 O(mn)

주어진 matrix와 똑같은 2차원 배열을 복사하여 복사한 배열을 순회하며 값이 0인 경우 matrix 배열에서 해당 행과 열을 0으로 변경

공간복잡도 O(m + n)

matrix의 행과 열의 길이만큼의 배열(m, n)을 생성하여 각각 해당 행과 열이 0으로 세팅되어야 하는지 판단하는데 사용, matrix의 값을 순회하면서 값이 0인경우 m과 n배열의 각 인덱스를 0으로 세팅하고 마지막에 m과 n배열을 순회하며 값이 0인 행과 열의 값을 변경

공간복잡도 O(1)

O(m + n)과 풀이 방법은 같으나 m과 n배열을 따로 생성하지 않고 matrix배열 자체를 이용한다.
첫 번째 행을 n배열로 사용하고 첫 번째 열을 m배열로 사용한다. 다만 [0][0]번째 값은 행과 열에서 겹치므로 하나의 변수를 사용하여 행과 열중 하나를 판단하는데 사용한다.

문제에서 O(mn), O(m + n)의 공간 복잡도보다 효율적인 풀이를 요구하고 있으므로 마지막 방법을 이용하여 풀이한다.

우선 첫 번째 행이나 첫 번째 열을 판단하기 위한 변수를 하나 선언해야한다. 이번 문제에서는 이 변수를 첫 번째 행을 판단하기 위해 사용한다.

// 배열의 첫 번째 행과 열은 해당 행과 열을
// 0으로 치환해야하는지 판단하는데 사용

// 첫 번째 행을 0으로 채워야하는지 판별하기 위한 변수
// 첫 번째 행과 첫 번째 열은 겹치기 때문에 행 판단을 위한 변수를 따로 사용
boolean firstRow = false;

matrix 배열의 각 행과 열을 순회하면서 각 값이 속하는 행과 열이 0이 되어야 하는지 탐색한다.
만약 탐색중인 값이 0인 경우 해당 열의 첫 번째 행 값을 0으로 설정한다.
마찬가지로 해당 행의 첫 번째 열 값도 0으로 설정해야 하는데 첫 번째 행의 경우 firstRow라는 변수를 따로 사용하므로 조건을 분기하여 첫 번째 행인 경우 firstRow를 업데이트하고 첫 번째 행이 아닌경우에는 첫 번째 열 값을 업데이트한다.

// 배열의 각 행,열을 탐색하여
// 각 행과 열의 0 치환 여부를 판단
for(int i = 0; i < matrix.length; i++){
    for(int j = 0; j < matrix[0].length; j++){
        // 현재 탐색중인 값이 0이라면
        if(matrix[i][j] == 0) {
            // 현재 열은 0으로 치환해야하는 것으로 판단
            matrix[0][j] = 0;

            // 첫 번째 행이 아닌 경우
            // 현재 행은 0으로 치환해야하는 것으로 판단
            if(i > 0) matrix[i][0] = 0;
            // 첫 번째 행인 경우
            // 첫 번째 행은 0으로 치환해야하는 것으로 판단
            else firstRow = true;
        }
    }
}

탐색이 종료되면 첫 번째 행과 열의 값에 따라 해당 행과 열의 값을 0으로 바꿔주어야한다.
첫 번째 행과 열은 다른 값을 바꾸기위해 사용해야 하므로 나머지 행과 열의 값부터 바꾼 후 마지막에 첫 번째 행과 열의 값을 업데이트 한다.

// 첫 번째 행,열을 제외한 나머지 셀 값 치환
for(int i = 1; i < matrix.length; i++) {
    for(int j = 1; j < matrix[0].length; j++) {
        // 탐색중인 행이 0이거나 열이 0인 경우
        // 현재 값을 0으로 변경
        if(matrix[i][0] == 0 || matrix[0][j] == 0) {
            matrix[i][j] = 0;
        }
    }
}

// 첫 번째 열이 0인 경우
if(matrix[0][0] == 0) {
    // 첫 번째 열의 모든 값을 0으로 변경
    for(int i = 0; i < matrix.length; i++) {
        matrix[i][0] = 0;
    }
}

// 첫 번째 행이 0인 경우
if(firstRow) {
 // 첫 번째 행의 모든 값을 0으로 변경
    for(int i = 0; i < matrix[0].length; i++) {
        matrix[0][i] = 0;
    }
}

최종 코드

class Solution {
    public void setZeroes(int[][] matrix) {
        // 배열의 첫 번째 행과 열은 해당 행과 열을
        // 0으로 치환해야하는지 판단하는데 사용
        
        // 첫 번째 행을 0으로 채워야하는지 판별하기 위한 변수
        // 첫 번째 행과 첫 번째 열은 겹치기 때문에 행 판단을 위한 변수를 따로 사용
        boolean firstRow = false;
        
        // 배열의 각 행,열을 탐색하여
        // 각 행과 열의 0 치환 여부를 판단
        for(int i = 0; i < matrix.length; i++){
            for(int j = 0; j < matrix[0].length; j++){
                // 현재 탐색중인 값이 0이라면
                if(matrix[i][j] == 0) {
                    // 현재 열은 0으로 치환해야하는 것으로 판단
                    matrix[0][j] = 0;
                    
                    // 첫 번째 행이 아닌 경우
                    // 현재 행은 0으로 치환해야하는 것으로 판단
                    if(i > 0) matrix[i][0] = 0;
                    // 첫 번째 행인 경우
                    // 첫 번째 행은 0으로 치환해야하는 것으로 판단
                    else firstRow = true;
                }
            }
        }
        
        // 첫 번째 행,열을 제외한 나머지 셀 값 치환
        for(int i = 1; i < matrix.length; i++) {
            for(int j = 1; j < matrix[0].length; j++) {
                // 탐색중인 행이 0이거나 열이 0인 경우
                // 현재 값을 0으로 변경
                if(matrix[i][0] == 0 || matrix[0][j] == 0) {
                    matrix[i][j] = 0;
                }
            }
        }
        
        // 첫 번째 열이 0인 경우
        if(matrix[0][0] == 0) {
            // 첫 번째 열의 모든 값을 0으로 변경
            for(int i = 0; i < matrix.length; i++) {
                matrix[i][0] = 0;
            }
        }
        
        // 첫 번째 행이 0인 경우
        if(firstRow) {
         // 첫 번째 행의 모든 값을 0으로 변경
            for(int i = 0; i < matrix[0].length; i++) {
                matrix[0][i] = 0;
            }
        }
    }
}

[LeetCode] 143. Reorder List - Java

HYOJUN — Tue, 24 Jan 2023 23:05:48 +0900

https://leetcode.com/problems/reorder-list/

Reorder List - LeetCode

Reorder List - You are given the head of a singly linked-list. The list can be represented as: L0 → L1 → … → Ln - 1 → Ln Reorder the list to be on the following form: L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → … You may not modify the va

leetcode.com

문제

You are given the head of a singly linked-list. The list can be represented as:

L0 → L1 → … → Ln - 1 → Ln

Reorder the list to be on the following form:

L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …

You may not modify the values in the list's nodes. Only nodes themselves may be changed.

Example 1:

Input: head = [1,2,3,4]
Output: [1,4,2,3]

Example 2:

Input: head = [1,2,3,4,5]
Output: [1,5,2,4,3]

Constraints:

The number of nodes in the list is in the range [1, 5 * 104].
1 <= Node.val <= 1000

풀이

풀이 과정

리스트의 head 노드가 주어지고 리스트의 각 노드가 0 → 1 → ... n-1 → n 이라고 할 때 주어진 리스트를 0 → n → 1 → n-1 → ... 의 형태로 재배열하는 문제이다.

문제에서 주어진 조건을 다시 정리하면 리스트의 시작점과 끝점에서부터 각각 노드가 한번씩 교차하도록 재배열을 해야한다. 재배열하기위해 크게 다음 세가지 단계를 거친다.

리스트를 절반으로 나누기
나누어진 리스트 중 뒤의 리스트를 역순 배열하기
나누어진 두 리스트를 번갈아가며 합치기

먼저 리스트를 절반으로 나누기 위해서는 한 칸씩 움직이는 포인터와 두 칸씩 움직이는 두 개의 포인터를 이용한다. 두 칸씩 움직이는 포인터가 리스트의 끝에 도달할 때 한 칸씩 움직이는 포인터의 위치가 리스트의 가운데가 된다.

// 중앙 값을 구하기 위해
// 한 칸씩 움직일 포인터와
// 두 칸씩 움직일 포인터 선언
ListNode slow = head;
ListNode fast = head;

// fast 포인터가 끝에 도착할 때 까지 포인터 이동
while(fast.next != null && fast.next.next != null){
    slow = slow.next;
    fast = fast.next.next;
}

다음으로 나누어진 리스트 중 뒤의 리스트를 역순 배열하기 위해서 LeetCode의 206. Reverse Linked의 풀이를 참고하여 리스트를 역순 정렬하는 함수를 작성한다.

[LeetCode] 206. Reverse Linked List - Java

https://leetcode.com/problems/reverse-linked-list/description/ Reverse Linked List - LeetCode Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview. leetcode.com 문제

hyojun.tistory.com

// 리스트 역순 정렬
public ListNode reverseList(ListNode head) {
    // 빈 리스트이거나 다음 노드가 없으면 재귀 호출 종료
    if(head == null || head.next == null){
        return head;
    }

    // 다음 노드 재귀 호출
    ListNode List = reverseList(head.next);

    // 현재 노드의 다음 노드가 가리키는 next 값을 현재 head로 설정
    head.next.next = head;
    // 현재 노드가 가리키는 다음 노드를 null로 설정
    head.next = null;

    // 변경된 List를 return
    return List;
}

만들어진 함수를 이용하여 절반으로 나누어진 리스트 중 뒤의 리스트를 역순 정렬하고 slow 포인터의 next를 null로 설정하여 앞의 절반까지의 리스트를 만든다.

// 절반 이후 부터 역순으로 정렬
ListNode list2 = reverseList(slow.next);
// 절반까지의 리스트
slow.next = null;
ListNode list1 = head;

마지막으로 나누어진 두 개의 리스트를 번갈아가면서 노드를 삽입하여 재졍렬된 리스트를 구한다.

while(list1 != null && list2 != null){
    // 번갈아 가며 노드를 삽입
    ListNode temp = list1.next;
    list1.next = list2;
    list1 = list2;
    list2 = temp;
}

리스트의 길이가 2이하인 경우 재정렬을 하는 경우에도 같은 리스트이기 때문에 처음에 조건을 주어 불필요한 연산을 제거한다.

// 리스트의 길이가 2이하 이면 정렬이 불필요하므로 종료
if(head == null || head.next == null || head.next.next == null) return;

최종 코드

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public void reorderList(ListNode head) {
        // 리스트의 길이가 2이하 이면 정렬이 불필요하므로 종료
        if(head == null || head.next == null || head.next.next == null) return;

        // 중앙 값을 구하기 위해
        // 한 칸씩 움직일 포인터와
        // 두 칸씩 움직일 포인터 선언
        ListNode slow = head;
        ListNode fast = head;

        // fast 포인터가 끝에 도착할 때 까지 포인터 이동
        while(fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        
        // 절반 이후 부터 역순으로 정렬
        ListNode list2 = reverseList(slow.next);
        // 절반까지의 리스트
        slow.next = null;
        ListNode list1 = head;
        
        while(list1 != null && list2 != null){
            // 번갈아 가며 노드를 삽입
            ListNode temp = list1.next;
            list1.next = list2;
            list1 = list2;
            list2 = temp;
        }
    }

    // 리스트 역순 정렬
    public ListNode reverseList(ListNode head) {
        // 빈 리스트이거나 다음 노드가 없으면 재귀 호출 종료
        if(head == null || head.next == null){
            return head;
        }

        // 다음 노드 재귀 호출
        ListNode List = reverseList(head.next);

        // 현재 노드의 다음 노드가 가리키는 next 값을 현재 head로 설정
        head.next.next = head;
        // 현재 노드가 가리키는 다음 노드를 null로 설정
        head.next = null;

        // 변경된 List를 return
        return List;
    }
}

[LeetCode] 23. Merge k Sorted Lists - Java

HYOJUN — Fri, 20 Jan 2023 23:10:55 +0900

https://leetcode.com/problems/merge-k-sorted-lists/description/

Merge k Sorted Lists - LeetCode

Merge k Sorted Lists - You are given an array of k linked-lists lists, each linked-list is sorted in ascending order. Merge all the linked-lists into one sorted linked-list and return it. Example 1: Input: lists = [[1,4,5],[1,3,4],[2,6]] Output: [1,1,2,

leetcode.com

문제

You are given an array of k linked-lists lists, each linked-list is sorted in ascending order.

Merge all the linked-lists into one sorted linked-list and return it.

Example 1:

Input: lists = [[1,4,5],[1,3,4],[2,6]]
Output: [1,1,2,3,4,4,5,6]
Explanation: The linked-lists are:
[
  1->4->5,
  1->3->4,
  2->6
]
merging them into one sorted list:
1->1->2->3->4->4->5->6

Example 2:

Input: lists = []
Output: []

Example 3:

Input: lists = [[]]
Output: []

Constraints:

k == lists.length
0 <= k <= 104
0 <= lists[i].length <= 500
-104 <= lists[i][j] <= 104
lists[i] is sorted in ascending order.
The sum of lists[i].length will not exceed 104.

풀이

풀이 과정

linked list들로 이루어진 배열 lists가 주어질 때 모든 주어진 리스트를 오름차순으로 병합된 리스트를 구해야한다.

우선순위 큐를 이용하여 풀이한다.
일반적인 큐는 먼저 들어온 데이터가 먼저 나가게 되는 FIFO(First In First Out) 형태의 자료구조이지만 우선순위 큐는 우선순위가 높은 데이터가 먼저 나가게 되는 자료구조이다.

우선 lists 배열이 빈 값인 경우 바로 null을 반환한다.

// 전달받은 리스트가 null인 경우 바로 null return
if(lists == null) return null;

탐색에 사용할 우선순위 큐를 선언한다. 이 때 리스트의 값을 기준으로 우선순위가 정의 되어야 하기 때문에 다음과 같이 리스트의 값을 기준으로 비교하도록 생성한다.

// 탐색에 사용할 우선순위 큐 선언
// 리스트 노드의 값을 기준으로 정렬
PriorityQueue<ListNode> pq = new PriorityQueue<>((a1,a2)->{
    return a1.val-a2.val;
});

리스트들을 합치는 과정은 다음과 같다.

모든 리스트 노드를 우선순위 큐에 삽입
우선순위가 가장 높은 리스트 노드(노드의 값이 가장 작은 리스트 노드)를 하나 꺼냄
꺼낸 리스트 노드를 정답에 추가
꺼낸 리스트 노드의 next 값이 존재한다면 우선순위 큐에 next 값 삽입
큐가 빌 때 까지 1 ~ 4의 과정을 반복

반복문을 이용하여 lists 배열에 있는 리스트들을 큐에 삽입한다.

// lists 배열에 있는 리스트들을 큐에 삽입
for(int i = 0; i < lists.length; i++){
    if(lists[i] != null) pq.offer(lists[i]);
}

탐색에 필요한 변수값들을 선언한다.

// 반환할 정답 리스트를 생성
ListNode answer = new ListNode(0);
// 노드를 추가하기 위한 포인터
ListNode pointer = answer;
// 현재 탐색중인 노드
ListNode curNode = null;

큐에서 값을 꺼내어 정답 리스트에 추가하고 꺼낸 값의 next 값을 큐에 삽입하는 과정을 큐가 빌 때 까지 반복한다.

// 큐가 빌 때 까지 반복
while(!pq.isEmpty()){
    // 큐에서 값을 꺼냄
    curNode = pq.poll();
    // 정답 리스트에 추가
    pointer.next = curNode;
    // 포인터 이동
    pointer = pointer.next;
    // 현재 탐색중인 노드의 next 값이 존재하는 경우 next 값을 큐에 다시 삽입
    if(curNode.next != null) pq.offer(curNode.next);
}

최종적으로 만들어진 리스트 노드를 return

// 정답 리스트 return
// 임의의 값을 넣어 생성하였으므로 next부터 return
return answer.next;

최종 코드

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        // 전달받은 리스트가 null인 경우 바로 null return
        if(lists == null) return null;

        // 탐색에 사용할 우선순위 큐 선언
        // 리스트 노드의 값을 기준으로 정렬
        PriorityQueue<ListNode> pq = new PriorityQueue<>((a1,a2)->{
            return a1.val-a2.val;
        });

        // lists 배열에 있는 리스트들을 큐에 삽입
        for(int i = 0; i < lists.length; i++){
            if(lists[i] != null) pq.offer(lists[i]);
        }

        // 반환할 정답 리스트를 생성
        ListNode answer = new ListNode(0);
        // 노드를 추가하기 위한 포인터
        ListNode pointer = answer;
        // 현재 탐색중인 노드
        ListNode curNode = null;

        // 큐가 빌 때 까지 반복
        while(!pq.isEmpty()){
            // 큐에서 값을 꺼냄
            curNode = pq.poll();
            // 정답 리스트에 추가
            pointer.next = curNode;
            // 포인터 이동
            pointer = pointer.next;
            // 현재 탐색중인 노드의 next 값이 존재하는 경우 next 값을 큐에 다시 삽입
            if(curNode.next != null) pq.offer(curNode.next);
        }

        // 정답 리스트 return
        // 임의의 값을 넣어 생성하였으므로 next부터 return
        return answer.next;
    }
}

[LeetCode] 3. Longest Substring Without Repeating Characters - Java

HYOJUN — Tue, 17 Jan 2023 23:43:31 +0900

https://leetcode.com/problems/longest-substring-without-repeating-characters/description/

Longest Substring Without Repeating Characters - LeetCode

Longest Substring Without Repeating Characters - Given a string s, find the length of the longest substring without repeating characters. Example 1: Input: s = "abcabcbb" Output: 3 Explanation: The answer is "abc", with the length of 3. Example 2: Input

leetcode.com

문제

Given a string s, find the length of the longest

without repeating characters.

Example 1:

Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.

Example 2:

Input: s = "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.

Example 3:

Input: s = "pwwkew"
Output: 3
Explanation: The answer is "wke", with the length of 3.
Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.

Constraints:

0 <= s.length <= 5 * 104
s consists of English letters, digits, symbols and spaces.

풀이

풀이 과정

알파벳, 숫자, 공백으로 이루어진 문자열 s가 주어질 때, 중복된 문자를 가지지 않는 가장 긴 연속되는 부분 문자열의 길이를 구하는 문제이다.

중복되는 문자를 판단하기 위한 map과 시작, 종료인덱스 투 포인터를 이용하여 풀이한다.

우선 최종적으로 반환할 문자열의 최대 길이 변수와 탐색에 사용할 map, start, end 변수를 선언한다.

// 문자열 최대 길이
int maxLength = 0;
// 이미 나온 문자를 탐색하기 위한 map
// 탐색한 문자와 그 문자의 인덱스를 저장
Map<Character, Integer> map = new HashMap<>();
int start = 0;  // 탐색할 문자열의 시작 인덱스
int end = 0;    // 탐색할 문자열의 종료 인덱스

탐색 과정은 아래와 같다.

end 포인터가 문자열의 끝에 도달하거나 앞으로 탐색할 문자열의 길이가 maxLength 이하가 될 때까지 반복한다.
처음 탐색하는 문자인 경우 map에 현재 탐색중인 문자와 그 인덱스 값을 저장한다.
이미 탐색했던 문자인 경우 이전에 등장했던 인덱스의 다음 인덱스와 현재 start 인덱스 중 큰 값으로 start를 갱신하고 현재 문자의 등장 인덱스를 갱신한다.
현재 만들어진 문자열의 길이와 최대 길이를 비교하여 최대 길이를 갱신한다.
종료 인덱스를 증가시킨다.

// 문자열을 끝까지 탐색하거나
// 탐색할 문자열의 길이가 maxLength 이하가 될 때 까지 반복
while(end < s.length() && maxLength <= s.length() - start) {
    char letter = s.charAt(end);
    // 처음 탐색하는 문자인 경우
    if(map.get(letter) == null) {
        // map에 현재 탐색중인 문자와 그 인덱스 값을 저장
        map.put(letter, end);
    }
    // 이미 탐색했던 문자인 경우
    else {
        // 이전에 등장했던 인덱스 다음 인덱스와 현재 start 인덱스 중 큰값으로 start 인덱스를 갱신
        start = Math.max(map.get(letter) + 1, start);
        // 현재 문자의 인덱스를 갱신
        map.put(letter, end);
    }
    // 현재 만들어진 문자열의 길이와 최대 길이를 비교하여 최대 길이 갱신
    maxLength = Math.max(maxLength, end - start + 1);
    end++; // 종료 인덱스 증가
}

최종적으로 구해진 최대 길이를 return한다.

// 최대 문자열의 길이를 return
return maxLength;

최종 코드

class Solution {
    public int lengthOfLongestSubstring(String s) {
        // 문자열 최대 길이
        int maxLength = 0;
        // 이미 나온 문자를 탐색하기 위한 map
        // 탐색한 문자와 그 문자의 인덱스를 저장
        Map<Character, Integer> map = new HashMap<>();
        int start = 0;  // 탐색할 문자열의 시작 인덱스
        int end = 0;    // 탐색할 문자열의 종료 인덱스
        
        // 문자열을 끝까지 탐색하거나
        // 탐색할 문자열의 길이가 maxLength 이하가 될 때 까지 반복
        while(end < s.length() && maxLength <= s.length() - start) {
            char letter = s.charAt(end);
            // 처음 탐색하는 문자인 경우
            if(map.get(letter) == null) {
                // map에 현재 탐색중인 문자와 그 인덱스 값을 저장
                map.put(letter, end);
            }
            // 이미 탐색했던 문자인 경우
            else {
                // 이전에 등장했던 인덱스 다음 인덱스와 현재 start 인덱스 중 큰값으로 start 인덱스를 갱신
                start = Math.max(map.get(letter) + 1, start);
                // 현재 문자의 인덱스를 갱신
                map.put(letter, end);
            }
            // 현재 만들어진 문자열의 길이와 최대 길이를 비교하여 최대 길이 갱신
            maxLength = Math.max(maxLength, end - start + 1);
            end++; // 종료 인덱스 증가
        }
        
        // 최대 문자열의 길이를 return
        return maxLength;
    }
}

[LeetCode] 102. Binary Tree Level Order Traversal - Java

HYOJUN — Tue, 17 Jan 2023 23:34:03 +0900

https://leetcode.com/problems/binary-tree-level-order-traversal/

Binary Tree Level Order Traversal - LeetCode

Binary Tree Level Order Traversal - Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level). Example 1: [https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg] Input: root = [

leetcode.com

문제

Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level).

Example 1:

Input: root = [3,9,20,null,null,15,7]
Output: [[3],[9,20],[15,7]]

Example 2:

Input: root = [1]
Output: [[1]]

Example 3:

Input: root = []
Output: []

Constraints:

The number of nodes in the tree is in the range [0, 2000].
-1000 <= Node.val <= 1000

풀이

풀이 과정

이진 트리가 주어질 때, 트리의 각 레벨별 노드를 리스트로 묶어 반환하는 문제이다.

이 문제에서는 큐를 이용하여 레벨별로 노드를 구한다.

우선 반환할 결과값 리스트, 탐색에 사용할 큐를 선언하고, 빈 트리가 들어왔을 경우 탐색할 필요가 없으므로 빈 리스트를 바로 return 하도록 먼저 처리해준다.

// 반환할 결과값 리스트
List<List<Integer>> result = new ArrayList<>();

// 빈 트리인 경우 탐색할 필요가 없으므로 빈 리스트를 바로 return
if(root == null) return result;

// 탐색에 사용할 큐
Queue<TreeNode> q = new LinkedList<>();

큐를 이용한 탐색의 과정은 다음과 같다.

먼저 전달받은 트리의 root 노드를 큐에 넣은 상태로 탐색을 시작한다.

// root를 큐에 넣고 탐색 시작
q.offer(root);

큐의 사이즈를 구하고 그 사이즈만큼 반복하며 큐에서 노드를 꺼내어 리스트에 추가한다.
첫 번째 탐색의 경우 한 번, 즉 1레벨 노드의 탐색이 가능하다.
그리고 꺼낸 노드의 좌우 노드를 큐에 추가한다.

1레벨 노드의 탐색이 종료되고 나면 1레벨 노드들은 큐에서 모두 빠지고 2레벨의 노드만이 남게 된다.
큐의 사이즈를 다시 구하고 위의 과정을 반복하면 각 레벨별로 노드의 리스트를 구할 수 있게된다.

// 큐가 빌 때까지 반복
while(!q.isEmpty()){
    // 현재 큐의 사이즈만큼 반복 -> 같은 레벨

    // 현재 레벨의 노드들이 담길 리스트
    List<Integer> curLevel = new ArrayList<>();

    // 큐의 사이즈 -> 같은 레벨이 담겨있는 만큼
    int size = q.size();
    for(int i = 0; i < size; i++){
        // 큐에서 값을 꺼냄
        TreeNode curNode = q.poll();
        // 현재 레벨의 리스트에 노드 추가
        curLevel.add(curNode.val);
        // 현재 노드의 좌우 노드를 큐에 추가
        if(curNode.left != null) q.offer(curNode.left);
        if(curNode.right != null) q.offer(curNode.right);
    }

    // 현재 레벨 노드 리스트를 정답 리스트에 추가
    result.add(curLevel);
}

최종적으로 만들어진 리스트를 return 한다.

// 최종 결과값 반환
return result;

최종 코드

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        // 반환할 결과값 리스트
        List<List<Integer>> result = new ArrayList<>();

        // 빈 트리인 경우 탐색할 필요가 없으므로 빈 리스트를 바로 return
        if(root == null) return result;

        // 탐색에 사용할 큐
        Queue<TreeNode> q = new LinkedList<>();

        // root를 큐에 넣고 탐색 시작
        q.offer(root);

        // 큐가 빌 때까지 반복
        while(!q.isEmpty()){
            // 현재 큐의 사이즈만큼 반복 -> 같은 레벨

            // 현재 레벨의 노드들이 담길 리스트
            List<Integer> curLevel = new ArrayList<>();

            // 큐의 사이즈 -> 같은 레벨이 담겨있는 만큼
            int size = q.size();
            for(int i = 0; i < size; i++){
                // 큐에서 값을 꺼냄
                TreeNode curNode = q.poll();
                // 현재 레벨의 리스트에 노드 추가
                curLevel.add(curNode.val);
                // 현재 노드의 좌우 노드를 큐에 추가
                if(curNode.left != null) q.offer(curNode.left);
                if(curNode.right != null) q.offer(curNode.right);
            }

            // 현재 레벨 노드 리스트를 정답 리스트에 추가
            result.add(curLevel);
        }

        // 최종 결과값 반환
        return result;
    }
}