算法专练 01 ：数组

1.2016. 增量元素之间的最大差值

原题链接
          给你一个下标从 0 开始的整数数组 nums ，该数组的大小为 n ，请你计算 nums[j] - nums[i] 能求得的 最大差值 ，其中 0 <= i < j < n 且 nums[i] < nums[j] 。
          返回 最大差值 。如果不存在满足要求的 i 和 j ，返回 -1 。
示例 1：
输入：nums = [7,1,5,4]
输出：4
解释：
最大差值出现在 i = 1 且 j = 2 时，nums[j] - nums[i] = 5 - 1 = 4 。
注意，尽管 i = 1 且 j = 0 时 ，nums[j] - nums[i] = 7 - 1 = 6 > 4 ，但 i > j 不满足题面要求，所以 6 不是有效的答案。
示例 2：
输入：nums = [9,4,3,2]
输出：-1
解释：
不存在同时满足 i < j 和 nums[i] < nums[j] 这两个条件的 i, j 组合。
示例 3：
输入：nums = [1,5,2,10]
输出：9
解释：
最大差值出现在 i = 0 且 j = 3 时，nums[j] - nums[i] = 10 - 1 = 9
提示：
n == nums.length
2 <= n <= 1000
1 <= nums[i] <= 10^9
          这道题没什么好说的，我们在模拟的过程中维护好数组中的最小值，然后不断更新ans即可。
          需要注意的是，这种做法如果没有找到合法的ans，最后ans会变为0，这个时候就要返回-1.

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

2.2239. 找到最接近 0 的数字

原题链接

          给你一个长度为 n 的整数数组 nums ，请你返回 nums 中最 接近 0 的数字。如果有多个答案，请你返回它们中的 最大值 。
示例 1：
输入：nums = [-4,-2,1,4,8]
输出：1
解释：
-4 到 0 的距离为 |-4| = 4 。
-2 到 0 的距离为 |-2| = 2 。
1 到 0 的距离为 |1| = 1 。
4 到 0 的距离为 |4| = 4 。
8 到 0 的距离为 |8| = 8 。
所以，数组中距离 0 最近的数字为 1 。
示例 2：
输入：nums = [2,-1,1]
输出：1
解释：1 和 -1 都是距离 0 最近的数字，所以返回较大值 1 。

          和上一道题类似，在模拟的过程中维护好该数到0的距离也就是$abs(i)$的最小值，如果当前的最小值小于之前的距离更新$dist$和$ans$，如果距离跟之前相等，我们选择较大的元素。

class Solution {
public:
    int findClosestNumber(vector<int>& nums) {
        int ans=INT_MAX;
        int dist=INT_MAX;
        for(auto i:nums){
            int val=abs(i);
            if(val<dist){
                dist=val;
                ans=i;
            }else if(val==dist){
                ans=max(ans,i);
            }
        }
        return ans;
    }
};

3.1475. 商品折扣后的最终价格

原题链接

          给你一个数组 prices ，其中 prices[i] 是商店里第 i 件商品的价格。
商店里正在进行促销活动，如果你要买第 i 件商品，那么你可以得到与 prices[j] 相等的折扣，其中 j 是满足 j > i 且 prices[j] <= prices[i] 的 最小下标 ，如果没有满足条件的 j ，你将没有任何折扣。
请你返回一个数组，数组中第 i 个元素是折扣后你购买商品 i 最终需要支付的价格。
示例 1：
输入：prices = [8,4,6,2,3]
输出：[4,2,4,2,3]
解释：
商品 0 的价格为 price[0]=8 ，你将得到 prices[1]=4 的折扣，所以最终价格为 8 - 4 = 4 。
商品 1 的价格为 price[1]=4 ，你将得到 prices[3]=2 的折扣，所以最终价格为 4 - 2 = 2 。
商品 2 的价格为 price[2]=6 ，你将得到 prices[3]=2 的折扣，所以最终价格为 6 - 2 = 4 。
商品 3 和 4 都没有折扣。
示例 2：
输入：prices = [1,2,3,4,5]
输出：[1,2,3,4,5]
解释：在这个例子中，所有商品都没有折扣。
示例 3：
输入：prices = [10,1,1,6]
输出：[9,0,1,6]
提示：
1 <= prices.length <= 500
1 <= prices[i] <= 10^3

          这道题暴力过就好了，数据量只有1000，O(n^2)完全可以接受。遍历两边数组即可。

class Solution {
public:
    vector<int> finalPrices(vector<int>& prices) {
        vector<int> ans;
        for(int i=0;i<prices.size();++i){
            int flag=true;
            for(int j=i+1;j<prices.size();++j){
                if(prices[j]<=prices[i]){
                    ans.push_back(prices[i]-prices[j]);
                    flag=false;
                    break;
                }
            }
            if(flag){
                ans.push_back(prices[i]);
            }
        }
        return ans;
    }
};

4.2248. 多个数组求交集

原题链接

          给你一个二维整数数组 nums ，其中 nums[i] 是由 不同 正整数组成的一个非空数组，按 升序排列 返回一个数组，数组中的每个元素在 nums 所有数组 中都出现过。
示例 1：
输入：nums = [[3,1,2,4,5],[1,2,3,4],[3,4,5,6]]
输出：[3,4]
解释：
nums[0] = [3,1,2,4,5]，nums[1] = [1,2,3,4]，nums[2] = [3,4,5,6]，在 nums 中每个数组中都出现的数字是 3 和 4 ，所以返回 [3,4] 。
示例 2：
输入：nums = [[1,2,3],[4,5,6]]
输出：[]
解释：
不存在同时出现在 nums[0] 和 nums[1] 的整数，所以返回一个空列表 [] 。
提示：
1 <= nums.length <= 1000
1 <= sum(nums[i].length) <= 1000
1 <= nums[i][j] <= 1000
nums[i] 中的所有值 互不相同

          这道题的话由于每个数组的元素均不相同，所以可以用一个$hash$数组来对这个元素出现次数加一，最后统计$hash$数组中的每个元素看他是否为$N$，如果是的话就在返回数组中加入他.

class Solution {
public:
    vector<int> intersection(vector<vector<int>>& nums) {
        vector<int> ans;
        int hash[1005];
        memset(hash,0,sizeof(hash));
        int n=nums.size();
        for(int i=0;i<n;++i){
            for(int j=0;j<nums[i].size();++j){
                ++hash[nums[i][j]];
            }
        }
        for(int i=1;i<=1000;++i){
            if(hash[i]==n){
                ans.push_back(i);
            }
        }
        return ans;
    }
};