Input: n = 5
Output: 10
Explanation: The smallest multiple of both 5 and 2 is 10.

Input: n = 6
Output: 6
Explanation: The smallest multiple of both 6 and 2 is 6. Note that a number is a multiple of itself.

class Solution {
public:
    int smallestEvenMultiple(int n) {
        return n % 2 == 0 ? n : 2 * n;
    }
};

Input: s = "abacaba"
Output: 2
Explanation: There are 4 distinct continuous substrings: "a", "b", "c" and "ab".
"ab" is the longest continuous substring.

Input: s = "abcde"
Output: 5
Explanation: "abcde" is the longest continuous substring.

class Solution {
public:
    int longestContinuousSubstring(string s) {
        //longest continuous substring.
        //consecutive letters
        int res = 1; //at least one
        //continuous 
        int left = 0;
        int right = 0;
        int i = 0;
        int n = s.length();
        while(right < n){
            if(left == right) right++;
            else if((s[right] - 'a') == (s[right  - 1] - 'a') + 1 ){
                //check current right and previous
                right ++;
                res = max(res,right - left);
            }else left = right; //reset window
        }
        return res;
    }
};

Input: root = [2,3,5,8,13,21,34]
Output: [2,5,3,8,13,21,34]
Explanation: 
The tree has only one odd level.
The nodes at level 1 are 3, 5 respectively, which are reversed and become 5, 3.

Input: root = [7,13,11]
Output: [7,11,13]
Explanation: 
The nodes at level 1 are 13, 11, which are reversed and become 11, 13.

/**
 * 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* reverseOddLevels(TreeNode* root) {
        if(!root) return nullptr; 
        queue<TreeNode*> q;
        q.push(root);
        int depth = -1;

        while(!q.empty()){
            int size = q.size();
            depth++; 
            vector<TreeNode*> temp;
            for(int i = 0;i<size;i++){
                auto front = q.front();q.pop();
                if(front->left) q.push(front->left);
                if(front->right) q.push(front->right);
                
                if((depth + 1) % 2 == 0) temp.push_back(front);
            }
            
            if((depth + 1) % 2 == 0){
                int left = 0;
                int right = temp.size() - 1;
                 while(left < right){
                    swap(temp[left++]->val,temp[right--]->val);
                }   
            }

        }
        
        
//         for(int i = 0;i<node.size();i++){
//             int left = 0;
//             int right = node[i].size() - 1;
//             while(left < right){
//                 swap(node[i][left++]->val,node[i][right--]->val);
//             }
//         }
        return root;
    }
};

Input: words = ["abc","ab","bc","b"]
Output: [5,4,3,2]
Explanation: The answer for each string is the following:
- "abc" has 3 prefixes: "a", "ab", and "abc".
- There are 2 strings with the prefix "a", 2 strings with the prefix "ab", and 1 string with the prefix "abc".
The total is answer[0] = 2 + 2 + 1 = 5.
- "ab" has 2 prefixes: "a" and "ab".
- There are 2 strings with the prefix "a", and 2 strings with the prefix "ab".
The total is answer[1] = 2 + 2 = 4.
- "bc" has 2 prefixes: "b" and "bc".
- There are 2 strings with the prefix "b", and 1 string with the prefix "bc".
The total is answer[2] = 2 + 1 = 3.
- "b" has 1 prefix: "b".
- There are 2 strings with the prefix "b".
The total is answer[3] = 2.

Input: words = ["abcd"]
Output: [4]
Explanation:
"abcd" has 4 prefixes: "a", "ab", "abc", and "abcd".
Each prefix has a score of one, so the total is answer[0] = 1 + 1 + 1 + 1 = 4.

class TrieTree {
    public:
        TrieTree(){
            children = vector<TrieTree*>(26,nullptr);
        }
        int samePrefixCount = 0;//how many string have the same prefix
        vector<TrieTree*> children;
    
};


class Solution {
public:
    vector<int> sumPrefixScores(vector<string>& words) {
        TrieTree *root = new TrieTree();
        for(int i = 0;i<words.size();i++){
            BuildTree(words[i],root);
        }
        
        vector<int> res(words.size(),0);
        for(int i = 0;i<words.size();i++){
            res[i] = countPrefixSum(words[i],root);
        }
        
        return res;
    }
    
    void BuildTree(string& str, TrieTree *root){
        TrieTree *head = root;
        for(int i = 0;i<str.length();i++){
            if(head->children[str[i] - 'a'] == nullptr) head->children[str[i] - 'a'] = new TrieTree();
            head = head->children[str[i] - 'a'];
            head->samePrefixCount++;
        }
    }
    
    int countPrefixSum(string& str, TrieTree *root){
        int count = 0;
        TrieTree *head = root;
        for(int i = 0;i<str.length();i++){
            head = head->children[str[i] - 'a'];
            count += head-> samePrefixCount;
        }
        return count;
    }
};