墨奇科技（北京）有限公司的软件工程师 - C++ 开发 笔试题解

1. 给五张牌，看能否组成顺子。0可以任意替代1~13中的值。
   题解：判断两个：

• 不是0的值中是否有相同的牌；
• 不是0的值中，最大值和最小值的差是否小于等于4。

class Solution {
public:
    bool IsContinuous( vector<int> numbers ) {
        int n = numbers.size();
        int isSame = false;
        //是否有相同
        for (int i = 0; i < n; i++) {
            if (numbers[i] != 0) {
                for (int j = 0; j < n; j++) {
                    if ( numbers[j] != 0 && i != j) {
                        if (numbers[i] == numbers[j]) {
                            isSame = true;
                        }
                    }
                }
            }
        }
        if (isSame) return false;
        
        //差不超过4
        int mx = 0, mn = 13;
        for (int i = 0; i < n; i++) {
            if (numbers[i] != 0) {
                mx = max(mx, numbers[i]);
                mn = min(mn, numbers[i]);
            }
        }
        if (mx - mn > 4) return false;
        return true;
    }
};

2. 给定一个字符串($N\le 10000$)，返回最长的重复字符子串，重复字符子串是指有两个相同的字符串首尾拼接而成。
   解：第一重循环枚举最大长度，第二重循环枚举起始位置，这样字符串就确定了。第三重循环判断是否是重复字符子串。
   最坏可能达到$O(N^3)$，但是因为判断是否是重复字符子串比较快，且只求最长的，所以效果不会那么差。

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param a string字符串 待计算字符串
     * @return int整型
     */
    int solve(string a) {
        // write code here
        int n = a.length();
        //abcd
        //0->4
        for (int len = n/2*2; len >= 2; len -= 2) {
            for (int i = 0; i < n; i++) {
                if (i + len - 1 >= n) break;
                int flag = 0;
                for (int j = 0; j < len / 2; j++) {
                    if (a[i + j] != a[i + j + len/2]) {
                        flag=1;
                        break;
                    }
                }
                if (flag == 0) return len;
            }
        }
        return 0;
    }
}; 

3. 给出一棵树的前序遍历和中序遍历，请构造这颗二叉树。
   递归：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param preorder int整型vector 
     * @param inorder int整型vector 
     * @return TreeNode类
     */
    TreeNode* dfs(vector<int>&preorder, vector<int>&inorder, int prel, int prer, int inl, int inr) {
        if (prel > prer) return NULL;
        TreeNode* root = new TreeNode(preorder[prel]);
        
        int i;
        for (i = inl; i <= inr; i++) {
            if (inorder[i] == preorder[prel]) {
                break;
            }
        }
        root->left = dfs(preorder, inorder, prel + 1, prel + (i - inl), inl, i - 1);
        root->right = dfs(preorder, inorder, prel + (i - inl) + 1, prer , i + 1, inr);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        // write code here
        int n = preorder.size();
        return dfs(preorder, inorder, 0, n-1, 0, n-1);
    }
};