Math on Hang Zhang

Multiply Strings

Sun, 12 Apr 2026 00:00:00 +0000

43. Multiply Strings

Algorithm Steps

Iterate the array in reverse order
- Convert each character of num1 and num2 to integer, and store conversion results in integer array A and B
Simulate multiplication
- When multiplying 2 numbers of length n and m, the result has at most n + m digits
- Multiply A and B bit by bit accumulation，and store result in array C
  - C[i + j] = A[i] * B[j]
Handle carries
- Each digit of C is treated as unit digit, and the carry-over is accumulated to the next digit
Remove leading 0 and generate the result string
- Search for the first non-zero bit in the C from higher bit to the lower bit
- Convert the result array to string

Complexity Analysis

Length of num1 and num2 is n and m
Simulate multiplication O(n * m)
Handel carries and generate result string O(n + m)

Overall time complexity O(n * m)

Length of Result array C is n + m，space complexity O(n + m)

C++ Code

class Solution {
public:
    string multiply(string num1, string num2)
    {
        // get the length of num1 and num2
        int n = num1.size(), m = num2.size();

        // iterate the string in reverse order and convert to integer array
        std::vector<int> A, B;
        for (int i = n - 1; i >= 0; --i)
            A.push_back(num1[i] - '0');
        for (int i = m - 1; i >= 0; --i)
            B.push_back(num2[i] - '0');

        // initialize result array C
        std::vector<int> C(n + m, 0);

        // simulate multiplication
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; ++j)
                C[i + j] += A[i] * B[j];

        // handle carries
        for (int i = 0, t = 0; i < C.size(); ++i)
        {
            t += C[i];
            C[i] = t % 10;  // keep unit digit
            t /= 10;        // process carry part
        }

        // remove leading zeros
        int k = C.size() - 1;
        while (k > 0 && C[k] == 0) --k;

        // convert integer array to string
        std::string res;
        while (k >= 0)
            res += C[k--] + '0';

        return res;
    }
};

Python Code

class Solution:
    def multiply(self, num1: str, num2: str) -> str:
        n, m = len(num1), len(num2)

        A = [int(num1[i]) for i in range(n - 1, -1, -1)]
        B = [int(num2[i]) for i in range(m - 1, -1, -1)]

        C = [0] * (n + m)
        for i in range(n):
            for j in range(m):
                C[i + j] += A[i] * B[j]

        t = 0
        for i in range(len(C)):
            t += C[i]
            C[i] = t % 10
            t //= 10

        k = len(C) - 1
        while k > 0 and C[k] == 0:
            k -= 1

        res = ""
        while k >= 0:
            res += str(C[k])
            k -= 1

        return res

Go Code

func multiply(num1 string, num2 string) string {
    n, m := len(num1), len(num2)

    A := make([]int, n)
    B := make([]int, m)


    for i := 0; i < n; i ++ {
        A[i] = int(num1[n - 1 - i] - '0')
    }

    for i := 0; i < m; i ++ {
        B[i] = int(num2[m - 1 - i] - '0')
    }

    C := make([]int, n + m)
    for i := range A {
        for j := range B {
            C[i + j] += A[i] * B[j]
        }
    }

    t := 0
    for i := 0; i < len(C); i ++ {
        t += C[i]
        C[i] = t % 10
        t /= 10
    }

    k := len(C) - 1
    for k > 0 && C[k] == 0 {
        k -= 1
    }

    res := ""
    for k >= 0 {
        res += string(C[k] + '0')
        k -= 1
    }

    return res
}

JavaScript Code

/**
 * @param {string} num1
 * @param {string} num2
 * @return {string}
 */
var multiply = function (num1, num2) {
  let n = num1.length,
    m = num2.length;
  let A = [],
    B = [];

  for (let i = n - 1; i >= 0; i--) {
    A.push(Number(num1[i]));
  }

  for (let i = m - 1; i >= 0; i--) {
    B.push(Number(num2[i]));
  }

  let C = new Array(n + m).fill(0);
  for (let i = 0; i < n; i++) {
    for (let j = 0; j < m; j++) {
      C[i + j] += A[i] * B[j];
    }
  }

  let t = 0;
  for (let i = 0; i < C.length; i++) {
    t += C[i];
    C[i] = t % 10;
    t = Math.trunc(t / 10);
  }

  let k = C.length - 1;
  while (k > 0 && C[k] === 0) {
    k--;
  }

  let res = "";
  while (k >= 0) {
    res += String(C[k--]);
  }

  return res;
};

Max Points On A Line

Tue, 18 Feb 2025 00:00:00 +0000

149. 直线上最多的点数

分析

哈希表：通过哈希表来记录每个斜率出现的频次。对于每个点，遍历其他点，计算斜率，并更新哈希表。如果多个点具有相同的斜率，则它们在同一条直线上
特殊情况：需要考虑以下几种情况：
- 重复点：如果两个点重合，它们的斜率是相同的
- 竖直线：当 dx = 0 时，说明是竖直线，斜率可以用一个特殊值（如无穷大）表示
最终结果：对于每个点，计算该点与其他点的最大共线点数，并维护一个最大值

时间复杂度

时间复杂度 O(n^2)，其中 n 是点的数量。对于每个点 p，我们遍历所有其他点 q，计算它们的斜率

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int maxPoints(vector<vector<int>>& points)
    {
        int res = 0;
        for (std::vector<int>& p : points)
        {
            int same = 0, vertical = 0;
            std::unordered_map<long double, int> count;
            for (std::vector<int>& q : points)
            {
                if (p == q)  // 统计重叠点的个数
                    ++same;
                else if (p[0] == q[0])  // x坐标相同，统计竖直线上点的个数
                    ++vertical;
                else
                {
                    long double slope = (long double)(q[1] - p[1]) / (q[0] - p[0]);  // 计算斜率
                    ++count[slope];  // 记录相同斜率的点数
                }
            }

            // 找到最大斜率的点数（加上重叠点数）
            for (auto [slope, cnt] : count)
                res = std::max(res, same + cnt);

            // 比较竖直线的点数（加上重叠点数）和最大斜率的点数
            res = std::max(res, same + vertical);
        }
        return res;
    }
};

Pow X N

Mon, 17 Feb 2025 00:00:00 +0000

50. Pow(x, n)

分析

长整型 LL 定义：long long 类型用于处理 n = INT_MIN 的情况，因为 abs(INT_MIN) 会溢出 int 类型
判断 n 是否为负数：如果 n 是负数，最后需要返回 1 / res
快速幂的实现：通过右移 k（即 k >>= 1）将 n 每次除以 2，并根据 k 是否为奇数来决定是否将当前的 x 乘到结果中
计算 x^n：
- 如果 k 的最低位是 1（即 k & 1），则当前的 x 需要乘到结果中
- 每次将 x 平方，即 x = x * x，这相当于将指数减少了一半
负指数情况：如果 n 是负数，返回 1 / res，否则返回计算结果 res

时间复杂度

时间复杂度 O(logn)，每次将 n 减半，通过二进制方式快速计算

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    double myPow(double x, int n)
    {
        using LL = long long;  // 使用 long long 类型来处理 n = INT_MIN 的特殊情况
        bool is_minus = (n < 0);  // 判断 n 是否为负数
        double res = 1;

        // 使用绝对值的 n 进行计算，避免负数的影响
        for (LL k = std::abs(LL(n)); k; k >>= 1)  // 快速幂算法：k 是二进制表示
        {
            if (k & 1)  // 如果 k 的最低位是 1
                res *= x;  // 将当前的 x 乘到结果上
            x *= x;  // x 自身平方
        }

        if (is_minus)  // 如果 n 是负数，返回 1 / res
            return 1 / res;
        return res;
    }
};

Sqrt X

Sun, 16 Feb 2025 00:00:00 +0000

69. x的平方根

分析

初始化：设定左右边界 l = 0 和 r = x，表示搜索区间
二分查找：
- 通过 (l + 1ll + r) >> 1 计算中间值 mid。这里使用了 1ll 来确保计算过程中不会发生整数溢出
- 判断 mid * mid <= x，如果成立，说明平方根的整数部分不大于 mid，我们将搜索区间的左边界 l 移动到 mid
- 如果 mid * mid > x，说明平方根在 mid 左边，更新右边界 r 为 mid - 1
终止条件：当 l == r 时，搜索结束，r 即为 x 的整数平方根

时间复杂度

总时间复杂度 O(logx)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int mySqrt(int x)
    {
      int l = 0, r = x;  // 设置搜索区间 [0, x]

      while (l < r)
      {
        int mid = (l + 1ll + r) >> 1;  // 计算中间值 mid，避免整数溢出
        if (mid <= x / mid)  // 如果 mid 的平方小于等于 x，则 mid 可能是答案
          l = mid;  // 如果 mid 满足条件，调整左边界为 mid
        else
          r = mid - 1;  // 如果 mid 不满足条件，调整右边界为 mid-1
      }

      return r;  // 返回最终的结果，r 为整数平方根
    }
};

Factorial Trail Zeroes

Sat, 15 Feb 2025 00:00:00 +0000

172. 阶乘后的零

分析

尾随零的产生是因为 10 = 2 * 5，每次有一个因数 2 和 5 的乘积，都会形成一个 10，从而在阶乘结果的末尾增加一个零

由于阶乘的数值中，因数 2 的出现频率远高于因数 5，所以我们只需要考虑 5 出现的次数，计算 n! 中 5 的因数的个数，即可得到尾随零的个数

计算 n! 中因数 5 的个数
对于 n 中所有能被 5 整除的数，每个数都至少包含一个 5，例如：5, 10, 15, 20...
如果一个数能被 25 整除，则它会包含额外的一个因数 5，比如 25 会有两个因数 5，50 也会有两个因数 5，依此类推
因此，n! 中尾随零的数量就是 n / 5 + n / 25 + n / 125 + ...，直到 5^k > n

时间复杂度

时间复杂度：O(log_5 n) ，因为每次将 n 除以 5，直到 n 小于 5 为止

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int trailingZeroes(int n)
    {
      int res = 0;
      while (n)
      {
        res += n / 5;  // 计算能被 5 整除的数
        n /= 5;         // 除以 5，继续计算更高次方的 5
      }
      return res;
    }
};

Palindrome Number

Fri, 14 Feb 2025 00:00:00 +0000

9. 回文数

分析

负数一定不是回文数：
- 例如 -121 变成 121-，不对称，因此直接返回 false
将数字翻转后与原数比较：
- 反转 x 的每一位数字，存入 b，然后判断 b == x 是否成立

时间复杂度

时间复杂度与 x 的位数成正比，最多 10 次（int 最大 32 位）

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    bool isPalindrome(int x)
    {
      if (x < 0)  // 负数一定不是回文数
        return false;

      long a = x, b = 0;  // a 复制 x，b 存储翻转后的数
      while (a)
      {
        b = b * 10 + a % 10;  // 取出 a 的最后一位，加到 b 的末尾
        a /= 10;  // 去掉 a 的最后一位
      }

      return b == x;  // 判断反转后的 b 是否等于原数 x
    }
};

Plus One

Fri, 14 Feb 2025 00:00:00 +0000

66. 加一

分析

从低位到高位进行加法，考虑进位
如果所有位数都发生进位（如 999 -> 1000），需要在最高位补 1

时间复杂度

时间复杂度 O(n)，遍历数组两次（反转 + 加法）

空间复杂度

空间复杂度 O(1)

C++代码

class Solution
{
public:
    vector<int> plusOne(vector<int>& digits)
    {
      std::reverse(digits.begin(), digits.end());  // 反转数组，使低位在前
      int t = 1;  // 初始进位值为 1，即加 1

      for (int& x: digits)
      {
        t += x;   // 当前位加上进位
        x = t % 10;  // 更新当前位
        t /= 10;  // 计算新的进位
      }

      if (t)  // 最高位还有进位
        digits.push_back(t);

      std::reverse(digits.begin(), digits.end());  // 还原数组顺序
      return digits;
    }
};

Add Binary

Mon, 10 Feb 2025 00:00:00 +0000

67. 二进制求和

分析

字符串逆序遍历
- 为了方便从最低位到最高位逐位相加，首先将 a 和 b 字符串进行反转
逐位相加
- 维护进位变量 t，依次对 a 和 b 的每一位进行相加：
  - 若当前索引在 a 范围内，则加上 a[i] - '0'
  - 若当前索引在 b 范围内，则加上 b[i] - '0'
  - 将当前位结果 t % 2 转为字符加入结果字符串 c
  - 更新进位 t /= 2
处理多余进位
- 当遍历完两个字符串后，若仍有进位，则继续加入结果字符串
结果反转
- 将结果字符串 c 反转回正序，即为最终答案

时间复杂度

时间复杂度 O(max(m, n))，其中 m 和 n 分别为字符串 a 和 b 的长度

空间复杂度

空间复杂度为 O(max(m, n))

C++代码

class Solution
{
public:
    string addBinary(string a, string b)
    {
        // 反转字符串以方便从低位开始计算
        std::reverse(a.begin(), a.end());
        std::reverse(b.begin(), b.end());

        std::string c;
        for (int i = 0, t = 0; i < a.size() || i < b.size() || t; ++i)
        {
            // 加上 a 和 b 当前位的数值
            if (i < a.size()) t += a[i] - '0';
            if (i < b.size()) t += b[i] - '0';

            // 当前位结果加入结果字符串
            c += t % 2 + '0';

            // 更新进位
            t /= 2;
        }

        // 反转回正序
        std::reverse(c.begin(), c.end());
        return c;
    }
};

Nth Tribonacci Number

Mon, 06 Jan 2025 00:00:00 +0000

1137. 第N个泰波那契数

分析

状态转移：
- 当前值 T_n 由前三项的值 T_{n-1}、T_{n-2}、T_{n-3} 相加得出
初始化：
- a 表示 T_{n-3}
- b 表示 T_{n-2}
- c 表示 T_{n-1}
- 初始值为 a = 0、b = 1、c = 1
迭代计算：
- 按照递推公式依次计算 T_3 到 T_n，并更新 a、b、c 的值
返回结果：
- 经过 n 次迭代后，a 存储的就是第 n 个泰波那契数

时间复杂度

计算第 n 个泰波那契数需要迭代 n 次，每次计算仅涉及常数操作

时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int tribonacci(int n)
    {
        int a = 0, b = 1, c = 1; // 初始化 T0, T1, T2
        while (n--) // 循环 n 次，计算第 n 个泰波那契数
        {
            long long d = (long long)a + b + c; // 计算当前值
            a = b; // 更新 T(n-3) 为 T(n-2)
            b = c; // 更新 T(n-2) 为 T(n-1)
            c = d; // 更新 T(n-1) 为 T(n)
        }
        return a; // 返回结果
    }
};

Get Primes

Sat, 21 Dec 2024 00:00:00 +0000

筛质数

分析

定义全局变量：
- primes[N]：存储所有筛出的质数
- st[N]：标记每个数是否为合数（true 表示不是质数）
- cnt：统计质数数量
线性筛法（每个合数只会被它的最小质因子筛去一次）
- 遍历 i 从 2 到 n
- 如果 st[i] == false，说明 i 是质数，记录到 primes[cnt ++ ]
- 枚举当前已记录的质数 primes[j]
  - 将 primes[j] * i 标记为合数
  - 如果 i % primes[j] == 0，说明 primes[j] 是 i 的最小质因子，直接 break，防止重复标记
    - primes[j] 是 i 的最小质因子
    - 那么 primes[j] * i 的最小质因子仍然是 primes[j]
    - 如果继续用后面的 primes[k] 去乘 i，生成的 primes[k] * i 这个合数，其最小质因子可能不是 primes[k]，而是 primes[j]，违背线性筛只由最小质因子筛的原则

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度 O(n)

C++代码

#include <iostream>

const int N = 1000010;
int primes[N];  // 存储所有质数
bool st[N];     // st[i] 为 true 表示 i 是合数
int cnt = 0;    // 质数个数

void get_primes(int n)
{
  for (int i = 2; i <= n; ++ i)
  {
    if (!st[i])
      primes[cnt ++ ] = i;  // i 是质数，存入 primes
    for (int j = 0; primes[j] * i <= n; ++ j)
    {
      st[primes[j] * i] = true;  // 用质数 primes[j] 筛掉 i 的倍数
      if (i % primes[j] == 0) break;  // primes[j] 是 i 的最小质因子，跳出
    }
  }
}

int main()
{
  int n;
  std::cin >> n;

  get_primes(n);  // 筛出所有小于等于 n 的质数

  std::cout << cnt << '\n';  // 输出质数个数

  return 0;
}

Greatest Common Divisor Of Strings

Wed, 18 Dec 2024 00:00:00 +0000

1071. 字符串的最大公因子

分析

判断条件：
- 首先，字符串 str1 能否被 str2 整除以及 str2 能否被 str1 整除的关键条件是：str1 + str2 == str2 + str1
- 如果这个条件不成立，则不存在一个字符串能够同时整除这两个字符串，返回空字符串
最大公因子：
- 如果 str1 + str2 == str2 + str1，则可以根据字符串的长度来进一步判断最大公因子
- 假设 str1 的长度为 n1，str2 的长度为 n2，那么最大公因子字符串的长度应该是 gcd(n1, n2)
- 利用 gcd 函数计算出 n1 和 n2 的最大公因子，取 str1 或 str2 的前 gcd(n1, n2) 个字符作为最大公因子字符串

时间复杂度

字符串比较的时间复杂度是 O(n1 + n2)
gcd(n1, n2) 时间复杂度：O(log min(n1, n2))

总时间复杂度是 O(n1 + n2)

空间复杂度

空间复杂度 O(n1 + n2)

C++代码

class Solution
{
public:
    // 计算两个数的最大公因子
    int gcd(int a, int b)
    {
        return b ? gcd(b, a % b) : a;
    }

    // 返回能够同时整除 str1 和 str2 的最大公因子字符串
    string gcdOfStrings(string str1, string str2)
    {
        // 如果 str1 + str2 != str2 + str1，则不存在公共因子
        if (str1 + str2 != str2 + str1)
            return "";

        // 否则返回 str1 的前 gcd(str1.size(), str2.size()) 长度的子串
        return str1.substr(0, gcd(str1.size(), str2.size()));
    }
};

Great Common Divisor

Tue, 17 Dec 2024 00:00:00 +0000

最大公约数

分析

使用 **欧几里得算法（即辗转相除法）**来求两个数的最大公约数，其基本原理为：

当 b != 0 时，不断对 a % b 进行递归；
当 b == 0，说明余数为 0，返回的 a 就是最大公约数

时间复杂度

单次 gcd(a, b) 的时间复杂度为 O(log min(a, b))

所以总复杂度为 O(n * logN)，其中 N 为输入数据的最大值

空间复杂度

空间复杂度为 O(logN)

C++代码

#include <iostream>

// 欧几里得算法实现，递归方式求最大公约数
int gcd(int a, int b)
{
  return b ? gcd(b, a % b) : a; // 如果 b 不为 0，继续递归；否则返回 a
}

int main()
{
  int n;
  std::cin >> n; // 读入整数 n，表示有 n 对数字

  while (n -- )
  {
    int a, b;
    std::cin >> a >> b;         // 读入一对整数 a 和 b
    std::cout << gcd(a, b) << '\n'; // 输出这对数的最大公约数
  }

  return 0;
}