You are given a character array `keys` containing **unique** characters and a string array `values` containing strings of length 2. You are also given another string array `dictionary` that contains all permitted original strings after decryption. You should implement a data structure that can encrypt or decrypt a **0-indexed** string.

A string is **encrypted** with the following process:

1.  For each character `c` in the string, we find the index `i` satisfying `keys[i] == c` in `keys`.
2.  Replace `c` with `values[i]` in the string.

Note that in case a character of the string is **not present** in `keys`, the encryption process cannot be carried out, and an empty string `" "` is returned.

A string is **decrypted** with the following process:

1.  For each substring `s` of length 2 occurring at an even index in the string, we find an `i` such that `values[i] == s`. If there are multiple valid `i`, we choose **any** one of them. This means a string could have multiple possible strings it can decrypt to.
2.  Replace `s` with `keys[i]` in the string.

Implement the `Encrypter` class:

*   `Encrypter(char[] keys, String[] values, String[] dictionary)` Initializes the `Encrypter` class with `keys, values`, and `dictionary`.
*   `String encrypt(String word1)` Encrypts `word1` with the encryption process described above and returns the encrypted string.
*   `int decrypt(String word2)` Returns the number of possible strings `word2` could decrypt to that also appear in `dictionary`.

**Example 1:**

**Input**
\[ "Encrypter ",  "encrypt ",  "decrypt "\]
\[\[\['a', 'b', 'c', 'd'\], \[ "ei ",  "zf ",  "ei ",  "am "\], \[ "abcd ",  "acbd ",  "adbc ",  "badc ",  "dacb ",  "cadb ",  "cbda ",  "abad "\]\], \[ "abcd "\], \[ "eizfeiam "\]\]
**Output**
\[null,  "eizfeiam ", 2\]

**Explanation**
Encrypter encrypter = new Encrypter(\[\['a', 'b', 'c', 'd'\], \[ "ei ",  "zf ",  "ei ",  "am "\], \[ "abcd ",  "acbd ",  "adbc ",  "badc ",  "dacb ",  "cadb ",  "cbda ",  "abad "\]);
encrypter.encrypt( "abcd "); // return  "eizfeiam ". 
                           // 'a' maps to  "ei ", 'b' maps to  "zf ", 'c' maps to  "ei ", and 'd' maps to  "am ".
encrypter.decrypt( "eizfeiam "); // return 2. 
                              //  "ei " can map to 'a' or 'c',  "zf " maps to 'b', and  "am " maps to 'd'. 
                              // Thus, the possible strings after decryption are  "abad ",  "cbad ",  "abcd ", and  "cbcd ". 
                              // 2 of those strings,  "abad " and  "abcd ", appear in dictionary, so the answer is 2.

**Constraints:**

*   `1 <= keys.length == values.length <= 26`
*   `values[i].length == 2`
*   `1 <= dictionary.length <= 100`
*   `1 <= dictionary[i].length <= 100`
*   All `keys[i]` and `dictionary[i]` are **unique**.
*   `1 <= word1.length <= 2000`
*   `1 <= word2.length <= 200`
*   All `word1[i]` appear in `keys`.
*   `word2.length` is even.
*   `keys`, `values[i]`, `dictionary[i]`, `word1`, and `word2` only contain lowercase English letters.
*   At most `200` calls will be made to `encrypt` and `decrypt` **in total**.

고유** 문자를 포함하는 문자 배열 `키`와 길이 2의 문자열을 포함하는 문자열 배열 `값`이 주어집니다. 복호화 후 허용된 모든 원본 문자열을 포함하는 또 다른 문자열 배열 `사전`도 주어집니다. 0 인덱싱된 문자열을 암호화하거나 복호화할 수 있는 데이터 구조를 구현해야 합니다.

문자열은 다음과 같은 과정을 통해 **암호화**됩니다:

1.  문자열의 각 문자 `c`에 대해 `키스`에서 `키스[i] == c`를 만족하는 인덱스 `i`를 찾습니다.
2.  문자열에서 `c`를 `values[i]`로 바꿉니다.

문자열의 문자가 `keys`에 **없는** 경우 암호화 프로세스를 수행할 수 없으며 빈 문자열 `" "`이 반환됩니다.

문자열은 다음 프로세스를 통해 **복호화**됩니다:

1.  문자열의 짝수 인덱스에 존재하는 길이 2의 각 부분 문자열 `s`에 대해 `values[i] == s`가 되는 `i`를 찾습니다. 유효한 `i`가 여러 개 있으면 그 중 하나를 선택합니다. 즉, 하나의 문자열에 복호화할 수 있는 문자열이 여러 개 있을 수 있습니다.
2.  문자열에서 `s`를 `keys[i]`로 바꿉니다.

Encrypter` 클래스를 구현합니다:

* `Encrypter(char[] keys, String[] values, String[] dictionary)` `Encrypter` 클래스를 `keys, values`, `dictionary`로 초기화합니다.
* `String encrypt(String word1)` 위에서 설명한 암호화 프로세스를 사용하여 `word1`을 암호화하고 암호화된 문자열을 반환합니다.
* `int decrypt(String word2)` `word2`가 복호화할 수 있는 문자열 중 `사전`에도 나타날 수 있는 문자열의 개수를 반환합니다.

**예제 1:**

**입력**
\["암호화기","암호화","암호 해독"\]
\[\[\['a', 'b', 'c', 'd'\], \["ei ", "zf ", "ei ", "am"\], \["abcd ", "acbd ", "adbc ", "badc ", "dacb ", "cadb ", "cbda ", "abad"\]\], \["abcd"\], \["eizfeiam "\]\]
**출력**
\[null, "eizfeiam ", 2\]

설명** **설명
암호화기 암호화기 = 새로운 암호화기(\[\['a', 'b', 'c', 'd'\], \["ei ", "zf ", "ei ", "am"\], \["abcd ", "acbd ", "adbc ", "badc ", "dacb ", "cadb ", "cbda ", "abad "\]);
encrypter.encrypt("abcd "); // 반환 "eizfeiam ".
                           // 'a'는 "ei", 'b'는 "zf", 'c'는 "ei", 'd'는 "am"으로 맵핑됩니다.
encrypter.decrypt("eizfeiam "); // 반환 2.
                              // "ei"는 'a' 또는 'c'에 매핑될 수 있고, "zf"는 'b'에 매핑되며, "am"은 'd'에 매핑됩니다.
                              // 따라서 복호화 후 가능한 문자열은 "abad ", "cbad ", "abcd ", "cbcd " 입니다.
                              // 이 중 2개 문자열인 "abad", "abcd"가 사전에 나타나므로 답은 2입니다.

**제약 조건:**

* `1 <= keys.length == values.length <= 26`
* `values[i].length == 2`
* `1 <= dictionary.length <= 100`
* `1 <= dictionary[i].length <= 100`
* 모든 `keys[i]`와 `dictionary[i]`는 **유니크**입니다.
* `1 <= word1.length <= 2000`
* `1 <= word2.length <= 200`
* 모든 `word1[i]`는 `keys`에 나타납니다.
* `word2.length`는 짝수입니다.
* `keys`, `values[i]`, `dictionary[i]`, `word1`, `word2`에는 소문자 영어 문자만 포함됩니다.
* 암호화`와 `복호화` 호출은 최대 `200`번만 수행됩니다.
