快手2019年秋季校园招聘笔试试卷—工程A试卷

a/b

题目描述

求 a/b 的小数表现形式。如果 a 可以整除 b 则不需要小数点。如果是有限小数，则可以直接输出。如果是无限循环小数，则需要把小数循环的部分用"()"括起来。

输入描述

两个整数a和b，其中

• 0 <= a <= 1000 000

• 1 <= b <= 10 000

输出描述

一个字符串，该分数的小数表现形式。

解题思路

当某个余数重复出现时，说明为无限循环小数。需要记录每个余数的位置。

代码实现

int main() {
    int a, b;
    scanf("%d%d", &a, &b);
    int x = 0;
    while (a >= b)x++, a -= b;
    if (a == 0) {
        printf("%d", x);
        return 0;
    }
    int idx = 0;
    string s;
    unordered_map<int, int> mp;
    while (a > 0 && mp.find(a) == mp.end()) {
        mp[a] = idx;
        a *= 10;
        s.append(to_string(a / b));
        a -= a / b * b, idx++;
    }
    if (a != 0) {
        idx = mp[a];
        s = s.substr(0, idx) + "(" + s.substr(idx) + ")";
    }
    s = to_string(x) + "." + s;
    printf("%s", s.c_str());
    return 0;
}

时间复杂度：$O(b)$，余数最多有 $b$ 个。

空间复杂度：$O(b)$。

善变的同伴

题目描述

又到了吃午饭的时间，你和你的同伴刚刚研发出了最新的GSS-483型自动打饭机器人，现在你们正在对机器人进行功能测试。

为了简化问题，我们假设午饭一共有N个菜，对于第i个菜，你和你的同伴对其定义了一个好吃程度（或难吃程度，如果是负数的话……）A[i]，
由于一些技（经）术（费）限制，机器人一次只能接受一个指令：两个数L, R——表示机器人将会去打第L~R一共R-L+1个菜。

本着不浪费的原则，你们决定机器人打上来的菜，含着泪也要都吃完，于是你们希望机器人打的菜的好吃程度之和最大。

然而，你善变的同伴希望对机器人进行多次测试（实际上可能是为了多吃到好吃的菜），他想知道机器人打M次菜能达到的最大的好吃程度之和。

当然，打过一次的菜是不能再打的，而且你也可以对机器人输入-1, -1，表示一个菜也不打。

输入描述

第一行：N, M。

第二行：A[1], A[2], …, A[N]。

输出描述

一个数字S，表示M次打菜的最大好吃程度之和。

解题思路

最大 $m$ 段字段和的变形。

令 $dp[i][j]$ = 将前 $i$ 项划分为 $j$ 段且第 $j$ 段包含第 $i$ 项的最大 $j$ 段和，则有

• 若 $a_i$ 单独作为一段，则 $dp[i][j]=max(dp[x][j-1])+a_i$，其中， $j-1\le x\le i-1$。
• 若 $a_i$ 与前项同在一段，则 $dp[i][j]=dp[i-1][j]+a_i$。

故 $dp[i][j]=max(dp[x][j-1],dp[i-1][j])+a_i$。

故，答案为 $max(dp[x][y])$。

代码实现

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    int a[n + 1], dp[n + 1][m + 1], res = 0;
    for (int i = 1; i <= n; ++i)
        scanf("%d", &a[i]);
    memset(dp, 0, sizeof dp);
    for (int i = 1; i <= n; i++) {
        for (int j = 1, jl = min(i, m); j <= jl; j++) {
            dp[i][j] = dp[i - 1][j];
            for (int k = j - 1; k < i; k++)
                dp[i][j] = max(dp[i][j], dp[k][j - 1]);
            dp[i][j] += a[i];
            res = max(res, dp[i][j]);
        }
    }
    printf("%d", res);
    return 0;
}

时间复杂度：$O(m\times n^2)$。

空间复杂度：$O(mn)$。

优化实现

1. 由 $dp[i][j]=max(dp[x][j-1],dp[i-1][j])+a_i$ 可知，在计算第 $j$ 列时，只用到第 $j-1$ 和第 $j$ 列，故可将 $dp$ 数组第二维大小由 $m$ 降至 $2$。

2. 为便于书写，交换原 $dp$ 数组 $i$ 和 $j$ 的含义，递推式变为 $dp[i][j]=max(dp[i-1][x],dp[i][j-1])+a_i$ 。

3. 观察以下两等式

   • $dp[i][j]=max(dp[i-1][x],dp[i][j-1])+a_i$ ，$x\le i-1\le j-1$。
   • $dp[i][j-1]=max(dp[i-1][x],dp[i][j-2])+a_i$ ，$x\le i-1\le j-2$。

   可令 $pm=max(dp[i][x],dp[i][j-2])$，则

   • $dp[i][j]=max(pm,dp[i-1][j-1],dp[i][j-1])$。
   • $pm=max(pm,dp[i-1][j-1])$。

int main() {
    typedef long long ll;
    int n, m;
    scanf("%d%d", &n, &m);
    ll a[n + 1], dp[2][n + 1], pm, res = 0;
    for (int i = 1; i <= n; ++i)
        scanf("%lld", &a[i]);
    memset(dp, 0, sizeof dp);
    for (int i = 1; i <= m; i++) {
        pm = dp[i & 1][i - 1] = -1e18;
        for (int j = i, t = n - m + i; j <= t; j++) {
            pm = max(pm, dp[(i - 1) & 1][j - 1]);
            dp[i & 1][j] = max(dp[i & 1][j - 1], pm) + a[j];
            res = max(res, dp[i & 1][j]);
        }
    }
    printf("%lld", res);
    return 0;
}

时间复杂度：$O(mn)$。

空间复杂度：$O(n)$。

最小代价爬楼梯

题目描述

你需要爬上一个 n 层的楼梯，在爬楼梯过程中， 每阶楼梯需花费非负代价，第i阶楼梯花费代价表示为 cost[i] ， 一旦你付出了代价，你可以在该阶基础上往上爬一阶或两阶。

你可以从第 0 阶或者 第 1 阶开始，请找到到达顶层的最小的代价是多少。

n 和 cost[i] 皆为整数。

数据范围： 2≤𝑛≤1000 , 0≤𝑐𝑜𝑠𝑡[𝑖]≤1000。

输入描述

输入为一串半角逗号分割的整数，对应cost数组。

输出描述

输出一个整数，表示花费的最小代价。

解题思路

令 $dp[i]$ = 到达第 $i$ 阶的最小代价，则 $dp[i]=max(dp[i-2]+c_{i-2},dp[i-1]+c_{i-1})$。

代码实现

int main() {
    int n = 0;
    scanf("%d", &a[++n]);
    while (scanf(",%d", &a[++n]));
    for (int i = 2; i <= n; i++) {
        dp[i] = min(dp[i - 2] + a[i - 2], dp[i - 1] + a[i - 1]);
    }
    printf("%d", dp[n]);
    return 0;
}

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

空间复杂度：$O(n)$。

END

文章文档：公众号 字节幺零二四 回复关键字可获取本文文档。

题目来源：快手2019年秋季校园招聘笔试试卷—工程A试卷

文章声明：题目来源 牛客 平台，如有侵权，请联系删除！