七月集训(1)数组

1.LeetCode:2319. 判断矩阵是否是一个 X 矩阵

原题链接

        如果一个正方形矩阵满足下述 全部 条件，则称之为一个 X 矩阵 ：

        矩阵对角线上的所有元素都 不是 0

        矩阵中所有其他元素都是 0

        给你一个大小为 n x n 的二维整数数组 grid ，表示一个正方形矩阵。如果 grid 是一个 X 矩阵 ，返回 true ；否则，返回 false 。

        示例 1：

        输入：grid = [[2,0,0,1],[0,3,1,0],[0,5,2,0],[4,0,0,2]]

        输出：true

        示例 2

        输入：grid = [[5,7,0],[0,3,1],[0,5,0]]

        输出：false

        提示：

        n == grid.length == grid[i].length

        3 <= n <= 100

        0 <= grid[i][j] <= 1e5

        这道题别被题目误导了，这里的对角线并不是说每条对角线而是两条主对角线，所以我们遍历矩阵并判断即可（主对角线横纵坐标相等或者相加等于n-1）

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

2.LeetCode:599. 两个列表的最小索引总和

原题链接

        假设 Andy 和 Doris 想在晚餐时选择一家餐厅，并且他们都有一个表示最喜爱餐厅的列表，每个餐厅的名字用字符串表示。

        你需要帮助他们用最少的索引和找出他们共同喜爱的餐厅。 如果答案不止一个，则输出所有答案并且不考虑顺序。 你可以假设答案总是存在。

        示例 1:

        输入: list1 = [“Shogun”, “Tapioca Express”, “Burger King”, “KFC”]，list2 = [“Piatti”, “The Grill at Torrey Pines”, “Hungry Hunter Steakhouse”, “Shogun”]

        输出: [“Shogun”]

        示例 2:

        输入:list1 = [“Shogun”, “Tapioca Express”, “Burger King”, “KFC”]，list2 = [“KFC”, “Shogun”, “Burger King”]

        输出: [“Shogun”]

        提示:

        1 <= list1.length, list2.length <= 1000

        1 <= list1[i].length, list2[i].length <= 30

        list1[i] 和 list2[i] 由空格 ’ ’ 和英文字母组成。

        list1 的所有字符串都是 唯一 的。

        list2 中的所有字符串都是 唯一 的。

        也没什么好说的利用哈希表对其中一个数组的字符串和下标进行计数，然后利用另一个数组中查找，如果遇到了更小的索引和就删除原有答案数组并更新新的索引和。

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        unordered_map<string,int> map;
        vector<string> ans;
        for(int i=0;i<list1.size();i++)
        map[list1[i]]=i;
        int inf=0x3f3f3f3f;
        for(int i=0;i<list2.size();i++)
        {
            if(map.count(list2[i]))
            {
                int tmp=map[list2[i]]+i;
                if(tmp==inf) ans.push_back(list2[i]);
                else if(tmp<inf)
                {
                    ans.clear(),ans.push_back(list2[i]),inf=tmp;
                }
            }
        }
        return ans;
    }
};

3.LeetCode:674. 最长连续递增序列

原题链接

        给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

        连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], …, nums[r - 1], nums[r]] 就是连续递增子序列。

        示例 1：

        输入：nums = [1,3,5,4,7]

        输出：3

        示例 2：

        输入：nums = [2,2,2,2,2]

        输出：1

        提示：

        1 <= nums.length <= 1e4

        -1e9 <= nums[i] <= 1e9

        没什么好说的，经典题目了，可以dp可以滑动窗口。
滑动窗口：

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int ans=1;
        int i=0,j=i+1,k=0;
        while(j<nums.size())
        {
            while(i<j&&j<nums.size()&&nums[j]>nums[i]){
                j++;
                i++;
            }
            ans=max(ans,i-k+1);
            k=i=j;
            ++j;
        }
        return ans;
    }
};

dp:

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int dp[10010];
        memset(dp,0,sizeof(dp));
        dp[0]=1;
        int ans=1;
        for(int i=1;i<nums.size();++i){
            dp[i]=nums[i]>nums[i-1]?dp[i-1]+1:1;
            ans=max(ans,dp[i]);
        }
        return ans;
    }
};

4.LeetCode:989. 数组形式的整数加法

原题链接

        整数的 数组形式 num 是按照从左到右的顺序表示其数字的数组。

        例如，对于 num = 1321 ，数组形式是 [1,3,2,1] 。

        给定 num ，整数的 数组形式 ，和整数 k ，返回 整数 num + k 的 数组形式 。

        示例 1：

        输入：num = [1,2,0,0], k = 34

        输出：[1,2,3,4]

        示例 2：

        输入：num = [2,7,4], k = 181

        输出：[4,5,5]

        示例 3：

        输入：num = [2,1,5], k = 806

        输出：[1,0,2,1]

        提示：

        1 <= num.length <= 1e4

        0 <= num[i] <= 9

        num 不包含任何前导零，除了零本身

        1 <= k <= 1e4

        这里直接模拟大数加法即可。

int* addToArrayForm(int* num, int numSize, int k, int* returnSize)
{
    int ksize=0;
    int ret=k;
    while(ret)
    {
        ret/=10;
        ksize++;
    }
    int max=numSize>ksize?numSize+1:ksize+1;
    int *retarr=(int *)malloc(sizeof(int)*(max));
    int ai=numSize-1;
    int len=max-1;
    int i=0,next=0;
    while(len--)
    {
        int a=0;
        if(ai>=0)
        {
            a=num[ai--];
        }
        int ret=k%10+a+next;
        if(ret>9)
        {
            ret-=10;
            next=1;
        }
        else
        {
            next=0;
        }
        retarr[i]=ret;
        i++;
        k/=10;
    }
    if(next==1)
    {
        retarr[i]=1;
        i++;
    }
    int left=0,right=i-1;
    while(left<right)
    {
        int tmp=retarr[left];
        retarr[left]=retarr[right];
        retarr[right--]=tmp;
        left++;
    }  
    *returnSize=i;
    return retarr;
}