561. 数组拆分 I；566. 重塑矩阵；581. 最短无序连续子数组；605. 种花问题；628. 三个数的最大乘积；643. 子数组最大平均数 I；661. 图片平滑器；665. 非递减数列

561. 数组拆分 I；
     给定长度为 2n 的数组, 你的任务是将这些数分成 n 对,例如 (a1, b1), (a2, b2), …, (an, bn) ，使得从1 到 n 的 min(ai, bi) 总和最大。

int arrayPairSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        int res = 0;        
        for(int i = 0 ; i<nums.size() ; )        
         {           
          	res = res + nums[i];            
         	 i = i+2;        
        }        
       return res;    
   }

562. 重塑矩阵

vector<vector<int>> matrixReshape(vector<vector<int>>& nums, int r, int c)
 {        
 int m = nums.size();        
 int n = nums[0].size();       
  if(m*n!=r*c) return nums;        
  vector<vector<int>> res(r,vector<int>(c)); // 定义格式       
   for(int i = 0; i<r*c ;i++)     
      {           
       res[i/c][i%c] = nums[i/n][i%n]; 
	 }   
    return res;
  //------------------------------------------------------------------------------------------------------       
   // if(nums.size()*nums[0].size()!=r*c) return nums;      
// vector<vector<int>> res;       
 // vector<int> temp;       
 // int colum = 0 ;
 // colum flag       
 // for (int i = 0 ;i < nums.size() ; i++)       
 //     for(int j = 0 ;j<nums[i].size() ; j++)        
 //     {        
 //         temp.push_back(nums[i][j]);       
  //         colum++;       
   //         if(colum==c)       
    //         {       
     //             res.push_back(temp);      
 //             temp.clear();     
//             colum = 0;       
 //         }      
 //     }             
// return res;
    }

563. 最短无序连续子数组
     给定一个整数数组，你需要寻找一个连续的子数组，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。

class Solution {
public:   
 int findUnsortedSubarray(vector<int>& nums)
  {       
   int length = nums.size();        
   int res_left = 0 , res_right = 0 , left_flag = nums[0] , right_flag = nums[length-1];        
   for (int i = 0 ; length > i ; i++)        
   {           
         left_flag = max(left_flag,nums[i]);            
         right_flag = min(right_flag ,nums[length-1-i]);            
         if(left_flag > nums[i]) res_left = i;            
         if(right_flag < nums[length-1-i]) res_right = length-1-i;       
   }        
      return res_left>res_right? res_left - res_right + 1 : 0;            
  }
  };

564. 种花问题
     假设你有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花卉不能种植在相邻的地块上，它们会争夺水源，两者都会死去。
     给定一个花坛（表示为一个数组包含0和1，其中0表示没种植花，1表示种植了花），和一个数 n 。能否在不打破种植规则的情况下种入 n 朵花。

class Solution {
public:    bool canPlaceFlowers(vector<int>& flowerbed, int n) {       
 // 添加元素        
 flowerbed.insert(flowerbed.begin(),0);        
 flowerbed.push_back(0);       
  for(int i = 1 ; i < flowerbed.size()-1 ; i++)        
  { 
             if(flowerbed[i-1]==0 && flowerbed[i]==0 && flowerbed[i+1]==0)
                {                
                    flowerbed[i] = 1; //更新 flowerbed                
                       n--;                
                     if(n <= 0) return true;           
                }        
   }      
      return n<=0?true : false    ;  //   >0 返回 false
 }
 };

565. 三个数的最大乘积
     给定一个整型数组，在数组中找出由三个数组成的最大乘积，并输出这个乘积.

class Solution {
public:    
	int maximumProduct(vector<int>& nums) {
	  sort(nums.begin(),nums.end());        
	   int len = nums.size();       
	    // judge        
	 return max(nums[len-1]*nums[len-2]*nums[len-3] , nums[0]*nums[1]*nums[len-1]);            }};

566. 子数组最大平均数 I
     给定 n 个整数，找出平均数最大且长度为 k 的连续子数组，并输出该最大平均数.

int res = INT_MIN ,temp = 0; //  一定要使用INT_MIN   
  for(int i = 0 ; i<k ;i++)    
      {      
        temp += nums[i];    
       }  
  res = max(res,temp);    
 for(int i = 1 ; i < nums.size()-k+1 ; i++) 
  {     
   temp = temp - nums[i-1] + nums[i+k-1];   
   res = max(res,temp);    
  }      
   return res/(double)k;

567. 图片平滑器
     包含整数的二维矩阵 M 表示一个图片的灰度。你需要设计一个平滑器来让每一个单元的灰度成为平均灰度 (向下舍入) ，平均灰度的计算是周围的8个单元和它本身的值求平均，如果周围的单元格不足八个，则尽可能多的利用它们。

vector<vector<int>> imageSmoother(vector<vector<int>>& M) {        
// 一定要注意小错误 。。。。。。。。emmmmmmmmm    
    int raw = M.size() , col = M[0].size(),sum = 0, count = 0;    
    vector<vector<int>> res(raw,vector<int>(col));  
     for(int i = 0 ; i<raw ; i++)  
        for(int j = 0 ; j<col;j++)   
      {  
          for(int r = i-1 ; r <= i+1 ; r++) 
           for(int c = j-1 ; c <= j+1 ; c++)    
            {       
             if(0<=r && r<raw && 0<=c && c<col) 
                   {   
               sum += M[r][c]; 
               count++; 
                   }
             }  
             sum = sum/count;   
              res[i][j] = sum;  
              sum = 0;   
              count = 0; 
      }   
 return res;

665. 非递减数列
     给定一个长度为 n 的整数数组，你的任务是判断在最多改变 1 个元素的情况下，该数组能否变成一个非递减数列。我们是这样定义一个非递减数列的： 对于数组中所有的 i (1 <= i < n)，满足 array[i] <= array[i + 1]。

bool checkPossibility(vector<int>& nums) {      
  if(nums.size()<3) return true; ///坑      
     int count = 0,len = nums.size();   
          // 先判断第一个和最后一个     
             if(nums[0]>nums[1])      
                {        
                    nums[0] = nums[1];    
                            count++;      
                } 
            if(nums[len-2]>nums[len-1])   
            {       
                      nums[len-1] = nums[len-2];     
                             count++;      
             } 
	 if(count>1) return false;     
	    for(int i = 1 ; i < nums.size()-1; i++)     
	       {      
	             if(nums[i]>nums[i+1])     
			 {             
	                    count++;       
	                 if(count>1) return false;          
	                    if(nums[i-1]>nums[i+1])              
	                        nums[i+1] = nums[i];    // 把  nums[i+1] 变大   2 3 1                				
	                    else                   
	                        nums[i] = nums[i-1];  // 把 nums[i] 变小      2 4 3
            }   
                 }    
        return true;          
}