【LeetCode top100】0927 在排序数组中查找元素的第一个位置和最后一个位置，旋转图像，最大子数组和

目录

34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）

 48. 旋转图像 - 力扣（LeetCode）

53. 最大子数组和 - 力扣（LeetCode）

---

34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）

思路：O(log n)的时间复杂度，有序的数组，只能是二分法。可以写一个函数binary_search（）使用二分法进行查找，找到左边界和右边界的下一个值。（python && c++）

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


    vector<int> searchRange(vector<int>& nums, int target) {
        int leftIdx = binary_search(nums,target,true);
        int rightIdx = binary_search(nums,target,false) - 1;
        if (leftIdx <= rightIdx && rightIdx < nums.size() && nums[leftIdx] == target && nums[rightIdx] == target){
            return vector<int>{leftIdx,rightIdx};
        }
        return vector<int>{-1,-1};
    }
};

class Solution:
    def binarySearch(self,nums:List[int],target:int,lower:bool) -> int:
        # 二分搜索
        left,right,ans = 0, len(nums)-1,len(nums)
        while (left <= right):
            mid = left + (right-left) // 2;
            if (nums[mid] > target or (lower and nums[mid] >= target)):
                right = mid-1
                ans = mid
            else: left = mid+1
        return ans

    def searchRange(self, nums: List[int], target: int) -> List[int]:
        leftIndx = self.binarySearch(nums,target,True)
        rightIndx = self.binarySearch(nums,target,False) -1 
        if (leftIndx <= rightIndx and rightIndx < len(nums) and nums[leftIndx] == target and nums[rightIndx] == target): return [leftIndx,rightIndx]
        return [-1,-1]

 48. 旋转图像 - 力扣（LeetCode）

思路：寻找旋转过程中元素的位置变换规律，因为要求原地修改，需要使用变量存储一个元素，让其余的三个值完成位置转换，重点是旋转位置关系和旋转的次数。 

53. 最大子数组和 - 力扣（LeetCode）

思路：动态规划。定义dp[i]，推导dp[i]关系式，确定dp[i]边界。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        dp = [ 0 for _ in range(n)]
        dp[0] = nums[0]
        ans = nums[0]
        for i in range(1,n):
            dp[i] = max(dp[i-1] + nums[i],nums[i])
            ans = max(ans,dp[i])
        return ans

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n,0);
        dp[0] = nums[0];
        int ans = nums[0];
        for (int i = 1;i < n;i++){
            dp[i] = max(dp[i-1] + nums[i],nums[i]);
            ans = max(ans,dp[i]);
        }
        return ans;
    }
};

加油，一分耕耘一分收获！