标签：函数 nums int 旋转 matrix maxi day10 row size

396旋转函数

由于昨天也做了旋转函数，现在很自然地就想用昨天的函数，然后暴力求解

class Solution {
public:
    void rotate(vector<int>& nums, int k){
        int n = nums.size();
        k = k % n;
        int count = gcd(n, k);
        for(int i = 0; i < count; i++){
            int cur = i;
            int pre = nums[i];
            do{
                int next = (cur + k) % n;
                swap(nums[next], pre);
                cur = next;
            }while(cur != i);
        }
    }

    int maxRotateFunction(vector<int>& nums) {
        int maxi = INT_MIN;
        for(int i = 0; i < nums.size(); i++){
            int f = 0;
            if( i == 0);
            else 
              rotate(nums, 1);//每次都是在前面的基础上的，每次只转了1        
            for(int k = 0; k < nums.size(); k++){
                f += k * nums[k];
            }
            if(f > maxi) maxi = f;
        }
        return maxi;
    }
};

这样是n平方，超时了…

更好的解法肯定是不能用暴力，计算前后两次的区别，

F(0)= A[0] * 0 +A[1] * 1 +A[2] * 2 + … A[n-2] * (n-2) + A[n-1] * (n-1)

F(1)= A[n-1] * 0+ A[0] * 1 +A[1] * 2 +A[2] * 3 + … A[n-2] * (n-1)

F(1)-F(0)= -A[n-1] * (n-1) + A[0] + A[1] + … A[n-2]

     = -A[n-1]*n +sum

class Solution {
public:
    int maxRotateFunction(vector<int>& nums) {
        long long sum = 0;
        long long f = 0;
        for(int i = 0; i < nums.size(); i++){
            sum += nums[i];
            f += i * nums[i];//计算f0;
        }
        int maxi = f;
        for(int i = 1; i < nums.size(); i++){
           f += sum - nums.size() * nums[nums.size() - i];
           if(f > maxi) maxi = f;
        }

    return maxi;
    }
};

这样的话就是O(N),空间复杂度O(1),这里要注意sum的值要用长整型

54螺旋矩阵

这题好像也不需要什么算法和想法，设置好方向和边界一个一个push就行了

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> res;
        int left = 0;
        int right = matrix[0].size() - 1;
        int top = 0;
        int bottom = matrix.size() - 1;
        while(left <= right && top <= bottom){
             for(int col = left; col <= right; col ++){  //左上到右上
                 res.push_back(matrix[top][col]);
             }

             for(int row = top + 1; row <= bottom; row++){
                 res.push_back(matrix[row][right]); //右上到右下
             }
             
             if(left < right && top < bottom){
                for(int col = right - 1; col >= left; col--){
                  res.push_back(matrix[bottom][col]); //右下到左下
                }

                for(int row = bottom - 1; row > top; row--){
                   res.push_back(matrix[row][left]); //左下到左上
                }
             }
         
             left++;
             right--;
             top++;
             bottom--;
        }
        return res;
    }
};

时间复杂度O(mn),空间复杂度O(1)

标签：函数,nums,int,旋转,matrix,maxi,day10,row,size
来源： https://blog.csdn.net/Sophia2333333331/article/details/115691399

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。