力扣打怪记005

力扣打怪记005

今天多更几题~~

题目一：判断重复

给定一个整数数组，判断是否存在重复元素。如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

示例 ：

输入: [1,2,3,1]         输出: true  ；输入: [1,2,3,4]         输出: false；

输入: [1,1,1,3,3,4,3,2,4,2]        输出: true；

方法一：哈希表

//用set实现
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int>hash;
        for(int i:nums)
        {if(hash.find(i)!=hash.end())
            return true;
            hash.insert(i);
        }
        return false;
    }
};


//用map实现
class Solution{
public:
    bool containsDuplicate(vector<int>& nums){
        unordered_map<int,int>mp;
        for(int i:nums)
        {mp[i]++;
         if(mp[i]>1)return true;
        }
return false;
    }
};

分析：代码很好理解，就是遍历查找，如果没有就插入，时间复杂度O(N)，要注意set的函数.

方法二：排序

class Solution{
public:
bool containsDuplicate(vector<int>&nums){
sort(nums.begin(),nums.end());
for(int i=0;i<nums.size()-1;++i)
if(nums[i]==nums[i+1])return true;
return false;
}
};

分析:这里用了快排,时间复杂度为O(nlogn),有大佬说用两个for循环类似双指针那样好像超时了~~

方法三:集合巧秒解法

class Solution{
public:
    bool containsDuplicate(vector<int>&nums){
        return nums.size()>unordered_set<int>(nums.begin(),nums.end()).size();}
};

 没有分析:额,复习一下集合三大特点互异性,确定性,无序性

题目二 :最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

 示例:

1.     输入：nums = [-2,1,-3,4,-1,2,1,-5,4]

        输出：6

        解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

2.     输入：nums = [-1]

        输出：-1

方法一:暴力

class Solution
{
public:
   int maxSubArray(vector<int> &nums)
   {
      int max = INT_MIN, sum = 0;
      int length = nums.size();
      for (int i = 0; i < length; ++i)
      {
         sum = nums[i];
         if (sum > max)
            max = sum;
         for (int j = i + 1; j < length; ++j)
         {
            sum += nums[j];
            if (sum > max)
               max = sum;
         }
      }
      return max;
   }
};

 分析:暴力也有美感,类似于两数相加拓展到n数相加,这里引入了新知识INT_MIN(int型最小负数),感兴趣可以去查查相关用法,这里的思路可能有点陡,只要记得它是求连续的,所以都可以改变首位数

方法二:贪心算法

class Solution{
   public:
   int maxSubArray(vector<int> &nums){
   int sum=0, length=nums.size(), result=INT_MIN;
   for(int i=0;i<nums.size();++i)
   {
        sum+=nums[i];
        result=max(result,sum);
        if(sum<0)sum=0;
   }
   return result;
}
};

 分析:这里找最优在于找到和小于0的部分,并让这部分归零,从之后开始重新计数

方法三：动态规划（DP）

//方法一：dp数组法
class Solution
{
public:
   int maxSubArray(vector<int> &nums)
   {
      int numsSize = nums.size(), result = INT_MIN;
      vector<int> dp(numsSize);//这里是给dp数组规定大小
      dp[0] = nums[0];
      result = nums[0];
      for (int i = 1; i < numsSize; ++i)
      {
         dp[i] = max(dp[i - 1] + nums[i], nums[i]);
         result = max(result, dp[i]);
      }
      return result;
   }
};


//方法二：dp数字法
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result=INT_MIN, dp(nums[0]);//这里dp被初始化赋值为nums[0]
        int numsSize=nums.size();
        result=dp;
        for(int i=1;i<numsSize;++i)
        {
            dp=max(dp+nums[i],nums[i]);
            result=max(dp,result);
        }
        return result;
    }
};

分析：动态规划就在于dp[n]，dp[n-1],   现在的数，用两次比大小进行排除