For example:

A -> 1
B -> 2
C -> 3
...
Z -> 26
AA -> 27
AB -> 28 
...

Example 1:

Input: columnTitle = "A"
Output: 1

Example 2:

Input: columnTitle = "AB"
Output: 28

Example 3:

Input: columnTitle = "ZY"
Output: 701

Example 4:

Input: columnTitle = "FXSHRXW"
Output: 2147483647

Constraints:

• 1 <= columnTitle.length <= 7
• columnTitle consists only of uppercase English letters.
• columnTitle is in the range ["A", "FXSHRXW"].

Solution: Base conversion

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int titleToNumber(string s) {
    int ans = 0;    
    for (int i = s.length() - 1, cur = 0; i >= 0; --i) {
      cur = cur ? cur * 26 : 1;
      ans += (s[i] - 'A' + 1) * cur;
    }
    return ans;
  }
};

Related Problems

• 花花酱 LeetCode 168. Excel Sheet Column Title

The post 花花酱 LeetCode 171. Excel Sheet Column Number appeared first on Huahua's Tech Road.

The numerical value of some string of lowercase English letters s is the concatenation of the letter values of each letter in s, which is then converted into an integer.

• For example, if s = "acb", we concatenate each letter’s letter value, resulting in "021". After converting it, we get 21.

You are given three strings firstWord, secondWord, and targetWord, each consisting of lowercase English letters 'a' through 'j' inclusive.

Return true if the summation of the numerical values of firstWord and secondWord equals the numerical value of targetWord, or false otherwise.

Example 1:

Input: firstWord = "acb", secondWord = "cba", targetWord = "cdb"
Output: true
Explanation:
The numerical value of firstWord is "acb" -> "021" -> 21.
The numerical value of secondWord is "cba" -> "210" -> 210.
The numerical value of targetWord is "cdb" -> "231" -> 231.
We return true because 21 + 210 == 231.

Example 2:

Input: firstWord = "aaa", secondWord = "a", targetWord = "aab"
Output: false
Explanation: 
The numerical value of firstWord is "aaa" -> "000" -> 0.
The numerical value of secondWord is "a" -> "0" -> 0.
The numerical value of targetWord is "aab" -> "001" -> 1.
We return false because 0 + 0 != 1.

Example 3:

Input: firstWord = "aaa", secondWord = "a", targetWord = "aaaa"
Output: true
Explanation: 
The numerical value of firstWord is "aaa" -> "000" -> 0.
The numerical value of secondWord is "a" -> "0" -> 0.
The numerical value of targetWord is "aaaa" -> "0000" -> 0.
We return true because 0 + 0 == 0.

Constraints:

• 1 <= firstWord.length, secondWord.length, targetWord.length <= 8
• firstWord, secondWord, and targetWord consist of lowercase English letters from 'a' to 'j' inclusive.

Solution: Brute Force

Tips: Write a reusable function to compute the score of a word.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  bool isSumEqual(string firstWord, string secondWord, string targetWord) {
    auto score = [](string_view s) {
      int ans = 0;
      for (char c : s)
        ans = ans * 10 + (c - 'a');
      return ans;
    };
    return score(firstWord) + score(secondWord) == score(targetWord);
  }
};

The post 花花酱 LeetCode 1880. Check if Word Equals Summation of Two Words appeared first on Huahua's Tech Road.

Your job at this factory is to put each ball in the box with a number equal to the sum of digits of the ball’s number. For example, the ball number 321 will be put in the box number 3 + 2 + 1 = 6 and the ball number 10 will be put in the box number 1 + 0 = 1.

Given two integers lowLimit and highLimit, return the number of balls in the box with the most balls.

Example 1:

Input: lowLimit = 1, highLimit = 10
Output: 2
Explanation:
Box Number:  1 2 3 4 5 6 7 8 9 10 11 ...
Ball Count:  2 1 1 1 1 1 1 1 1 0  0  ...
Box 1 has the most number of balls with 2 balls.

Example 2:

Input: lowLimit = 5, highLimit = 15
Output: 2
Explanation:
Box Number:  1 2 3 4 5 6 7 8 9 10 11 ...
Ball Count:  1 1 1 1 2 2 1 1 1 0  0  ...
Boxes 5 and 6 have the most number of balls with 2 balls in each.

Example 3:

Input: lowLimit = 19, highLimit = 28
Output: 2
Explanation:
Box Number:  1 2 3 4 5 6 7 8 9 10 11 12 ...
Ball Count:  0 1 1 1 1 1 1 1 1 2  0  0  ...
Box 10 has the most number of balls with 2 balls.

Constraints:

• 1 <= lowLimit <= highLimit <= 105

Solution: Hashtable and base-10

Max sum will be 9+9+9+9+9 = 45

Time complexity: O((hi-lo) * log(hi))
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int countBalls(int lowLimit, int highLimit) {
    vector<int> balls(46);
    int ans = 0;
    for (int i = lowLimit; i <= highLimit; ++i) {
      int n = i;
      int box = 0;
      while (n) { box += n % 10; n /= 10; }
      ans = max(ans, ++balls[box]);
    }
    return ans;
  }
};

# Author: Huahua
class Solution:
  def countBalls(self, lowLimit: int, highLimit: int) -> int:
    balls = defaultdict(int)
    ans = 0
    for x in range(lowLimit, highLimit + 1):
      s = sum(int(d) for d in str(x))
      balls[s] += 1
      ans = max(ans, balls[s])
    return ans

The post 花花酱 LeetCode 1742. Maximum Number of Balls in a Box appeared first on Huahua's Tech Road.

You may assume that the version strings are non-empty and contain only digits and the . character.

The . character does not represent a decimal point and is used to separate number sequences.

For instance, 2.5 is not “two and a half” or “half way to version three”, it is the fifth second-level revision of the second first-level revision.

You may assume the default revision number for each level of a version number to be 0. For example, version number 3.4 has a revision number of 3 and 4 for its first and second level revision number. Its third and fourth level revision number are both 0.

Example 1:

Input: version1 = "0.1", version2 = "1.1"
Output: -1

Example 2:

Input: version1 = "1.0.1", version2 = "1"
Output: 1

Example 3:

Input: version1 = "7.5.2.4", version2 = "7.5.3"
Output: -1

Example 4:

Input: version1 = "1.01", version2 = "1.001"
Output: 0
Explanation: Ignoring leading zeroes, both “01” and “001" represent the same number “1”

Example 5:

Input: version1 = "1.0", version2 = "1.0.0"
Output: 0
Explanation: The first version number does not have a third level revision number, which means its third level revision number is default to "0"

Note:

1. Version strings are composed of numeric strings separated by dots . and this numeric strings may have leading zeroes.
2. Version strings do not start or end with dots, and they will not be two consecutive dots.

Solution: String

Split the version string to a list of numbers, and compare two lists.

Time complexity: O(l1 + l2)
Space complexity: O(l1 + l2)

// Author: Huahua
class Solution {
public:
  int compareVersion(string version1, string version2) {
    const auto& v1 = parseVersion(version1);
    const auto& v2 = parseVersion(version2);
    int i1 = 0, i2 = 0;
    while (i1 < v1.size() || i2 < v2.size()) {    
      int n1 = i1 < v1.size() ? v1[i1++] : 0;
      int n2 = i2 < v2.size() ? v2[i2++] : 0;
      if (n1 < n2) return -1;
      else if (n1 > n2) return 1;
    }
    return 0;
  }
private:
  vector<int> parseVersion(const string& version) {
    vector<int> v;
    int s = 0;
    for (char c : version) {
      if (c == '.') {
        v.push_back(s);
        s = 0;
      } else {
        s = s * 10 + (c - '0');
      }
    }
    v.push_back(s);
    return v;
  }
};

The post 花花酱 LeetCode 165. Compare Version Numbers appeared first on Huahua's Tech Road.

Given a string num representing a decimal integer N, return the Hexspeak representation of N if it is valid, otherwise return "ERROR".

Example 1:

Input: num = "257"
Output: "IOI"
Explanation:  257 is 101 in hexadecimal.

Example 2:

Input: num = "3"
Output: "ERROR"

Constraints:

• 1 <= N <= 10^12
• There are no leading zeros in the given string.
• All answers must be in uppercase letters.

Solution: Simulation

Time complexity: O(logn)
Space complexity: O(logn)

// Author: Huahua
class Solution {
public:
  string toHexspeak(string num) {
    long n = stol(num);
    string ans;
    while (n) {
      int r = n % 16;
      char c;
      if (r == 0) c = 'O';
      else if (r == 1) c = 'I';
      else if (r >= 10 && r <= 15) c = 'A' + r - 10;
      else return "ERROR";
      ans += c;
      n >>= 4;
    }
    reverse(begin(ans), end(ans));
    return ans;
  }
};

The post 花花酱 LeetCode 1271. Hexspeak appeared first on Huahua's Tech Road.

Problem

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

Symbol       Value
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

For example, two is written as II in Roman numeral, just two one’s added together. Twelve is written as, XII, which is simply X + II. The number twenty seven is written as XXVII, which is XX + V + II.

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

• I can be placed before V (5) and X (10) to make 4 and 9.
• X can be placed before L (50) and C (100) to make 40 and 90.
• C can be placed before D (500) and M (1000) to make 400 and 900.

Given a roman numeral, convert it to an integer. Input is guaranteed to be within the range from 1 to 3999.

Example 1:

Input: "III"
Output: 3

Example 2:

Input: "IV"
Output: 4

Example 3:

Input: "IX"
Output: 9

Example 4:

Input: "LVIII"
Output: 58
Explanation: C = 100, L = 50, XXX = 30 and III = 3.

Example 5:

Input: "MCMXCIV"
Output: 1994
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.

Solution

accumulate the value of each letter.

If the value of current letter is greater than the previous one, deduct twice of the previous value.

e.g. IX, 1 + 10 – 2 * 1 = 9 instead of 1 + 10 = 11

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int romanToInt(string s) {
    map<char, int> m{{'I', 1}, {'V', 5}, 
                     {'X', 10}, {'L', 50},
                     {'C', 100}, {'D', 500},
                     {'M', 1000}};
    int ans = 0;
    for (int i = 0; i < s.length(); i++) {
      ans += m[s[i]];
      if (i > 0 && m[s[i]] > m[s[i - 1]])
        ans -= 2 * m[s[i - 1]];
    }
    return ans;
  }
};

// Author: Huahua
class Solution {
  private int v(char R) {
    switch (R) {
      case 'I' : return 1;
      case 'V' : return 5;
      case 'X' : return 10;
      case 'L' : return 50;
      case 'C' : return 100;
      case 'D' : return 500;
      case 'M' : return 1000;
      default: break;
    }
    return 0;
  }
  
  public int romanToInt(String s) {
    int ans = 0;
    for (int i = 0; i < s.length(); i++) {
      ans += v(s.charAt(i));
      if ( i > 0 && v(s.charAt(i)) > v(s.charAt(i - 1)))        
          ans -= 2 * v(s.charAt(i - 1));        
    }
    return ans;
  }
}

class Solution:
  def romanToInt(self, s):
    m = {'I' : 1, 'V': 5, 'X': 10, 'L' : 50,
         'C' : 100, 'D': 500, 'M': 1000}
    ans = m[s[0]]
    for c, p in zip(s[1:], s[0:-1]):
      ans += m[c]
      if m[c] > m[p]: ans -= 2 * m[p]
    return ans

The post 花花酱 LeetCode 13. Roman to Integer appeared first on Huahua's Tech Road.

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

Symbol       Value
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

For example, two is written as II in Roman numeral, just two one’s added together. Twelve is written as, XII, which is simply X + II. The number twenty seven is written as XXVII, which is XX + V + II.

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

• I can be placed before V (5) and X (10) to make 4 and 9.
• X can be placed before L (50) and C (100) to make 40 and 90.
• C can be placed before D (500) and M (1000) to make 400 and 900.

Given an integer, convert it to a roman numeral. Input is guaranteed to be within the range from 1 to 3999.

Example 1:

Input: 3
Output: "III"

Example 2:

Input: 4
Output: "IV"

Example 3:

Input: 9
Output: "IX"

Example 4:

Input: 58
Output: "LVIII"
Explanation: C = 100, L = 50, XXX = 30 and III = 3.

Example 5:

Input: 1994
Output: "MCMXCIV"
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.

Solution: HashTable + Simulation

Map integer 1,4,5,9,10,40,50,90, …, 1000 to Romain

Start from the largest number y,

if x >= y:
ans += Roman[y]
x -= y

Time complexity: O(x)

Space complexity: O(x)

// Author: Huahua
class Solution {
public:
  string intToRoman(int num) {
    vector<pair<int,string>> v{{1000, "M"}, {900, "CM"}, {500, "D"}, {400, "CD"},
                               { 100, "C"}, { 90, "XC"}, { 50, "L"}, { 40, "XL"}, 
                               {  10, "X"}, {  9, "IX"}, {  5, "V"}, {  4, "IV"}, 
                               {   1, "I"}};
    string ans;
    auto it = cbegin(v);
    while (num) {
      if (num >= it->first) {
        num -= it->first;
        ans += it->second;
      } else {
        ++it;
      }
    }
    return ans;
  }
};

# Author: Huahua
class Solution:
  def intToRoman(self, num):
    m = [[1000, "M"], [900, "CM"], [500, "D"], [400, "CD"],
         [ 100, "C"], [ 90, "XC"], [ 50, "L"], [ 40, "XL"], 
         [  10, "X"], [  9, "IX"], [  5, "V"], [  4, "IV"], 
         [   1, "I"]]    
    index = 0
    ans = ''
    while num > 0:
      if num >= m[index][0]:
        ans += m[index][1]
        num -= m[index][0]
      else:
        index += 1
    return ans

The post 花花酱 LeetCode 12. Integer to Roman appeared first on Huahua's Tech Road.

Implement atoi which converts a string to an integer.

The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible, and interprets them as a numerical value.

The string can contain additional characters after those that form the integral number, which are ignored and have no effect on the behavior of this function.

If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because either str is empty or it contains only whitespace characters, no conversion is performed.

If no valid conversion could be performed, a zero value is returned.

Note:

• Only the space character ' ' is considered as whitespace character.
• Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2³¹,  2³¹ − 1]. If the numerical value is out of the range of representable values, INT_MAX (2³¹ − 1) or INT_MIN (−2³¹) is returned.

Example 1:

Input: "42"
Output: 42

Example 2:

Input: "   -42"
Output: -42
Explanation: The first non-whitespace character is '-', which is the minus sign.
             Then take as many numerical digits as possible, which gets 42.

Example 3:

Input: "4193 with words"
Output: 4193
Explanation: Conversion stops at digit '3' as the next character is not a numerical digit.

Example 4:

Input: "words and 987"
Output: 0
Explanation: The first non-whitespace character is 'w', which is not a numerical 
             digit or a +/- sign. Therefore no valid conversion could be performed.

Example 5:

Input: "-91283472332"
Output: -2147483648
Explanation: The number "-91283472332" is out of the range of a 32-bit signed integer.
             Thefore INT_MIN (−231) is returned.

Solution: Simulation

You need to handle all corner cases in order to pass…

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int myAtoi(const string& s) {
    long long ans = 0;
    int neg = 0;
    int pos = 0;
    bool p = false; // has '.'
    bool a = false; // has letters
    bool n = false; // has number
    for (int i = 0; i < s.length(); ++i) {      
      if (s[i] == ' ') { if (n || neg || pos) break; }
      else if (s[i] == '-') { if (n) break; else neg++; }
      else if (s[i] == '+') { if (n) break; else pos++; }
      else if (s[i] == '.') p = true;
      else if (s[i] >= '0' && s[i] <= '9' && !p && !a) {
        ans = ans * 10 + (s[i] - '0');
        n = true;
      } else {
        a = true;
      }
      if (ans / 10 > INT_MAX) break; // ans can be > 64 bit
    }

    if (neg) ans = -ans;

    if (ans > INT_MAX) ans = INT_MAX;
    if (ans < INT_MIN) ans = INT_MIN;

    if (pos + neg > 1) ans = 0;

    return ans;
  }
};

The post 花花酱 LeetCode 8. String to Integer (atoi) appeared first on Huahua's Tech Road.

Given a 32-bit signed integer, reverse digits of an integer.

Example 1:

Input: 123
Output: 321

Example 2:

Input: -123
Output: -321

Example 3:

Input: 120
Output: 21

Note:
Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2³¹,  2³¹ − 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.

Solution: Simulation

Reverse digit by digit. Be careful about the overflow and negative numbers (especially in Python)

Time complexity: O(log(x)) ~ O(1)

Space complexity: O(log(x)) ~ O(1)

// Author: Huahua
class Solution {
public:
  int reverse(int x) {
    int ans = 0;
    while (x != 0) {
      int r = x % 10;
      if (ans > INT_MAX / 10 || ans < INT_MIN / 10) return 0;
      ans = ans * 10 + r;
      x /= 10;
    }
    return ans;
  }
};

class Solution {
  public int reverse(int x) {
    int ans = 0;
    while (x != 0) {
      int r = x % 10;
      if (ans > Integer.MAX_VALUE / 10 || ans < Integer.MIN_VALUE / 10) return 0;
      ans = ans * 10 + r;
      x /= 10;
    }
    return ans;
  }
}

class Solution:
  def reverse(self, x):
    min_val = -(2**31);
    max_val = 2**31 - 1;
    sign = -1 if x < 0 else 1
    x = abs(x)
    ans = 0
    while x != 0:            
      ans = ans * 10 + (x % 10)
      x //= 10
    ans *= sign
    if ans > max_val or ans < min_val: return 0
    return ans

The post 花花酱 LeetCode 7. Reverse Integer appeared first on Huahua's Tech Road.

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)

P   A   H   N
A P L S I I G
Y   I   R

And then read line by line: "PAHNAPLSIIGYIR"

Write the code that will take a string and make this conversion given a number of rows:

string convert(string s, int numRows);

Example 1:
<preclass=”crayon:false”>Input: s = “PAYPALISHIRING”, numRows = 3 Output: “PAHNAPLSIIGYIR”

Example 2:

Input: s = "PAYPALISHIRING", numRows = 4
Output: "PINALSIGYAHRPI"
Explanation:

P     I    N
A   L S  I G
Y A   H R
P     I

Solution: Simulation

Store the zigzag results for each row and then output row by row.

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  string convert(string s, int nRows) {
    if (nRows == 1) return s;

    vector<string> ss(nRows);
    int l = s.length();
    int x = 0, y = 0, i = 0;
    bool down = true;
    while (i < l) {
      ss[y] += s[i];
      if (down) {
        ++y;
        if (y == nRows) {
            down = false;
            y -=2;
        }
      } else {
        --y;
        if (y < 0) {
            down = true;
            y = 1;
        }
      }
      i++;
    }

    string ans;
    for(const string& r : ss)
      ans += r;
    return ans;
  }
};

The post 花花酱 LeetCode 6. ZigZag Conversion appeared first on Huahua's Tech Road.

Problem

Given an integer, return its base 7 string representation.

Example 1:

Input: 100
Output: "202"

Example 2:

Input: -7
Output: "-10"

Note: The input will be in range of [-1e7, 1e7].

Solution: Simulation

Time complexity: O(logn)

Space complexity: O(logn)

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  string convertToBase7(int num) {
    bool is_nagetive = num<0;
    num = abs(num);
    string ans;
    do {
        ans += ('0' + (num % 7));
        num /= 7;
    } while (num > 0);
    
    if (is_nagetive)
        ans += "-";
    
    reverse(begin(ans), end(ans));
    
    return ans;
  }
};

The post 花花酱 LeetCode 504. Base 7 appeared first on Huahua's Tech Road.

In the following, every capital letter represents some hexadecimal digit from 0 to f.

The red-green-blue color "#AABBCC" can be written as "#ABC" in shorthand.  For example, "#15c" is shorthand for the color "#1155cc".

Now, say the similarity between two colors "#ABCDEF" and "#UVWXYZ" is -(AB - UV)^2 - (CD - WX)^2 - (EF - YZ)^2.

Given the color "#ABCDEF", return a 7 character color that is most similar to #ABCDEF, and has a shorthand (that is, it can be represented as some "#XYZ"

Example 1:
Input: color = "#09f166"
Output: "#11ee66"
Explanation:  
The similarity is -(0x09 - 0x11)^2 -(0xf1 - 0xee)^2 - (0x66 - 0x66)^2 = -64 -9 -0 = -73.
This is the highest among any shorthand color.

Note:

• color is a string of length 7.
• color is a valid RGB color: for i > 0, color[i] is a hexadecimal digit from 0 to f
• Any answer which has the same (highest) similarity as the best answer will be accepted.
• All inputs and outputs should use lowercase letters, and the output is 7 characters.

Solution: Brute Force

R, G, B are independent, find the closest color for each channel separately.

Time complexity: O(3 * 16)

Space complexity: O(1)

// Author: Huahua
// Running time: 7 ms
class Solution {
public:
  string similarRGB(string color) {
    const string hex{"0123456789abcdef"};
    vector<int> rgb(3, 0);
    for (int i = 0; i < 3; ++i)
      rgb[i] = hex.find(color[2 * i + 1]) * 16 + hex.find(color[2 * i + 2]);
    
    string ans(7, '#');    
    for (int i = 0; i < 3; ++i) {
      int best = INT_MAX;
      for (int j = 0; j < 16; ++j) {
        int diff = abs(j * 16 + j - rgb[i]);
        if (diff >= best) continue;
        best = diff;
        ans[2 * i + 1] = ans[2 * i + 2] = hex[j];
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 800. Simple RGB Color appeared first on Huahua's Tech Road.

Problem:

Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.

Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.

For example, you may serialize the following tree

1
   / \
  2   3
     / \
    4   5

as "[1,2,3,null,null,4,5]", just the same as how LeetCode OJ serializes a binary tree. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.

Note: Do not use class member/global/static variables to store states. Your serialize and deserialize algorithms should be stateless.

https://leetcode.com/problems/serialize-and-deserialize-binary-tree/description/

Idea:

Recursion

Time Complexity O(n)

Solution 1: ASCII

// Author: Huahua
// Running time: 39 ms
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        ostringstream out;
        serialize(root, out);
        return out.str();
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        istringstream in(data);
        return deserialize(in);
    }
private:
    void serialize(TreeNode* root, ostringstream& out) {
        if (!root) {
            out << "# ";
            return;
        }        
        out << root->val << " ";
        serialize(root->left, out);
        serialize(root->right, out);
    }
    
    TreeNode* deserialize(istringstream& in) {
        string val;
        in >> val;
        if (val == "#") return nullptr;        
        TreeNode* root = new TreeNode(stoi(val));        
        root->left = deserialize(in);
        root->right = deserialize(in);        
        return root;
    }
};

Solution 2: Binary

// Author: Huahua
// Running time: 23 ms (beat 98.07%)
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        ostringstream out;
        serialize(root, out);
        return out.str();
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        istringstream in(data);
        return deserialize(in);
    }
private:
    enum STATUS {
        ROOT_NULL = 0x0,
        ROOT = 0x1,
        LEFT = 0x2,
        RIGHT = 0x4
    };
    
    void serialize(TreeNode* root, ostringstream& out) {
        char status = 0;
        if (root) status |= ROOT;
        if (root && root->left) status |= LEFT;
        if (root && root->right) status |= RIGHT;
        out.write(&status, sizeof(char));        
        if (!root) return;
        out.write(reinterpret_cast<char*>(&(root->val)), sizeof(root->val));
        if (root->left) serialize(root->left, out);
        if (root->right) serialize(root->right, out);
    }
    
    TreeNode* deserialize(istringstream& in) {
        char status;
        in.read(&status, sizeof(char));
        if (!status & ROOT) return nullptr;
        auto root = new TreeNode(0);
        in.read(reinterpret_cast<char*>(&root->val), sizeof(root->val));        
        root->left = (status & LEFT) ? deserialize(in) : nullptr;
        root->right = (status & RIGHT) ? deserialize(in) : nullptr;
        return root;
    }
};

// Your Codec object will be instantiated and called as such:
// Codec codec;
// codec.deserialize(codec.serialize(root));

// Author: Huahua
// Running time: 23 ms (<98.13%)
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        string s;
        serialize(root, s);
        return s;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) { 
        int pos = 0;
        return deserialize(data, pos);
    }
private:
    enum STATUS {
        ROOT_NULL = 0x0,
        ROOT = 0x1,
        LEFT = 0x2,
        RIGHT = 0x4
    };
    
    void serialize(TreeNode* root, string& s) {
        char status = ROOT_NULL;
        if (root) status |= ROOT;
        if (root && root->left) status |= LEFT;
        if (root && root->right) status |= RIGHT;
        s.push_back(status);
        if (!root) return;
        s.append(reinterpret_cast<char*>(&root->val), sizeof(root->val));
        if (root->left) serialize(root->left, s);
        if (root->right) serialize(root->right, s);
    }
    
    TreeNode* deserialize(const string& s, int& pos) {
        char status = s[pos++];
        if (!status) return nullptr;
        TreeNode* root = new TreeNode(0);
        memcpy(&root->val, s.data() + pos, sizeof(root->val));
        pos += sizeof(root->val);  
        root->left = (status & LEFT) ? deserialize(s, pos) : nullptr;
        root->right = (status & RIGHT) ? deserialize(s, pos) : nullptr;
        return root;
    }
};

Related Problems

• LeetCode 449. Serialize and Deserialize BST

The post 花花酱 LeetCode 297. Serialize and Deserialize Binary Tree appeared first on Huahua's Tech Road.