每日刷题 Day08

题一：相同的树
给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1：
输入：p = [1,2,3], q = [1,2,3]
输出：true

示例 2：
输入：p = [1,2], q = [1,null,2]
输出：false

示例 3：
输入：p = [1,2,1], q = [1,1,2]
输出：false

提示：
两棵树上的节点数目都在范围 [0, 100] 内
-104 <= Node.val <= 104

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/same-tree

深度遍历二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    //利用深度优先遍历，检查两个树是否相同
    bool isSameTree(TreeNode* p, TreeNode* q) {
        //若二叉树均为空，则返回true
        if(p==NULL&&q==NULL)
            return true;
        //若一个为空，则不相同，返回false
        else if(p==NULL||q==NULL)
            return false;
        //若两个结点的值不相等，则两个二叉树不相同
        else if(p->val!=q->val)
            return false;
        //当值相同时，需要继续遍历其他结点
        else{
            return isSameTree(p->left,q->left)&&isSameTree(p->right,q->right);
        }
    }
};

也可以使用广度优先遍历，借助队列来完成操作

题二：杨辉三角
给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。
在「杨辉三角」中，每个数是它左上方和右上方的数的和。

示例 1:
输入: numRows = 5
输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
示例 2:
输入: numRows = 1
输出: [[1]]

提示:
1 <= numRows <= 30

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/pascals-triangle

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> nums(numRows);
        for(int i=0;i<numRows;i++){
            nums[i].resize(i+1);  //设置每行数组大小
            nums[i][0]=nums[i][i]=1;//每行的第一个元素和最后一个元素的值都为1
            for(int j=1;j<i;j++){
                nums[i][j]=nums[i-1][j-1]+nums[i-1][j];
            }
        }
        return nums;
    }
};

题三： 航班预订统计
这里有 n 个航班，它们分别从 1 到 n 进行编号。
有一份航班预订表 bookings ，表中第 i 条预订记录 bookings[i] = [firsti, lasti, seatsi] 意味着在从 firsti 到 lasti （包含 firsti 和 lasti ）的 每个航班 上预订了 seatsi 个座位。
请你返回一个长度为 n 的数组 answer，里面的元素是每个航班预定的座位总数。

示例 1：
输入：bookings = [[1,2,10],[2,3,20],[2,5,25]], n = 5
输出：[10,55,45,25,25]
解释：
航班编号     1 2  3  4 5
预订记录 1 ： 10 10
预订记录 2 ：   20 20
预订记录 3 ：      25 25 25 25
总座位数：      10   55  45  25 25
因此，answer = [10,55,45,25,25]

示例 2：
输入：bookings = [[1,2,10],[2,2,15]], n = 2
输出：[10,25]
解释：
航班编号     1  2
预订记录 1 ：  10 10
预订记录 2 ：       15
总座位数：      10 25
因此，answer = [10,25]

提示：
1 <= n <= 2 * 104
1 <= bookings.length <= 2 * 104
bookings[i].length == 3
1 <= firsti <= lasti <= n
1 <= seatsi <= 104

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/corporate-flight-bookings

class Solution {
public:
    void increment(int i, int j, vector<int> &nums,int val) {
        nums[i] += val;
        if (j + 1 < nums.size()) {
            nums[j + 1] -= val;
        }
    }
    vector<int> corpFlightBookings(vector<vector<int>>& bookings, int n) {
        
        //利用差分数组的思路
        vector<int> nums(n);
        for(int i=0;i<bookings.size();i++){
            increment(bookings[i][0]-1,bookings[i][1]-1,nums,bookings[i][2]);
        }
        vector<int> result(n);
        // 根据差分数组构造结果数组
        result[0] = nums[0];
        for (int i = 1; i < nums.size(); i++) {
            result[i] = result[i - 1] + nums[i];
        }
        return result;
    }
};