7.2 数组简单 lcp01 lcp06 1365 1732

lcp01 猜数字

小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？
输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。

class Solution {
public:
    int game(vector<int>& guess, vector<int>& answer) {
        //判断两个数组各位元素是否相等
        int ans = 0;
        for(int i = 0 ; i < guess.size() ; i++){
            if(answer[i] == guess[i]){ ans++; }
        }
        return ans;

    }
};

lcp06 拿硬币

桌上有 n 堆力扣币，每堆的数量保存在数组 coins 中。我们每次可以选择任意一堆，拿走其中的一枚或者两枚，求拿完所有力扣币的最少次数。

最少次数：每次能拿2 就不拿1，按数组中存储的堆的顺序拿就行，O(n)，其实直接算除法就好

class Solution {
public:
    int minCount(vector<int>& coins) {
        int ans = 0;
        for(int n : coins){
            if( n % 2 == 1){
                ans += n/2 +1;
            }
            else{
                ans += n/2;
            }
        }
        return ans;
    }
};

优化：省去条件语句 O(n)

class Solution {
public:
    int minCount(vector<int>& coins) {
        int ans = 0;
        for(int n : coins){
            ans += (n+1) / 2;
        }
        return ans;
    }
};

1365 有多少小于当前数字的数字

给你一个数组 nums，对于其中每个元素 nums[i]，请你统计数组中比它小的所有数字的数目。
换而言之，对于每个 nums[i] 你必须计算出有效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i] 。
以数组形式返回答案。

class Solution {
public:
    vector<int> smallerNumbersThanCurrent(vector<int>& nums) {
        //暴力，能不能用排序算法？，但感觉是不能转换元素位置
        vector<int> ans;
        for(int n : nums ){
            int l = 0;
            for(int i = 0 ; i < nums.size() ; i++ ){
                if(n > nums[i]){l++;}
            }
            ans.push_back(l);
        }
        return ans;
    }
};

c++代码学习

emplace_back()它的作用是直接在容器的末尾构造元素，以提高效率。
//与 push_back 不同，emplace_back 允许我们传递构造函数的参数，这样元素可以直接在容器的末尾构造，而不是先创建一个临时对象然后拷贝（或移动）到容器中。这减少了不必要的拷贝或移动操作，从而提高了性能。与 push_back 相比，emplace_back 更高效，尤其是对于需要复杂构造的对象。 
理解来看，有点像python中的字典创建，但运用更灵活，对于元素的数据类型没有太多限制。可以是字符串，整数，一元数组也可以自定义vector容器中的类型，可以通过索引访问。

vector<pair<int,int>> data;
//也可以换成<int ,string>
data.emplace_back(1,3);
data.emplace_back(2,4);
//访问：data[0].first = 1 data[0].second = 3 
//data[1].first = 2 data[1].second = 4 

时间复杂度优化：排序算法sort()–>$O(nlogn)$

class Solution {
public:
    vector<int> smallerNumbersThanCurrent(vector<int>& nums) {
        //排序，记录原数组元素的位置
        vector<pair<int,int>> arr;
        int n = nums.size();
        for(int i = 0 ; i < n ; i++){
            arr.emplace_back(nums[i] , i);
        }
        sort(arr.begin() , arr.end());

        vector<int> ans(n , 0);//不能直接push_back了，只能按照arr中的顺序来
        //要找小于它的数字，就要看他在哪个位置，如果在i=0的位置就是0
        //即如果他和周围不相等那就是i，这个周围主要是适合他前一个比较
        //如果相等和前一个的数目相等prev不用动，如果不等就可以prev = i;
        int prev = -1;
        for(int i = 0 ; i < n ; i++){
            if(prev == -1 || arr[i].first != arr[i-1].first){
                prev = i;
            }
            ans[arr[i].second] = prev;
        }
        return ans;

    }
}; 

1732 找到最高海拔

有一个自行车手打算进行一场公路骑行，这条路线总共由 n + 1 个不同海拔的点组成。自行车手从海拔为 0 的点 0 开始骑行。
给你一个长度为 n 的整数数组 gain ，其中 gain[i] 是点 i 和点 i + 1 的 净海拔高度差（0 <= i < n）。请你返回 最高点的海拔 。

class Solution {
public:
    int largestAltitude(vector<int>& gain) {
        vector<int> atti; //可以省去数组的创建
        atti.push_back(0);
        for(int i = 0 ; i < gain.size() ; i++){
            int last = atti[i];
            atti.push_back(last + gain[i]);
        }
        int max = 0 ;
        for(int a : atti){
            if(a > max){
                max = a;
            }
        }
        return max;
    }
};

优化：前缀和,用于快速计算数组中某一段区间的元素和。前缀和的核心思想是预先计算出数组的前缀和数组，然后通过前缀和数组可以在常数时间内计算出任意子数组的和。
在这里只是在计算前缀和后直接比较得到最大海拔，并没有使用计算从i到j的海拔差高度。

class Solution {
public:
    int largestAltitude(vector<int>& gain) {
        int ans = 0 , sum = 0;
        for(int n : gain){
            sum += n;
            sum > ans ? ans = sum : ans;
        }
        return ans;

    }
};