좌충우돌 anecdote

문제

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

Given an m x n matrix, return all elements of the matrix in spiral order.

=> m x n 행렬이 주어지면 행렬의 모든 원소를 나선형 순서로 반환하라.

문제 풀이

2차열 배열을 나선형 순서로 순회하는 문제이다.

1. 위쪽 가로줄

2. 오른쪽 세로줄

3. 아래쪽 가로줄

4. 왼쪽 세로줄

1~4까지 순서대로 순회하면 되는데, 단 3, 4번에서 1, 2를 방문했는지 체크해야 한다. 

예를 들어보자.
3번을 순회하는데 top이 bottom을 넘으면 이미 위쪽 가로줄을 방문한 상태이므로 아래로 내려갈 필요가 없다.

또 4번을 순회하는데 left가 right을 넘으면 이미 오른쪽 세로줄을 방문한 상태이므로 왼쪽으로 이동할 필요가 없다.

해당 규칙만 알고 문제를 풀면 된다.

코드

/**
 * @param {number[][]} matrix
 * @return {number[]}
 */
var spiralOrder = function(matrix) {
    if (!matrix || matrix.length === 0) {
        return [];
    }

    const result = [];
    let top = 0;
    let right = matrix[0].length - 1;
    let bottom = matrix.length - 1;
    let left = 0;

    while (top <=bottom && left <= right) {
        // 위쪽 가로줄
        for (let i=left; i<=right; i++) {
            result.push(matrix[top][i])
        }
        top++;

        // 오른쪽 세로줄
        for (let i=top; i<=bottom; i++) {
            result.push(matrix[i][right])
        }
        right--;

        // 아래 가로줄
        if (top <= bottom) {
            for (let i=right; i>=left; i--) {
                result.push(matrix[bottom][i])
            }
            bottom--;
        }

        // 왼쪽 세로줄
        if (left <= right) {
            for (let i=bottom; i>=top; i--) {
                result.push(matrix[i][left])
            }
            left ++;
        }
    }
    return result;
};

문제

이번 정보 올림피아드대회에서 좋은 성적을 내기 위하여 현수는 선생님이 주신 N개의 문제를 풀려고 한다.
각 문제는 그것을 풀었을 때 얻는 점수와 푸는 데 걸리는 시간이 주어지게 된다.
제한 시간 M 안에 N개의 문제 중 최대점수를 얻을 수 있는 경우를 구하는 문제이다.
단, 해당 문제는 해당 시간이 걸리면 푸는 걸로 간주하고 한 유형당 한 개만 풀 수 있다.

문제 풀이

해당 문제는 "문제를 풀거냐, 말거냐"로 나눠지는 이진트리 방식인 DFS 로 해결할 수 있다.

문제를 풀었을 때 얻는 점수 = sum

문제를 푸는 데 걸리는 시간 = time

DFS(L, sum, time)이 들어가고, 

1. 문제를 풀것인가
2. 문제를 풀지 않을 것인가

L이 n번째까지 오지 않을 경우

1번의 경우 L + 1, sum + 이전 sum, time + 이전 time

2번의 경우 L만 +1되고 sum, time

L이 n번째까지 온 경우

합계 비교 후 최대값을 넣어준다.

const fs = require('fs');
const filePath =
	process.platform === 'linux'
		? '/dev/stdin'
		: 'Javascript/dfs/최대점수구하기.txt';
const input = fs.readFileSync(filePath).toString().split('\n');

solution(input);

function solution(input) {
	const [n, m] = input[0].split(' ').map((i) => +i);
	let answer = Number.MIN_SAFE_INTEGER;
	const ps = []; // 점수
	const pt = []; // 문제를 푸는데 걸리는 시간
	for (let i = 1; i < n; i++) {
		[ps[i], pt[i]] = input[i].split(' ').map((i) => +i);
	}

	function DFS(L, sum, time) {
		if (time > m) return;
		if (L === n) {
			if (time <= m) {
				answer = Math.max(answer, sum);
			}
		} else {
			DFS(L + 1, sum + ps[L], time + pt[L]); // 문제를 푼다
			DFS(L + 1, sum, time); // 문제를 안푼다
		}
	}

	DFS(0, 0, 0);
	console.log(answer);
}

스택 프레임 (stack frame)

• 메모리의 스택 영역은 함수의 호출과 관계되는 지역 변수와 매개변수가 저장되는 영역이다.
• 스택 영역은 함수의 호출과 동시에 할당되며, 함수의 호출이 완료되면 소멸한다.

함수가 호출되면 스택에는 복귀 주소(호출이 끝난 뒤 돌아갈 반환 주소값), 매개 변수, 함수에서 선언된 지역 변수 등이 저장된다.

이렇게 스택 영역에 차례대로 저장되는 함수의 호출 정보를 스택 프레임(stack frame)이라고 한다.

-> 스택 프레임 덕분에 함수 호출이 끝난 뒤에, 해당 함수가 호출되기 이전 상태로 돌아갈 수 있게 된다.

function DFS(L) {
	if (L === 0) return;
        else {
            DFS(L-1);
            console.log(L);
        }
}

해당 코드에서 L이 3이라면

스택에는 아래부터 위로 DFS(3) -> DFS(2) -> DFS(1) -> DFS(0)이 된다.

DFS(0)이 되었을 때 함수는 return; 을 맞닿고 함수 호출이 완료된다.

따라서 가장 위에 있던 DFS(0)이 사라지고(pop) 복귀 주소를 갖고 있었기 때문에 DFS(1)로 내려간다.
여기서 DFS(1)은 하지 못했던 일을 수행하기 위해 다음 줄로 내려간다.

즉, console.log(L)로 내려간다.

1을 반환하고, 호출이 끝났기 때문에 pop되고 DFS(2)로 복귀된다.
또 2를 반환하고 DFS(2)가 사라진다. 다시 DFS(3)로 내려오고 3이 반환된다.

참고 자료

http://www.tcpschool.com/c/c_memory_stackframe

문제

Given a string s, find the length of the longest substring without repeating characters.

문자열이 지정된 경우 반복 문자 없이 가장 긴 부분 문자열의 길이를 찾아라.

풀이법

1. 겹치치 않는 문자열을 저장한다. a2. a에서 s[i]와 겹치는 게 있는지 확인한다.

- 겹치는 게 있다면 a에서 s[i] 인덱스를 기준으로 slice 한다.

- 겹치는 게 없다면 a에 s[i]를 추가한다.

3. 가장 긴 문자열 기준이므로 문자열 길이를 저장한다.

코드

var lengthOfLongestSubstring = function (s) {
	let substr = ''; // 겹치치 않는 문자열 저장
	let count = 0;
	for (let i = 0; i < s.length; i++) {
		if (substr.includes(s[i])) {
			// 만약 substr에 포함되어 있으면
			// 포함되어 있는 s[i]의 인덱스를 찾아서 +1부터 끝까지 자른다.
			substr = substr.slice(substr.indexOf(s[i]) + 1);
		}
		substr += s[i];
		if (count < substr.length) {
			count = substr.length;
		}
	}
	return count;
};

문제 풀이

하나의 문자열 배열이 그룹인지 아닌지 판단해야 한다.
그룹을 판단하는 함수 내에서는 새로운 배열을 만들어, 그룹이라면 해당 값을 넣어준다.
예를 들어, str 배열이 ['h', 'a', 'p', 'p', 'y'] 이렇게 생겼다면, 새로운 배열 안에 h, a, p 넣고, p가 또 왔을 때 이전 값과 동일하기 때문에 넣어준다. 

이제 그룹을 판단했으니, 해당 newArr이 기존의 값과 동일한지 체크한다.

const fs = require('fs');
const filePath =
	process.platform === 'linux' ? '/dev/stdin' : 'Javascript/b1316/input.txt';
let input = fs.readFileSync(filePath).toString().trim().split('\n');

solution(input);

function solution(input) {
	let count = 0;
	for (let i = 1; i < input.length; i++) {
		const str = input[i].split('');
		if (isGroup(str).join('') === str.join('')) {
			count++;
		}
	}
	console.log(count);

	/** 그룹 판단 함수 */
	function isGroup(str) {
		let newArr = [];
		for (let i = 0; i < str.length; i++) {
			// 배열 안에 아무것도 없거나 이전 값과 현재 값이 같으면
			if (newArr.indexOf(str[i]) === -1 || str[i] === str[i - 1]) {
				newArr.push(str[i]);
			}
		}
		return newArr;
	}
}