图搜索 leetcode c++实现

#include <iostream>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <unordered_set>
#include <algorithm>


using namespace std;

bool cmp(int a,int b)
{
    return a>b;
}
class Solution
{
public:
    /***************************************************
    *  函数功能： 岛屿数量
    *  参数说明
    *       输入参数:
                        11000
                        11000
                        00100
                        00011
    *       输出参数：  3
    *  复杂性分析：时间复杂度：O(n^2)，空间复杂度：O()
    *  题目来源  ：https://leetcode.com/problems/number-of-islands/description/
    *  日期：2018-07-06-19.36
    ***************************************************/
    int numIslands(vector<vector<char> >& grid)
    {
        vector<vector<int> > mark;
        for(int i=0;i<grid.size();i++)
        {
            mark.push_back(vector<int>());
            for(int j=0;j<grid[i].size();j++)
            {
                mark[i].push_back(0);
            }
        }
        int num_lands=0;

        for(int i=0;i<mark.size();i++)
        {
            for(int j=0;j<mark[i].size();j++)
            {
                if(grid[i][j]=='1' && mark[i][j]==0)
                {
                    BFS_lands(grid,mark,i,j);
                    num_lands++;
                }
            }
        }
        return num_lands;
    }

    /***************************************************
    *  函数功能：词语阶梯
    *  参数说明
    *       输入参数：
                        beginWord = "hit",
                        endWord = "cog",
                        wordList = ["hot","dot","dog","lot","log","cog"]
    *       输出参数： 5
    *  复杂性分析：时间复杂度：O()，空间复杂度：O()
    *  题目来源  ：https://leetcode.com/problems/word-ladder/description/
    *  日期：2018-07-06-21.58
    ***************************************************/
    int ladderLength(string beginWord,string endWord,vector<string>& wordList)
    {
         map<string,vector<string> > graph;
         consturc_graph(beginWord,wordList,graph);

         for(auto it=graph.begin();it!=graph.end();it++)
         {
             cout<<it->first<<":";
             vector<string> S=it->second;
             for(int j=0;j<S.size();j++)
             {
                 cout<<"-->"<<S[j];
             }
             cout<<endl;
         }

        return BFS_search(beginWord,endWord,graph);
    }

    int ladderLength1(string beginWord,string endWord,vector<string>& wordList)
    {
        //wordList.push_back(endWord);

        unordered_set<string> wordSet(wordList.begin(), wordList.end());

        queue<pair<string,int>> Q;
        Q.push(make_pair(beginWord,1));
        //wordSet.erase(wordSet.find(beginWord));

        while(!Q.empty())
        {

            string Word=Q.front().first;
            int step=Q.front().second;

            Q.pop();
            if(Word==endWord) return step;
            for(int j=0;j<Word.size();j++)
            {
                string str=Word;
                for(int i=0;i<26;i++)
                {
                    str[j]='a'+i;
                    if(wordSet.count(str)==1)
                    {
                        Q.push(make_pair(str,step+1));
                        wordSet.erase(wordSet.find(str));
                    }
                }
            }

        }
        return 0;
    }

    /***************************************************
    *  函数功能：火柴棍摆正方形
    *  参数说明
    *       输入参数：[1,1,2,2,2]
    *       输出参数：true
    *  复杂性分析：时间复杂度：O()，空间复杂度：O()
    *  题目来源  ： https://leetcode.com/problems/matchsticks-to-square/description/
    *  日期：2018-07-07-20.13
    ***************************************************/
    bool makesquare(vector<int>& nums)
    {
        if(nums.size()<4) return false;
        int sum=0;
        for(int i=0;i<nums.size();i++)
        {
            sum+=nums[i];
        }
        if(sum%4!=0) return false;
        int target=sum/4;
        sort(nums.begin(),nums.end(),cmp);
        if(!is_ok(nums,target,0,nums.size()-1))
        {

            return false;
        }
        int bucks[4]={0};
        return IS_makesquare(0,nums,target,bucks);
    }

     

private:
 

    bool is_ok(vector<int>& nums,int target,int begins,int ends)
    {
        if(ends==0)
        {
             if(nums[ends]<=target)
             {
                 return true;
             }else
             {
                 return false;
             }
        }
        int mid=(begins+ends)/2;
        if(nums[mid]<=target)
        {
            is_ok(nums,target,begins,mid);
        }else
        {
            return false;

        }


    }
    bool IS_makesquare(int i,vector<int>& nums,int target,int bucks[])
    {
         if(i>=nums.size())
         {
             for(int j=0;j<4;j++)
             {
                 if(bucks[j]!=target)
                 {
                     return false;
                 }
             }
             return true;
         }

         for(int j=0;j<4;j++)
         {
            if(bucks[j]+nums[i]>target)
            {
                continue;
            }
            bucks[j]+=nums[i];
            if(IS_makesquare(i+1,nums,target,bucks))
            {
                return true;
            }
            bucks[j]-=nums[i];
         }


         return false;
    }

    int BFS_search(string beginWord,string endWord,map<string,vector<string> >& graph)
    {
        queue<pair<string,int> > Q;
        Q.push(make_pair(beginWord,1));
        set<string> visit;
        visit.insert(beginWord);
        while(!Q.empty())
        {
            string Word=Q.front().first;
            int step=Q.front().second;
            Q.pop();
            if(Word==endWord)
            {
                return step;
            }
            vector<string> TT=graph[Word];
            for(int i=0;i<TT.size();i++)
            {
                if(visit.find(TT[i])==visit.end())
                {
                    Q.push(make_pair(TT[i],step+1));
                    visit.insert(TT[i]);
                }
            }
        }
        return 0;
    }
    void consturc_graph(string beginWord,vector<string>& wordList,map<string,vector<string> >& graph)
    {
        wordList.push_back(beginWord);
        for(int i=0;i<wordList.size();i++)
        {
            graph[wordList[i]]=vector<string>();
        }
        for(int i=0;i<wordList.size();i++)
        {
            for(int j=i+1;j<wordList.size();j++)
            {
                if(one_char_not(wordList[i],wordList[j]))
                {
                    graph[wordList[i]].push_back(wordList[j]);
                    graph[wordList[j]].push_back(wordList[i]);
                }
            }
        }
    }
    bool one_char_not(string A,string B)
    {
        int cnt=0;
        for(int i=0;(i<A.size()) && (i< B.size());i++)
        {
            if(A[i]!=B[i])
            {
                cnt++;
                if(cnt>1)
                {
                    return false;
                }
            }
        }
        return true;
    }

    void DFS_lands(vector<vector<char> >& grid,vector<vector<int> >& mark,int x,int y)
    {
        const int dx[]={-1,1,0,0}; // 上、下、左、右
        const int dy[]={0,0,-1,1};
        mark[x][y]=1;
        for(int i=0;i<4;i++)
        {
            int new_x=x+dx[i];
            int new_y=y+dy[i];
            if(new_x<0 || new_x>=mark.size() || new_y<0 || new_y>=mark[0].size())
            {
                continue;
            }
            if(mark[new_x][new_y]==0 && grid[new_x][new_y]=='1')
            {
                DFS_lands(grid,mark,new_x,new_y);
            }
        }
    }
    void BFS_lands(vector<vector<char> >& grid,vector<vector<int> >& mark,int x,int y)
    {
        queue<pair<int,int> > Q;
        Q.push(make_pair(x,y));
        const int dx[]={-1,1,0,0};
        const int dy[]={0,0,-1,1};//上、下、左、右
        while(!Q.empty())
        {
            int new_x=Q.front().first;
            int new_y=Q.front().second;
            Q.pop();
            for(int i=0;i<4;i++)
            {
                int new_xx=new_x+dx[i];
                int new_yy=new_y+dy[i];
                if(new_xx<0 || new_xx>=mark.size() || new_yy<0 || new_yy>=mark[0].size())
                {
                    continue;
                }
                if(grid[new_xx][new_yy]=='1' && mark[new_xx][new_yy]==0)
                {
                    Q.push(make_pair(new_xx,new_yy));
                    mark[new_xx][new_yy]=1;
                }
            }
        }
    }

};


int main()
{
    Solution ss;
    int a[]={1,1,2,4,3,2,3};
    //int a[]={3,3,3,3,4};
    int len=sizeof(a)/sizeof(*a);
    vector<int> nums;
    for(int i=0;i<len;i++)
    {
        nums.push_back(a[i]);
    }

    cout<<"is ok ? :"<<ss.makesquare1(nums)<<endl;
    return 0;
}

/*
int main()
{
    string beginWord="hit";
    string endWord="cog";
    vector<string> wordList;
    wordList.push_back("hot");
    wordList.push_back("dot");
    wordList.push_back("dog");
    wordList.push_back("lot");
    wordList.push_back("log");
    wordList.push_back("cog");

    Solution ss;
    cout<<ss.ladderLength3(beginWord,endWord,wordList)<<endl;
    cout << "Hello world!" << endl;
    return 0;
}
*/

/*
int main()
{
    vector<vector<char> > grid;
    char str[10][10]={"11100","11000","00100","00011"};
    for(int i=0;i<4;i++)
    {
        grid.push_back(vector<char>());
        for(int j=0;j<5;j++)
        {
            grid[i].push_back(str[i][j]);
        }
    }
    Solution ss;
    cout<<ss.numIslands(grid)<<endl;
    cout << "Hello world!" << endl;
    return 0;
}
*/