leetcode每日一题43

116. 填充每个节点的下一个右侧节点指针

层序遍历嘛

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* levelOder(Node* root)
    {
        queue<Node*> que;
        if(root==NULL)
        {
            return root;
        }
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            for(int i=0;i<size;i++)
            {
                Node* node = que.front();
                que.pop();
                if(i<size-1)
                    node->next=que.front();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
    Node* connect(Node* root) {
        return levelOder(root);
    }
};

120. 三角形最小路径和

其实就是DP啦

1. 确定dp数组（dp table）以及下标的含义
   dp[i][j]就是三角形的第i行第j列的最小路径和
2. 确定递推公式
   不在三角形的腰上时，路径和由上一行的两个路径和中选更小的
   dp[i][j]=min(dp[i-1][j-1], dp[i-1][j]) + c[i][j]
   c[i][j]为三角形第i行第j列的值
   三角形的两个腰上的值是只能由上一行的腰上的值决定
   dp[i][0]=c[i][0]+dp[i-1][0]
   dp[i][i]=c[i][i]+dp[i-1][i-1]
3. dp数组如何初始化
   三角形的两个腰上的值是只能由上一行的腰上的值决定
   dp[0][0]=c[0][0]
4. 确定遍历顺序
   从上到小从左到右
5. 举例推导dp数组

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int size = triangle.size();
        vector<vector<int>> dp(size, vector<int>(size));
        dp[0][0]=triangle[0][0];
        for(int i=1;i<size;i++)
        {
            dp[i][0] = triangle[i][0] + dp[i-1][0];
            for(int j=1;j<i;j++)
            {
                dp[i][j]=min(dp[i-1][j-1], dp[i-1][j]) + triangle[i][j];
            }
            dp[i][i] = triangle[i][i]+dp[i-1][i-1];
        }
        int min = dp[size-1][0];
        for(int i =1;i<size;i++)
        {
            if(min>dp[size-1][i])
                min = dp[size-1][i];
        }
        return min;
    }
};

128. 最长连续序列

直接用sort()的话是O(nlogn)
题目要求O(n)
所以我们使用一个哈希表对于数据进行快速的查找
当前数字nums[i]是序列的第一个数据的条件是找不到nums[i]-1
找到第一个数据后，递增，找下一个数据在不在哈希表里，若在，当前序列长度++

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        int res_len = 0;
        unordered_set<int> num_set(nums.begin(), nums.end());  
        int cur_len;
        for(int i=0;i<nums.size();i++)
        {
            int cur = nums[i];
            if(!num_set.count(cur-1)){
                cur_len = 1;
                while(num_set.count(++cur))
                    cur_len++;
                res_len = max(res_len,cur_len);
            }
        }
        return res_len;
    }
};

为什么代码里for里套了while还是O(n)呢

如果所有数字都是连续的，那么只有第一个数字会去走while，其他数字无法通过if判断，那么每个数字都只处理一次。如果所有数字都是不连续的，每个数字都去走while，但是while只会处理这个数字，相当于还是每个数字只处理一次。不是说for里面套了while就一定是平方级别的复杂度，关键在于看数组中每个元素的处理次数。

就酱

129. 求根节点到叶节点数字之和

深度搜索，前序遍历
从根节点开始，遍历每个节点，如果遇到叶子节点，则获得该路径的数字。如果当前节点不是叶子节点，则计算其子节点对应的数字，然后对子节点递归遍历，获得该节点对应的所有路径的数字之和。

1. 参数及返回值
   因为要用到当前路径到达父节点组成的值，所以参数不仅要当前节点，也需要父节点组成的值presum
   返回值是当前节点到叶节点的数字之和，整型
2. 终止条件
   当前节点为根节点的时候，返回当前值
   if(root->left==nullptr&&root->right==nullptr)
   return sum;
   因为左右节点是空的时候已经判断了，那么整个树的root节点是空的时候，返回0
   if(root==nullptr)
   return 0;
3. 单层逻辑
   首先计算当前节点对应的数字int sum=preSum*10+root->val;
   然后深度遍历，获得左右节点的值之和

int leftSum=0;
int rightSum=0;
if(root->left)
    leftSum=preOrder(root->left,sum);
if(root->right)
    rightSum=preOrder(root->right,sum);

最后将左右节点对应的路径的数字之和再求和，就是当前节点所在的所有路径的数字之和

/**
 * 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:
    int preOrder(TreeNode* root, int preSum)
    {
        if(root==nullptr)
            return 0;
        int sum=preSum*10+root->val;
        if(root->left==nullptr&&root->right==nullptr)
            return sum;
        int leftSum=0;
        int rightSum=0;
        if(root->left)
            leftSum=preOrder(root->left,sum);
        if(root->right)
            rightSum=preOrder(root->right,sum);
        return leftSum+rightSum;
    }
    int sumNumbers(TreeNode* root) {
        return preOrder(root,0);
    }
};