896. 单调数列；1128. 等价多米诺骨牌对的数量;1200. 最小绝对差；1266. 访问所有点的最小时间；849. 到最近的人的最大距离；1160. 拼写单词；914. 卡牌分组

896. 单调数列
     如果数组是单调递增或单调递减的，那么它是单调的。
     如果对于所有 i <= j，A[i] <= A[j]，那么数组 A 是单调递增的。 如果对于所有 i <= j，A[i]> = A[j]，那么数组 A 是单调递减的。
     当给定的数组 A 是单调数组时返回 true，否则返回 false。

 bool isMonotonic(vector<int>& A) {   
      if(A.size()<=1) return true;     
      int up = 0 , down = 0;    
      for(int i = 1 ; i < A.size() ; i++)    
          {        
             if(A[i]>A[i-1]) up = 1;      
             if(A[i]<A[i-1]) down = 1;   
          }      
      if(up+down==2)  return false;        
       return true; 
}

1128. 等价多米诺骨牌对的数量
      给你一个由一些多米诺骨牌组成的列表 dominoes。
      如果其中某一张多米诺骨牌可以通过旋转 0 度或 180 度得到另一张多米诺骨牌，我们就认为这两张牌是等价的。
      形式上，dominoes[i] = [a, b] 和 dominoes[j] = [c, d]，等价的前提是 a=c 且 b=d，或是 a=d 且 b=c。
      在 0 <= i < j < dominoes.length 的前提下，找出满足 dominoes[i] 和 dominoes[j] 等价的骨牌对 (i, j) 的数量。

 int numEquivDominoPairs(vector<vector<int>>& dominoes) {   
      // 先将其 全部 转化为 小数在上 大数在下   
     map<int , int> res;   
    int temp = 0 , count = 0;    
   for(auto i : dominoes)     
      {        
        temp = i[0]>i[1]?i[1]*10+i[0]:i[0]*10+i[1]; //小数在上 大数在下           
        count+=res[temp];         // 在前
        res[temp]++;    // 在后
      }   
   return count; 
}

1200. 最小绝对差
      给你个整数数组 arr，其中每个元素都 不相同。
      请你找到所有具有最小绝对差的元素对，并且按升序的顺序返回.

 vector<vector<int>> minimumAbsDifference(vector<int>& arr) {        
 sort(arr.begin(),arr.end());        
 int temp = INT_MAX;    
  for(int i = 1 ; i < arr.size() ; i++)   
      {        
          if(arr[i]-arr[i-1]<temp) temp = arr[i]-arr[i-1];    
      }    
   vector<vector<int>> res;    
 for(int i = 1 ; i < arr.size() ; i++)   
    {        
       if(arr[i]-arr[i-1]==temp)                 
       res.push_back({arr[i-1],arr[i]});        
   }   
return res;
    }

1266. 访问所有点的最小时间
      平面上有 n 个点，点的位置用整数坐标表示 points[i] = [xi, yi]。请你计算访问所有这些点需要的最小时间（以秒为单位）。
      你可以按照下面的规则在平面上移动：
      每一秒沿水平或者竖直方向移动一个单位长度，或者跨过对角线（可以看作在一秒内向水平和竖直方向各移动一个单位长度）。
      必须按照数组中出现的顺序来访问这些点。

int minTimeToVisitAllPoints(vector<vector<int>>& points) {    
     int res = 0;      
     for(int i = 1 ; i < points.size() ; i++)      
         {          
           res  += max(abs(points[i][1]-points[i-1][1]),abs(points[i][0]-points[i-1][0]));   
         }   
     return res;  
}

849. 到最近的人的最大距离
     在一排座位（ seats）中，1 代表有人坐在座位上，0 代表座位上是空的。
     至少有一个空座位，且至少有一人坐在座位上。
     亚历克斯希望坐在一个能够使他与离他最近的人之间的距离达到最大化的座位上。
     返回他到离他最近的人的最大距离

 int maxDistToClosest(vector<int>& seats) {    
 int res = 0 , cnt = 0 ,leng = seats.size();     
 for(int i = 0 ; i < leng ; i++)     
     {        
        if(seats[i]==1)       
           {            
             cnt = 0;     
           }        
        else        
           {       
               cnt++;     
               res = max(res , (cnt+1)/2);         
           }     
  }   
       // 左边界      
     for(int i = 0 ; i < leng ; i++)   
       {          
         if(seats[i]==1)           
           {                                                                                  		
           res = max(res , i);                                            		
           break;         
	 }      
        }      
 // 右边界      
	for(int i = leng-1 ; i >=0 ; i--)     
	{           
		if(seats[i]==1)      
		{             
			res = max(res , leng-1-i);      
			break;       
		}      
	}    
	return res;  
}

1160. 拼写单词
      给你一份『词汇表』（字符串数组） words 和一张『字母表』（字符串） chars。
      假如你可以用 chars 中的『字母』（字符）拼写出 words 中的某个『单词』（字符串），那么我们就认为你掌握了这个单词。
      注意：每次拼写时，chars 中的每个字母都只能用一次。
      返回词汇表 words 中你掌握的所有单词的 长度之和。

int countCharacters(vector<string>& words, string chars) {  
      map<char , int> res;    
      for(auto i : chars)     
          res[i]++;     
     int cnt = 0 , flag = 1;        
     for(int i = 0 ; i < words.size() ; i++)     
       {            
        map<char , int> temp = res;            
        flag = 1;            
        for(int j = 0 ; j < words[i].size() ; j++)          
          {                
          	if (temp[words[i][j]]<1)               
           	{                   
           	 flag = 0;                   
             	 break;                
          	}                
         	temp[words[i][j]]--;     
          }         
        if(flag == 1) cnt+=words[i].size();  
}   
return cnt;   
 }

914. 卡牌分组
     给定一副牌，每张牌上都写着一个整数。
     此时，你需要选定一个数字 X，使我们可以将整副牌按下述规则分成 1 组或更多组。
     每组都有 X 张牌
     组内所有的牌上都写着相同的整数
     仅当你可选的 X >= 2 时返回 true。

class Solution {
public:    
bool hasGroupsSizeX(vector<int>& deck) {        
// 个数全为odd or even  xxxxx        
// 寻找个数的公约数        
if(deck.size()<=1) return false;        
map<int,int> temp;        
for(auto i : deck)            
	temp[i]++;        
int res = -1;        
for(int i = 0 ; i < deck.size() ; i++)        
	{            
		if(temp[deck[i]]>0)            
		{                
			if(res == -1 )                    
			res = temp[deck[i]];                
			else                    
			res = gcd(res , temp[deck[i]]);            
		}        
	}               
	return res>=2;    
}
private :
	int gcd(int x, int y) 
	{        
		return x == 0 ? y : gcd(y%x, x);
	}
};