LeetCode-433 最小基因变化

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-genetic-mutation

题目描述

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

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

例如，"AACCGGTT" --> "AACCGGTA" 就是一次基因变化。
另有一个基因库 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遍历的方法寻找目标基因，返回遍历的层数，层数就是变异的次数。

代码展示

class Solution {
public:
    int minMutation(string start, string end, vector<string>& bank) {
        int n = bank.size();
        const int iLength = 8;
        vector<vector<int>> vviAdjacencyTable(n, vector<int>(n, 0));
        int iEndIndex = -1;
        for(int i = 0; i < n; i ++)
        {
            if(bank[i] == end)
                iEndIndex = i;
            for(int j = i + 1; j < n; j++)
            {
                int iCount = 0;
                for(int k = 0; k < iLength; k++)
                {
                    if(bank[i][k] != bank[j][k])
                        iCount++;
                }
                if(iCount == 1)
                {
                    vviAdjacencyTable[i][j] = 1;
                    vviAdjacencyTable[j][i] = 1;
                }    
            }
        }
        if(iEndIndex == -1)
            return -1;
        queue<int> queue_i_Visiting;
        unordered_set<int> set_i_Visited;
        for(int i = 0; i < n; i++)
        {
            int iCount = 0;
            for(int k = 0; k < iLength; k++)
            {
                if(bank[i][k] != start[k])
                    iCount++;
            }
            if(iCount == 1)
            {
                queue_i_Visiting.push(i);
                set_i_Visited.emplace(i);
            }
        }
        int iStep = 1;
        while(!queue_i_Visiting.empty())
        {
            int iSize = queue_i_Visiting.size();
            for(int i = 0; i < iSize; i++)
            {
                int iIndex = queue_i_Visiting.front();
                queue_i_Visiting.pop();
                set_i_Visited.emplace(iIndex);
                if(iIndex == iEndIndex)
                    return iStep;
                for(int j = 0; j < n; j++)
                {
                    if(set_i_Visited.find(j) == set_i_Visited.end() && vviAdjacencyTable[iIndex][j])
                        queue_i_Visiting.push(j);
                }
            }
            iStep++;
        }
        return -1;
    }
}; 

运行结果