diff --git a/solutions/43. Multiply Strings.md b/solutions/43. Multiply Strings.md
new file mode 100644
index 0000000..4818285
--- /dev/null
+++ b/solutions/43. Multiply Strings.md	
@@ -0,0 +1,138 @@
+# [43. Multiply Strings](https://leetcode.com/problems/multiply-strings/)
+# 思路
+题目要求实现大整数乘法。   
+## 思路一
+最直观的思路，就是是我们小学学的两数相乘的方法。回忆一下小学求456x123的过程:
+```
+        456
+      x 123
+    -------
+       1368  ->   1238 
+       921.  ->   9210
+    + 456..  ->  45600 
+    ------------------
+               = 56088
+```
+
+即分成两个大步：
+1. 求123中每个数字3、2、1分别对456的乘积1368、921和456；
+2. 将上面得到的乘积相加（注意合理插入一些0）得最终结果56088。
+
+我们将上面这两步定义成两个函数`digit_mul_reversed_bigNum`和`reversed_bigNum_add`，具体定义见代码详细解释。
+> 为了方便处理，将所有用string表示的大数做了翻转处理，即123 -> "321"。
+
+若m和n分别代表两个大数的长度，则易知时间复杂度O(mn)，空间复杂度O(m+n)。
+
+
+## 思路二
+虽然思路一很好想，但是实现起来略显复杂，而且需要先对字符串进行翻转，因此时间效率比较低。有没有elegant一点的方法？
+
+我们知道，位数分别为len1和len2的两整数相乘，结果的位数不会超过len1 + len2（例如99 x 999 < 100 x 1000 = 100000），所以一开始我们可以开一个大小为len1 + len2的数组来存放这个乘积。而且，对于num1和num2中的每一个数字，我们都知道这两个数字的积对应于前面数组的哪一位，例如num1=456，num2=123时，6和3相乘结果对应于最终乘积的最末位(同时有个进位)，5与3的相乘结果对应于最终结果的倒数第二位(也有个进位)，以此类推。所以我们有如下算法:   
+
+1. 首先开一个大小为len1 + len2的int型数组res_num并初始化为0；   
+2. 对num1和num2做一个双重循环从后向前(即i、j的初始值分别为len1-1、len2-1)遍历，当前位置的两个数字相乘的结果对应res_num中的位置是`i+j+1`（例如初始时i=len1-1，j=len2-1，对应的就是len1+len2-1），所以应该`num_res[i + j + 1] += (num1[i] - '0') * (num2[j] - '0');`
+3. 处理进位，使num_res每一个元素都位于0到9，我们也可以在第2步同时处理进位，但是单独处理的话计算量会小一些。
+4. 到目前位置我们就得到了数值型的结果，再转换成string即可，注意跳过前导0。
+
+时间复杂度O(mn)，空间复杂度O(m+n)。
+
+
+# C++
+## 思路一
+``` C++
+class Solution {
+private:
+    string digit_mul_reversed_bigNum(const int &dt, const string &bN, int lead_0){
+        /*第1步：求一个数字(0-9)与一个大数的乘积。
+        bN: 翻转后的大数，例如bN="321"代表123
+        lead_0: 结果中前面先插入的0的个数 
+        return: 乘积(同样是翻转了的，即"0129"代表9210)
+        */
+        if(!dt) return "0";
+        if(bN.size() == 1 && bN[0] == '0') return "0";
+        string res;
+        while(lead_0--) res += '0'; // 插入0
+        int mul, cin = 0; // cin表示进位，下同
+        for(int i = 0; i < bN.size(); i++){
+            mul = dt * (bN[i] - '0') + cin;
+            res += (mul % 10 + '0');
+            cin = mul / 10;
+        }
+        if(cin > 0) res += (cin + '0');
+        return res;
+    }
+    void reversed_bigNum_add(string &a, const string &b){ // a+=b
+        /*第2步: 将第1步求得的乘积累加起来，a和b都是翻转后的大数
+        注意 a 传入的是引用
+        */
+        int sum, cin = 0;
+        int i = 0, len1 = a.size(), len2 = b.size();
+        while(i < len1 && i < len2){ // 大数加法
+            sum  = a[i] - '0' + b[i] - '0' + cin;
+            a[i] = sum % 10 + '0';
+            cin = sum / 10;
+            i++;
+        }
+        // 下面两个while至多执行一个
+        while(i < len1 && cin > 0){ // a 比 b 长
+            sum = a[i] - '0' + cin;
+            a[i] = sum % 10 + '0';
+            cin = sum / 10;
+            i++;
+        }
+        while(i < len2){ // b 比 a 长
+            if(!cin){ // 如果cin=0，那么直接将b的剩余部分接到a后面即可
+                a.append(b, i, len2);
+                break;
+            }
+            sum = b[i] - '0' + cin;
+            a += (sum % 10 + '0');
+            cin = sum / 10;
+            i++;
+        }
+        if(cin > 0) a += (cin + '0');
+    }
+public:
+    string multiply(string num1, string num2) {
+        reverse(num1.begin(), num1.end());
+        reverse(num2.begin(), num2.end());
+        string res, tmp;
+        for(int i = 0; i < num1.size(); i++){
+            tmp = digit_mul_reversed_bigNum(num1[i]-'0', num2, i);
+            reversed_bigNum_add(res, tmp);
+        }
+        reverse(res.begin(), res.end());
+        if(res.empty()) return "0";
+        return res;
+    }
+};
+```
+
+## 思路二
+``` C++
+class Solution {
+public:
+    string multiply(string num1, string num2) {
+        int len1 = num1.size(), len2 = num2.size();
+        string res;
+        int num_res[len1 + len2] = {0};
+        for(int i = len1 - 1; i >= 0; i--){
+            for(int j = len2 - 1; j >= 0; j--){
+                num_res[i + j + 1] += (num1[i] - '0') * (num2[j] - '0');
+                // num_res[i + j + 1] += num_res[i + j + 2] / 10;
+                // num_res[i + j + 2] %= 10;
+            }
+        }
+        for(int i = len1 + len2 - 1; i > 0; i--){ // 处理进位
+            num_res[i - 1] += num_res[i] / 10;
+            num_res[i] %= 10;
+        }
+        
+        int i = 0;
+        while(i < len1 + len2 && !num_res[i]) i++; // 跳过前导0
+        while(i < len1 + len2) res += num_res[i++] + '0';        
+        if(res.empty()) return "0";
+        return res;
+    }
+};
+```
\ No newline at end of file