674. 最长连续递增序列；697. 数组的度；724. 寻找数组的中心索引；746. 使用最小花费爬楼梯；867. 转置矩阵；766. 托普利茨矩阵；977. 有序数组的平方905. 按奇偶排序数组

674. 最长连续递增序列
     给定一个未经排序的整数数组，找到最长且连续的的递增序列

int findLengthOfLCIS(vector<int>& nums) {
        if(nums.size() == 0) return 0;       
        int res = 1 , temp = 1;       
        for(int i = 1 ; i < nums.size() ; i++)   
             {            
             if(nums[i]>nums[i-1])    
                      {           
                          temp = max(temp,++res);     
                       }     
            else      
                     {       
                         res = 1;       
		    }        
           }  
      return temp; 
 }

697. 数组的度
     给定一个非空且只包含非负数的整数数组 nums, 数组的度的定义是指数组里任一元素出现频数的最大值。你的任务是找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度

int findShortestSubArray(vector<int>& nums) {
        // 在判断距离 次数等时  首先使用 map   
             map<int,int> res;      // 记录次数    
             map<int , pair<int,int>> temp; // 记录位置   
             int count = INT_MAX , degree = INT_MIN ; 
              for(int i = 0 ; i < nums.size() ; i++)      
                {       
                     if(++res[nums[i]] == 1)  //第一次出现这个数  ++ res[nums[i]]指的是个数 第一次是0 ++ =1     
                            {             
                               temp[nums[i]] = {i,i};  // 输入坐标       
                             }           
                       else    // 更新位置即可       
                            {         
                                   temp[nums[i]].second = i;     
                             }       
                                  // 更新 度      
			degree = max(degree , res[nums[i]]);   
		 }   
		  for (auto iter:res)    
		      {         
		         if(degree == iter.second) // 度 相等        
		     count = min(count , temp[iter.first].second - temp[iter.first].first + 1) ;   
		          }    
		 return count; 
   }

724. 寻找数组的中心索引
     给定一个整数类型的数组 nums，请编写一个能够返回数组“中心索引”的方法。
     我们是这样定义数组中心索引的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。
     如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。

int pivotIndex(vector<int>& nums) {    
    // 公式 sum-nums[i] = left * 2；    
        int sum = 0,res = 0 , left = 0;  
        for(int i = 0 ; i < nums.size() ; i++)    
              sum+=nums[i];       
        for(int i = 0 ; i < nums.size() ; i++)    
              {         
                  if(sum-nums[i] == left*2)          
                        return i;     // 第一个       
                  else          
                       left+=nums[i];     
              }    
    return -1;   
 }

746. 使用最小花费爬楼梯
     数组的每个索引做为一个阶梯，第 i个阶梯对应着一个非负数的体力花费值 cost[i](索引从0开始。
     每当你爬上一个阶梯你都要花费对应的体力花费值，然后你可以选择继续爬一个阶梯或者爬两个阶梯。
     您需要找到达到楼层顶部的最低花费。在开始时，你可以选择从索引为 0 或 1 的元素作为初始阶梯。

int minCostClimbingStairs(vector<int>& cost) {   
     int len = cost.size();     
     cost.push_back(0);      
    if(len < 2) return 0;   
     vector<int> res;    
    res.push_back(cost[0]); // 第零个台阶的cost    
    res.push_back(cost[1]); // 第1个台阶的cost    
    for(int i = 2;i <= len ; i++)      
      {         
        res.push_back(min(res[i-1] , res[i-2]) + cost[i]);    
      }   
        return  res.back(); 
 }

747. 至少是其他数字两倍的最大数
     在一个给定的数组nums中，总是存在一个最大元素。
     查找数组中的最大元素是否至少是数组中每个其他数字的两倍。如果是，则返回最大元素的索引，否则返回-1

 int dominantIndex(vector<int>& nums) {   
      map<int,int> res;    
      for(int i = 0 ; i < nums.size() ; i++)       
     res[nums[i]] = i;       
     sort(nums.begin(),nums.end()); 
      int temp = nums.back() , temp_flag = res[temp];    // 记录出现位置     
       for(int i = 0 ; i < nums.size()-1 ; i++)      
         {          
           if(temp<2*nums[i])        
            	return -1;
        }  
     return temp_flag;  
  }

867. 转置矩阵
     给定一个矩阵 A， 返回 A 的转置矩阵。
     矩阵的转置是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。

vector<vector<int>> transpose(vector<vector<int>>& A) {   
     vector<vector<int>> res;    
     vector<int> temp;      
     for (int i = 0 ; i < A[0].size() ; i++)    
          {         
             for(int j = 0 ; j < A.size() ; j++)      
                 {            
                    temp.push_back(A[j][i]);     
                 }      
             res.push_back(temp);   
             temp.clear();    
          }        
    return res;  
}

766. 托普利茨矩阵
     如果一个矩阵的每一方向由左上到右下的对角线上具有相同元素，那么这个矩阵是托普利茨矩阵。
     给定一个 M x N 的矩阵，当且仅当它是托普利茨矩阵时返回 True。

 bool isToeplitzMatrix(vector<vector<int>>& matrix) {   
      if(matrix.size()==1) return true;    
          for(int i = 1 ; i < matrix.size() ; i++)       
               for(int j = 1 ; j < matrix[0].size() ; j++)     
                      {          
                            if(matrix[i-1][j-1]!=matrix[i][j])         
                            return false;         
                      }    
              return true;   
 }     

985. 查询后的偶数和
     给出一个整数数组 A 和一个查询数组 queries。
     对于第 i 次查询，有 val = queries[i][0], index = queries[i][1]，我们会把 val 加到 A[index] 上。然后，第 i 次查询的答案是 A 中偶数值的和。
     （此处给定的 index = queries[i][1] 是从 0 开始的索引，每次查询都会永久修改数组 A。）
     返回所有查询的答案。你的答案应当以数组 answer 给出，answer[i] 为第 i 次查询的答案。

vector<int> sumEvenAfterQueries(vector<int>& A, vector<vector<int>>& queries) {        	
vector<int> answer;      
  int sum = 0;    
 for(int i = 0 ; i < A.size() ; i++)  
      {      
           if(A[i]%2==0)       
           sum +=A[i];   
      }     
for(int i = 0 ; i < A.size() ; i++)
       {    
             int val = queries[i][0] , index = queries[i][1];            
             if(A[index]%2==0) sum-=A[index]; // 是偶数先减去              
             A[index] +=val;     
            if(A[index]%2==0) sum+=A[index];  // 加上                        
             answer.push_back(sum);   
        }    
  return answer;   
}

977. 有序数组的平方
     给定一个按非递减顺序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序

vector<int> sortedSquares(vector<int>& A) 
{      
  vector<int> res;     
  for(int i = 0 ; i < A.size() ; i++)    
     {           
      res.push_back(A[i]*A[i]); 
     }      
       sort(res.begin(),res.end());     
       return res;   
}

905. 按奇偶排序数组
     给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。
     你可以返回满足此条件的任何数组作为答案。

 vector<int> sortArrayByParity(vector<int>& A) {     
 vector<int> res;    
 int count = 0;     
 for(int i = 0 ; i < A.size() ; i++ )   
 {      
   if(A[i]%2==0)       
    {                                         
     res.insert(res.begin()+count,A[i]);                
     count++;     
    }        
  else                
   res.push_back(A[i]);                  
   }     
  return res;   
}