解题思路

因为如果在原数组上进行更改，如果超过了原数组的位数，那么就会很麻烦。

所以我们尽可能要先建立一个vector<int> res作为结果返回数组。

这样push_back()计算后的结果，最终只需要reverse倒一下就行。

其次计算过程中，要注意carry进位的问题，每次计算都要将k的当前位和num的当前位以及carry相加。

k的当前位只需要每次%10然后k /= 10随之更改k的值即可。

最后要考虑数组位数大于k，和k的位数大于数组，以及两个数加和后位数变大的可能 。

位数变大就要有carry，

在第一个 循环中，哪怕 数组的位数大，循环后res会和num的位数一样大，如果有进位，会在下一个循环中进行判断并push_back()进位值(前提是k的位数小于num.size());

如果k的位数过大，会在第二个循环中带着第一个循环剩下的carry进行计算。(需要注意，如果num位数小于k且最后一次计算是可能仍产生carry的)；

代码

  
  

   
   
   
   
  
  
class Solution {
public:
    vector<int> addToArrayForm(vector<int>& num, int k) {
        int n = num.size();
        int carry = 0;
        vector<int> res;
        //注意：num有多少位，就要进行多少次运算。注意 i的取值范围。
        //没必要管k到底有多少位，如果 位数少，后期直接加0即可。但是得把num数组中前面的数都push_back到res中。
        for(int i = n - 1 ;i >= 0 ; i--){
            int sum = num[i] + k % 10 + carry;
            k = k /10;
            carry = sum / 10;
            res.push_back(sum%10);
        }//有可能k的位数 太少，
        for(;k!=0||carry!=0;k/=10){
            int sum = k%10 + carry;
            carry = sum / 10;
            res.push_back(sum % 10);
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

解题思路

已知数组nums中一定有超过1个的元素。则最少序列长度为1.

只有后面大于前面的数才会使递增延续，length++。反之小于或者等于，都会让

递增序列断掉。断掉后进行和maxlength的比较，再将length赋值为最初的1.重新开始。

最后为了避免出现：全增，即最大序列长度等于nums.size(),会让maxlength失去和length的赋值比较

的机会，所以，在外面再进行一下比较。大的会return回去。

//如果下面nums[i]>nums[i+1]的话当遇到相等的两个数时会自动跳过，如果再次遇见的第一个非相等数是大于自己的，就会继续算到递增子序列中就会出现错误。只有改成>=才可以

代码

  
  

   
   
   
   
  
  
class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int maxlength = 1;
        int length = 1;
        for(int i = 0;i<nums.size()-1;i++){
            if(nums[i]<nums[i+1])
                length++;
            else if(nums[i] >= nums[i+1]){
                if(maxlength<length)
                    maxlength = length;
                length = 1;
            }
        }
        maxlength = maxlength>length?maxlength:length;
        return maxlength;
    }
};

解题思路

通过哈希表来存储第一个数组中的字符串的序号，然后再遍历第二个数组，来找是否具有相同字符串，

以及存储两个序号和。

值得注意的是，如果发现序号和更小的菜名，需要将之前存储在ret中的字符串都清理掉。

如果发现和序号和相同的菜名，需要将该字符串存储到ret中。

代码

  
  

   
   
   
   
  
  
class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        unordered_map<string,int> index;
        for(int i = 0;i<list1.size();i++){
            index[list1[i]] = i;
        }
        vector<string>ret;
        int indexsum = list1.size()+list2.size()-2;
        for(int i = 0;i<list2.size();i++){
            if(index.count(list2[i])>0){
                int j = index[list2[i]];//得到list1中餐厅序号
                if(i + j < indexsum){//如果序号更小，就要把之前存储的餐厅清理掉
                    ret.clear();
                    ret.push_back(list2[i]);
                    indexsum = i + j;
                }else if(i + j == indexsum){//如果相等 ，则都要放到输出vector中
                    ret.push_back(list2[i]);
                }
            }
        }
        return ret;
    }
};

解题思路

首先要知道，对角线坐标的变化情况，

左对角线：(0,0)->(n-1,n-1);

有对角线:(0,n-1)->(n-1,0);

在一次循环中

表示为 ：(i,i),以及(i,n-1-i);

其余情况在依次判断即可。

代码

  
  

   
   
   
   
  
  
class Solution {
public:
    bool checkXMatrix(vector<vector<int>>& grid) {
        int n = grid.size();
        for(int i = 0;i<n;i++){
            if(grid[i][i]==0) return false;
            if(grid[i][n-1-i] == 0) return false;
            for(int j = 0;j<n;j++){
                if(j == i) continue;
                if(j == n - 1 - i)continue;
                if(grid[i][j] != 0)return false;
            }
        }
        return true;
    }
};