【C++笔试强训】day04

Fibonacci数列

思路

由于第i个数只依赖前两个数，所以只需要3个变量就可以迭代地计算，打一个斐波那契数的表，然后再查表。

代码

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    vector<int> v;
    int a = 0, b = 1, c = 0;
    v.push_back(a);
    while (c <= 1000000)
    {
        v.push_back(c);
        c = a + b;
        a = b;
        b = c;
    }
    while (cin >> n)
    {
        int len = INT_MAX;
        for (auto&e : v) len = min(len, abs(n - e));
        cout << len << endl;
    }
    return 0;
}

• 时间复杂度：$O(n)$。

如果要优化的话，可以用二分找到第一个不小于 n 的元素的位置，比较 n 与这个元素及其前一个元素的差值，找到最小的差值。

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    vector<int> v;
    int a = 0, b = 1, c = 0;
    v.push_back(a);
    while (c <= 1000000)
    {
        v.push_back(c);
        c = a + b;
        a = b;
        b = c;
    }

    while (cin >> n)
    {
        auto it = lower_bound(v.begin(), v.end(), n);
        int len = INT_MAX;
        // 检查it及其前一个位置的值
        if (it != v.end())
            len = min(len, abs(n - *it));
        if (it != v.begin())
            len = min(len, abs(n - *(--it)));
        cout << len << endl;
    }
    return 0;
}

• 时间复杂度：$O(logn)$。

单词搜索

DFS

思路：

• 参数包括当前坐标 (i, j) 和当前匹配到单词的第 k 个字符。
• 边界条件检查：如果当前坐标越界或者当前字符不匹配，返回 false。
• 如果当前匹配到单词的最后一个字符，返回 true。
• 将当前单元格标记为已访问，防止重复使用。
• 递归检查上下左右四个方向的单元格是否可以匹配单词的下一个字符。
• 恢复当前单元格的值，回溯以便其他路径可以再次使用该单元格。
• 返回四个方向的递归结果的逻辑或（只要有一个方向可以继续，那就认为找到下一个单词）。

注意要遍历棋盘的每一个单元格作为起始点。

代码

class Solution
{
public:
    bool exist(vector<string> &board, string word)
    {
        int n = board.size(), m = board[0].size();
        function<bool(int, int, int)> dfs = [&](int i, int j, int k) -> bool
        {
            // 边界条件检查和字符匹配检查
            if (i < 0 || i == n || j < 0 || j == m || board[i][j] != word[k])
                return false;
            // 如果匹配到单词的最后一个字符，返回true
            if (k == word.size() - 1) return true;
            // 将当前单元格标记为已访问
            board[i][j] = '\0';
            // 递归检查上下左右四个方向
            bool res = dfs(i - 1, j, k + 1) ||
                       dfs(i + 1, j, k + 1) ||
                       dfs(i, j - 1, k + 1) ||
                       dfs(i, j + 1, k + 1);
            // 恢复当前单元格的值
            board[i][j] = word[k];
            return res;
        };
        // 遍历棋盘的每一个单元格作为起始点
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                // 如果找到单词，返回true
                if (dfs(i, j, 0)) return true;
        return false;
    }
};

• 时间复杂度：$O(4^{L}nm)$。其中 $L$ 是单词的长度。在最坏情况下，所有单元格都会被遍历一次，并且每个单元格会尝试 $4^L$ 种可能的路径。

杨辉三角

注意打印格式。

#include <iostream>
using namespace std;
const int N = 31;
int a[N][N];

int main()
{
    for (int i = 0; i < N; i++)
        a[i][i] = 1, a[i][0] = 1;
    for (int i = 2; i < N; i++)
        for (int j = 1; j < i; j++)
            a[i][j] = a[i - 1][j] + a[i - 1][j - 1];
    int n;
    while (cin >> n)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j <= i; j++)
                printf("%5d", a[i][j]);
            cout << endl;
        }  
    }
    return 0;
}