英雄算法6月18号

1361

class Solution {
public:
  int visited[10001] = {0};

  void dfs(int idx, vector<int>& leftChild, vector<int>& rightChild, vector<int>& hash){
    if(idx == -1){//边界条件，如果下标为-1，直接返回
      return ;
    }
    if(!visited[idx]){//防止循环访问，例如leftChild数组={1,0}.如果当前idx = 1,则访问到0号元素。0作为新下标，访问到1.
      visited[idx]=1;
      ++hash[idx];//改点访问过，次数++
      dfs(leftChild[idx],leftChild,rightChild,hash);//遍历改点左节点
      dfs(rightChild[idx],leftChild,rightChild,hash);//遍历改点右节点
    }
  }

  bool validateBinaryTreeNodes(int n, vector<int>& leftChild, vector<int>& rightChild) {
    vector<int> hash(n,0);
    for(int i = 0; i < n; ++i){//进行初次遍历，统计每个数字被访问的次数。
      if(leftChild[i] != -1){
        ++hash[leftChild[i]];
      }
      if(rightChild[i] != -1){
        ++hash[rightChild[i]];
      }
    }

    int numZero = 0;
    for(int x = 0; x < n; ++x){
      if(hash[x]==0){//访问次数为0，则初步认为改点是根节点
        dfs(x,leftChild,rightChild,hash);//从根节点开始遍历整棵树
        break;
      }
    }

    int numOne = 0, numTwo = 0;
    for(auto x: hash){
      if(x == 1){//经过两次遍历，更改hash表。如果符合二叉树，那么元素1只能出现1次，剩下的元素都输2
        numOne++;
      }
      if(x == 2){
        numTwo++;
      }
    }

    if(numTwo != n-1){
      return false;
    }
    if(numOne != 1){
      return false;
    }
    return true;
  }
};

思路

我们先确定根节点，然后从根节点开始，遍历整棵树。如果从根节点开始遍历能够保证所有元素都只被遍历1次，则为二叉树。

解法

• 根据leftChild，rightChild遍历所有元素，出现的非-1元素在hash表中统计，表示该元素被父元素指向过。
• 如果有元素为0，则表示该元素没有父节点，所以为根节点（不考虑多个0元素，因为之后还需要从根节点遍历全树，也能判断出来
• 以根节点为起点，遍历整棵树。
• 完成遍历后，统计1，2出现的次数。
  • 如果是二叉树，第一次hash遍历一定是一个0，其余全是1；第二次hash遍历全部+1

1367

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
/**
 * 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 fbs(ListNode* curListNode, TreeNode* curTreeNode){//确定当前节点为起点是否匹配
        if(curListNode == NULL) return true;//链表为空，表示全部匹配完成，成功
        if(curTreeNode == NULL) return false;//树节点为空，无法匹配，失败
        if(curTreeNode->val != curListNode->val) return false;//当树前节点不等于链表节点
        return fbs(curListNode->next,curTreeNode->right) || fbs(curListNode->next,curTreeNode->left);//匹配下一个链表元素。向左向右遍历tree
    }
    bool isSubPath(ListNode* head, TreeNode* root) {//遍历以head为节点的所有节点
        if(root == NULL) return false;//如果当前节点为空，终止循环遍历tree
        if(fbs(head,root)){ return true;}//当前节点成功，终止递归
        return isSubPath(head,root->left) || isSubPath(head,root->right);//递归遍历每一个tree节点
    }
};

思路

循环遍历每一个节点，以每一个节点为起始路径，查看是否能够匹配链表。

这题特殊点是：以每一个节点为开头，需要遍历每一个树节点，不好用循环解决，需要用递归遍历树节点。而和链表匹配时也需要递归，因此这题考察的重点是双递归。

一个函数负责判断以当前节点为根的子树是否符合题目要求，另一个用来遍历整个树的所有结点，具体每个结点再交给第一个函数来判断。在这个题目里面第一个函数就是dfs，第二个函数就是isSubPath。

​ ------------摘录自评论区大佬

解法

• fbs：
  • 匹配当前节点为路径开头，能否将链表匹配完成
• isSubPath
  • 循环遍历树节点，以每一个节点为开头，调用dfs匹配

1457

/**
 * 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 dfs(TreeNode* curTreeNode, vector<int> hash){
        if(curTreeNode==NULL) return 0;
        if(curTreeNode->left == NULL && curTreeNode->right == NULL){//路径匹配完成
            ++hash[curTreeNode->val];
            int numOdd = 0;
            for(int i = 0; i < 10; ++i){//遍历hash
                if(hash[i]&1) ++numOdd;//如果有出现奇数次数的数字,++
                if(numOdd>1) return 0;//回文串最多1个奇数数字
            }
            return 1;
        }
        ++hash[curTreeNode->val];
        return dfs(curTreeNode->left,hash)+dfs(curTreeNode->right,hash);
    }
    int pseudoPalindromicPaths (TreeNode* root) {
        vector<int> hash(10,0);
        return dfs(root, hash);
    }
};

思路

遍历每一条路径，统计数字出现次数。如果奇数次数的数字只出现0，或1次，则为回文。