图论(3)

目录

• 127WordLadder
• 841钥匙和房间
• 463岛屿的周长

127WordLadder

基本思路bfs搜索最短路径，因为是寻找最短路径，所以bfs搜索到的路径就是最短的
下面是bfs的基本思路
用set存储所有word
用map存储所有遍历过的word
用queue存储路径
从beginword开始，使用对从前到后的每一个字符进行从a到z的替换
然后检测是否在set之中，如果在，就入que入map，该word的路径就是beginword+1
递归进行搜索，最后得到答案

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        unordered_set<string> mapSet(wordList.begin(),wordList.end());
        if(mapSet.find(endWord)==mapSet.end())
        {
            return 0;
        }
        queue<string> que;
        que.push(beginWord);
        unordered_map<string,int> visitedMap;
        visitedMap.emplace(beginWord,1);
        while(!que.empty())
        {
            string curstr=que.front();que.pop();
            int path=visitedMap[curstr];
            for(int i=0;i<curstr.length();i++)
            {
                string newstr=curstr;
                for(int j=0;j<26;j++)
                {
                    newstr[i]=j+'a';
                    if(newstr==endWord)
                    {
                        return path+1;
                    }
                    if(mapSet.find(newstr)!=mapSet.end()&&
                        visitedMap.find(newstr)==visitedMap.end())
                        {
                            visitedMap[newstr]=path+1;
                            que.push(newstr);
                        }
                }
            }
        }
        return 0;
    }
};

841钥匙和房间

解题思路：广度优先搜索的应用
用一个que去记录搜索路径
用一个set去记录访问过的房间
从0号房间开始遍历钥匙，如果没访问过就加入que和set

class Solution {
public:
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        queue<int> que;
        unordered_set<int> visitedRooms;
        visitedRooms.emplace(0);
        for(int i=0;i<rooms[0].size();i++)
        {
            que.push(rooms[0][i]);
            visitedRooms.emplace(rooms[0][i]);
        }
        while(!que.empty())
        {
            int keyToNextRoom=que.front();que.pop();
            for(int i=0;i<rooms[keyToNextRoom].size();i++)
            {
                int key=rooms[keyToNextRoom][i];
                if(visitedRooms.find(key)==visitedRooms.end())
                {
                    que.push(key);
                    visitedRooms.emplace(key);
                }
            }
        }
        for(int i=0;i<rooms.size();i++)
        {
            if(visitedRooms.find(i)==visitedRooms.end())
            {
                return false;
            }
        }
        return true;

    }
};

463岛屿的周长

class Solution {
public:
    int islandPerimeter(vector<vector<int>>& grid) {
        int ans=0;
        for(int i=0;i<grid.size();i++)
        {
            for(int j=0;j<grid[0].size();j++)
            {
                if(grid[i][j]==1)
                {
                    if((i-1>=0&&grid[i-1][j]==0)||i-1<0)
                    {
                        ans++;
                    }
                    if((i+1<grid.size()&&grid[i+1][j]==0)||i+1>=grid.size())
                    {
                        ans++;
                    }
                    if((j-1>=0&&grid[i][j-1]==0)||j-1<0)
                    {
                        ans++;
                    }
                    if((j+1<grid[0].size()&&grid[i][j+1]==0)||j+1>=grid[0].size())
                    {
                        ans++;
                    }
                }
            }
        }
        return ans;

    }
};