LeetCode算法打卡--查找

35. 搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。

链接:https://leetcode-cn.com/problems/search-insert-position/

/*基本思想：二分查找
*/

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size()-1;
        while(left<=right)
        {
            int mid = (left+right)/2;
            if(nums[mid]==target)
               return mid;
            else if(nums[mid] > target)
               right = mid-1;
            else
               left = mid+1;
        }
        return left;
    }
};

33. 搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array

/*基本思想：二分查找，每次中点的位置判断肯定是一边是有序的，一边是无序的。对于target判断是不是在有序的一边比较容易，不在那就在无序的一边
          如果中点等于target返回，如果不等于，判断在无序的一边还是有序的一边，中点小于右边界，则右边有序，判断target是在右边还是在左边
          否则，右边无序，判断target在左边还是右边
*/
class Solution {
public:
    int search(vector<int>& nums, int target) {
        
        int l=0;
        int r = nums.size()-1;
        while(l<=r)
        {
            int m = (l+r)/2;
            if(nums[m] == target)
                return m;
            else if(nums[m]<nums[r])  //右边是有序的情况
            {
                if(nums[m]<target && nums[r]>=target)  //target在右边
                    l = m+1;
                else
                    r = m-1;
            }
            else  //右边是无序的情况，左边有序
            {
                if(nums[l]<=target && nums[m]>target)   //target在左边 
                    r = m-1;
                else
                    l = m+1;
            }
        }
        return -1;
    }
    
};

81. 搜索旋转排序数组 II

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。

编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。

链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii

/*基本思想：和无重复的旋转数组的思想基本一致，二分查找，判断是否在有序的一边，需要注意的是，因为数组可能有重复，
          所以，当mid的数字等于right的数字时，可能是右边是有序的，也可能是旋转之后导致的这时右边就是无序的，所以相等时要判断一下，
          要是有序的话，那右边所有的数都相等，一旦不相等，则右边就不是无序的，就按左边是无序的进行判断。

          方法二：mid和right相等的情况下，无法确定右边是否有序，那就直接left++，依次逐个判断也可以
*/

class Solution {
public:

    bool isequal(vector<int>&nums,int mid,int right)
    {
        int i;
        for(i=mid+1;i<=right;i++)
        {
            if(nums[i] != nums[mid] )
               return false;
        }
        return true;
    }
    bool search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size()-1;
        while(left<=right)
        {
            
            int mid = (left+right)/2;
            
            if(nums[mid] == target)
                return true;
            else if(nums[mid]<nums[right] || (nums[mid] == nums[right]&& isequal(nums,mid,right)))
            {

                if(target>nums[mid] && target <=nums[right])
                   left = mid+1;
                else
                   right = mid -1;
            }
            else{
                if(target<nums[mid] && target >=nums[left])
                   right = mid -1;
                else
                   left = mid+1;
            }
            
        }
        return false;
    }
};

127. 单词接龙

给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则：

每次转换只能改变一个字母。
转换过程中的中间单词必须是字典中的单词。

链接：https://leetcode-cn.com/problems/word-ladder

/*
   主要思想：广度优先搜索，对不同位置的字母使用26个字母轮流替换，如果出现了单词列表中的词，那么就保存下来，保存到一个队列中，然后继续替换第二个位置的字母，如果全部替换完且新添加的词逐个替换完也不会产生目标词，则说明不存在。
  每次替换一层（第一层就一个开始单词，第二层就是开始单词分别替换各个位置的字母产生的新单词集合，依次类推），就把路径计数值加1即可，因为这时说明替换了一个字母，完成了一次操作。

*/

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        
        unordered_set<string> wordset(wordList.begin(),wordList.end());
        unordered_map<string,int> m={{beginWord,1}};
        queue<string> q;
        q.push(beginWord);
        while(!q.empty())
        {
            string word = q.front();
            q.pop();
            
            for(int i=0;i<word.size();i++)
            {
                string newword = word;
                for(char c='a';c<='z';c++)
                {
                    newword[i] = c;
                    if(wordset.count(newword) && newword == endWord) return m[word]+1;
                    if(wordset.count(newword) && !m.count(newword))
                    {
                        m[newword] = m[word]+1;
                        q.push(newword);
                    }
                    
                }
            }
        }
        return 0;
    }

    
};

126. 单词接龙 II

给定两个单词（beginWord 和 endWord）和一个字典 wordList，找出所有从 beginWord 到 endWord 的最短转换序列。转换需遵循如下规则：

每次转换只能改变一个字母。
转换过程中的中间单词必须是字典中的单词。

链接：https://leetcode-cn.com/problems/word-ladder-ii

/*基本思想： 根据上一题的思路，对于每一个单词的每一位进行替换生成新的单词，对于单词建立两个map，一个存变换到这个单词需要的步数，另一个存可以走一步变到这个单词的所有词。
            对于新生成的单词，如果新的单词在字典里，那么对于新的单词，如果他已经出现过，就判断当前变换的步数，和之前广度遍历出现的次数相等，则可以记录这个变化，就存储下变化之前的单词，
            没出现过，就更新两个map，把新单词加入队列
             
            统计完之后，用深度优先搜索，从结束词的l中一步一步向前找，直到找到start即可是一种情况，存储即可（注意是倒着找的所以最后要倒序存储）。
*/
class Solution {
public:
    
    void dfs(const string& begin_word, const string &t, vector<string> temp, unordered_map<string, vector<string>>&l, vector<vector<string>>&res)
	{
		if (t == begin_word)
		{
			temp.push_back(t);
            vector<string> v=temp;
			reverse(v.begin(), v.end());
			res.push_back(v);
			return;
		}
		temp.push_back(t);
		for (int i = 0; i < l[t].size(); i++)
		{
			string word = l[t][i];
			dfs(begin_word, word, temp, l, res);
		}
	}
    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        
        unordered_set<string> wordset(wordList.begin(),wordList.end());
        unordered_map<string,int> m={{beginWord,1}};
        vector<string> st;
        st.push_back(beginWord);
        unordered_map<string,vector<string>> l={{beginWord,st}};
        queue<string> q;
        q.push(beginWord);
        vector<vector<string>> res;
        while(!q.empty())
        {
            string word = q.front();
            q.pop();
            
            for(int i=0;i<word.size();i++)
            {
                string newword = word;
               
               
                for(char c='a';c<='z';c++)
                {
                    newword[i] = c;
                    if(wordset.count(newword)) 
                    {
                       
                        
                        if(m.find(newword)!=m.end())
                        {
                            if(m[newword] == m[word]+1)
                                 l[newword].push_back(word);
                        }
                        else
                        {
                            q.push(newword);
                            m[newword] = m[word]+1;
                            l[newword].push_back(word);
                            
                        }
                    }
                }
            }
        }
        
        dfs(beginWord, endWord, {}, l, res);        
                   
        
        return res;
    }

    
};

 

 

74. 搜索二维矩阵

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：

每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。

链接：https://leetcode-cn.com/problems/search-a-2d-matrix

/*基本思想:
         方法一：从右上角开始找，如果大于target，则向左找，如果小于target则向下找，时间复杂度O(m+n)
         方法二：二分查找，将二维数组看成一维数组，根据下标转换成对应的行列下标，二分查找即可，时间复杂度O(log(mn))
                也可以两次二分，先行二分后列二分
*/
class Solution {
public:
   /* bool searchMatrix(vector<vector<int>>& matrix, int target) {
       
        if(matrix.size()==0)
            return false;
        int i=0,j=matrix[0].size()-1;
        while(i<matrix.size() && j>=0)
        {
            if(matrix[i][j] == target)
                return true;
            else if(matrix[i][j] < target)
                i++;
            else
                j--;
        }
        return false;
    }*/
    
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
       
        if(matrix.size()==0)
            return false;
        int len1 = matrix.size();
        int len2 = matrix[0].size();
        int begin = 0;
        int end = len1*len2-1;
        while(begin<=end)
        {
            int mid = (begin+end)/2;
            int row = mid/len2;
            int col = mid%len2;
            if(matrix[row][col]==target)
                return true;
            else if(matrix[row][col] < target)
                begin = mid+1;
            else
                end = mid-1;
        }
        return false;
    }
    
};