# 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

## 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

## 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

## 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;
int cntg;
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;
int st;
string res;
string originalDigits(string s) {
int len=s.size();
for(int i=0;i<len;i++)
st[s[i]-'a']++;
nums=st['z'-'a'];
nums=st['w'-'a'];
nums=st['u'-'a'];
nums = st['x'-'a'];
nums=st['g'-'a'];
nums = st['h'-'a'] - nums;
nums = st['f'-'a'] - nums;
nums = st['s'-'a'] - nums;

nums = st['o'-'a'] - nums - nums - nums;

nums = st['i'-'a'] - nums - nums - nums;
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

## 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

## 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.

Posted on Sun, 28 Nov 2021 16:45:05 -0500 by dan231