Problem:
Score : 300 points

Problem Statement

You are given strings S and T consisting of lowercase English letters.

You can perform the following operation on S any number of times:

Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.

Determine if S and T can be made equal by performing the operation zero or more times.

Constraints

1 \leq |S| \leq 2 \times 10^5

|S| = |T|

S and T consists of lowercase English letters.

Input

Input is given from Standard Input in the following format:

S
T

Output

If S and T can be made equal, print Yes; otherwise, print No.

Sample Input 1

azzel
apple

Sample Output 1

Yes

azzel can be changed to apple, as follows:

Choose e as c_1 and l as c_2. azzel becomes azzle.

Choose z as c_1 and p as c_2. azzle becomes apple.

Sample Input 2

chokudai
redcoder

Sample Output 2

No

No sequences of operation can change chokudai to redcoder.

Sample Input 3

abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu

Sample Output 3

Yes

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Objects;

public class Main {

	public static void main(String[] args) throws IOException {
		// TODO 自動生成されたメソッド・スタブ
		Main st = new Main();
		if(st.String_Transformation()) {
			System.out.println("Yes");
		}else {
			System.out.println("No");
		}
	}

	public boolean String_Transformation() throws IOException{
		/**
		 * <条件>
		 * 文字の種類数が一緒　かつ　同じ種類の文字は同数個ある
		 *
		 */
		//入力
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s1 = br.readLine();
		String s2= br.readLine();

		String[] s = new String[s1.length()];
		String[] t = new String[s2.length()];
		for(int i = 0; i < s1.length(); i++) {
			s[i] = String.valueOf(s1.charAt(i));
			t[i] = String.valueOf(s2.charAt(i));
		}


		HashMap<String, Integer> dictinary1 = new HashMap<>();
		HashMap<String, Integer> dictinary2 = new HashMap<>();
		/*
		 * それぞれの文字種類数を比較
		 *
		 */
		for(int i = 0; i < s.length; i++) {
			String a =  s[i];
			String b = t[i];
			int v;
		    if (dictinary1.containsKey(a)) {
		        // Mapに登録済み
		        v =dictinary1.get(a) + 1;
		    } else {
		        // Mapに未登録
		        v = 1;
		    }
		    dictinary1.put(a, v);

		    v = 0;
		    if (dictinary2.containsKey(b)) {
		        // Mapに登録済み
		        v =dictinary2.get(b) + 1;
		    } else {
		        // Mapに未登録
		        v = 1;
		    }
		    dictinary2.put(b, v);
		}

		HashMap<Integer, Integer> m1 = new HashMap<>();
		HashMap<Integer, Integer> m2 = new HashMap<>();
		if(dictinary1.size() == dictinary2.size()) {
			/*
			 * 同数個現れた文字の数が一致するかを比較
			 */
			for(int j = 0; j < dictinary1.size(); j++) {
				int key1 = dictinary1.get(s[j]);
				int key2 = dictinary2.get(t[j]);
				int v;
			    if (m1.containsKey(key1)) {
			        // Mapに登録済み
			        v = m1.get(key1) + 1;
			    } else {
			        // Mapに未登録
			        v = 1;
			    }
			    m1.put(key1, v);

			    v = 0;
			    if (m2.containsKey(key2)) {
			        v = m2.get(key2) + 1;
			    } else {
			        v = 1;
			    }
			    m2.put(key2, v);
			}
			if(m1.size() == m2.size()) {
				for(int h = 0; h < m1.size(); h++) {
					if(Objects.equals(m1.get(h),m2.get(h))) {
						return true;
					}
				}
			}
		}
		return false;
	}
}