leetcode 103/1448/46

103. 二叉树的锯齿形层序遍历(剑指offer32lll)【BFS、DFS】

给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

例如：
给定二叉树 [3,9,20,null,null,15,7],

3

/
9 20
/
15 7
返回锯齿形层序遍历如下：

[
[3],
[20,9],
[15,7]
]

BFS

/**
 * 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:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        queue<TreeNode*> level;
        vector<vector<int>> ans;

        if(!root)return ans;

        level.push(root);

        int left=1;
        while(!level.empty()){
            int cnt=level.size();
            vector<int> res(cnt);

            if(left){
                for(int i=0; i<cnt; i++){
                    TreeNode *tmp=level.front();
                    res[i]=tmp->val;
                    level.pop();
                    if(tmp->left)level.push(tmp->left);
                    if(tmp->right)level.push(tmp->right);
                }
            }else{
                for(int i=cnt-1; i>=0; i--){
                    TreeNode *tmp=level.front();
                    res[i]=tmp->val;
                    level.pop();
                    if(tmp->left)level.push(tmp->left);
                    if(tmp->right)level.push(tmp->right);
                }
            }
            
            left=1-left;
            ans.push_back(res);
        }
        return ans;
    }
};

DFS

/**
 * 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:
    vector<vector<int>> ans;

    void dfs(TreeNode* root, int level){
        if(!root) return;
        
        vector<int> res;
        if(ans.size()<=level)ans.push_back(res);
        
        if(level&1){//right to left
            ans[level].insert(ans[level].begin(),root->val);
        }else{//left to right
            ans[level].push_back(root->val);
        }
        dfs(root->left, level+1);
        dfs(root->right, level+1);
    }

    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        dfs(root, 0);
        return ans;
    }
};

感觉dfs也没有很快

1448. 统计二叉树中好节点的数目【DFS】

给你一棵根为 root 的二叉树，请你返回二叉树中好节点的数目。

「好节点」X 定义为：从根到该节点 X 所经过的节点中，没有任何节点的值大于 X 的值。

示例 1：

输入：root = [3,1,4,3,null,1,5]
输出：4
解释：图中蓝色节点为好节点。
根节点 (3) 永远是个好节点。
节点 4 -> (3,4) 是路径中的最大值。
节点 5 -> (3,4,5) 是路径中的最大值。
节点 3 -> (3,1,3) 是路径中的最大值。
示例 2：

输入：root = [3,3,null,4,2]
输出：3
解释：节点 2 -> (3, 3, 2) 不是好节点，因为 “3” 比它大。
示例 3：

输入：root = [1]
输出：1
解释：根节点是好节点。

提示：

二叉树中节点数目范围是 [1, 10^5] 。
每个节点权值的范围是 [-10^4, 10^4] 。

DFS

/**
 * 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 ans;

    void getGoodNodes(TreeNode* root,int maxNum){
        if(!root) return;
        if(maxNum<=root->val) {
            ans++;
            maxNum=root->val;
        }
        
        getGoodNodes(root->left, maxNum);
        getGoodNodes(root->right, maxNum);
    }

    int goodNodes(TreeNode* root) {
        ans=0;
        if(!root)return 0;
        getGoodNodes(root, root->val);
        return ans;
    }
};

记录这条路上最大值，然后比较

46. Permutations【回溯】！！！

Given an array nums of distinct integers, return all the possible permutations. You can return the answer in any order.

Example 1:

Input: nums = [1,2,3]
Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
Example 2:

Input: nums = [0,1]
Output: [[0,1],[1,0]]
Example 3:

Input: nums = [1]
Output: [[1]]

Constraints:

1 <= nums.length <= 6
-10 <= nums[i] <= 10
All the integers of nums are unique.

不swap

class Solution {
public:
    int n;
    vector<int> flag;
    vector<vector<int>> ans;
    vector<int> res;

    void getPermute(vector<int>& nums, int dep){
        if(dep==n){
            ans.push_back(res);
            return;
        }

        for(int i=0;i<n;i++){
            if(!flag[i]){
                flag[i]=1;
                res[dep]=nums[i];
                getPermute(nums, dep+1);
                flag[i]=0;
            }
        }
    }

    vector<vector<int>> permute(vector<int>& nums) {
        n=nums.size();
        res.resize(n);
        flag.resize(n,0);
        getPermute(nums, 0);
        return ans;
    }
};

时间复杂度O(nⁿ)

swap

class Solution {
public:
    int n;
    vector<vector<int>> ans;

    void getPermute(vector<int>& nums, int dep){
        if(dep==n){
            ans.push_back(nums);
            return;
        }

        for(int i=dep;i<n;i++){
                swap(nums[dep],nums[i]);
                getPermute(nums, dep+1);
                swap(nums[dep],nums[i]);
        }
    }

    vector<vector<int>> permute(vector<int>& nums) {
        n=nums.size();
        getPermute(nums, 0);
        return ans;
    }
};

时间复杂度O(n * n!)