leetcode 字節跳動模擬面試編程題（持續更新~）

模擬一

第一題  字符串中的單詞個數(簡單)

統計字符串中的單詞個數，這裏的單詞指的是連續的不是空格的字符。

請注意，你可以假定字符串裏不包括任何不可打印的字符。

示例:

輸入: "Hello, my name is John"
輸出: 5

 

 題解：注意開頭的空格。然後就一直while判斷就行了，看看有多少個被空格間隔的單詞。

 

參考代碼：

class Solution {
public:
    int countSegments(string s) {
        int len=s.length();
        int ans=0,i=0;
        if(len==0) return 0;
        while(i<len)
        {
            while(s[i]==' ' && i<len) ++i;
            
            if(s[i]!=' ' && i<len)
            {
                while(s[i]!=' ' && i<len) ++i;
                ans++;
            }
        }
        return ans;
    }
};

 

第二題 兩數相加 II(中等)

給定兩個非空鏈表來代表兩個非負整數。數字最高位位於鏈表開始位置。它們的每個節點只存儲單個數字。將這兩數相加會返回一個新的鏈表。

 

你可以假設除了數字 0 之外，這兩個數字都不會以零開頭。

進階:

如果輸入鏈表不能修改該如何處理？換句話說，你不能對列表中的節點進行翻轉。

示例:

輸入: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
輸出: 7 -> 8 -> 0 -> 7

題解：

　　將兩個鏈表反轉之後，按照位置加即可，設置一個進位add;

參考代碼：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode *l1, ListNode *l2) {
        ListNode* tmp = new ListNode(-1), *cur = tmp;
        int cnt = 0;
        l1 = reverseList(l1);
        l2 = reverseList(l2);
        while (l1 || l2) {
            int val1 = l1 ? l1 -> val : 0;
            int val2 = l2 ? l2 -> val : 0;
            int sum = val1 + val2 + cnt;
            cnt = sum / 10;
            cur -> next = new ListNode(sum % 10);
            cur = cur -> next;
            if (l1) l1 = l1 -> next;
            if (l2) l2 = l2 -> next;
        }
        if (cnt) cur -> next = new ListNode(1);
        return reverseList(tmp -> next);
    }

    ListNode* reverseList(ListNode *head) {
        if (!head) return head;
        ListNode* dummy = new ListNode(-1);
        dummy -> next = head;
        ListNode* cur = head;
        while (cur -> next) {
            ListNode *tmp = cur -> next;
            cur -> next = tmp -> next;
            tmp -> next = dummy -> next;
            dummy -> next = tmp;
        }
        return dummy -> next;
    }
};

 

第三題 最小區間(困難)

你有 k 個升序排列的整數數組。找到一個最小區間，使得 k 個列表中的每個列表至少有一個數包含在其中。

我們定義如果 b-a < d-c 或者在 b-a == d-c 時 a < c，則區間 [a,b] 比 [c,d] 小。

示例 1:

輸入:[[4,10,15,24,26], [0,9,12,20], [5,18,22,30]]
輸出: [20,24]
解釋: 
列表 1：[4, 10, 15, 24, 26]，24 在區間 [20,24] 中。
列表 2：[0, 9, 12, 20]，20 在區間 [20,24] 中。
列表 3：[5, 18, 22, 30]，22 在區間 [20,24] 中。

注意:

1. 給定的列表可能包含重複元素，所以在這裏升序表示 >= 。
2. 1 <= k <= 3500
3. -105 <= 元素的值 <= 105
4. 對於使用Java的用戶，請注意傳入類型已修改爲List<List<Integer>>。重置代碼模板後可以看到這項改動。

題解：

使用優先隊列（小頂堆），首先將k個數組的第一個元素加入隊列，並記錄最大值。然後用最大值-堆頂元素（即最小值）去更新答案。然後把堆頂的元素所在數組的指針向後移，如果已經到達數組末尾則跳出循環，輸出答案。

參考代碼：

class node {
public:
    int row;
    int col;
    int val;
    node(int ir, int ic, int iv) {
        row = ir;
        col = ic;
        val = iv;
    }
};

class cmp {
public:
    bool operator() (const node &lhs, const node &rhs) {
        return lhs.val > rhs.val;
    }
};

class Solution {
public:
    vector<int> smallestRange(vector<vector<int>>& nums) {
        priority_queue<node, vector<node>, cmp> pqn;
        const int k = nums.size();
        int max = -INT_MAX;
        for (int i = 0; i < k; i++) {
            if (nums[i][0] > max) {
                max = nums[i][0];
            }
            pqn.push(node(i, 0, nums[i][0]));            
        }
        int lret = 0;
        int rret = INT_MAX;
        bool has_next = true;
        do {
            auto min = pqn.top();
            pqn.pop();
            //cout << min.val << "," << max << endl;
            if (max - min.val < rret - lret) {
                lret = min.val;
                rret = max;
            }
            min.col++;
            if (min.col >= nums[min.row].size()) {
                has_next = false;
            } else {
                min.val = nums[min.row][min.col];
                if (max < min.val)
                    max = min.val;
                pqn.push(min);
            }
        } while(has_next);
        return {lret, rret};
    }
};

 

模擬二

第一題 重複的DNA序列(中等)

所有 DNA 都由一系列縮寫爲 A，C，G 和 T 的核苷酸組成，例如：“ACGAATTCCG”。在研究 DNA 時，識別 DNA 中的重複序列有時會對研究非常有幫助。

編寫一個函數來查找 DNA 分子中所有出現超過一次的 10 個字母長的序列（子串）。

 

示例：

輸入：s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
輸出：["AAAAACCCCC", "CCCCCAAAAA"]

題解：bitset; 因爲只有4個字符，所以可以把字符對應爲數字。然後兩個bitset,判斷是否出現過，和是否插入到答案集合。

 

參考代碼：

class Solution {
public:
   int charToBit(char c){
        switch (c){
            case 'A': return 0;
            case 'G': return 1;
            case 'C': return 2;
            case 'T': return 3;
        }
        return -1;  // never happened
    }

    vector<string> findRepeatedDnaSequences(string s) {
        vector<string> res;
        if(s.size() < 10) return res;
        bitset<1<<20> S1;
        bitset<1<<20> S2; // to avoid dulplication
        //init
        int val = 0;
        for(int i=0;i<10;i++){
            val = val << 2 | charToBit(s[i]);
        }
        S1.set(val);
        int mask = (1 << 20) - 1;
        for(int i=10;i<s.size();i++){
            val = ((val << 2) & mask) | charToBit(s[i]);
            if(S1[val]) {
                if (!S2[val]) {
                    res.push_back(s.substr(i - 9, 10));
                    S2.set(val);
                }
            }
            else{
                S1.set(val);
            }
        }
        return res;
    }
};

 

第二題 分割數組的最大值(困難)

給定一個非負整數數組和一個整數 m，你需要將這個數組分成 m 個非空的連續子數組。設計一個算法使得這 m 個子數組各自和的最大值最小。

注意:
數組長度 n 滿足以下條件:

• 1 ≤ n ≤ 1000
• 1 ≤ m ≤ min(50, n)

示例:

輸入:
nums = [7,2,5,10,8]
m = 2

輸出:
18

解釋:
一共有四種方法將nums分割爲2個子數組。
其中最好的方式是將其分爲[7,2,5] 和 [10,8]，
因爲此時這兩個子數組各自的和的最大值爲18，在所有情況中最小

題解：動態規劃。dp[i][j]:表示前i個數分成j個區間所能得到的最大值的最小值。

轉移方程爲：dp[i][j]=min(dp[i][j],max(dp[k][j-1],pre[i]-pre[j]));

 

參考代碼：

class Solution {
public:
    int splitArray(vector<int>& nums, int m) 
    {
        int n=nums.size();
        unsigned long long dp[n+2][m+2];
        memset(dp,127,sizeof(dp));
        unsigned long long sum[n+3];
        sum[0]=dp[0][0]=0;
        for(int i=1;i<=n;i++)
            sum[i]=sum[i-1]+nums[i-1];
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                for(int k=0;k<i;k++)
                {
                    dp[i][j]=min(dp[i][j],max(dp[k][j-1],sum[i]-sum[k]));
                }
            }
        }
        return dp[n][m];
    }
};

 

第三題 樹中距離之和(困難)

給定一個無向、連通的樹。樹中有 N 個標記爲 0...N-1 的節點以及 N-1 條邊 。

第 i 條邊連接節點 edges[i][0] 和 edges[i][1] 。

返回一個表示節點 i 與其他所有節點距離之和的列表 ans。

示例 1:

輸入: N = 6, edges = [[0,1],[0,2],[2,3],[2,4],[2,5]]
輸出: [8,12,6,10,10,10]
解釋: 
如下爲給定的樹的示意圖：
  0
 / \
1   2
   /|\
  3 4 5

我們可以計算出 dist(0,1) + dist(0,2) + dist(0,3) + dist(0,4) + dist(0,5) 
也就是 1 + 1 + 2 + 2 + 2 = 8。 因此，answer[0] = 8，以此類

題解：兩遍dfs。

第一次dfs出以0節點爲根的每個節點到根節點的間距離和每個節點的子節點數量。

第二次dfs,從根開始，它的子節點到所有節點的距離= ans[root] (當前節點的父節點到所有節點的距離) - count[i]（當前節點的子節點的數量，包含自己）+ size (所有節點的數量) -count[i];

 

參考代碼：

class Solution {
public:
     vector<unordered_set<int>> tree;
    vector<int> res, count;

    vector<int> sumOfDistancesInTree(int N, vector<vector<int>>& edges) {
        tree.resize(N);
        res.assign(N, 0);
        count.assign(N, 1);
        for (auto e : edges) {
            tree[e[0]].insert(e[1]);
            tree[e[1]].insert(e[0]);
        }
        dfs(0, -1);
        dfs2(0, -1);
        return res;

    }

    void dfs(int root, int pre) {
        for (auto i : tree[root]) {
            if (i == pre) continue;
            dfs(i, root);
            count[root] += count[i];
            res[root] += res[i] + count[i];
        }
    }

    void dfs2(int root, int pre) {
        for (auto i : tree[root]) {
            if (i == pre) continue;
            res[i] = res[root] - count[i] + count.size() - count[i];
            dfs2(i, root);
        }
    }
};