To change the owner of a Power Apps app we will need to gather 3 pieces of information:

• Environment ID from the Power Apps maker portal
• App ID from the Power Apps maker portal
• User Account Object ID from Azure Active Directory

Obtain The Environment ID

Open make.powerapps.com and open the settings menu. Choose developer resources.

The Environment ID will appear in the developer resources menu：

6955xxxx-fxxx-4xxx-axxx-2bxxxxxxxxxx

Get The Power Apps App ID

Go to the Apps menu in the maker portal, select the three dots beside the app then click Details.

The App ID will appear in the Details menu：

edxxxxxx-5xxx-4xxx-axxx-66xxxxxxxxxx

Currently, you can see the Owner of the App is Hexuan Weng.

Find The New Owner’s User Account Object ID

Login to portal.azure.com and search for the user account you want to transfer ownership to. In this case we will make a user called Power Platform Service Account the Owner.

The Object ID will appear in the user’s profile.

dexxxxxx-fxxx-4xxx-8xxx-f1xxxxxxxxxx

Method 1: Change Power Apps App Owner With A Flow

The first way we can change the owner of a Power Apps app is by building a flow to transfer ownership. Create a new Power Automate flow with an instant trigger. Name the flow Change App Owner, select Manually trigger a flow then click Create.

Add the flow action Power Apps For Admins – Set App Owner with the following parameters and fill in the environment name, Power App Name and New PowerApp Owner with the unique identifiers we gathered earlier.

In this step:

1
2
3

$EnvironmentName = Environment ID
$AppName = App ID
$NewAppOwner = Object ID

Run the flow.

The Power Platform Service Account now owns the app.

Method 2: Change Power Apps App Owner With PowerShell

If you like to use PowerShell for automating administrative tasks there is a robust library of Power Apps cmdlets including a cmdlet to set the Power App owner. Open the Windows PowerShell ISE and Run as administrator.

Create a new script called ChangeAppOwner.ps1

Paste the following code into the text editor. Switch the environment name, app name and new app owner with your own information then press the green play button to execute the script.

1
2
3
4
5

$EnvironmentName = '6955xxxx-fxxx-4xxx-axxx-2bxxxxxxxxxx'
$AppName = 'edxxxxxx-5xxx-4xxx-axxx-66xxxxxxxxxx'
$NewAppOwner = 'dexxxxxx-fxxx-4xxx-8xxx-f1xxxxxxxxxx'

Set-AdminPowerAppOwner –AppName $AppName -AppOwner $NewAppOwner –EnvironmentName $EnvironmentName

Possible Error

There are a couple of possibilites

1. You need to be a Global Admin or AAD Admin in the tenant to run the “Admin” commands. Are you a global admin?
2. Are you supplying the GUIDS for the Appname, Environment, and AppOwner? The examples all show guids, rather than just names.

Method 3: Change Power Apps App Owner Using The Center Of Excellence Starter Kit

The Power Apps Center Of Excellence Starter Kit offers the easiest way to change a Power Apps App owner. Open the canvas app called Admin – App Permission Center that is included in the CoE Starter Kit. Browse to the app’s environment, select the app from the list and then click Add Permissions.

[^1]: Power Apps cmdlets

[^2]: Power Apps Center Of Excellence Starter Kit

A maximum tree is a tree where every node has a value greater than any other value in its subtree.
You are given the root of a maximum binary tree and an integer val.
Just as in the previous problem, the given tree was constructed from a list a (root = Construct(a)) recursively with the following Construct(a) routine:
If a is empty, return null.
Otherwise, let a[i] be the largest element of a. Create a root node with the value a[i].
The left child of root will be Construct([a[0], a[1], …, a[i - 1]]).
The right child of root will be Construct([a[i + 1], a[i + 2], …, a[a.length - 1]]).
Return root.
Note that we were not given a directly, only a root node root = Construct(a).
Suppose b is a copy of a with the value val appended to it. It is guaranteed that b has unique values.
Return Construct(b).

Example 1:

Input: root = [4,1,3,null,null,2], val = 5Output: [5,4,null,1,3,null,null,2]Explanation: a = [1,4,2,3], b = [1,4,2,3,5]
1
2
Example 2:
{% asset_img e2.jpg e2%}
Input: root = [5,2,4,null,1], val = 3Output: [5,2,4,null,1,null,3]Explanation: a = [2,1,5,4], b = [2,1,5,4,3]
1
2
Example 3:
{% asset_img e3.jpg e3%}
Input: root = [5,2,3,null,1], val = 4Output: [5,2,4,null,1,3]Explanation: a = [2,1,5,3], b = [2,1,5,3,4]
1
2

Constraints:
The number of nodes in the tree is in the range [1, 100].1 <= Node.val <= 100All the values of the tree are unique.1 <= val <= 100
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

## Solution
Because the new val is added at the end of the array, we can compare with the root node,
- If it is larger than the root, then val is the new root and the original root is its left subtree (since val is to the right of the original root's value in the array).
- If it is smaller than the root node, it means that val must be recursively added to the right node of the original root. Note that recursion may change the root of the right subtree, so reassign the right node of the root node.
Finally, if the recursive root is empty, a new leaf node can be returned directly.

```python
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def insertIntoMaxTree(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root:
            return TreeNode(val)
        
        if val > root.val:
            cur = TreeNode(val)
            cur.left = root
            return cur
        
        root.right = self.insertIntoMaxTree(root.right, val)
        return root
[^1]: [998. Maximum Binary Tree II](https://leetcode.com/problems/maximum-binary-tree-ii/)

You are given an integer array nums with no duplicates. A maximum binary tree can be built recursively from nums using the following algorithm:

1. Create a root node whose value is the maximum value in nums.
2. Recursively build the left subtree on the subarray prefix to the left of the maximum value.
3. Recursively build the right subtree on the subarray suffix to the right of the maximum value.
   Return the maximum binary tree built from nums.

Example 1:

1
2
3
4
5
6
7
8
9
10
11
12

Input: nums = [3,2,1,6,0,5]
Output: [6,3,5,null,2,0,null,null,1]
Explanation: The recursive calls are as follow:
- The largest value in [3,2,1,6,0,5] is 6. Left prefix is [3,2,1] and right suffix is [0,5].
    - The largest value in [3,2,1] is 3. Left prefix is [] and right suffix is [2,1].
        - Empty array, so no child.
        - The largest value in [2,1] is 2. Left prefix is [] and right suffix is [1].
            - Empty array, so no child.
            - Only one element, so child is a node with value 1.
    - The largest value in [0,5] is 5. Left prefix is [0] and right suffix is [].
        - Only one element, so child is a node with value 0.
        - Empty array, so no child.

Example 2:

1
2

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

Constraints:

1
2
3

1 <= nums.length <= 1000
0 <= nums[i] <= 1000
All integers in nums are unique.

Solution

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        def dfs(arr):
            if not arr:
                return None 
            
            root = max(arr)
            idx = arr.index(root)
            return TreeNode(root, dfs(arr[:idx]), dfs(arr[idx+1:]))
        return dfs(nums)

[^1]: 654. Maximum Binary Tree

Given a string array words, return the maximum value of length(word[i]) * length(word[j]) where the two words do not share common letters. If no such two words exist, return 0.

Example 1:

1
2
3

Input: words = ["abcw","baz","foo","bar","xtfn","abcdef"]
Output: 16
Explanation: The two words can be "abcw", "xtfn".

Example 2:

1
2
3

Input: words = ["a","ab","abc","d","cd","bcd","abcd"]
Output: 4
Explanation: The two words can be "ab", "cd".

Example 3:

1
2
3

Input: words = ["a","aa","aaa","aaaa"]
Output: 0
Explanation: No such pair of words.

Constraints:

1
2
3

2 <= words.length <= 1000
1 <= words[i].length <= 1000
words[i] consists only of lowercase English letters.

Solution

1. create a list called s to store all the individual letter of each word
2. using two for loops to compare each two words in the list, if there is no common letter, update the answer

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# O(n^2) time | O(n) space
class Solution:
    def maxProduct(self, words: List[str]) -> int:
        ans = 0
        d = []
        for word in words:
            d.append(set(list(word)))

        for i in range(len(words)):
            for j in range(i+1, len(words)):
                if not d[i] & d[j]:
                    ans = max(ans, len(words[i])*len(words[j]))
        return ans

[^1]: 318. Maximum Product of Word Lengths

Given the array nums consisting of 2n elements in the form [x1,x2,…,xn,y1,y2,…,yn].
Return the array in the form [x1,y1,x2,y2,…,xn,yn].

Example 1:

1
2
3

Input: nums = [2,5,1,3,4,7], n = 3
Output: [2,3,5,4,1,7] 
Explanation: Since x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 then the answer is [2,3,5,4,1,7].

Example 2:

1
2

Input: nums = [1,2,3,4,4,3,2,1], n = 4
Output: [1,4,2,3,3,2,4,1]

Example 3:

1
2

Input: nums = [1,1,2,2], n = 2
Output: [1,2,1,2]

Constraints:

1
2
3

1 <= n <= 500
nums.length == 2n
1 <= nums[i] <= 10^3

Solution

1. slow index: i, faster index: j
   • initial i = 0, j = n
2. when j reaches to the end, i reaches the end of the first half of this array

1
2
3
4
5
6
7
8
9
10

# O(n) time | O(n) space
class Solution:
    def shuffle(self, nums: List[int], n: int) -> List[int]:
        i, j = 0, n
        ans = []
        for j in range(n, len(nums)):
            ans.append(nums[i])
            ans.append(nums[j])
            i += 1
        return ans

[^1]: 1470. Shuffle the Array

Given the root of a binary tree, return the maximum width of the given tree.

The maximum width of a tree is the maximum width among all levels.

The width of one level is defined as the length between the end-nodes (the leftmost and rightmost non-null nodes), where the null nodes between the end-nodes that would be present in a complete binary tree extending down to that level are also counted into the length calculation.

It is guaranteed that the answer will in the range of a 32-bit signed integer.

Example 1:

1
2
3

Input: root = [1,3,2,5,3,null,9]
Output: 4
Explanation: The maximum width exists in the third level with length 4 (5,3,null,9).

Example 2:

1
2
3

Input: root = [1,3,2,5,null,null,9,6,null,7]
Output: 7
Explanation: The maximum width exists in the fourth level with length 7 (6,null,null,null,null,null,7).

Example 3:

1
2
3

Input: root = [1,3,2,5]
Output: 2
Explanation: The maximum width exists in the second level with length 2 (3,2).

Constraints:

1
2

The number of nodes in the tree is in the range [1, 3000].
-100 <= Node.val <= 100

Soution

Using the full binary tree number, the distance between any two nodes in the same layer (with empty nodes) can be easily calculated, and our BFS returns the layer with the largest distance between the leftmost and the rightmost.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

from collections import deque

class Solution:
    def widthOfBinaryTree(self, root: Optional[TreeNode]) -> int:
        ans = 0
        queue = deque([(1, root)])

        while queue:
            l, r = float('inf'), 0
            for _ in range(len(queue)):
                idx, popnode = queue.popleft()
                if popnode.left:
                    queue.append((idx*2, popnode.left))
                if popnode.right:
                    queue.append((idx*2+1, popnode.right))
                l, r = min(idx, l), max(idx, r)
            ans = max(ans, r-l+1)
        return ans

#Runtime: 42 ms, faster than 97.03% of Python3 online submissions for Maximum Width of Binary Tree.
#Memory Usage: 14.8 MB, less than 46.14% of Python3 online submissions for Maximum Width of Binary Tree.

[^1]: 662. Maximum Width of Binary Tree

Given the array of integers nums, you will choose two different indices i and j of that array. Return the maximum value of (nums[i]-1)*(nums[j]-1).

Example 1:

1
2
3

Input: nums = [3,4,5,2]
Output: 12 
Explanation: If you choose the indices i=1 and j=2 (indexed from 0), you will get the maximum value, that is, (nums[1]-1)*(nums[2]-1) = (4-1)*(5-1) = 3*4 = 12.

Example 2:

1
2
3

Input: nums = [1,5,4,5]
Output: 16
Explanation: Choosing the indices i=1 and j=3 (indexed from 0), you will get the maximum value of (5-1)*(5-1) = 16.

Example 3:

1
2

Input: nums = [3,7]
Output: 12

Constraints:

1
2

2 <= nums.length <= 500
1 <= nums[i] <= 10^3

Solutions

Sorting

1. Sort first
2. then the last two values ​​are the largest two values
3. find the final answer as required and return

1
2
3
4
5

# O(nlogn) time | O(1) space
class Solution:
    def maxProduct(self, nums: List[int]) -> int:
        nums.sort()
        return (nums[-1]-1)*(nums[-2]-1)

Two Pointers

This problem is actually to find the first and second largest numbers in the array. We only need to use first and second to represent the subscripts of the first and second largest numbers, and then traverse the array and compare them one by one.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# O(n) time | O(1) space
class Solution:
    def maxProduct(self, nums: List[int]) -> int:
        first, second = 0, 1
        if nums[second] > nums[first]:
            first, second = 1, 0
        
        for i in range(2, len(nums)):
            v = nums[i]
            if v > nums[first]:
                first, second = i, first
            elif v > nums[second]:
                second = i
        return (nums[first]-1)*(nums[second]-1)

[^1]: 1464. Maximum Product of Two Elements in an Array

Given a sorted integer array arr, two integers k and x, return the k closest integers to x in the array. The result should also be sorted in ascending order.

An integer a is closer to x than an integer b if:

1
2

|a - x| < |b - x|, or
|a - x| == |b - x| and a < b

Example 1:

1
2

Input: arr = [1,2,3,4,5], k = 4, x = 3
Output: [1,2,3,4]

Example 2:

1
2

Input: arr = [1,2,3,4,5], k = 4, x = -1
Output: [1,2,3,4]

Constraints:

1
2
3
4

1 <= k <= arr.length
1 <= arr.length <= 104
arr is sorted in ascending order.
-104 <= arr[i], x <= 104

Solutions

The answer must be a continuous window; numbers are excluded from the left and right ends of the window, leaving k numbers at the end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# O(n) time | O(1) space
class Solution:
    def findClosestElements(self, arr: List[int], k: int, x: int) -> List[int]:
        n = len(arr)
        left, right = 0, n-1
        remaining = n - k
        ans = []
        
        for _ in range(remaining):
            if abs(arr[left] - x) > abs(arr[right] - x):
                left +=1
            else:
                right -=1
        
        for i in range(left, right+1):
            ans.append(arr[i])
        return ans

[^1]: 658. Find K Closest Elements

Write an efficient algorithm that searches for a value target in an m x n integer matrix matrix. This matrix has the following properties:
Integers in each row are sorted in ascending from left to right.
Integers in each column are sorted in ascending from top to bottom.

Example 1:

1
2

Input: matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
Output: true

Example 2:

1
2

Input: matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20
Output: false

Constraints:

1
2
3
4
5
6
7

m == matrix.length
n == matrix[i].length
1 <= n, m <= 300
-109 <= matrix[i][j] <= 109
All the integers in each row are sorted in ascending order.
All the integers in each column are sorted in ascending order.
-109 <= target <= 109

Solution

BFS
Start the search from the upper right corner

• search down if it is smaller than the target
• search to the left if it is larger than the target)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        m, n = len(matrix), len(matrix[0])
        queue = deque([(0,n-1)])
        visited = set()
        while queue:
            x, y = queue.popleft()
            cur_val = matrix[x][y]
            if cur_val == target:
                return True
            
            if cur_val < target:
                nx, ny = x+1, y
                if 0<= nx < m and 0<= ny < n and (nx, ny) not in visited:
                    queue.append((nx, ny))
                    visited.add((nx, ny))
            else:
                nx, ny = x, y-1
                if 0<= nx < m and 0<= ny < n and (nx, ny) not in visited:
                    queue.append((nx, ny))
                    visited.add((nx, ny))
            
        return False

[^1]: 240. Search a 2D Matrix II

There are n people that are split into some unknown number of groups. Each person is labeled with a unique ID from 0 to n - 1.
You are given an integer array groupSizes, where groupSizes[i] is the size of the group that person i is in. For example, if groupSizes[1] = 3, then person 1 must be in a group of size 3.
Return a list of groups such that each person i is in a group of size groupSizes[i].
Each person should appear in exactly one group, and every person must be in a group. If there are multiple answers, return any of them. It is guaranteed that there will be at least one valid solution for the given input.

Example 1:

1
2
3
4
5
6
7

Input: groupSizes = [3,3,3,3,3,1,3]
Output: [[5],[0,1,2],[3,4,6]]
Explanation: 
The first group is [5]. The size is 1, and groupSizes[5] = 1.
The second group is [0,1,2]. The size is 3, and groupSizes[0] = groupSizes[1] = groupSizes[2] = 3.
The third group is [3,4,6]. The size is 3, and groupSizes[3] = groupSizes[4] = groupSizes[6] = 3.
Other possible solutions are [[2,1,6],[5],[0,4,3]] and [[5],[0,6,2],[4,3,1]].

Example 2:

1
2

Input: groupSizes = [2,1,3,3,3,2]
Output: [[1],[0,5],[2,3,4]]

Constraints:

1
2
3

groupSizes.length == n
1 <= n <= 500
1 <= groupSizes[i] <= n

Solutions

1. key: length of the group, value: the index of each element
2. store them in the dictionary
3. for loop value and use v[i:i+k] to slice the string based on the key

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

from sortedcontainers import SortedList
class Solution:
    def groupThePeople(self, groupSizes: List[int]) -> List[List[int]]:
        new_group = SortedList()
        for i, v in enumerate(groupSizes):
            new_group.add((v,i))
        # print(new_group)

        i = 0
        ans = []
        while i < len(groupSizes):
            size, y = new_group[i]
            group = []
            for s in range(size):
                group.append(new_group[i+s][1])
            i = i+s+1
            ans.append(group)
        return ans

#Runtime: 234 ms, faster than 5.20% of Python3 online submissions for Group the People Given the Group Size They Belong To.
#Memory Usage: 14.5 MB, less than 17.57% of Python3 online submissions for Group the People Given the Group Size They Belong To.

Optimised HashTable

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Solution:
    def groupThePeople(self, groupSizes: List[int]) -> List[List[int]]:
        ans = []
        mp = defaultdict(list)
        for i, v in enumerate(groupSizes):
            mp[v].append(i)

        for k, v in mp.items():
            for i in range(0, len(v), k):
                ans.append(v[i:i+k])
            
        return ans

#Runtime: 89 ms, faster than 82.67% of Python3 online submissions for Group the People Given the Group Size They Belong To.
#Memory Usage: 13.9 MB, less than 88.49% of Python3 online submissions for Group the People Given the Group Size They Belong To.

[^1]: 1282. Group the People Given the Group Size They Belong To

You are given an alphanumeric string s. (Alphanumeric string is a string consisting of lowercase English letters and digits).
You have to find a permutation of the string where no letter is followed by another letter and no digit is followed by another digit. That is, no two adjacent characters have the same type.
Return the reformatted string or return an empty string if it is impossible to reformat the string.

Example 1:

1
2
3

Input: s = "a0b1c2"
Output: "0a1b2c"
Explanation: No two adjacent characters have the same type in "0a1b2c". "a0b1c2", "0a1b2c", "0c2a1b" are also valid permutations.

Example 2:

1
2
3

Input: s = "leetcode"
Output: ""
Explanation: "leetcode" has only characters so we cannot separate them by digits.

Example 3:

1
2
3

Input: s = "1229857369"
Output: ""
Explanation: "1229857369" has only digits so we cannot separate them by characters.

Constraints:

1
2

1 <= s.length <= 500
s consists of only lowercase English letters and/or digits.

Solutions

1. Traverse s and store letters and numbers in two different lists: nums, letters
2. If the difference between the lengths of len(nums) and len(letters) is greater than 1, return “” directly
3. If len(nums) ≥ len(letters), append the value of nums first in the result, and vice versa
4. If there are remaining values, append to ans

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# O(n) time | O(n) space
class Solution:
    def reformat(self, s: str) -> str:
        nums, letters = [],  []
        ans = []
        for i in s:
            if i.isdigit():
                nums.append(i)
            else:
                letters.append(i)
        
        # print(nums, letters)
        if abs(len(nums) - len(letters)) > 1:
            return ""
        else:
            i = 0
            while i <min(len(nums), len(letters)):
                if len(nums) >= len(letters):
                    ans.append(nums[i])
                    ans.append(letters[i])
                else:
                    ans.append(letters[i])
                    ans.append(nums[i])
                i+=1
            if i < len(nums):
                ans.append(nums[-1])
            if i < len(letters):
                ans.append(letters[-1])
        return "".join(ans)

[^1]: 1417. Reformat The String

Solve a given equation and return the value of ‘x’ in the form of a string “x=#value”. The equation contains only ‘+’, ‘-‘ operation, the variable ‘x’ and its coefficient. You should return “No solution” if there is no solution for the equation, or “Infinite solutions” if there are infinite solutions for the equation.
If there is exactly one solution for the equation, we ensure that the value of ‘x’ is an integer.

Example 1:

1
2

Input: equation = "x+5-3+x=6+x-2"
Output: "x=2"

Example 2:

1
2

Input: equation = "x=x"
Output: "Infinite solutions"

Example 3:

1
2

Input: equation = "2x=x"
Output: "x=0"

Constraints:

1
2
3

3 <= equation.length <= 1000
equation has exactly one '='.
equation consists of integers with an absolute value in the range [0, 100] without any leading zeros, and the variable 'x'.

Solution

1. Move all expressions to the left
2. Then all minus signs are preceded by a plus sign as a prefix
3. Divide the equation by plus sign
4. Count the number of x and the operation result of the number
5. Get results based on the requirements

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

class Solution:
    def solveEquation(self, equation: str) -> str:
        left, right = equation.split("=")
        new_left = []
        new_right = []
        if right[0] != "-":
            right = "+" + right

        for i in range(len(left)):
            if left[i] == "-":
                new_left.append("+-")
            else:
                new_left.append(left[i])
        for i in range(len(right)):
            if right[i] == "+":
                new_right.append("+-")
            elif right[i] == "-":
                new_right.append("+")
            else:
                new_right.append(right[i])
        e = "".join(new_left)+"".join(new_right)

        print(e.split("+"))
        
        letter = 0
        num = 0
        for cur in e.split("+"):
            sign, coe, l = 1, 0, 0
            if cur:
                if cur[0] == "-":
                    sign = -1
                    if cur[-1] == "x":
                        coe = int(cur[1:-1]) if len(cur) > 2 else 1
                        letter += sign * coe
                    else:
                        num += int(cur)
                else:
                    if cur[-1] == "x":
                        coe = int(cur[:-1]) if len(cur) > 1 else 1
                        letter += sign * coe
                    else:
                        num += int(cur)
           
        if letter == num == 0:
            return "Infinite solutions"
        elif letter == 0 and num != 0:
            return "No solution"
        else:
            v = int(-num / letter)
            return "x="+str(v)

[^1]: 640. Solve the Equation

Given an array of integers nums, you start with an initial positive value startValue.
In each iteration, you calculate the step by step sum of startValue plus elements in nums (from left to right).
Return the minimum positive value of startValue such that the step by step sum is never less than 1.

Example 1:

1
2
3
4
5
6
7
8
9
10

Input: nums = [-3,2,-3,4,2]
Output: 5
Explanation: If you choose startValue = 4, in the third iteration your step by step sum is less than 1.
step by step sum
startValue = 4 | startValue = 5 | nums
  (4 -3 ) = 1  | (5 -3 ) = 2    |  -3
  (1 +2 ) = 3  | (2 +2 ) = 4    |   2
  (3 -3 ) = 0  | (4 -3 ) = 1    |  -3
  (0 +4 ) = 4  | (1 +4 ) = 5    |   4
  (4 +2 ) = 6  | (5 +2 ) = 7    |   2

Example 2:

1
2
3

Input: nums = [1,2]
Output: 1
Explanation: Minimum start value should be positive. 

Example 3:

1
2

Input: nums = [1,-2,-3]
Output: 5

Constraints:

1
2

1 <= nums.length <= 100
-100 <= nums[i] <= 100

Solution

The smallest positive integer is required.
We can get the smallest negative sum, and the answer is the opposite of the negative number + 1

1
2
3
4
5
6
7
8
9
10

# O(n) time | O(1) space
class Solution:
    def minStartValue(self, nums: List[int]) -> int:
        ans = 0
        cur = 0
        for i in nums:
            cur += i
            if cur < ans:
                ans = cur
        return -ans + 1

[^1]: 1413. Minimum Value to Get Positive Step by Step Sum

Given an integer n, return a string with n characters such that each character in such string occurs an odd number of times.
The returned string must contain only lowercase English letters. If there are multiples valid strings, return any of them.

Example 1:

1
2
3

Input: n = 4
Output: "pppz"
Explanation: "pppz" is a valid string since the character 'p' occurs three times and the character 'z' occurs once. Note that there are many other valid strings such as "ohhh" and "love".

Example 2:

1
2
3

Input: n = 2
Output: "xy"
Explanation: "xy" is a valid string since the characters 'x' and 'y' occur once. Note that there are many other valid strings such as "ag" and "ur".

Example 3:

1
2

Input: n = 7
Output: "holasss"

Constraints:

1

1 <= n <= 500

Solutions

• When n is an odd number, you can use one character, which itself is an odd number of times;
• Two characters can be used when n is even, odd+odd=even

1
2
3
4
5
6

class Solution:
    def generateTheString(self, n: int) -> str:
        if n % 2 == 0:
            return "a"*(n-1)+"b"
        else:
            return "a"*n

[^1]: 1374. Generate a String With Characters That Have Odd Counts

Given the root of a binary tree, the level of its root is 1, the level of its children is 2, and so on.
Return the smallest level x such that the sum of all the values of nodes at level x is maximal.

Example 1:

1
2
3
4
5
6
7

Input: root = [1,7,0,7,-8,null,null]
Output: 2
Explanation: 
Level 1 sum = 1.
Level 2 sum = 7 + 0 = 7.
Level 3 sum = 7 + -8 = -1.
So we return the level with the maximum sum which is level 2.

Example 2:

1
2

Input: root = [989,null,10250,98693,-89388,null,null,null,-32127]
Output: 2

Constraints:

1
2

The number of nodes in the tree is in the range [1, 104].
-105 <= Node.val <= 105

Solution

BFS counts the sum of each layer, and returns the one with the largest sum and the smallest number of layers.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
from collections import deque

class Solution:
    def maxLevelSum(self, root: Optional[TreeNode]) -> int:
        queue = deque([root])
        maxi = float('-inf')
        level = 1
        ans = 0
        while queue:
            l = len(queue)
            summ = 0
            for _ in range(l):
                cur = queue.popleft()
                summ += cur.val
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            if summ > maxi:
                maxi = summ
                ans = level
            level+=1
        return ans

[^1]: 1161. Maximum Level Sum of a Binary Tree

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

import torch

# step 1: prepare the dataset
x_data = torch.tensor([[1.0],[2.0],[3.0]])
y_data = torch.tensor([[2.0],[4.0],[6.0]])

# step2: design model
"""
Our model class should inherit from torch.nn.Module, which is the base class for all of the neural networks.
__init__() and forward() have to be implemented.
class nn.Linear contains two Tensor components: weight and bias
class nn.Linear has implemented the magic method __call__(), which enable the instance of the class to be called like a function.
therefore, model(data) can call the forward function
"""

class LinearModel(torch.nn.Module):
    def __init__(self):
        super(LinearModel, self).__init__()
        # (1, 1) is the sie of each input sample and output sample
        # parameters in this model: weights and bias
        # model: y = xm + b
        self.linear = torch.nn.Linear(1, 1)
    
    def forward(self, x):
        y_pred = self.linear(x)
        return y_pred

model = LinearModel()

# step3: construct loss and optimizer
criterion = torch.nn.MSELoss(size_average = False)
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01) #iterable of parameters to optimizer. model.parameters() can get all the parameters in the model

# step4: training cycle - forward, backward, update
for epoch in range(1000):
    y_pred = model(x_data)
    loss = criterion(y_pred, y_data)
    print(epoch, loss.item())

    optimizer.zero_grad() # the grad will be accumulated, so before backward, we need to set the grad to zero
    loss.backward() # backward: autograd
    optimizer.step() # update w, b

print('w=', model.linear.weight.item())
print('b=', model.linear.weight.item())

# step5: test model
x_test = torch.tensor([4.0])
y_test = model(x_test)
print('y_pred= ', y_test.data)

# 980 3.610836074585677e-10
# 981 3.6504843592410907e-10
# 982 3.5726088754017837e-10
# 983 3.4162894735345617e-10
# 984 3.445990159889334e-10
# 985 3.355609123900649e-10
# 986 3.370388412804459e-10
# 987 3.249738256272394e-10
# 988 3.1610625228495337e-10
# 989 3.1587887860951014e-10
# 990 3.1248248433257686e-10
# 991 3.1373303954751464e-10
# 992 3.1042191039887257e-10
# 993 3.0178171073202975e-10
# 994 3.0526337013725424e-10
# 995 2.9184832328610355e-10
# 996 2.9478997021215037e-10
# 997 2.864908310584724e-10
# 998 2.8178703814774053e-10
# 999 2.765574436125462e-10
# w= 2.0000112056732178
# b= 2.0000112056732178
# y_pred=  tensor([8.0000])

[^1]: PyTorch Tutorial - P5 Linear Regression with PyTorch

A gene string can be represented by an 8-character long string, with choices from ‘A’, ‘C’, ‘G’, and ‘T’.
Suppose we need to investigate a mutation from a gene string start to a gene string end where one mutation is defined as one single character changed in the gene string.
For example, “AACCGGTT” –> “AACCGGTA” is one mutation.
There is also a gene bank bank that records all the valid gene mutations. A gene must be in bank to make it a valid gene string.
Given the two gene strings start and end and the gene bank bank, return the minimum number of mutations needed to mutate from start to end. If there is no such a mutation, return -1.
Note that the starting point is assumed to be valid, so it might not be included in the bank.

Example 1:

1
2

Input: start = "AACCGGTT", end = "AACCGGTA", bank = ["AACCGGTA"]
Output: 1

Example 2:

1
2

Input: start = "AACCGGTT", end = "AAACGGTA", bank = ["AACCGGTA","AACCGCTA","AAACGGTA"]
Output: 2

Example 3:

1
2

Input: start = "AAAAACCC", end = "AACCCCCC", bank = ["AAAACCCC","AAACCCCC","AACCCCCC"]
Output: 3

Constraints:

1
2
3
4
5

start.length == 8
end.length == 8
0 <= bank.length <= 10
bank[i].length == 8
start, end, and bank[i] consist of only the characters ['A', 'C', 'G', 'T'].

Solution

This question is very similar to [127]
If end is not in the bank, return -1 directly

• Store start in the queue, because there are only four letters of ACGT, so traverse the gene sequence and change one of the letters. If the changed letter is not in visited, put it in the queue
• If the changed letter is equal to the value of end, return to step
• If no matching gene is found, return -1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# O(nm) time | O(nm) space
from collections import deque
class Solution:
    def minMutation(self, start: str, end: str, bank: List[str]) -> int:
        if end not in bank:
            return -1
        
        queue = deque([(start,0)])
        visited = set({start})
        while queue:
            cur, step = queue.popleft()
            if cur == end:
                return step
            for i in range(8):
                for j in ["A","C","G", "T"]:
                    nxt = cur[:i]+j+cur[i+1:]
                    if nxt in bank and nxt not in visited:
                        queue.append((nxt, step+1))
                        visited.add(nxt)
        return -1

[^1]: 433. Minimum Genetic Mutation
[^2]: 127. Word Ladder

There is a binary tree rooted at 0 consisting of n nodes. The nodes are labeled from 0 to n - 1. You are given a 0-indexed integer array parents representing the tree, where parents[i] is the parent of node i. Since node 0 is the root, parents[0] == -1.
Each node has a score. To find the score of a node, consider if the node and the edges connected to it were removed. The tree would become one or more non-empty subtrees. The size of a subtree is the number of the nodes in it. The score of the node is the product of the sizes of all those subtrees.
Return the number of nodes that have the highest score.

Example 1:

1
2
3
4
5
6
7
8
9

Input: parents = [-1,2,0,2,0]
Output: 3
Explanation:
- The score of node 0 is: 3 * 1 = 3
- The score of node 1 is: 4 = 4
- The score of node 2 is: 1 * 1 * 2 = 2
- The score of node 3 is: 4 = 4
- The score of node 4 is: 4 = 4
The highest score is 4, and three nodes (node 1, node 3, and node 4) have the highest score.

Example 2:

1
2
3
4
5
6
7

Input: parents = [-1,2,0]
Output: 2
Explanation:
- The score of node 0 is: 2 = 2
- The score of node 1 is: 2 = 2
- The score of node 2 is: 1 * 1 = 1
The highest score is 2, and two nodes (node 0 and node 1) have the highest score.

Constraints:
n == parents.length
2 <= n <= 105
parents[0] == -1
0 <= parents[i] <= n - 1 for i != 0
parents represents a valid binary tree.

Solutions

1. Store the number of in-degree nodes for each node in degree
2. Store the parent node and child node of the current node in two hash tables respectively
3. The final answer is the product of the number of remaining nodes of the parent node to be deleted and the number of nodes of the self node.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

from collections import deque
class Solution:
    def countHighestScoreNodes(self, parents: List[int]) -> int:
        n = len(parents)
        degree = [0]*n
        fathers = defaultdict(list)
        total = [1]*n
        children = defaultdict(list)
        
        for i, v in enumerate(parents[1:],1):
            fathers[i].append(v)
            children[v].append(i)
            degree[v] += 1

        queue = deque()
        for i in range(n):
            if degree[i] == 0:
                queue.append(i)
        
        while queue:
            cur = queue.popleft()
            for root in fathers[cur]:
                total[root] += total[cur]
                degree[root]-=1
                if degree[root] == 0:
                    queue.append(root)

        maxi, ans = 0, 0
        for i in range(n):
            cur = 1
            for c in children[i]:
                cur*=total[c]
            if i != 0:
                cur*=(total[0] - total[i])

            if cur > maxi:
                maxi = cur
                ans = 1
            elif cur == maxi:
                ans +=1
        return ans

[^1]: 2049. Count Nodes With the Highest Score

There is a group of n people labeled from 0 to n - 1 where each person has a different amount of money and a different level of quietness.
You are given an array richer where richer[i] = [ai, bi] indicates that ai has more money than bi and an integer array quiet where quiet[i] is the quietness of the ith person. All the given data in richer are logically correct (i.e., the data will not lead you to a situation where x is richer than y and y is richer than x at the same time).
Return an integer array answer where answer[x] = y if y is the least quiet person (that is, the person y with the smallest value of quiet[y]) among all people who definitely have equal to or more money than the person x.

Example 1:

1
2
3
4
5
6
7
8
9

Input: richer = [[1,0],[2,1],[3,1],[3,7],[4,3],[5,3],[6,3]], quiet = [3,2,5,4,6,1,7,0]
Output: [5,5,2,5,4,5,6,7]
Explanation: 
answer[0] = 5.
Person 5 has more money than 3, which has more money than 1, which has more money than 0.
The only person who is quieter (has lower quiet[x]) is person 7, but it is not clear if they have more money than person 0.
answer[7] = 7.
Among all people that definitely have equal to or more money than person 7 (which could be persons 3, 4, 5, 6, or 7), the person who is the quietest (has lower quiet[x]) is person 7.
The other answers can be filled out with similar reasoning.

Example 2:

1
2

Input: richer = [], quiet = [0]
Output: [0]

Constraints:
n == quiet.length
1 <= n <= 500
0 <= quiet[i] < n
All the values of quiet are unique.
0 <= richer.length <= n * (n - 1) / 2
0 <= ai, bi < n
ai != bi
All the pairs of richer are unique.
The observations in richer are all logically consistent.

Solution

1. Draw the graph as required
2. Create a mapping table 【connect】:
   • key: the vertex of the in-degree
   • value: which elements will this vertex of the in-degree point to
3. Create an in-degree table 【degree】 ：
   • key: the value of the vertex;
     value: how many in-degree elements there are, for example, vertex 3 has 3 in-degree elements (if the vertex is an index, we only need to create an array/list)
4. Find the key/index that are 0 in the in-degree table, that is, 2, 3, 5, 6, and put these values in the queue
5. Compare the quiet value of the current popleft value and the quiet value of the outdegree element, and update the element

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# O(n+m) time | O(n+m) space
from collections import deque
class Solution:
    def loudAndRich(self, richer: List[List[int]], quiet: List[int]) -> List[int]:
        n = len(quiet)
        connect = defaultdict(list)
        degree = [0]*n
        queue = deque()
        
        for cur, nxt in richer:
            connect[cur].append(nxt)
            degree[nxt] +=1
        
        for i in range(n):
            if degree[i] == 0:
                queue.append(i)
        
        ans = [i for i in range(n)]
        while queue:
            cur = queue.popleft()
            for nxt in connect[cur]:
                degree[nxt]-=1
                if degree[nxt] == 0:
                    queue.append(nxt)
                
                if quiet[ans[cur]] < quiet[ans[nxt]]:
                    ans[nxt] = ans[cur]
        return ans

[^1]: 851. Loud and Rich

There are a total of numCourses courses you have to take, labeled from 0 to numCourses - 1. You are given an array prerequisites where prerequisites[i] = [ai, bi] indicates that you must take course bi first if you want to take course ai.
For example, the pair [0, 1], indicates that to take course 0 you have to first take course 1.
Return the ordering of courses you should take to finish all courses. If there are many valid answers, return any of them. If it is impossible to finish all courses, return an empty array.

Example 1:

1
2
3

Input: numCourses = 2, prerequisites = [[1,0]]
Output: [0,1]
Explanation: There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1].

Example 2:

1
2
3
4

Input: numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
Output: [0,2,1,3]
Explanation: There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0.
So one correct course order is [0,1,2,3]. Another correct ordering is [0,2,1,3].

Example 3:

1
2

Input: numCourses = 1, prerequisites = []
Output: [0]

Constraints:
1 <= numCourses <= 2000
0 <= prerequisites.length <= numCourses * (numCourses - 1)
prerequisites[i].length == 2
0 <= ai, bi < numCourses
ai != bi
All the pairs [ai, bi] are distinct.

Solution

• Prerequesite is stored in courses: [following courses]
• The number of pre-courses required for each course is stored in pre_nums
• Traverse pre_nums, if the number of pre-courses of the current course is 0, append the course to the queue
• After processing all pre_nums[nxt], enqueue all courses with an in-degree of 0 (meaning subjects without pre-course requirements), and run topological sorting. If the length ans of the sorted courses is equal to numCourses, return ans, otherwise return [].

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#O(n+m) time | O(n+m) space
from collections import deque
class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        courses = defaultdict(list)
        pre_nums = [0] * numCourses
        queue = deque([])
        for cur, pre in prerequisites:
            courses[pre].append(cur)
            pre_nums[cur] +=1
        
        for i in range(numCourses):
            if pre_nums[i] == 0:
                queue.append(i)
        
        ans = []
        while queue:
            cur = queue.popleft()
            ans.append(cur)
            for nxt in courses[cur]:
                pre_nums[nxt] -=1
                if pre_nums[nxt] == 0:
                    queue.append(nxt)
        return ans if len(ans) == numCourses else []

[^1]: 207. Course Schedule
[^2]: 210. Course Schedule II