LeeCode-数据结构-day3-数组

day3-数组

1、两个数组的交集

1. 描述

   给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。
   
   示例 1：
   输入：nums1 = [1,2,2,1], nums2 = [2,2]
   输出：[2,2]
   示例 2:
   输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
   输出：[4,9]
   提示：
   1 <= nums1.length, nums2.length <= 1000
   0 <= nums1[i], nums2[i] <= 1000
   
   进阶：
   如果给定的数组已经排好序呢？你将如何优化你的算法？
   如果 nums1 的大小比 nums2 小，哪种方法更优？
   如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？
   

2. 思路

   • 将其中一个数组放入map，遍历另一个数组并获取map中个数
   • 根据进阶版，直接sort数组，然后一一比较判等否

3. 代码

   思路一

   #include <iostream>
   using namespace std;
   #include <vector>
   #include <map>
   
   class Solution {
   public:
       vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
           map<int,int> num_map;
           int tmp;
           for(int i = 0; i < nums2.size(); i++) {
               tmp = nums2[i];
               num_map[tmp]++;
           }
           auto inter = num_map.begin();
           while(inter != num_map.end()) {
               printf(" %d   -   %d\n",inter->first,inter->second);
               inter++;
           }
           vector<int> res;
           for(int i = 0; i < nums1.size(); i++) {
               tmp = nums1[i];
               if(num_map[tmp] != 0) {
                   num_map[tmp]--;
                   res.push_back(tmp);
               }
           }
           for(int i = 0; i < res.size(); i++) {
               cout << res[i] << "  ";
           }
           cout << endl;
           return res;
       }
   };
   
   int main() {
       Solution sol;
       vector<int> nums1 = {4,9,5};
       vector<int> nums2 = {9,4,9,8,4};
       sol.intersect(nums1, nums2);
       return 0;
   }
   

   思路二

   /*
   给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。
   
   示例 1：
   输入：nums1 = [1,2,2,1], nums2 = [2,2]
   输出：[2,2]
   示例 2:
   输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
   输出：[4,9]
   提示：
   1 <= nums1.length, nums2.length <= 1000
   0 <= nums1[i], nums2[i] <= 1000
   
   进阶：
   如果给定的数组已经排好序呢？你将如何优化你的算法？
   如果 nums1 的大小比 nums2 小，哪种方法更优？
   如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？
   */
   #include <iostream>
   using namespace std;
   #include <vector>
   #include <algorithm>
   
   class Solution {
   public:
       vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
           sort(nums1.begin(),nums1.end());
           sort(nums2.begin(),nums2.end());
           for(int i = 0; i < nums1.size(); i++) {
               cout << nums1[i] << "  ";
           }
           cout << endl;
           for(int i = 0; i < nums2.size(); i++) {
               cout << nums2[i] << "  ";
           }
           cout << endl;
           vector<int> res;
           for(int i = 0,j = 0; i < nums1.size();) {
               if(j >= nums2.size())   break;
               if(nums1[i] == nums2[j]) {
                   res.push_back(nums1[i]);
                   i++;
                   j++;
               } else if(nums1[i] > nums2[j]) {
                   j++;
               } else if(nums1[i] < nums2[j]) {
                   i++;
               }
           }
           for(int i = 0; i < res.size(); i++) {
               cout << res[i] << "  ";
           }
           cout << endl;
           return res;
       }
   };
   
   int main() {
       Solution sol;
       vector<int> nums1 = {1,2,2,1};
       vector<int> nums2 = {2,2};
       sol.intersect(nums1, nums2);
       return 0;
   }
   

2、买卖股票的最佳时机

1. 描述

   给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
   你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
   返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
   
   示例 1：
   输入：[7,1,5,3,6,4]
   输出：5
   解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
        注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
   示例 2：
   输入：prices = [7,6,4,3,1]
   输出：0
   解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
    
   提示：
   1 <= prices.length <= 105
   0 <= prices[i] <= 104
   

2. 思路

   暴力解法，直接遍历（数组size太大，超时了）

   动态规划，保存当前得到的结果最大值以及数值最小值，比较后获取最后的结果

3. 代码

   #include <iostream>
   using namespace std;
   #include <vector>
   
   class Solution {
   public:
       int maxProfit(vector<int>& prices) {
           // vector<int> dp ;
           // dp.push_back(0);
           int res = 0;
           int min = prices[0];
           for(int i = 1; i < prices.size(); i++) {
               if(prices[i] < min) {
                   min = prices[i];
                   continue;
               }
               // dp[i] = dp.back() > (prices[i] - min) ? dp[i - 1] : (prices[i] - min);
               // if(dp.back() < (prices[i] - min))
               //     dp.push_back(prices[i] - min);
               if(res < (prices[i] - min))
                   res = prices[i] - min;
               cout << res << "  ";
           }
           cout << endl;
           return res;
       }
   };
   
   int main() {
       vector<int> prices = {7,1,5,3,6,4};
        Solution sol;
       sol.maxProfit(prices);
       return 0;
   }