433. 最小基因变化

基因序列可以表示为一条由 8 个字符组成的字符串，其中每个字符都是 'A'、'C'、'G' 和 'T' 之一。

假设我们需要调查从基因序列 start 变为 end 所发生的基因变化。一次基因变化就意味着这个基因序列中的一个字符发生了变化。

• 例如，"AACCGGTT" --> "AACCGGTA" 就是一次基因变化。

另有一个基因库 bank 记录了所有有效的基因变化，只有基因库中的基因才是有效的基因序列。（变化后的基因必须位于基因库 bank 中）

给你两个基因序列 start 和 end ，以及一个基因库 bank ，请你找出并返回能够使 start 变化为 end 所需的最少变化次数。如果无法完成此基因变化，返回 -1 。

注意：起始基因序列 start 默认是有效的，但是它并不一定会出现在基因库中。

示例 1：

输入：start = "AACCGGTT", end = "AACCGGTA", bank = ["AACCGGTA"]
输出：1

示例 2：

输入：start = "AACCGGTT", end = "AAACGGTA", bank = ["AACCGGTA","AACCGCTA","AAACGGTA"]
输出：2

示例 3：

输入：start = "AAAAACCC", end = "AACCCCCC", bank = ["AAAACCCC","AAACCCCC","AACCCCCC"]
输出：3

提示：

• start.length == 8
• end.length == 8
• 0 <= bank.length <= 10
• bank[i].length == 8
• start、end 和 bank[i] 仅由字符 ['A', 'C', 'G', 'T'] 组成

这道题是一道广度优先BFS的题。可以用图来描述基因结构的变化，结合题意，可以与当前节点相连的节点为bank数组中与当前节点字符串相差一个字符的数组。可以采用广度优先遍历这个图，由于需要记录基因编译的次数，因此可以采用分层遍历的方法，遍历到第几层，发现了目标基因，就认为基因变异的次数是几。

下面上代码： 容易踩到坑的地方我注释了一下

class Solution {
private:
    int DiffNum(const string& a_gene, const string& b_gene) //获得开始基因和目标基因之间差异的字符数
    {
        int diff_c = 0;
        for (int i = 0; i < a_gene.size(); i++)
        {
            diff_c += (a_gene[i] != b_gene[i]);
        }
        return diff_c;
    }

public:
    int minMutation(string startGene, string endGene, vector<string>& bank) {

        if (startGene == endGene) // 如果两个基因本来就一样，不需要变异就达到了目标
        {
            return 0;
        }
        queue<string> que; // 队列
        que.push(startGene); 

        int change_num = -1; // 记录编译的次数，第一个基因弹出的时候，没有变异，但是也得自增，因此 设置为-1
        bool finded = false; //记录是不是发现了目标基因
        while (!que.empty()&&!finded)
        {
            change_num++; //
            int qs = que.size(); // 队列的长度，这里面的是一整层的节点
            for (int i = 0; i < qs; i++)// 把这一整层都遍历完，并把它们相连的节点 插入到que， 这里有个坑，千万不要把 i<qs 写成 i<que.size()，因为在遍历的时候que的尺寸在变化。
            {
                auto& front = que.front();
                if (front == endGene)
                {
                    finded = true;
                }
                for (int i = 0; i < bank.size(); i++)
                {
                    if (DiffNum(front, bank[i]) == 1)
                    {
                        que.push(bank[i]);
                    }
                }
                que.pop();
            }

        }

        if (!finded)
        {
            return -1; // 如果没有发现返回-1；题干中没有给出遍历不成功返回-1的说明，算题意不完整吧。
        }
        return change_num;
    }
};

// 代码写完了，但超时了，需要进一步减枝。

这也很简单，我当访问下一个节点时，判断是不是已经被访问过了，由于我们采用的是广度优先搜索，一层一层的搜索，原来已经访问过的没有必要再访问，再访问只会增加路径长度，还有可能形成死循环。借助unordered_set 结构来做标记，更改后的代码如下：

class Solution {
private:
    int DiffNum(const string& a_gene, const string& b_gene)
    {
        int diff_c = 0;
        for (int i = 0; i < a_gene.size(); i++)
        {
            diff_c += (a_gene[i] != b_gene[i]);
        }
        return diff_c;
    }

public:
    int minMutation(string startGene, string endGene, vector<string>& bank) {

        if (startGene == endGene)
        {
            return 0;
        }
        queue<string> que;
        que.push(startGene);
        std::unordered_set<string> invited; // 记录是否访问过

        int change_num = -1;
        bool finded = false;

        invited.insert(startGene);
        while (!que.empty()&&!finded)
        {
            change_num++;
            int qs = que.size();
            for (int i = 0; i < qs; i++)
            {
                auto& front = que.front();
                if (front == endGene)
                {
                    finded = true;
                }

                for (int i = 0; i < bank.size(); i++)
                {
                    if (DiffNum(front, bank[i]) == 1&&invited.count(bank[i])==0)// 只遍历没有访问过的节点
                    {
                        que.push(bank[i]);
                        invited.insert(bank[i]); // 把节点加入到记录的哈希结构中。
                    }
                }
                que.pop();
            }

        }

        if (!finded)
        {
            return -1;
        }
        return change_num;
    }
};

//速度击败100%, 内存击败89.9%