Given two numbers represented as strings, return multiplication of the numbers as a string.
Note: The numbers can be arbitrarily large and are non-negative.
第一眼看到这个题目，潜意识里觉得直接将字符串转换为数字相乘，然后将结果再转换为字符串，难道这题考的是字符串与数值之间的转换？
细看，发现数字可能非常大，那么问题来了：这个数据类型怎么定义呢？显然这种思路完全是错的了。
那么怎么解决这个问题呢？仔细一想问题可能在于如何理解这个乘法过程（题目中multiply可是关键字）了。由于经验尚浅，花了一些时间去琢磨，最后参照一些资料做出了如下分析：（算法题还是有很多值得用心思考的地方的，要学会抓住解决问题的痛点，和把握细节）
1、要模拟竖式乘法的计算过程（透过问题看本质）
2、这个过程有乘法思维，还有加法思维在里面（因为涉及到进位）
3、要把乘法和加法操作过程分清楚，每次一个新位与被乘数相乘之前，都要加上进位再处理。（注意细节）
4、为了顺应习惯，把两个数字reverse过来再操作，最后还原顺序。
代码如下：
class Solution {public:string multiply(string num1, string num2) { int m = num1.size(), n = num2.size();//字符串元素个数 if (num1 == "0" || num2 == "0") return "0"; vector res(m+n, 0); reverse(begin(num1),end(num1));//字符串反转 reverse(begin(num2),end(num2)); for (int i = 0; i < n; ++i) for (int idx = i, j = 0; j < m; ++j) res[idx++] += (num2[i]-'0')*(num1[j]-'0');// 字符转化为数字然后相乘（ascll码） int carry = 0; for (int i = 0; i < m+n; ++i) { int tmp = res[i]; res[i] = (tmp+carry)%10; carry = (tmp+carry)/10;//进位 } string str(m+n,'0'); for (int k = 0, i = res.size()-1; i >= 0; --i) str[k++] = res[i]+'0';//还原顺序 auto idx = str.find_first_not_of('0');//将str字符串中第一个不匹配字符‘0’的索引值赋给idx return str.substr(idx);//从起始字符序号idx开始取得str中的子字符串(消除了前面的0)}}; 其他解法：
1、 class Solution {public:string multiply(string num1, string num2) { string sum(num1.size() + num2.size(), '0'); for (int i = num1.size() - 1; 0 <= i; --i) { int carry = 0; for (int j = num2.size() - 1; 0 <= j; --j) { int tmp = (sum[i + j + 1] - '0') + (num1[i] - '0') * (num2[j] - '0') + carry; sum[i + j + 1] = tmp % 10 + '0'; carry = tmp / 10; } sum[i] += carry; } size_t startpos = sum.find_first_not_of("0"); if (string::npos != startpos) { return sum.substr(startpos); } return "0";}};
This is an example of the pretty straightforward but very efficient C++ solution with 8ms runtime on OJ. It seems most of people here implemented solutions with base10 arithmetic, however that is suboptimal. We should use a different base.
This was a hint. Now stop, think, and consider coding your own solution before reading the spoiler below.
The idea used in the algorithm below is to interpret number as number written in base 1 000 000 000 as we decode it from string. Why 10^9? It is max 10^n number which fits into 32-bit integer. Then we apply the same logic as we used to hate in school math classes, but on digits which range from 0 to 10^9-1.
You can compare the multiplication logic in other posted base10 and this base1e9 solutions and you'll see that they follow exactly same pattern.
Note, that we have to use 64-bit multiplication here and the carry has to be a 32-bit value as well
class Solution {public: void toBase1e9(const string& str, vector & out) { int i = str.size() - 1; uint32_t v = 0; uint32_t f = 1; do { int n = str[i] - '0'; v = v + n * f; if (f == 100000000) { out.push_back(v); v = 0; f = 1; } else { f *= 10; } i--; } while (i >= 0); if (f != 1) { out.push_back(v); } } string fromBase1e9(const vector & num) { stringstream s; for (int i = num.size() - 1; i >= 0; i--) { s << num[i]; s << setw(9) << setfill('0'); } return s.str(); } string multiply(string num1, string num2) { if (num1.size() == 0 || num2.size() == 0) return "0"; vector d1; toBase1e9(num1, d1); vector d2; toBase1e9(num2, d2); vector result; for (int j = 0; j < d2.size(); j++) { uint32_t n2 = d2[j]; int p = j; uint32_t c = 0; for (int i = 0; i < d1.size(); i++) { if (result.size() <= p) result.push_back(0); uint32_t n1 = d1[i]; uint64_t r = n2; r *= n1; r += result[p]; r += c; result[p] = r % 1000000000; c = r / 1000000000; p++; } if (c) { if (result.size() <= p) result.push_back(0); result[p] = c; } } return fromBase1e9(result); }};