_{[0129 - Sum Root to Leaf Numbers](https://leetcode.com/problems/sum-root-to-leaf-numbers/)} | _{<divalign='center'>[✔️](c%2F0129-sum-root-to-leaf-numbers.c)</div>} | _{<divalign='center'>[✔️](cpp%2F0129-sum-root-to-leaf-numbers.cpp)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](java%2F0129-sum-root-to-leaf-numbers.java)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](kotlin%2F0129-sum-root-to-leaf-numbers.kt)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>}

_{[0337 - House Robber III](https://leetcode.com/problems/house-robber-iii/)} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](java%2F0337-house-robber-iii.java)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](kotlin%2F0337-house-robber-iii.kt)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>}

_{[0951 - Flip Equivalent Binary Trees](https://leetcode.com/problems/flip-equivalent-binary-trees/)} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](java%2F0951-flip-equivalent-binary-trees.java)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](kotlin%2F0951-flip-equivalent-binary-trees.kt)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>}

_{[1993 - Operations On Tree](https://leetcode.com/problems/operations-on-tree/)} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](kotlin%2F1993-operations-on-tree.kt)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>}

_{[1993 - Operations On Tree](https://leetcode.com/problems/operations-on-tree/)} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](java%2F1993-operations-on-tree.java)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](kotlin%2F1993-operations-on-tree.kt)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>}

_{[0894 - All Possible Full Binary Trees](https://leetcode.com/problems/all-possible-full-binary-trees/)} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](java%2F0894-all-possible-full-binary-trees.java)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](kotlin%2F0894-all-possible-full-binary-trees.kt)</div>} | _{<divalign='center'>[✔️](python%2F0894-all-possible-full-binary-trees.py)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>}

_{[0513 - Find Bottom Left Tree Value](https://leetcode.com/problems/find-bottom-left-tree-value/)} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](java%2F0513-find-bottom-left-tree-value.java)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](kotlin%2F0513-find-bottom-left-tree-value.kt)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>}

_{[0669 - Trim a Binary Search Tree](https://leetcode.com/problems/trim-a-binary-search-tree/)} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](go%2F0669-trim-a-binary-search-tree.go)</div>} | _{<divalign='center'>[✔️](java%2F0669-trim-a-binary-search-tree.java)</div>} | _{<divalign='center'>[✔️](javascript%2F0669-trim-a-binary-search-tree.js)</div>} | _{<divalign='center'>[✔️](kotlin%2F0669-trim-a-binary-search-tree.kt)</div>} | _{<divalign='center'>[✔️](python%2F0669-trim-a-binary-search-tree.py)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](typescript%2F0669-trim-a-binary-search-tree.ts)</div>}

_{[0173 - Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/)} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](java%2F0173-binary-search-tree-iterator.java)</div>} | _{<divalign='center'>[✔️](javascript%2F0173-binary-search-tree-iterator.js)</div>} | _{<divalign='center'>[✔️](kotlin%2F0173-binary-search-tree-iterator.kt)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>}

_{[0538 - Convert Bst to Greater Tree](https://leetcode.com/problems/convert-bst-to-greater-tree/)} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](cpp%2F0538-convert-bst-to-greater-tree.cpp)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](kotlin%2F0538-convert-bst-to-greater-tree.kt)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>}

_{[0538 - Convert Bst to Greater Tree](https://leetcode.com/problems/convert-bst-to-greater-tree/)} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](cpp%2F0538-convert-bst-to-greater-tree.cpp)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](java%2F0538-convert-bst-to-greater-tree.java)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>[✔️](kotlin%2F0538-convert-bst-to-greater-tree.kt)</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>} | _{<divalign='center'>❌</div>}

_{[0124 - Binary Tree Maximum Path Sum](https://leetcode.com/problems/binary-tree-maximum-path-sum/)} | _{<div align='center'>[✔️](c%2F0124-binary-tree-maximum-path-sum.c)</div>} | _{<div align='center'>[✔️](cpp%2F0124-binary-tree-maximum-path-sum.cpp)</div>} | _{<div align='center'>[✔️](csharp%2F0124-binary-tree-maximum-path-sum.cs)</div>} | _{<div align='center'>❌</div>} | _{<div align='center'>[✔️](go%2F0124-binary-tree-maximum-path-sum.go)</div>} | _{<div align='center'>[✔️](java%2F0124-binary-tree-maximum-path-sum.java)</div>} | _{<div align='center'>[✔️](javascript%2F0124-binary-tree-maximum-path-sum.js)</div>} | _{<div align='center'>[✔️](kotlin%2F0124-binary-tree-maximum-path-sum.kt)</div>} | _{<div align='center'>[✔️](python%2F0124-binary-tree-maximum-path-sum.py)</div>} | _{<div align='center'>❌</div>} | _{<div align='center'>[✔️](rust%2F0124-binary-tree-maximum-path-sum.rs)</div>} | _{<div align='center'>❌</div>} | _{<div align='center'>[✔️](swift%2F0124-binary-tree-maximum-path-sum.swift)</div>} | _{<div align='center'>[✔️](typescript%2F0124-binary-tree-maximum-path-sum.ts)</div>}

_{[0297 - Serialize And Deserialize Binary Tree](https://leetcode.com/problems/serialize-and-deserialize-binary-tree/)} | _{<div align='center'>[✔️](c%2F0297-serialize-and-deserialize-binary-tree.c)</div>} | _{<div align='center'>[✔️](cpp%2F0297-serialize-and-deserialize-binary-tree.cpp)</div>} | _{<div align='center'>[✔️](csharp%2F0297-serialize-and-deserialize-binary-tree.cs)</div>} | _{<div align='center'>❌</div>} | _{<div align='center'>[✔️](go%2F0297-serialize-and-deserialize-binary-tree.go)</div>} | _{<div align='center'>[✔️](java%2F0297-serialize-and-deserialize-binary-tree.java)</div>} | _{<div align='center'>[✔️](javascript%2F0297-serialize-and-deserialize-binary-tree.js)</div>} | _{<div align='center'>[✔️](kotlin%2F0297-serialize-and-deserialize-binary-tree.kt)</div>} | _{<div align='center'>[✔️](python%2F0297-serialize-and-deserialize-binary-tree.py)</div>} | _{<div align='center'>❌</div>} | _{<div align='center'>❌</div>} | _{<div align='center'>❌</div>} | _{<div align='center'>[✔️](swift%2F0297-serialize-and-deserialize-binary-tree.swift)</div>} | _{<div align='center'>[✔️](typescript%2F0297-serialize-and-deserialize-binary-tree.ts)</div>}

classSolution {

publicList<List<String>>groupAnagrams(String[]strs) {

Map<String,List<String>>res =newHashMap<>();

for (Strings :strs) {

int[]count =newint[26];

for (charc :s.toCharArray()) {

count[c -'a']++;

}

StringBuildersb =newStringBuilder();

for (inti =0;i <26;i++) {

sb.append('#');

sb.append(count[i]);

}

Stringkey =sb.toString();

if (!res.containsKey(key)) {

res.put(key,newArrayList<>());

}

res.get(key).add(s);

}

returnnewArrayList<>(res.values());

}

}

-------------------------------------------------------------------------

classSolution {

publicList<List<String>>groupAnagrams(String[]strs) {

Map<String,List<String>>map =newHashMap<>();

classSolution {

privateintcurSum =0;

publicTreeNodeconvertBST(TreeNoderoot) {

convertBSTRecursive(root);

returnroot;

}

privatevoidconvertBSTRecursive(TreeNodenode) {

if (node ==null) {

return;

}

convertBSTRecursive(node.right);

inttemp =node.val;

node.val +=curSum;

curSum +=temp;

convertBSTRecursive(node.left);

}

}

classSolution {

publicTreeNodeconvertBST(TreeNoderoot) {

Stack<TreeNode>stack =newStack<>();

TreeNodecur =root;

intcurSum =0;

while (cur !=null || !stack.isEmpty()) {

while (cur !=null) {

stack.push(cur);

cur =cur.right;

}

cur =stack.pop();

cur.val +=curSum;

curSum =cur.val;

cur =cur.left;

}

returnroot;

}

}

classSolution {

publicList<Integer>sequentialDigits(intlow,inthigh) {

List<Integer>res =newArrayList<>();

Queue<Integer>q =newLinkedList<>();

for(inti =1;i <10;i++)

q.add(i);

while(!q.isEmpty()){

intn =q.poll();

if(n >high)

continue;

if(n >=low &&n <=high)

res.add(n);

intones =n %10;

if(ones <9)

q.add(n *10 + (ones +1));

}

returnres;

}

}

classSolution {

privatefinalint[]parent;

privatefinalint[]locked;

privatefinalMap<Integer,List<Integer>>child;

publicLockingTree(int[]parent) {

this.parent =parent;

locked =newint[parent.length];

child =newHashMap<>();

for (inti =0;i <parent.length;i++) {

child.putIfAbsent(parent[i],newArrayList<>());

child.putIfAbsent(i,newArrayList<>());

child.get(parent[i]).add(i);

}

}

publicbooleanlock(intnum,intuser) {

if (locked[num] <=0) {

locked[num] =user;

returntrue;

}

returnfalse;

}

publicbooleanunlock(intnum,intuser) {

if (locked[num] ==user) {

locked[num] =0;

returntrue;

}

returnfalse;

}

publicbooleanupgrade(intnum,intuser) {

if (!noneAncestorsLocked(num)) {

returnfalse;

}

intlockedCount =checkDescendantsAndLockIfNeeded(num);

if (lockedCount >0) {

locked[num] =user;

}

returnlockedCount >0;

}

privatebooleannoneAncestorsLocked(intnum) {

while (num != -1) {

if (locked[num] !=0) {

returnfalse;

}

num =parent[num];

}

returntrue;

}

privateintcheckDescendantsAndLockIfNeeded(intnum) {

intlockedCount =0;

Deque<Integer>deque =newArrayDeque<>();

deque.addFirst(num);

while (!deque.isEmpty()) {

intn =deque.pollLast();

if (locked[n] >0) {

lockedCount++;

locked[n] =0;

}

for (Integeri :child.get(n)) {

deque.addFirst(i);

}

}

returnlockedCount;

}

}

classSolution {

funfirstUniqChar(s:String):Int {

var count=IntArray (26)

for (cin s)

count[c-'a']++

for ((i, c)in s.withIndex()) {

if (count[c-'a']==1)

return i

}

}

}

classSolution {

funmaxSumAfterPartitioning(arr:IntArray,k:Int):Int {

val n= arr.size

val dp=IntArray (k)

dp[0]= arr[0]

for (iin1 until n) {

var curMax=0

var maxAtI=0

for (jin i downTo (i- k+1)) {

if (j<0)break

curMax= maxOf(curMax, arr[j])

val winLen= i- j+1

val curSum= curMax* winLen

val subArrSum=if (j>0) dp[(j-1)% k]else dp[k-1]

maxAtI= maxOf(maxAtI, curSum+ subArrSum)

}

dp[i% k]= maxAtI

}

return dp[(n-1)% k]

}

}

classSolution {

funmaxSumAfterPartitioning(arr:IntArray,k:Int):Int {

val n= arr.size

val dp=IntArray (n) {-1 }

fundfs(i:Int):Int {

if (i== n)return0

if (dp[i]!=-1)return dp[i]

var curMax=0

var res=0

for (jin i until minOf(n, i+ k)) {

curMax= maxOf(curMax, arr[j])

val winLen= j- i+1

res= maxOf(

res,

dfs(j+1)+ curMax* winLen

)

}

dp[i]= res

return res

}

return dfs(0)

}

}

classSolution {

funsequentialDigits(low:Int,high:Int):List<Int> {

var q=mutableListOf(1,2,3,4,5,6,7,8,9)

var res= mutableListOf<Int>()

while (q.isNotEmpty()) {

var n= q.removeFirst()

if (n> high)continue

if (n>= low) res.add(n)

val d= n%10

if (d<9) q.add(n*10+ (d+1))

}

return res

}

}