class Solution {
public:
    int minMutation(string start, string end, vector<string>& bank) {
        //>> transform bank to hash map
        unordered_set<string> bankSet;
        for(const auto &g : bank) {
            bankSet.insert(g);
        }

        //>> prepare two sets. one is from head and the other is from end
        unordered_set<string> headSet, tailSet, *smallerSetPtr, *biggerSetPtr;
        headSet.insert(start);

        //>> check end is reachable or not
        if(bankSet.find(end) != bankSet.end()) {
            tailSet.insert(end);
        }

        int step = 0;
        const int len = start.length();

        while(!headSet.empty() && !tailSet.empty()) {
            ++step;

            smallerSetPtr = (headSet.size() < tailSet.size()) ? &headSet : &tailSet;
            biggerSetPtr = (headSet.size() < tailSet.size()) ? &tailSet : &headSet;

            unordered_set<string> nextReachableSet;

            for(const auto &gene : *smallerSetPtr) {
                for(int i = 0; i < len; i++) {
                    string newGene = gene;
                    for(int j = 0; j < 4; j++) {
                        char ch;
                        switch(j) {
                            case 0:
                                ch = 'A';
                                break;
                            case 1:
                                ch = 'C';
                                break;
                            case 2:
                                ch = 'G';
                                break;
                            case 3:
                                ch = 'T';
                                break;
                        }

                        newGene[i] = ch;

                        //>> find ans
                        if(biggerSetPtr->find(newGene) != biggerSetPtr->end()) {
                            return step;
                        }

                        //>> find valid next step
                        if(bankSet.find(newGene) != bankSet.end()) {
                            nextReachableSet.insert(newGene);
                            bankSet.erase(newGene);
                        }
                    }
                }
            }

            //>> change smallerSet to nextReachableSet
            swap(*smallerSetPtr, nextReachableSet);
        }

        return -1;
    }
};