code_offer

Author: AnandrewChan

Search/17.letter-combinations-of-a-phone-number.cpp

@@ -32,21 +32,18 @@
  * in any order you want.
  * 
  */
-class Solution
-{
-  public:
+class Solution {
+public:
     vector<string> letterCombinations(string digits)
     {
         if (digits.empty())
             return {};
-        vector<string> an{""};
-        string dict[] = {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
-        for (int i = 0; i < digits.size(); i++)
-        {
+        vector<string> an{ "" };
+        string dict[] = { "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz" };
+        for (int i = 0; i < digits.size(); i++) {
             vector<string> t;
             string str = dict[digits[i] - '2'];
-            for (int j = 0; j < str.size(); j++)
-            {
+            for (int j = 0; j < str.size(); j++) {
                 for (string s : an)
                     t.push_back(s + str[j]);
             }

Search/[O]39.combination-sum.cpp

@@ -14,73 +14,69 @@
  * Given a set of candidate numbers (candidates) (without duplicates) and a
  * target number (target), find all unique combinations in candidates where the
  * candidate numbers sums to target.
- * 
+ *
  * The same repeated number may be chosen from candidates unlimited number of
  * times.
- * 
+ *
  * Note:
- * 
- * 
+ *
+ *
  * All numbers (including target) will be positive integers.
  * The solution set must not contain duplicate combinations.
- * 
- * 
+ *
+ *
  * Example 1:
- * 
- * 
+ *
+ *
  * Input: candidates = [2,3,6,7], target = 7,
  * A solution set is:
  * [
  * ⁠ [7],
  * ⁠ [2,2,3]
  * ]
- * 
- * 
+ *
+ *
  * Example 2:
- * 
- * 
+ *
+ *
  * Input: candidates = [2,3,5], target = 8,
  * A solution set is:
  * [
  * [2,2,2,2],
  * [2,3,3],
  * [3,5]
  * ]
- * 
- * 
+ *
+ *
  */
 
 /*
 Runtime: 92 ms
 Memory Usage: 21.8 MB
 */
-class Solution
-{
-  public:
-    void search(vector<int> &candidates, int pos, int target, vector<int> temp, vector<vector<int>> &an)
+class Solution {
+public:
+    void search(vector<int>& candidates, int pos, int target, vector<int> temp,
+        vector<vector<int>>& an)
     {
-        if (target == 0)
-        {
+        if (target == 0) {
             an.push_back(temp);
             return;
         }
         if (pos >= candidates.size())
             return;
         int c = target / candidates[pos];
-        for (int i = 0; i <= c; i++)
-        {
-            for (int j = 0; j < i; j++)
-            {
+        for (int i = 0; i <= c; i++) {
+            for (int j = 0; j < i; j++) {
                 temp.push_back(candidates[pos]);
             }
             search(candidates, pos + 1, target - i * candidates[pos], temp, an);
-            for (int j = 0; j < i; j++)
-            {
+            for (int j = 0; j < i; j++) {
                 temp.pop_back();
             }
         }
     }
-    vector<vector<int>> combinationSum(vector<int> &candidates, int target)
+    vector<vector<int>> combinationSum(vector<int>& candidates, int target)
     {
         sort(candidates.begin(), candidates.end());
         vector<int> temp;

code_offer/10_Fibonacci.cpp

@@ -0,0 +1,150 @@
+/*******************************************************************
+Copyright(c) 2016, Harry He
+All rights reserved.
+
+Distributed under the BSD license.
+(See accompanying file LICENSE.txt at
+https://github.com/zhedahht/CodingInterviewChinese2/blob/master/LICENSE.txt)
+*******************************************************************/
+
+//==================================================================
+// 《剑指Offer——名企面试官精讲典型编程题》代码
+// 作者：何海涛
+//==================================================================
+
+// 面试题10：斐波那契数列
+// 题目：写一个函数，输入n，求斐波那契（Fibonacci）数列的第n项。
+
+#include <cstdio>
+
+// ====================方法1：递归====================
+long long Fibonacci_Solution1(unsigned int n)
+{
+    if (n <= 0)
+        return 0;
+
+    if (n == 1)
+        return 1;
+
+    return Fibonacci_Solution1(n - 1) + Fibonacci_Solution1(n - 2);
+}
+
+// ====================方法2：循环====================
+long long Fibonacci_Solution2(unsigned n)
+{
+    int result[2] = { 0, 1 };
+    if (n < 2)
+        return result[n];
+
+    long long fibNMinusOne = 1;
+    long long fibNMinusTwo = 0;
+    long long fibN = 0;
+    for (unsigned int i = 2; i <= n; ++i) {
+        fibN = fibNMinusOne + fibNMinusTwo;
+
+        fibNMinusTwo = fibNMinusOne;
+        fibNMinusOne = fibN;
+    }
+
+    return fibN;
+}
+
+// ====================方法3：基于矩阵乘法====================
+#include <cassert>
+
+struct Matrix2By2 {
+    Matrix2By2(
+        long long m00 = 0,
+        long long m01 = 0,
+        long long m10 = 0,
+        long long m11 = 0)
+        : m_00(m00)
+        , m_01(m01)
+        , m_10(m10)
+        , m_11(m11)
+    {
+    }
+
+    long long m_00;
+    long long m_01;
+    long long m_10;
+    long long m_11;
+};
+
+Matrix2By2 MatrixMultiply(
+    const Matrix2By2& matrix1,
+    const Matrix2By2& matrix2)
+{
+    return Matrix2By2(
+        matrix1.m_00 * matrix2.m_00 + matrix1.m_01 * matrix2.m_10,
+        matrix1.m_00 * matrix2.m_01 + matrix1.m_01 * matrix2.m_11,
+        matrix1.m_10 * matrix2.m_00 + matrix1.m_11 * matrix2.m_10,
+        matrix1.m_10 * matrix2.m_01 + matrix1.m_11 * matrix2.m_11);
+}
+
+Matrix2By2 MatrixPower(unsigned int n)
+{
+    assert(n > 0);
+
+    Matrix2By2 matrix;
+    if (n == 1) {
+        matrix = Matrix2By2(1, 1, 1, 0);
+    } else if (n % 2 == 0) {
+        matrix = MatrixPower(n / 2);
+        matrix = MatrixMultiply(matrix, matrix);
+    } else if (n % 2 == 1) {
+        matrix = MatrixPower((n - 1) / 2);
+        matrix = MatrixMultiply(matrix, matrix);
+        matrix = MatrixMultiply(matrix, Matrix2By2(1, 1, 1, 0));
+    }
+
+    return matrix;
+}
+
+long long Fibonacci_Solution3(unsigned int n)
+{
+    int result[2] = { 0, 1 };
+    if (n < 2)
+        return result[n];
+
+    Matrix2By2 PowerNMinus2 = MatrixPower(n - 1);
+    return PowerNMinus2.m_00;
+}
+
+// ====================测试代码====================
+void Test(int n, int expected)
+{
+    if (Fibonacci_Solution1(n) == expected)
+        printf("Test for %d in solution1 passed.\n", n);
+    else
+        printf("Test for %d in solution1 failed.\n", n);
+
+    if (Fibonacci_Solution2(n) == expected)
+        printf("Test for %d in solution2 passed.\n", n);
+    else
+        printf("Test for %d in solution2 failed.\n", n);
+
+    if (Fibonacci_Solution3(n) == expected)
+        printf("Test for %d in solution3 passed.\n", n);
+    else
+        printf("Test for %d in solution3 failed.\n", n);
+}
+
+int main(int argc, char* argv[])
+{
+    Test(0, 0);
+    Test(1, 1);
+    Test(2, 1);
+    Test(3, 2);
+    Test(4, 3);
+    Test(5, 5);
+    Test(6, 8);
+    Test(7, 13);
+    Test(8, 21);
+    Test(9, 34);
+    Test(10, 55);
+
+    Test(40, 102334155);
+
+    return 0;
+}

code_offer/11_MinNumberInRotatedArray.cpp

@@ -0,0 +1,121 @@
+/*******************************************************************
+Copyright(c) 2016, Harry He
+All rights reserved.
+
+Distributed under the BSD license.
+(See accompanying file LICENSE.txt at
+https://github.com/zhedahht/CodingInterviewChinese2/blob/master/LICENSE.txt)
+*******************************************************************/
+
+//==================================================================
+// 《剑指Offer——名企面试官精讲典型编程题》代码
+// 作者：何海涛
+//==================================================================
+
+// 面试题11：旋转数组的最小数字
+// 题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
+// 输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如数组
+// {3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。
+
+#include <cstdio>
+#include <exception>
+
+int MinInOrder(int* numbers, int index1, int index2);
+
+int Min(int* numbers, int length)
+{
+    if (numbers == nullptr || length <= 0)
+        throw new std::exception("Invalid parameters");
+
+    int index1 = 0;
+    int index2 = length - 1;
+    int indexMid = index1;
+    while (numbers[index1] >= numbers[index2]) {
+        // 如果index1和index2指向相邻的两个数，
+        // 则index1指向第一个递增子数组的最后一个数字，
+        // index2指向第二个子数组的第一个数字，也就是数组中的最小数字
+        if (index2 - index1 == 1) {
+            indexMid = index2;
+            break;
+        }
+
+        // 如果下标为index1、index2和indexMid指向的三个数字相等，
+        // 则只能顺序查找
+        indexMid = (index1 + index2) / 2;
+        if (numbers[index1] == numbers[index2] && numbers[indexMid] == numbers[index1])
+            return MinInOrder(numbers, index1, index2);
+
+        // 缩小查找范围
+        if (numbers[indexMid] >= numbers[index1])
+            index1 = indexMid;
+        else if (numbers[indexMid] <= numbers[index2])
+            index2 = indexMid;
+    }
+
+    return numbers[indexMid];
+}
+
+int MinInOrder(int* numbers, int index1, int index2)
+{
+    int result = numbers[index1];
+    for (int i = index1 + 1; i <= index2; ++i) {
+        if (result > numbers[i])
+            result = numbers[i];
+    }
+
+    return result;
+}
+
+// ====================测试代码====================
+void Test(int* numbers, int length, int expected)
+{
+    int result = 0;
+    try {
+        result = Min(numbers, length);
+
+        for (int i = 0; i < length; ++i)
+            printf("%d ", numbers[i]);
+
+        if (result == expected)
+            printf("\tpassed\n");
+        else
+            printf("\tfailed\n");
+    } catch (...) {
+        if (numbers == nullptr)
+            printf("Test passed.\n");
+        else
+            printf("Test failed.\n");
+    }
+}
+
+int main(int argc, char* argv[])
+{
+    // 典型输入，单调升序的数组的一个旋转
+    int array1[] = { 3, 4, 5, 1, 2 };
+    Test(array1, sizeof(array1) / sizeof(int), 1);
+
+    // 有重复数字，并且重复的数字刚好的最小的数字
+    int array2[] = { 3, 4, 5, 1, 1, 2 };
+    Test(array2, sizeof(array2) / sizeof(int), 1);
+
+    // 有重复数字，但重复的数字不是第一个数字和最后一个数字
+    int array3[] = { 3, 4, 5, 1, 2, 2 };
+    Test(array3, sizeof(array3) / sizeof(int), 1);
+
+    // 有重复的数字，并且重复的数字刚好是第一个数字和最后一个数字
+    int array4[] = { 1, 0, 1, 1, 1 };
+    Test(array4, sizeof(array4) / sizeof(int), 0);
+
+    // 单调升序数组，旋转0个元素，也就是单调升序数组本身
+    int array5[] = { 1, 2, 3, 4, 5 };
+    Test(array5, sizeof(array5) / sizeof(int), 1);
+
+    // 数组中只有一个数字
+    int array6[] = { 2 };
+    Test(array6, sizeof(array6) / sizeof(int), 2);
+
+    // 输入nullptr
+    Test(nullptr, 0, 0);
+
+    return 0;
+}