오프로드 탐험기

[LeetCode - 15] 3Sum - C++

thecloer — Sun, 19 Jan 2025 14:56:49 +0900

문제

Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.

Notice that the solution set must not contain duplicate triplets.

Example 1:

Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]
Explanation: 
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0.
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0.
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0.
The distinct triplets are [-1,0,1] and [-1,-1,2].
Notice that the order of the output and the order of the triplets does not matter.

Example 2:

Input: nums = [0,1,1]
Output: []
Explanation: The only possible triplet does not sum up to 0.

Example 3:

Input: nums = [0,0,0]
Output: [[0,0,0]]
Explanation: The only possible triplet sums up to 0.

Constraints:

3 <= nums.length <= 3000
-10⁵ <= nums[i] <= 10⁵

풀이

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> ans;

        for(int i = 0, end = nums.size() - 2; i < end; i++) {
            if(nums[i] > 0) break;
            if(i > 0 && nums[i] == nums[i - 1]) continue; // 중복 쌍 제거

            int j = i + 1, k = nums.size() - 1;
            while(j < k) {
                int sum = nums[i] + nums[j] + nums[k];
                if(sum < 0) j++;
                else if (sum > 0) k--;
                else {
                    ans.push_back({ nums[i], nums[j], nums[k] });

                    j++;
                    k--;
                    while(j < k && nums[j] == nums[j - 1]) j++; // 중복 쌍 제거
                }
            }
        }
        return ans;
    }
};

`i`를 `0 ~ nums.size() - 2`까지 순회하며 `i + 1 ~ nums.size() - 1`사이에서 투포인터로 Two Sum 2 문제를 푼다.

중복되는 쌍을 제거하는 일이 까다로울 수 있다.

정렬한 후 같은 숫자에 대해서는 `i`와 투 포인터의 `j`를 끝까지 밀어 중복 쌍을 카운트하지 않도록한다.

[LeetCode - 167] Two Sum II - Input Array Is Sorted - C++

thecloer — Sun, 19 Jan 2025 14:51:33 +0900

문제

Given a 1-indexed array of integers numbers that is already sorted in non-decreasing order, find two numbers such that they add up to a specific target number. Let these two numbers be numbers[index₁] and numbers[index₂] where 1 <= index₁ < index₂ <= numbers.length.

Return the indices of the two numbers, index₁ and index₂, added by one as an integer array [index₁, index₂] of length 2.

The tests are generated such that there is exactly one solution. You may not use the same element twice.

Your solution must use only constant extra space.

Example 1:

Input: numbers = [2,7,11,15], target = 9
Output: [1,2]
Explanation: The sum of 2 and 7 is 9. Therefore, index1 = 1, index2 = 2. We return [1, 2].

Example 2:

Input: numbers = [2,3,4], target = 6
Output: [1,3]
Explanation: The sum of 2 and 4 is 6. Therefore index1 = 1, index2 = 3. We return [1, 3].

Example 3:

Input: numbers = [-1,0], target = -1
Output: [1,2]
Explanation: The sum of -1 and 0 is -1. Therefore index1 = 1, index2 = 2. We return [1, 2].

Constraints:

2 <= numbers.length <= 3 * 10⁴
-1000 <= numbers[i] <= 1000
numbers is sorted in non-decreasing order.
-1000 <= target <= 1000
The tests are generated such that there is exactly one solution.

풀이

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        int l = 0, r = numbers.size() - 1;
        while(l < r) {
            int sum = numbers[l] + numbers[r];
            if(sum == target) return { l + 1, r + 1 };
            if(sum < target) l++;
            else r--;
        }
        return { 0, 0 };
    }
};

[LeetCode - 125] Valid Palindrome - C++

thecloer — Sun, 19 Jan 2025 14:49:25 +0900

문제

A phrase is a palindrome if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers.

Given a string s, return true if it is a palindrome, or false otherwise.

Example 1:

Input: s = "A man, a plan, a canal: Panama"
Output: true
Explanation: "amanaplanacanalpanama" is a palindrome.

Example 2:

Input: s = "race a car"
Output: false
Explanation: "raceacar" is not a palindrome.

Example 3:

Input: s = " "
Output: true
Explanation: s is an empty string "" after removing non-alphanumeric characters.
Since an empty string reads the same forward and backward, it is a palindrome.

Constraints:

1 <= s.length <= 2 * 10⁵
s consists only of printable ASCII characters.

풀이

class Solution {
public:
    bool isPalindrome(string s) {
        int l = 0, r = s.size() - 1;
        while(l < r) {
            while(l < r && !isAlphanumeric(s[l])) l++;
            while(l < r && !isAlphanumeric(s[r])) r--;
            if(tolower(s[l]) != tolower(s[r])) return false;
            l++; r--;
        }
        return true;
    }

    bool isAlphanumeric(char c) {
        return (
            'A' <= c && c <= 'Z' ||
            'a' <= c && c <= 'z' ||
            '0' <= c && c <= '9'
        );
    }
};

투포인터가 양쪽에서 가운데로 모이며 non-alphanumeric 문자는 무시한다.

[TS] 타입이론과 고급 타입 추론

thecloer — Thu, 14 Nov 2024 02:06:23 +0900

유튜브에 공개된 네이버 사내 기술 교류 행사인 NAVER ENGINEERING DAY 2024(5월)에서 발표되었던 세션을 보고 타입스크립트의 타입 시스템에 대한 이해가 깊어졌습니다. 해당 발표 영상을 보고 추후 다시 찾아볼 수 있도록 정리한 내용입니다. 본문에는 제 나름 대로의 해석이 추가되어 오해의 여지가 있을 수 있습니다.

발표 영상: infer, never만 보면 두려워지는 당신을 위한 고급 TypeScript

타입이론과 TypeScript

러셀의 역설(Russell's Paradox)의 발견으로 수학의 근간인 집합론이 흔들리며 함수에 대한 고찰도 이루어졌다.

기존 집합 사이의 관계로만 생각했던 함수에 대한 고찰을 시작은 람다 대수(Lambda Calculus)의 고안을 이끌었고 이를 고도화하던 중 타입의 개념이 도입되었다. 관련 내용은 해당 문서에 상세히 나와있다. https://plato.stanford.edu/entries/type-theory/

놀랍게도 TypeScript는 1.8까지 공식문서가 존재했으나 Microsoft가 문서 유지보수를 포기하며 tsc의 구현이 곧 TypesScript의 스펙이 되었다.

TypeScript Language Specification 1.8.pdf

1.62MB

해당 영상은 tsc를 블랙박스로 간주하고 수학적 일관성과 실험을 근거로 서술한다.

기초 타입 추론

슈퍼타입과 서브타입

영상에서는 타입을 `어떤 심벌(Symbol, ≒ 변수명)에 엮인(binded) 메모리 공간에 존재할 수 있는 값(value)의 집합과 그 값들이 가질 수 있는 성질(properties)`로 정의한다.

`3.141592 : number` 이와 같은 표기는 `값 3.141592는 타입 number에 속한다.`로 이해할 수 있다.

$$\{\text{x}:\text{number};\thinspace\text{y}?:\text{string} \}\lesssim\{\text{x}:\text{number}\}$$

타입 $\{\text{x}:\text{number};\thinspace\text{y}?:\text{string}\}$은 타입 $\{\text{x}:\text{number}\}$에 속한다.

타입 $\{\text{x}:\text{number};\thinspace\text{y}?:\text{string} \}$은 타입 $\{\text{x}:\text{number}\}$의 서브타입이다.

타입 $\{\text{x}:\text{number}\}$은 타입 $\{\text{x}:\text{number};\thinspace\text{y}?:\text{string}\}$의 슈퍼타입이다.

`타입 B가 가지는 모든 속성을 타입 A가 가지면, 타입 A는 B의 서브타입이다.`

`서브타입은 슈퍼타입의 모든 속성을 갖는다.`

타입 간의 관계와 대입

타입은 4가지 관계를 가질 수 있다.

$\text{a} \gtrsim \text{b}$: a가 b의 슈퍼타입이다. ( $\text{number} \gtrsim 42$ )
$\text{a} \lesssim \text{b}$: a가 b의 서브타입이다. ( $\text{string} \lesssim \text{string \textbar number}$ )
$\text{a} \simeq \text{b}$: a와 b가 서로 서브타입이다. ( $\{\text{x}?:\text{number}\}\simeq \{\text{x}:\text{number \textbar \text{undefined}}\}$ )
$\text{a} \not\simeq \text{b}$: 서로 관계가 없다. ( $\text{number} \not\simeq \{\text{x}:\text{string}\}$ )

작은 타입을 큰 타입에 대입할 수 있다.

`서브타입을 슈퍼타입에 대입할 수 있다.`

원시 타입(Primitive Type)

boolean, number, string, symbol, null, undefined
공리적으로 정의
상호 무관계
null을 제외한 모든 원시 타입은 `typeof`연산 결과 해당 타입의 이름이 나온다.

리터럴 타입(Literal Type)

어떤 타입에 속한 값 하나만으로 구성하는 타입
본래 타입의 서브타입으로 간주
as const 키워드로 특정 값을 리터럴 타입으로 선언할 수 있다.

const x = 6; // x: number (원시 타입으로 추론)
const y = 6 as const; // y: 6 (리터럴)

객체 타입(Object Type)

타입 L과 R에서 타입 L의 모든 속성 P에 대하여 $\text{L[P]}\gtrsim \text{R[P]}$이면 $\text{L}\gtrsim\text{R}$이다.
이때 객체의 타입은 속성의 타입에 대해 `공변적(Covariant)`이라 한다.

배열/튜플 타입(Array/Typle Type)

객체와 동일하다. 키가 number로 고정되어 있다는 점만 다르다.
튜플은 length가 상수 리터럴 타입으로 고정되어 있다.

$$\text{a}\lesssim\text{b}\Longrightarrow\text{A[ ]}\lesssim\text{B[ ]}$$

함수 타입(Function Type)

반환형과 인자형의 대입 조건을 모두 만족해야 한다.
반환형에 대해서는 `공변적(Covariant)`
- $\text{A}\lesssim\text{B}\Longrightarrow\text{X}\mapsto\text{A}\lesssim\text{X}\mapsto\text{B}$
- 인자형이 같은 두 함수에서 A가 B의 서브타입이라면 A를 반환하는 함수가 B를 반환하는 함수의 서브타입이다.
- 함수의 타입 관계는 반환형의 타입관계와 같은 방향이다. (공변적이다.)
- 반환값은 rvalue로 사용되기 때문에 함수의 타입과 반환형의 타입은 공변적이다.
인자형에 대해서는 `반변적(Contravariant)`
- $\text{A}\lesssim\text{B}\Longrightarrow\text{A}\mapsto\text{X}\gtrsim\text{B}\mapsto\text{X}$
- 반환형이 같은 두 함수에서 A가 B의 서브타입이라면 A를 인자로 갖는 함수는 B를 인자로 갖는 함수의 슈퍼타입이다.
인자의 수가 불일치하는 경우
- 인자가 적은 함수를 인자가 많은 함수에 대입할 수 있다.
- 인자가 적은 함수가 서브타입, 인자가 많은 함수가 슈퍼타입이 된다.
- 인터페이스(슈퍼타입, 인자 많은 함수)로 들어오는 넘치는 인자는 구현체(서브타입, 인자 적은 함수)에서 버리면 그만이다.

특수 타입

Javascript에는 존재하지 않으나 TypeScript에서 타입상으로만 존재하는 타입

never, unknown, any, void
never & unknown
- $\forall_T:\text{never}\lesssim\text{T}\lesssim\text{unknown}$
- `never`는 가장 좁은 타입이다.
  - 모든 타입의 서브타입이다.
  - 공집합과 비슷하다.
  - 어떤 타입도 대입할 수 없다.
  - 타입 에러를 고의적으로 발생시킬 때에도 사용(제네릭에서 사용)
- `unknown`은 가장 넓은 타입이다.
  - 모든 타입의 슈퍼타입이다.
  - any, unknown을 제외한 어떠한 곳에도 대입이 불가능하다.
  - 모든 값을 받을 수는 있지만 대입할 수는 없다.
any
- $\forall_{\text{T}\not=\text{never}}:\text{T}\simeq\text{any},\,\text{never}\lesssim\text{any}$
- never를 제외한 모든 타입과 서로 서브타입이다.
- never를 제외한 모든 타입에 대입 가능하며 모든 타입을 받을 수 있다.

const thisIsNever: never = undefined; // ERROR: never는 모든 타입의 서브타입이다.
const thisIsUnknown: unknown = 0; // unknown은 모든 타입의 슈퍼타입이다.

퀴즈

// 다음 중 이론 상 가장 넓은 함수의 타입은? (슈퍼타입은?)
type A = (...args: unknown[]) => unknow;
type B = (...args: never[]) => unknow;
type C = (...args: any[]) => any;
type D = (...args: void[]) => never;

`B`는 모든 함수의 슈퍼타입이다.

함수의 타입은 반환형과 공변적, 인자형과 반변적이므로 반환형은 넓고, 인자형은 좁을수록 함수의 타입은 넓어진다.

반환형이 가장 넓은 타입인`unknown`이고 인자형이 가장 좁은 타입인 `never`인 `B`가 가장 넓은 함수 타입이다.

고급 타입 추론

타입 검사(Type Checking)

어떤 전체/부분 심벌에 대한 대입, 연산, 참조가 가능성을 확인하는 과정이다.

모든 심벌이 제약 조건(타입)을 만족하는가?
어떤 코드 맥락에서, 심벌이 가질 수 있는 타입은 어떤 것인가(type guard에 의한 분기)

타입 검사의 구현은 제약조건을 갖는 만족 가능성 문제(Constrained Satisfaction Problem, CSP)와 동치다. 하지만 SAT 문제(Satisfiability Problem)는 NP-완전 문제로 이론상 지수시간의 시간복잡도를 갖는다.

tsc는 SAT solver 혹은 CSP solver를 구현하지 않고 Greedy 알고리즘을 사용하는 것으로 추정된다. 실제 SAT solver가 아니기 때문에 추론 깊이의 한계가 있고 복잡하고 깊이가 깊은 타입을 구현할 경우 tsc에서 타입 추론을 정확하게 수행하지 못한다.

제네릭(Generic)

제네릭은 타입에 대한 함수이자 관계 그 자체다.
1차 논리만 서술 가능하다.
- 즉 고차 함수는 허용하지 않는다.

명시적 타입 전달(Explicit Type Argument Passing)

제네릭 타입 인자에 직접 타입을 기술
- ex) `useState<{ x?: number}>({})`
실행 흐름 상에서 명시적 타입 전달이 된 이후부터는 전달된 타입으로 추론

타입 인자 추론(Type Argument Inference)

타입 선언 안 한 경우, 제네릭 타입의 인자를 생략한 경우, infer 문을 사용한 경우
실행 흐름상에서 분석된 정보를 바탕으로 타입 인자를 추론
최대한 비관적이고 보수적으로 분석
- 가장 작은 타입으로 추론한다.
Greedy로 추론하기 때문에 완벽하게 추론되지 않는 경우가 있다.
라이브러리 제작자가 자주 고려해야 할 방식
- 함수 시그니쳐 오버로딩에서 순서에 민감하다.
- 가장 위부터 만족하는 함수 시그니쳐를 찾고 찾았다면 그 이후 시그니쳐는 확인하지 않는다.

조건부 타입(Conditional Type)

어떤 타입이 다른 타입의 서브타입인지 확인
그 여부에 따라서 다른 타입으로 변환
생각보다 Greedy 하고 일관성 없음 (왜 안되는지 모를 때가 많음)
`type HasName<T> = T extends { name: string }? true : false`

응용문제

아래 `flattenObject` 함수의 타입을 작성해 보자.

전체 코드는 TS Playground에서 확인하실 수 있습니다.

function flattenObject(obj: any, result: any = {}): any {
	for (const key in obj) {
    	if (typeof obj[key] === 'object' && obj[key] && !(obj[key] instanceof Array)) {
        	flattenObject(obj[key], result);
        } else {
        	result[key] = obj[key];
        }
    }
    return result;
}

/**
 * ```ts
 * const input: {
 *     a: number;
 *     b: string;
 *     c: string[];
 *     d: {
 *         dd: {
 *             ddd: null;
 *         };
 *         dddd: undefined;
 *     };
 *     e: {
 *         ee: string;
 *     };
 *     f: boolean;
 * }
 * ```
 */
const input = {
  a: 0,
  b: 'B',
  c: ['C'],
  d: {
    dd: {
      ddd: null,
    },
    dddd: undefined,
  },
  e: {
  	ee: 'E'
  },
  f: true
};

/** 
 * ```ts
 * const output: {
 *     a: number;
 *     b: string;
 *     c: string[];
 *     f: boolean;
 *     dddd: undefined;
 *     ddd: null;
 *     ee: string;
 * }
 * ```
 */
const output = flattenObject(input);

step 1. 이미 평탄화된 속성과 중첩 객체 속성 분리하기

먼저 depth가 1인 속성들(`a, b, c, d, e, f`)를 살펴보자. depth가 1인 속성 중에서 이미 평탄화가 되어있는 속성인 `a, b, c, f`는 그대로 출력하고 배열이 아닌 객체 타입을 값으로 갖는 속성인 `d, e` 재귀적으로 평탄화하면 된다. 이 둘을 분류하는 타입을 작성해 보자.

이미 평탄화된 속성 추출하기 1 (값을 never로 추론)

평탄화된 속성을 추출하는 방법으로 추출하지 않을 속성들의 타입을 `never`로 만들어 제거하는 방법을 생각해 볼 수 있다. 하지만 이 경우 키는 지워지지 않고 키의 값이 never로 추론돼 원하는 결과를 얻지 못한다.

/**
 * `CopyObjects`는 객체 타입을 그대로 복사하는 타입이다.
 * 타입을 복사한 후 배열이 아닌 객체 타입을 걸러내 원하는 결과를 얻어보자.
 */
type CopyObject<T extends object> = {
  [K in keyof T]: T[K]
};

/**
 * 중첩 타입 속성의 `값 타입을 never로 추론`해 해당 속성를 지운다.
 * 이 경우 속성는 남고 해당 속성의 타입이 never로 추론돼 원하는 결과를 얻지 못한다.
 */
type FilterByNonNestedValue<T> = 
  T extends object
    ? T extends unknown[]  // 배열 타입의 최상위 슈퍼타입인 unknown[]으로 배열 타입 검사
      ? T                  // 배열 타입을 갖는 속성은 타입을 그대로 반환
      : never              // 중첩 객체 값을 갖는 속성의 값 타입을 never로 추론해 속성 삭제 시도
    : T;                   // 객체가 아닌 값을 갖는 속성은 값 타입을 그대로 반환

type NonNestedObjectByValue<T extends object> = {
  [K in keyof T]: FilterByNonNestedValue<T[K]>
};

/**
 * ```ts
 * type NonNestedObjectByValueResult = {
 *     a: number;
 *     b: string;
 *     c: string[];
 *     d: never;    // Error!
 *     e: never;    // Error!
 *     f: boolean;
 * }
 * ```
 */
type NonNestedObjectByValueResult = NonNestedObjectByValue<typeof input>;

이미 평탄화된 속성 추출하기 2 (속성을 never로 추론)

위 `NonNestedObjectByValue`에서는 속성이 지워지지 않아 원하는 결과를 얻지 못했다. 값의 타입이 아닌 `속성의 타입을 never로 추론`해 속성을 지우면 원하는 결과를 얻을 수 있다.

/**
 * 위 `NonNestedObjectByValue`에서는 속성이 지워지지 않아 원하는 결과를 얻지 못했다.
 * `속성의 타입을 never로 추론`해 속성를 지워보자.
 */
type FilterByNonNestedProperty<T, K> = 
  K extends keyof T
    ? T[K] extends object         // 값이 객체 타입인지 확인
      ? T[K] extends unknown[]    // 값이 배열 타입인지 확인
        ? K                       // 값이 배열 타입이라면 속성을 필터링하지 않는다.
        : never                   // 값이 배열이 아닌 객체 타입이라면 속성을 필터링한다.
      : K                         // 값이 객체 타입이 아니라면 속성을 필터링하지 않는다.
    : never;                      // K가 T의 속성이 아닌 경우는 무시한다.

type NonNestedObject<T extends object> = {
  [K in FilterByNonNestedProperty<T, keyof T>]: T[K]
};

/**
 * ```ts
 * type NonNestedObjectResult = {
 *     a: number;
 *     b: string;
 *     c: string[];
 *     f: boolean;
 * }
 * ```
 */
type NonNestedObjectResult = NonNestedObject<typeof input>;

step 2. 중첩 객체 속성 타입 추출하기

이번엔 반대로 위 `NonNestedObject`에서 삭제한 중첩 객체 속성을 추출해 보자. `FilterByNonNestedProperty`타입에서 필터링하는 부분만 거꾸로 해주면 된다.

/**
 * 이번엔 반대로 위 `NonNestedObject`에서 삭제한 중첩 객체 속성을 추출해 보자. 
 * `FilterByNonNestedProperty`타입에서 필터링하는 부분만 거꾸로 해주면 된다.
 */
type FilterByNested<T, K> = 
  K extends keyof T
    ? T[K] extends object       // 값이 객체 타입인지 확인
      ? T[K] extends unknown[]  // 값이 객체 타입이라면 배열 타입인지 확인한다.
        ? never                 // 값이 배열 타입이라면 키를 필터링한다.
        : K                     // 값이 배열이 아닌 객체 타입이라면 필터링하지 않는다.
      : never                   // 값이 객체 타입이 아니라면 키를 필터링한다.
    : never;                    // K가 T의 키가 아닌 경우는 무시한다.

type ShallowNestedObject<T extends object> = {
  [K in FilterByNested<T, keyof T>]: T[K]
};

/**
 * ```ts
 * type ShallowNestedObjectResult = {
 *     d: {
 *         dd: {
 *             ddd: null;
 *         };
 *         dddd: undefined;
 *     };
 *     e: {
 *         ee: string;
 *     };
 * }
 * ```
 */
type ShallowNestedObjectResult = ShallowNestedObject<typeof input>;

step 3. 중첩 객체 차원 낮추기

`ShallowNestedObject`는 중첩 객체를 값으로 갖는 속성들만 추출한 타입이다. 이 타입의 차원을 하나 낮춰보자.

`ToIntersection`타입이 이해가지 않을 수 있다. 유니온 타입을 인터섹션 타입으로 변환해 주는 타입이다.

먼저 첫 번째 삼항 연산자는 `T extends any ? (_: T) => void : never` 항상 참이므로 `T`를 인자로 받는 함수 타입을 반환한다. 바로 함수 타입을 만들지 않고 삼항연산자로 만드는 이유는 분배법칙을 이용하기 위해서다.

만약 직접 함수타입을 만든다면 `T = string | number`인 경우 `(_: string | number) => void`와 같은 타입으로 추론된다.

여기서 삼항 연산자를 사용하면 분배법칙이 적용되어 `((_: string) => void) | ((_: number) => void)`와 같은 타입으로 추론된다.

두 개의 함수의 유니온 형태로 만들어 슈퍼타입을 추론하면 두 함수의 인자 타입의 서브타입인 인터섹션 타입을 얻을 수 있다.

// `Values`는 값의 타입을 유니온으로 추출한다.
type Values<T extends object> = T[keyof T];

/**
 * ```ts
 * type ValuesShallowNestedObjectResult = {
 *     dd: {
 *         ddd: null;
 *     };
 *     dddd: undefined;
 * } | {
 *     ee: string;
 * }
 * ```
 */
type ValuesShallowNestedObjectResult = Values<ShallowNestedObject<typeof input>>;


// `ToIntersection`은 유니온 타입을 인터섹션 타입으로 변환시키는 타입이다.
type ToIntersection<T> = (
  T extends any                   // 항상 참이다.
    ? (_: T) => void              // 조건부 타입 추론을 통해 유니온으로 묶인 T를 T를 인자로 갖는 함수의 유니온으로 분배법칙을 적용한다.
    : never
  ) extends (_: infer S) => void  // 유니온으로 묶인 함수의 슈퍼타입을 추론하면 인자의 반변성으로 인자는 서브타입으로 추론되어 인터섹션으로 변환된다.
    ? S
    : never;

type ShallowUnwrappedObject<T extends object> = ToIntersection<Values<ShallowNestedObject<T>>>;

/**
 * ```ts
 * type ShallowUnwrappedObjectResult = {
 *     dd: {
 *         ddd: null;
 *     };
 *     dddd: undefined;
 * } & {
 *     ee: string;
 * }
 * ```
 */
type ShallowUnwrappedObjectResult = ShallowUnwrappedObject<typeof input>


type ShallowFlattenObject<T extends object> = NonNestedObject<T> & ShallowUnwrappedObject<T>

/**
 * ```ts
 * type ShallowFlattenObjectResult = NonNestedObject<{
 *     a: number;
 *     b: string;
 *     c: string[];
 *     d: {
 *         dd: {
 *             ddd: null;
 *         };
 *         dddd: undefined;
 *     };
 *     e: {
 *         ee: string;
 *     };
 *     f: boolean;
 * }> & {
 *     dd: {
 *         ddd: null;
 *     };
 *     dddd: undefined;
 * } & {
 *     ee: string;
 * }
 * ```
 */
type ShallowFlattenObjectResult = ShallowFlattenObject<typeof input>

step 4. 재귀적으로 차원 낮추기

이제 위에서 만든 `ShallowFlattenObject`를 재귀적으로 적용해 `FlattenObject`를 완성해 보자.

하지만 아래와 같이 재귀적으로 작성하면 `type circulary references inself` 에러가 발생한다.

// Type alias 'ErrorDeepUnrappedObject' circularly references itself.(2456)
type ErrorDeepUnrappedObject<T extends object> = 
  ToIntersection<                          // 3. 결과 인터섹션
    ErrorDeepFlattenObject<                // 2-3. 1-depth 평탄화 된 타입에 대해 재귀적으로 평탄화
      Values<                              // 2-2. 중첩 객체 타입 1-depth 평탄화
        ShallowNestedObject<T>             // 2-1. 중첩 객체 타입 추출
      >       
    >
  > 

type ErrorDeepFlattenObject<T extends object> = 
  NonNestedObject<T>                       // 1. 이미 평탄회된 속성
  & ErrorDeepUnrappedObject<T>             // 2. 중첩 객체 타입에 대해 재귀적으로 평탄화

이를 삼항연산자를 이용해 지연평가 시켜 해결할 수 있다.

타입도 tsc가 해석한다. 이때 위 오류가 발생한 코드에 삼항연산자를 적용하면 tsc의 런타임에 타입 평가가 지연되어 오류가 발생하지 않는다.

// 삼항연산자의 지연평가를 이용한 재귀 헬퍼 타입
type RecursionHelper<T> = 
  T extends object                         // (항상 참이지만 지연평가된다.)
    ? DeepFlattenObject<T>                 // 2-3. 1-depth 평탄화 된 타입에 대해 재귀적으로 평탄화
    : never;

type DeepUnwrappedObject<T extends object> = 
  ToIntersection<                          // 3. 결과 인터섹션
    RecursionHelper<
      Values<                              // 2-2. 중첩 객체 타입 1-depth 평탄화
        ShallowNestedObject<T>             // 2-1. 중첩 객체 타입 추출
      >
    >
  > 

type DeepFlattenObject<T extends object> = 
  NonNestedObject<T>                       // 1. 이미 평탄회된 속성
  & DeepUnwrappedObject<T>                 // 2. 중첩 객체 타입에 대해 재귀적으로 평탄화

/**
 * ```ts
 * type DeepFlattenObjectResult = NonNestedObject<{
 *     a: number;
 *     b: string;
 *     c: string[];
 *     d: {
 *         dd: {
 *             ddd: null;
 *         };
 *         dddd: undefined;
 *     };
 *     e: {
 *         ee: string;
 *     };
 *     f: boolean;
 * }> & NonNestedObject<{
 *     dd: {
 *         ddd: null;
 *     };
 *     dddd: undefined;
 * }> & NonNestedObject<...> & NonNestedObject<...>
 * ```
 */
type DeepFlattenObjectResult = DeepFlattenObject<typeof input>;

step 5. 마무리

`DeepFlattenObject` 타입으로 원하는 결과를 얻었다. 하지만 위 타입은 디버깅이 어렵다. `Roll` 타입으로 tsc 트릭을 사용할 수 있다.

// 단순히 타입을 그대로 복사하는 타입이지만 타입 추론을 읽기 쉽도록 해준다.
type Roll<T> = {
  [K in keyof T]: T[K]
} & {};


/**
 * ```ts
 * type RollResult = {
 *     a: number;
 *     b: string;
 *     c: string[];
 *     f: boolean;
 *     dddd: undefined;
 *     ddd: null;
 *     ee: string;
 * }
 * ```
 */
type RollResult = Roll<DeepFlattenObject<typeof input>>


function flattenObject<T extends object>(obj: T, result: any = {}): Roll<DeepFlattenObject<T>> {
	for (const key in obj) {
    	if (typeof obj[key] === 'object' && obj[key] && !(obj[key] instanceof Array)) {
        	flattenObject(obj[key], result);
        } else {
        	result[key] = obj[key];
        }
    }
    return result;
}

부록

공변성(Covariant), 반공변성(Contravariance)

“두 타입간의 관계와 두 타입이 매핑된 타임간의 관계 사이의 관계”로 생각할 수 있다.

관계 사이의 관계라는 말이 와닿지 않을 수 있는데, 예시를 보면 이해가 쉽다.

두 타입간의 관계: $\text{과일} \gtrsim \text{사과}$ (과일은 사과의 슈퍼타입이다.)
매핑함수: $\text{X} \Longrightarrow \text{X주스}$
매핑된 타입간의 관계: $\text{과일주스} \gtrsim \text{사과주스}$

두 타입간의 관계와 매핑된 두 타입간의 관계가 같다. 따라서 매핑함수의 결과는 공변적이라고 볼 수 있다.

참고: https://ko.m.wikipedia.org/wiki/공변성과_반공변성_(컴퓨터_과학)

평탄화

평탄화(flatten)은 객체 혹은 배열의 depth를 줄이는 개념으로 이해할 수 있다. 집합으로 예를들면 최대 깊이가 2인 X를 평탄화해 깊이를 줄이면 Y와 같은 결과를 예상할 수 있다.
X = { a, b, { c }, d }

Y = { a, b, c , d }

대표적으로 javaScript의 `Array.prototype.flat()`이 있다.

참고: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat

[Build your own React] step0: Review

thecloer — Sun, 20 Oct 2024 17:24:31 +0900

시리즈에 대한 설명과 관련 글은 이 글에서 모아보실 수 있습니다.

Step 0: Review

이 글에서는 React.js(이하 React)의 내부 동작을 살펴보기 앞서 기본 개념에 대해 다룹니다. React, JSX, DOM 요소가 기본적으로 어떻게 상호작용하며 동작하는지 알고 있다면 건너뛰어도 좋습니다.

const element = <h1 title="foo">Hello</h1>;
const container = document.getElementById("root");
ReactDOM.render(element, container);

위 세 줄의 코드로 작성된 React 앱으로 React, JSX, DOM에 대해 가볍게 살펴봅시다.
첫 번째 줄은 React 요소(element)를 정의하고 두 번째 줄은 DOM으로부터 컨테이너로 사용할 노드(node)를 가져옵니다. 마지막 줄은 React 요소를 컨테이너 노드에 그립니다(render). 이 간단한 React 앱에서 React에서 제공하는 기능을 vanilla JS로 대체해 해당 기능을 조금 더 자세히 이해해 봅시다.

JSX and React element

React 요소를 정의하는 첫 번째 줄은 javascript 문법이 아닙니다. 이는 JSX 문법이며 JS 런타임에서 실행 가능하도록 Babel과 같은 빌드툴에 의해 JS로 변환됩니다. React를 Vanilla JS로 치환하기 전에 JSX를 JS로 변환해 봅시다. JSX를 JS로 변환하는 과정은 단순합니다. 코드를 파싱하여 태그 이름(`h1`), 속성(`title="foo"`), 자식(`Hello`)을 추출하고 추출한 값을 인자로 `createElement` 함수를 호출하면 됩니다. 이름, 속성, 값 등에 대해 validation과 같은 추가적인 과정이 있지만 글의 맥락과 맞지 않아 생략하겠습니다. JSX를 걷어낸 코드는 아래와 같습니다.

const element = React.createElement(
  "h1",
  { title: "foo" },
  "Hello"
);

const container = document.getElementById("root");
ReactDOM.render(element, container);

`React.createElement`는 React 요소를 반환합니다. 이렇게 생성된 React 요소는 아래와 같이 전달된 인자를 속성으로 갖는 객체입니다. 실제로는 더 많은 속성을 갖지만 이 역시 글의 주제에서 벗어나 생략했습니다.

const element = {
  type: "h1",
  props: {
    title: "foo",
    children: "Hello",
  },
};

const container = document.getElementById("root");
ReactDOM.render(element, container);

위 React 요소 객체에서 `type` 속성은 `document.createElement`에 전달되는 `tagName`으로 사용됩니다. `document.createElement`를 래핑하는 `React.createElement`함수는 Step VII에서 다룹니다.

`props`는 JSX 태그의 attributes에서 추출된 키-값 쌍을 가지며 `children`이라는 특별한 속성도 갖고 있습니다. 위 예시에서 `children`은 문자열 타입이지만 다른 React 요소로 이루어진 배열도 가능합니다. 따라서 `children`속성에 의해 React 요소들은 단방향 계층 구조로 연결되고 트리 구조를 갖습니다.

Render

마지막 줄 또한 React에서 제공하는 함수입니다. `render`는 React가 DOM을 조작하는 부분입니다. 이 부분을 vanilla JS로 변경해 보겠습니다.

가장 먼저 DOM에 삽입할 DOM 노드를 생성해야 합니다. 그 뒤, 요소의 `props`를 생성된 노드에 추가하면 됩니다.

(node와 element가 많이 혼용되어 사용되곤 합니다. 오해를 줄이기 위해 React 요소는 element, DOM 요소는 node를 사용하겠습니다.)

const element = {
  type: "h1",
  props: {
    title: "foo",
    children: "Hello",
  },
};

const container = document.getElementById("root");

const node = document.createElement(element.type);
node["title"] = element.props.title;
// ... 생략 ...

이제 생성된 노드에 자식 노드들을 생성해야 합니다. 위 예시에서는 자식으로 문자열을 가지므로 text node를 생성합니다.

const element = {
  type: "h1",
  props: {
    title: "foo",
    children: "Hello",
  },
};

const container = document.getElementById("root");

const node = document.createElement(element.type);
node["title"] = element.props.title;

const text = document.createTextNode("");
text["nodeValue"] = element.props.children;
// ... 생략 ...

`innerText`대신 `textNode`를 사용한 이유는 나중에 모든 요소들에 대해 같은 방법으로 처리하기 위함입니다. 비슷한 이유로 `h1` 노드에서 `title`속성을 추가한 것과 같은 방식으로 `text` 노드에 `nodeValue`를 설정합니다.

마지막으로 `textNode`를 `node`에, `node`를 `container`에 추가(append)합니다.

const element = {
  type: "h1",
  props: {
    title: "foo",
    children: "Hello",
  },
};

const container = document.getElementById("root");

const node = document.createElement(element.type);
node["title"] = element.props.title;

const text = document.createTextNode("");
text["nodeValue"] = element.props.children;

node.appendChild(text);
container.appendChild(node);

이렇게 처음 세 줄의 React 앱을 React를 사용하지 않은 vanilla JS로 변환하며 JSX와 React 그리고 DOM이 어떻게 상호작용 하는지 간단하게 알아봤습니다.

이제 React에서 제공하는 함수들을 직접 제작하며 React를 이해해 봅시다.

[Build your own React] README

thecloer — Sun, 20 Oct 2024 16:57:05 +0900

Build your own React 시리즈는 React.js를 직접 구현하며 내부 구조와 동작 방식을 이해하는 과정을 정리한 글 모음입니다.

Rodrigo Pombo(Pomber)님의 Build your own React글을 따라가며 내용을 해석, 추가하여 정리했습니다.

step 0: Review
step I: The `createElement` Function
Step II: The `render` Function
Step III: Concurrent Mode
Step IV: Fibers
Step V: Render and Commit Phases
Step VI: Reconciliation
Step VII: Function Components
Step VIII: Hooks

Slash 24

thecloer — Fri, 23 Aug 2024 12:53:31 +0900

올해도 토스 개발자 컨퍼런스 slash24가 돌아왔습니다. 작년 slash23의 server-driven UI로 마지막 어드민만들기를 아주 감명깊게 봤던 기억이 있어 바로 응모했습니다. 올해에는 직접 볼 수 있기를ㅠ

내 시간표

[LeetCode - 238] Products of Array Discluding Self - C++

thecloer — Fri, 31 May 2024 17:38:44 +0900

문제

Products of Array Discluding Self

Given an integer array nums, return an array output where `output[i]` is the product of all the elements of nums except `nums[i]`.

Each product is guaranteed to fit in a 32-bit integer.

Follow-up: Could you solve it in ( ) time without using the division operation?

Example 1:

Input: nums = [1,2,4,6]
Output: [48,24,12,8]

Example 2:

Input: nums = [-1,0,1,2,3]
Output: [0,-6,0,0,0]

Constraints:

`2 <= nums.length <= 1000`
`-20 <= nums[i] <= 20`

풀이

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans(n, 1);

        for(int i=1; i<n; i++)
            ans[i] = ans[i-1] * nums[i-1];

        int acc = 1;
        for(int i=n-2; i>=0; i--) {
            acc *= nums[i+1];
            ans[i] *= acc;
        }

        return ans;
    }
};

나눗셈을 사용하지 않고 선형시간에 풀라는 제약조건이 없다면 아주 쉬운 문제다.

우선 `nums`의 원소를 모두 곱한 후 `ans[i] = prod / nums[i]`로 답을 선형 시간에 구할 수 있다.

나누기를 사용하지 말라는 조건이 신선했다.

기본 아이디어는 `ans[k] = nums[0] * nums[1] * ... * nums[k-1] * nums[k+1] * ... * nums[n-1]`이므로

rightward로 누적곱과 leftward로 누적곱을 계산해 `k`의 양쪽의 누적곱을 곱해 `ans[k]`를 계산하는 아이디어다.

처음에는 두개의 누적곱을 계산하는 배열을 만들어 구현했다.

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n = nums.size();
        int leftward[n], rightward[n];
        rightward[0] = nums[0];
        leftward[n-1] = nums[n-1];

        for(int i=1; i<n; i++) {
            rightward[i] = rightward[i-1] * nums[i];
            leftward[n-1-i] = leftward[n-i] * nums[n-1-i];
        }

        vector<int> ans(n, 1);
        for(int i=0; i<n; i++) {
            if(i > 0) ans[i] *= rightward[i - 1];
            if(i < n-1) ans[i] *= leftward[i + 1];
        }
        return ans;
    }
};

선형 누적 계산이어서 추가적인 저장공간을 사용하지 않고 풀 수 있을 것 같다는 생각에 더 고민해봤고 `ans`만을 이용한 풀이를 생각했다.

[LeetCode - 271] encode and decode strings - C++

thecloer — Thu, 30 May 2024 22:24:34 +0900

분류: 문자열 /

문제

271. String Encode and Decode

Design an algorithm to encode a list of strings to a single string. The encoded string is then decoded back to the original list of strings.

Please implement encode and decode

Example 1:

Input: ["neet","code","love","you"]
Output: ["neet","code","love","you"]

Example 2:

Input: ["we","say",":","yes"]
Output: ["we","say",":","yes"]

Constraints:

`0 <= strs.length < 100`
`0 <= strs[i].length < 200`
`strs[i]` contains only UTF-8 characters.

풀이

class Solution {
public:

    string encode(vector<string>& strs) {
        string ans = "";
        for(const string &str:strs) 
            ans += to_string(str.size()) + ":" + str;
        return ans;
    }

    vector<string> decode(string s) {
        vector<string> ans;
        int i = 0, len = s.size();
        while(i < len) {
            int start = i;
            while(s[i] != ':') i++;
            int length = stoi(s.substr(start, i++ - start));
            ans.push_back(s.substr(i, length));
            i += length;
        }
        return ans;
    }
};

두개의 함수를 구현해 `output = decode(endcode(input))`일 때 `output == input`인 단방향 역원을 구현하는 점이 재밌는 문제였다.

백준은 출력, 프로그래머스는 하나의 함수를 구현하는 형태의 문제지만 릿코드는 조금 더 다양한 문제가 있는것 같다.

`encode`를 구현하는 것은 아주 쉽다. 구분자(delimiter)를 끼워넣어 합치면 된다. 여기서 문제는 `decode`에서 발생한다.

입력값은 모두 UTF-8 문자이므로 구분자가 포함된 입력이 들어올 경우 문제가 발생한다.

예시)

input = ["a,b"], delimiter = ','

output = ["a", "b"]

구분자를 입력값에서 등장할 확률이 매우 낮게 설정할 수도 있을 것이다. 예를들어 `"ㄱ@#a%ㅂㅁ^!#$%ㅍ@$#!ㅏ#$;_!#$%(!"` 와 같이 말이다. 아마 아주 긴 구분자를 사용한다면 테케는 통과할 것 같다.

하지만 이는 뭔가 찝찝한 느낌이 들것이다. 긴 구분자를 사용할 경우 인코딩 문자열이 아주 길어진다는 단점과 결국 확률에 의존해야한다는 단점이 있다. 어떻게 하면 UTF-8 문자를 이용한 구분자를 이용해 문자열로 인코딩하고 원본으로 디코딩 할 수 있을까?

키는 단순히 같은 구분자를 사용하는 것이 아니라 구분자에 정보를 담는 방법이다. 인코딩하는 문자열의 숫자를 적고 그 뒤에 문자열을 붙인다.

예시)

input = [ "aaa", "1234" ]

encoded = "3:aaa4:123"

여기서 문자열의 길이와 문자열 사이에 `:`를 넣는 이유는 문자열이 숫자로 시작하는 경우 어디까지가 메타 데이터이고 어디서부터 데이터인지 알 수 없기 때문이다.

[백준 - 17070] 파이프 옮기기 1 - C++

thecloer — Sun, 7 Apr 2024 18:45:54 +0900

분류: DP, DFS /

문제

문제 링크

문제 설명

유현이가 새 집으로 이사했다. 새 집의 크기는 N×N의 격자판으로 나타낼 수 있고, 1×1크기의 정사각형 칸으로 나누어져 있다. 각각의 칸은 (r, c)로 나타낼 수 있다. 여기서 r은 행의 번호, c는 열의 번호이고, 행과 열의 번호는 1부터 시작한다. 각각의 칸은 빈 칸이거나 벽이다.

오늘은 집 수리를 위해서 파이프 하나를 옮기려고 한다. 파이프는 아래와 같은 형태이고, 2개의 연속된 칸을 차지하는 크기이다.

파이프는 회전시킬 수 있으며, 아래와 같이 3가지 방향이 가능하다.

파이프는 매우 무겁기 때문에, 유현이는 파이프를 밀어서 이동시키려고 한다. 벽에는 새로운 벽지를 발랐기 때문에, 파이프가 벽을 긁으면 안 된다. 즉, 파이프는 항상 빈 칸만 차지해야 한다.

파이프를 밀 수 있는 방향은 총 3가지가 있으며, →, ↘, ↓ 방향이다. 파이프는 밀면서 회전시킬 수 있다. 회전은 45도만 회전시킬 수 있으며, 미는 방향은 오른쪽, 아래, 또는 오른쪽 아래 대각선 방향이어야 한다.

파이프가 가로로 놓여진 경우에 가능한 이동 방법은 총 2가지, 세로로 놓여진 경우에는 2가지, 대각선 방향으로 놓여진 경우에는 3가지가 있다.

아래 그림은 파이프가 놓여진 방향에 따라서 이동할 수 있는 방법을 모두 나타낸 것이고, 꼭 빈 칸이어야 하는 곳은 색으로 표시되어져 있다.

가로

세로

대각선

가장 처음에 파이프는 (1, 1)와 (1, 2)를 차지하고 있고, 방향은 가로이다. 파이프의 한쪽 끝을 (N, N)로 이동시키는 방법의 개수를 구해보자.

입력

첫째 줄에 집의 크기 N(3 ≤ N ≤ 16)이 주어진다. 둘째 줄부터 N개의 줄에는 집의 상태가 주어진다. 빈 칸은 0, 벽은 1로 주어진다. (1, 1)과 (1, 2)는 항상 빈 칸이다.

출력

첫째 줄에 파이프의 한쪽 끝을 (N, N)으로 이동시키는 방법의 수를 출력한다. 이동시킬 수 없는 경우에는 0을 출력한다. 방법의 수는 항상 1,000,000보다 작거나 같다.

풀이

- DFS

#include <iostream>
#include <vector>
using namespace std;

int N, ans;
bool isWall[17][17];
int dx[] {0, 1, 1}; // direction -> delta position
int dy[] {1, 1, 0}; // direction -> delta position
vector<int> nxt[] {{0, 1}, {0, 1, 2}, {1, 2}}; // direction -> next directions
vector<int> check[] {{0}, {0, 1, 2}, {2}}; // next direction -> directions should be checked

inline bool isValid(int x, int y) {
    return x < N and y < N and not isWall[x][y];
}

void dfs(int dir, int x, int y) {
    if(x == N-1 and y == N-1) {
        ans++;
        return;
    }

    for(int nd:nxt[dir]) {
        int nx = x + dx[nd], ny = y + dy[nd];
        if(not isValid(nx, ny)) continue;
        
        bool pass = true;
        for(int d:check[nd]) {
            if(isValid(x + dx[d], y + dy[d])) continue;
            pass = false;
            break;
        }

        if(not pass) continue;
        dfs(nd, nx, ny);
    }
}

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> N;
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            cin >> isWall[i][j];
    
    dfs(0, 0, 1);
    cout << ans;
}

DFS로 완전탐색

가로 방향을 0, 대각선 방향을 1, 세로 방향을 2로 정의

`nxt[i]`는 `i`방향으로 이동해서 `(x, y)`왔을 때, `(x, y)`에서 이동할 수 있는 다음 방향을 의미

`check[i]`는 `i`방향으로 이동하기 위해 확인해야하는 방향을 의미

`dfs(dir, x, y)`는 `dir` 방향으로 이동해 `(x, y)`에 도착했을 때 다음 이동을 DFS로 탐색하는 함수

`dfs()`를 살펴보면 아래와 같다.

종료 조건: 목적지 `(N-1, N-1)` 도착할 경우 경로 수 1 증가(`ans++`)
`(x, y)`로 들어온 방향(`dir`)에 따라 다음에 갈 수 있는 방향(`nxt[dir]`)으로 다음을 수행
- 다음 방향(`nd`)으로 갈 때, 확인해야 하는 방향(`check[nd]`)으로 모두 갈 수 있는 지 확인
- 갈 수 있다면 해당 방향(`nd`)로 이동하고 재귀 호출

- DP

#include <iostream>
using namespace std;

int N;
bool isWall[17][17];
int way[17][17][3];

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> N;
    for(int i=1; i<=N; i++)
        for(int j=1; j<=N; j++)
            cin >> isWall[i][j];
    
    way[1][2][0] = 1;
    for(int x=1; x<=N; x++) {
        for(int y=1; y<=N; y++) {
            if(isWall[x][y]) continue;
            way[x][y][0] += way[x][y-1][0] + way[x][y-1][1];
            way[x][y][2] += way[x-1][y][1] + way[x-1][y][2];
            if(isWall[x-1][y] or isWall[x][y-1]) continue;
            way[x][y][1] += way[x-1][y-1][0] + way[x-1][y-1][1] + way[x-1][y-1][2];
        }
    }
    cout << way[N][N][0] + way[N][N][1] + way[N][N][2];
}

처음 DFS로 풀었을 때 시간은 152ms. 보통 0ms ~ 20ms 사이의 시간이 나와야 마음이 편안해 지는데 152ms는 뭔가 느리다고 생각해 더 빠른 풀이를 더 생각해 봤다.

DFS 탐색보다 빠른 완전탐색을 생각해보면 백트래킹, 분기한정 등을 이용한 프루닝을 통해 탐색 범위를 좁히는 방법(시간 복잡도는 거의 같다)들과 DP 정도가 떠올랐다.

`way[x][y][dir]`은 `(x, y)`에서 `dir` 방향으로 들어오는 경로의 수다.

따라서 `way[x][y][0] = way[x][y-1][0] + way[x][y-1][1]`의 의미는 가로 방향으로 `(x, y)`에 들어오는 경로(`way[x][y][0]`)는 가로방향으로 `(x, y-1)`에 도착한 경우(`way[x][y-1][0]`)와 대각선 방향으로 `(x, y-1)`에 도착한 경우(`way[x][y-1][1]`)의 합과 같다.

마지막의 `way[x][y][1]`의 경우 대각선으로 들어오는 경우를 의미하고 이 경우에는 추가적으로 주변에 벽이 있는지 확인해야 한다.

등호가 아닌 `+=`로 기존 값에 더하는 이유는 초기값 때문이다. 논리적으로는 등호가 알맞다. 하지만 등호로 구현할 경우 초기값인 `way[1][2][0]`이 덮어쓰여지지 않도록 추가적인 작업이 필요하다. 어차피 초기화된 값이 0이므로 추가적인 작업을 구현하지 않기 위해 `+=`로 구현했다.