# 11.21-559. Maximum depth of n-ary tree

## Problem surface

Given an N-ary tree, find its maximum depth.

The maximum depth is the total number of nodes on the longest path from the root node to the farthest leaf node.

N-ary tree input is represented by sequence traversal serialization, with each group of child nodes separated by null values (see example).

Source: LeetCode

Link: https://leetcode-cn.com/problems/maximum-depth-of-n-ary-tree

The copyright belongs to Lingkou network. For commercial reprint, please contact the official authorization, and for non-commercial reprint, please indicate the source.

## thinking

There's nothing to say, dfs/bfs board problem.

## main points

Graph theory dfs/bfs

## code

/* // Definition for a Node. class Node { public: int val; vector<Node*> children; Node() {} Node(int _val) { val = _val; } Node(int _val, vector<Node*> _children) { val = _val; children = _children; } }; */ class Solution { public: int maxDepth(Node* root) { if (root==NULL) return 0; else{ int res=0; for (auto node:root->children) res=max(res,maxDepth(node)); res=res+1; return res; } } };

## Completion status

Independent completion

# 11.22-384. Scrambling arrays

## Problem surface

Give you an integer array nums and design an algorithm to disrupt an array without duplicate elements.

Implement Solution class:

Solution(int[] nums) initializes the object with an integer array nums

int[] reset() resets the array to its initial state and returns

int[] shuffle() returns the result of random array scrambling

Source: LeetCode

Link: https://leetcode-cn.com/problems/shuffle-an-array

The copyright belongs to Lingkou network. For commercial reprint, please contact the official authorization, and for non-commercial reprint, please indicate the source.

## thinking

Maintain two pointers, i i i pointer and j j j pointer. i i i pointer from left to right, j j j pointer is [ i , n − 1 ] [i,n-1] Random pointer in the range [i,n − 1]. Every time i i i and j j Exchange of digital values pointed to by j.

## main points

shuffle algorithm

## code

class Solution { public: vector<int> nums; vector<int> orig; Solution(vector<int>& nums) { this->nums=nums; this->orig.resize(nums.size()); copy(nums.begin(),nums.end(),orig.begin()); } vector<int> reset() { copy(orig.begin(),orig.end(),nums.begin()); return nums; } vector<int> shuffle() { for(int i=0;i<nums.size();i++){ int j=i+rand()%(nums.size()-i); swap(nums[i],nums[j]); } return nums; } }; /** * Your Solution object will be instantiated and called as such: * Solution* obj = new Solution(nums); * vector<int> param_1 = obj->reset(); * vector<int> param_2 = obj->shuffle(); */

## Completion status

With the help of problem solving

# 11.23-859. Intimacy string

## Problem surface

Give you two strings S and goal. As long as we can get the result equal to goal by exchanging the two letters in s, we will return true; Otherwise, false is returned.

The definition of exchange letter is: take two subscripts I and J (subscript starts from 0) and meet I= j. The characters at s[i] and s[j] are then exchanged.

For example, exchanging elements of subscript 0 and subscript 2 in "abcd" can generate "cbad".

Source: LeetCode

Link: https://leetcode-cn.com/problems/buddy-strings

The copyright belongs to Lingkou network. For commercial reprint, please contact the official authorization, and for non-commercial reprint, please indicate the source.

## thinking

This question needs to count 26 letters and the number of times each letter appears. But there are many details to consider: if the two strings are different in length, false is returned directly. If two strings are the same, you need to consider whether a character has appeared twice. If the two strings are different, you need to consider whether there are and only 2 characters different.

## code

class Solution { public: int cnts[26]; int cntg[26]; bool buddyStrings(string s, string goal) { if(s.size()!=goal.size()) return false; int len=s.size(); int sum=0; for(int i=0;i<len;i++){ cntg[goal[i]-'a']++; cnts[s[i]-'a']++; if(goal[i]!=s[i]) sum++; } bool swapflag=false; for(int i=0;i<26;i++) if (cnts[i]>=2){ swapflag=true; break; } for(int i=0;i<26;i++) if(cnts[i]!=cntg[i]) return false; if(sum==2||sum==0&&swapflag) return true; else return false; } };

## Completion status

Independent completion

# 11.24-423. Reconstruction of figures from English

## Problem surface

Give you a string s, which contains several numbers (0-9) represented by English words in disordered alphabetical order. Returns the original number in ascending order

## thinking

Count. The number of z is 0; The number of w is 2; The number of u is 4; The number of x is 6; The number of g is 8. These five numbers can be reconstructed directly. next

, 3 and 8 have h; Both 5 and 4 have f; Both 7 and 6 have s, and these can also be rebuilt. 1. 0, 2 and 4 have o, rebuild 1; 5. 6, 8 and 9 have i, reconstruction 9.

## code

class Solution { public: int nums[10]; int st[26]; string res; string originalDigits(string s) { int len=s.size(); for(int i=0;i<len;i++) st[s[i]-'a']++; nums[0]=st['z'-'a']; nums[2]=st['w'-'a']; nums[4]=st['u'-'a']; nums[6] = st['x'-'a']; nums[8]=st['g'-'a']; nums[3] = st['h'-'a'] - nums[8]; nums[5] = st['f'-'a'] - nums[4]; nums[7] = st['s'-'a'] - nums[6]; nums[1] = st['o'-'a'] - nums[0] - nums[2] - nums[4]; nums[9] = st['i'-'a'] - nums[5] - nums[6] - nums[8]; for (int i = 0; i < 10; ++i) { for (int j = 0; j < nums[i]; ++j) { res += char(i + '0'); } } return res; } };

## Completion status

Completed independently, but not the optimal solution.

# 11.25-458. Poor little pig

## Problem surface

There are buckets of liquid, one of which contains poison, and the rest is water. They all look the same from the outside. In order to find out which bucket contains poison, you can feed some pigs and judge by observing whether the pigs will die. Unfortunately, you only have minutes to test minutes to determine which barrel of liquid is toxic.

The rules for feeding pigs are as follows:

Several live pigs were selected for feeding

Piglets can be allowed to drink any number of buckets of water at the same time, and the process does not take time.

The piglet must have a minute to die cooling time after drinking water. During this time, you can only observe, not continue to feed pigs.

After minutes to die, all the pigs that drank the poison will die and all the other pigs will survive.

Repeat this process until time runs out.

Give you the number of buckets, minutesToDie and minutesToTest, and return the minimum number of pigs required to determine which bucket is toxic within a specified time.

Source: LeetCode

Link: https://leetcode-cn.com/problems/poor-pigs

The copyright belongs to Lingkou network. For commercial reprint, please contact the official authorization, and for non-commercial reprint, please indicate the source.

## thinking

Push formula: number of test rounds
k
=
m
i
n
u
t
e
s
T
o
T
e
s
t
/
m
i
n
u
t
e
s
T
o
D
i
e
k=minutesToTest/minutesToDie
k=minutesToTest/minutesToDie

Number of piglets
r
e
s
=
⌈
(
l
o
g
2
(
b
u
c
k
e
t
s
)
/
l
o
g
2
(
k
)
)
⌉
res=\lceil (log_2(buckets)/log_2(k)) \rceil
res=⌈(log2(buckets)/log2(k))⌉

## main points

Number theory. Hexadecimal representation. State compression

## code

class Solution { public: int poorPigs(int buckets, int minutesToDie, int minutesToTest) { int k=minutesToTest/minutesToDie; return ceil(log(buckets)/log(k+1)); } };

## Completion status

With the help of problem solving

# 11.26-700. Search in binary search tree

## Problem surface

Given the root node and a value of a binary search tree (BST). You need to find the node whose node value is equal to the given value in the BST. Returns the subtree with this node as the root. NULL if the node does not exist.

## thinking

There's nothing to say, dfs.

## code

/** * 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: TreeNode* searchBST(TreeNode* root, int val) { if(root==NULL) return NULL; TreeNode* res=NULL; if (root->val>val) res=searchBST(root->left,val); if(root->val==val) res=root; if(root->val<val) res=searchBST(root->right,val); return res; } };

## Completion status

Independent completion

# 11.27-519. Random flip matrix

## Problem surface

Give you a binary matrix of m x n, and all values are initialized to 0. Please design an algorithm, randomly select a subscript (i, j) that satisfies matrix[i][j] == 0, and change its value to 1. All subscripts (i, j) satisfying matrix[i][j] == 0 shall be equally selected.

Minimize calls to built-in random functions and optimize time and space complexity.

Implement the Solution class:

Solution(int m, int n) initializes the object with the sizes m and N of the binary matrix

int[] flip() returns a random subscript [i, j] satisfying matrix[i][j] == 0, and changes the value in its corresponding lattice to 1

void reset() resets all values in the matrix to 0

Source: LeetCode

Link: https://leetcode-cn.com/problems/random-flip-matrix

The copyright belongs to Lingkou network. For commercial reprint, please contact the official authorization, and for non-commercial reprint, please indicate the source.

## thinking

Use the hash table to store 1 bit in the matrix. Second order of matrix i , j i,j i. One for bit J k k k represents. k = i ∗ n + j k=i*n+j k=i∗n+j. The rest of the operation is similar to the shuffle algorithm.

## main points

Hash table. The subscript of a matrix is represented by a number. shuffle algorithm

## code

class Solution { public: int m,n,cnt; map<int,int> st; Solution(int m, int n) { this->m=m; this->n=n; this->cnt=m*n; } vector<int> flip() { int x=rand()%cnt; vector<int> ans; cnt--; if(!st.count(x)) ans={x/n,x%n}; else ans={st[x]/n,st[x]%n}; if(st.count(cnt)) st[x]=st[cnt]; else st[x]=cnt; return ans; } void reset() { cnt=m*n; st.clear(); } }; /** * Your Solution object will be instantiated and called as such: * Solution* obj = new Solution(m, n); * vector<int> param_1 = obj->flip(); * obj->reset(); */

## Completion status

Read the solution. And after reading the problem solution, I remembered that I had done a problem of shuffling algorithm a few days ago. Sure enough, it's easy to see before and forget after.