算法提升(C++) 2020-09-28 -- 2020-10-4

2020-09-28

排序

去掉最低工资和最高工资后的工资平均值

class Solution {
public:
    double average(vector<int>& salary) {
        sort(salary.begin(),salary.end());
        double result = 0;
        for(int i = 1; i < salary.size()-1; i++) {
            result += salary[i];
        }
        return result/(salary.size()-2);
    }
};

重新排列字符串

class Solution {
public:
    string restoreString(string s, vector<int>& indices) {
        string str(indices.size(),0);
        for(int i = 0; i < indices.size(); i++) {
           str[indices[i]] = s[i];
        }
        return str;
    }

};

距离顺序排列矩阵单元格

class Solution {
public:
    vector<vector<int>> allCellsDistOrder(int R, int C, int r0, int c0) {
        vector<vector<int>> nums;
        vector<int> num;
        for(int r = 0; r < R; r++) {
            for(int  c = 0; c < C; c++) {
                num.push_back(r);
                num.push_back(c);
                num.push_back(abs(r-r0)+abs(c-c0));
                nums.push_back(num);
                num.clear();
            } 
        }
        sort(nums.begin(),nums.end(),compare);
        for(int i = 0; i < nums.size(); i++) nums[i].pop_back();
        return nums;
    }
    static bool compare(vector<int>& a, vector<int>& b) {
        return a[2]<b[2];
    } 
};

数组

2020-09-29

存在连续三个奇数的数组

class Solution {
public:
    bool threeConsecutiveOdds(vector<int>& arr) {
        int tmp = 0;
        for(int i = 0; i < arr.size(); i++) {
            if(tmp >= 3) return true;
            if(arr[i]%2 == 0) tmp = 0;
            else tmp++;
        }
        if(tmp>=3) return true;
        return false;
    }
};

转置矩阵

class Solution {
public:
    vector<vector<int>> transpose(vector<vector<int>>& A) {
        vector<vector<int>> nums(A[0].size(),vector(A.size(),0));
        for(int i = 0; i < nums.size(); i++) {
            for(int j = 0; j < nums[0].size(); j++) {
                nums[i][j] = A[j][i];
            }
        }
        return nums;
    }
};

所有奇数长度子数组的和

class Solution {
public:
    int sumOddLengthSubarrays(vector<int>& arr) {
        int res = 0;
        for(int i = 1; i <= arr.size(); i+=2) {
            res += Judgment(i,arr);
        }
        return res;
    }
    int Judgment(int n, vector<int> arr) { 
        int res = 0;
        int tmp;
        for(int i = 0; i < arr.size(); i++) {
            tmp = n;
            while(tmp) {
                res += arr[i];
                i++;
                tmp--;
                if(i == arr.size()) return res;
            } 
            i-=n;
        }
        return res;
    }
};

杨辉三角

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> nums(numRows,vector<int>(numRows,0));
        int tmp;
        for(int i = 0; i < numRows; i++) {
            nums[i][0]=1;
            nums[i][i]=1;
            for(int j = 1; j <= i-1;j++) {
                nums[i][j] = nums[i-1][j-1]+nums[i-1][j];
            }
            tmp =numRows-i-1;
            while(tmp) {
                nums[i].pop_back();
                tmp--;
            }
        }
        return nums;
    }
};

杨辉三角 II

class Solution {
public:
    vector<int> getRow(int rowIndex) {
        vector<int> num(rowIndex+1,1);
        for(int i = 0; i < rowIndex+1; i++) {
            for(int j = i-1; j >= 1; j--)
                num[j] = num[j-1]+num[j];
        }
        return num;
    }
};

2020-09-30

一维数组的动态和

class Solution {
public:
    vector<int> runningSum(vector<int>& nums) {   
        int sum = nums[0];
        int n=nums.size();
        for(int i = 1; i < n; i++) {
            sum += nums[i];
            nums[i] = sum;
        }
        return nums;
    }
};

拥有最多糖果的孩子

class Solution {
public:
    vector<bool> kidsWithCandies(vector<int>& candies, int extraCandies) {
        int n = candies.size();
        vector<bool> Judg(n,true);
        int max = *max_element(candies.begin(),candies.end());
        for(int i = 0; i < n; i++) {
            Judg[i] = (candies[i]+extraCandies)>=max?true:false;
        }
        return Judg;
    }
};

重新排列数组

class Solution {
public:
    vector<int> shuffle(vector<int>& nums, int n) {
        vector<int> num(n*2,0);
        for(int i = 0,j = 0; i < n*2; i+=2) {
            num[i] = nums[j];
            num[i+1] = nums[n+j];
            j++;
        }
        return num;
    }
};

解压缩编码列表

class Solution {
public:
    vector<int> decompressRLElist(vector<int>& nums) {
        vector<int> num;
        int n = nums.size();
        for(int i = 0; i < n; i+=2) {
            while(nums[i]) {
                num.push_back(nums[i+1]);
                nums[i]--;
            }
        }
        return num;
    }
};

按既定顺序创建目标数组

class Solution {
public:
    vector<int> createTargetArray(vector<int>& nums, vector<int>& index) {
        int length = nums.size();
        vector<int> target(length);
        int tmp[101] = {-1};
        for(int i = 0; i < length; ++i) {
            if(tmp[index[i]] >= 0) {
                for(int j = length-2; j >= index[i]; --j) {
                    target[j+1] =  target[j];
                }
                target[index[i]] = nums[i];
            }
            else {
                target[index[i]] = nums[i];
                tmp[index[i]]++;
            }
        }
        return target;
    }
};