拼多多笔试真题-多多的Boss挑战(C++/Py/Java /Js/Go)

多多的Boss挑战

拼多多技术岗 5月17号笔试第一题

题目内容

多多鸡在挑战强大的 B O S S BOSS BOSS，他有 n n n个技能，每个技能具有：

伤害值：释放一次造成的伤害
冷却时间：释放后必须等待的时间（从释放开始计算）
注意：一旦释放某个技能，就必须周期性地持续释放它！
具体规则如下：
你可以在 t t t 秒内使用 1 1 1 次初始释放一个技能：
每次释放耗时 1 1 1 秒，期间不能释放其他技能
之后必须在 t + c , t + 2 c , t + 3 c , . . . t + c, t + 2c ,t+3c, ... t+c,t+2c,t+3c,... 持续释放该技能（只要不超时），其中 c c c 为冷却时间。如果 c c c 小于 1 s 1s 1s，因为有释放时间，则两次释放之间仍然必须大于等于 1 s 1s 1s。
不能中途切换技能，也不能组合多个技能
同一时间只能释放一个技能（所以不同技能的时间方案互斥）
战斗从时刻 0 0 0 开始，持续 T T T 秒，你只能选择一个技能和一个起始时间（起始时间为 0 0 0 到 T T T 之间的正整数），进行周期性释放。
目标：选择一个技能和一个起始时间，使得在 [ 0 , T ) [0,T) [0,T) 时间内造成的总伤害最大。

输入描述

第一行：一个整数 T T T，表示总战斗时长（ 1 ≤ T ≤ 1000 1 \le T \le 1000 1≤T≤1000）

第二行： N N N 个整数，表示每个技能的伤害值 d a m a g e $i$ damage $i$ damage $i$ （ 1 ≤ n ≤ 10 1 \le n \le 10 1≤n≤10， 1 ≤ d a m a g e $i$ ≤ 10 9 1 \le damage $i$ \le 10^9 1≤damage $i$ ≤109）

第三行： N N N 个整数表示每个技能的冷却时间 c o o l d o w n $i$ cooldown $i$ cooldown $i$ （ 1 ≤ n ≤ 10 1 \le n \le 10 1≤n≤10， 0 ≤ c o o l d o w n $i$ ≤ 1000 0 \le cooldown $i$ \le 1000 0≤cooldown $i$ ≤1000）

其中，第二第三行的数据个数一定是相等的。

输出描述

总伤害最大值。

样例1

输入

复制代码

10
50
3

输出

复制代码

说明

技能只有 1 1 1 个，伤害 50 50 50，冷却时间 3 3 3。

起始时间 t = 0 t=0 t=0：可在 0 , 3 , 6 , 9 0,3,6,9 0,3,6,9 释放 → 4 → 4 →4 次
总伤害 = 50 × 4 = 200 = 50 × 4 = 200 =50×4=200
其他起始时间不会更多
输出 200 200 200

样例2

输入

复制代码

5
30
2

输出

复制代码

说明

t = 0 t=0 t=0： 0 , 2 , 4 → 3 次 → 3 × 30 = 90 0,2,4 → 3次 → 3×30 = 90 0,2,4→3次→3×30=90
t = 1 t=1 t=1： 1 , 3 → 2 次 → 2 × 30 = 60 1,3 → 2次 → 2×30 = 60 1,3→2次→2×30=60
最大是 90 90 90

题解和思路

思路

实现思路：模拟

每个技能要想获取总伤害最大，肯定都是从0开始进行释放，能最大程度获取最大释放次数。
按照题意模拟计算每个技能能获取最大总伤害damage[i] * (1 + (T - 1) / gap)，记录求种最大值即可。
额外注意，cooldown[i] < 1情况下，需要强制将gap设置为1

C++

cpp 复制代码

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


// 通用 切割函数 函数 将字符串str根据delimiter进行切割
vector<int> split(const string& str, const string& delimiter) {
    vector<int> result;
    size_t start = 0;
    size_t end = str.find(delimiter);
    while (end != string::npos) {
        result.push_back(stoi(str.substr(start, end - start)));
        start = end + delimiter.length();
        end = str.find(delimiter, start);
    }
    // 添加最后一个部分
    result.push_back(stoi(str.substr(start)));
    return result;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int T;
    cin >> T;
    // 忽略换行符
    cin.ignore();
    vector<int> damage,cooldown;
    string input1, input2;
    getline(cin, input1);
    getline(cin, input2);
    
    damage = split(input1, " ");
    cooldown = split(input2, " ");
    
    long maxDamage = -1;
    int n = damage.size();
    for (int i = 0; i < n; i++) {
        int gap = max(1, cooldown[i]);
        long currentDamage = (long)damage[i] * (1 + (T - 1) / gap);
        maxDamage = max(maxDamage, currentDamage);
    }
    cout << maxDamage;
    return 0;
}

Java

java 复制代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int T = Integer.parseInt(br.readLine());

        String input1 = br.readLine();
        String input2 = br.readLine();

        String[] damageStr = input1.split(" ");
        String[] cooldownStr = input2.split(" ");

        long maxDamage = -1;
        int n = damageStr.length;

        for (int i = 0; i < n; i++) {
            int damage = Integer.parseInt(damageStr[i]);
            int cooldown = Integer.parseInt(cooldownStr[i]);

            int gap = Math.max(1, cooldown);
            long currentDamage = (long) damage * (1 + (T - 1) / gap);
            maxDamage = Math.max(maxDamage, currentDamage);
        }

        System.out.println(maxDamage);
    }
}

python

python 复制代码

T = int(input())

# 读取伤害数组
damage = list(map(int, input().split()))

# 读取冷却数组
cooldown = list(map(int, input().split()))

max_damage = -1
n = len(damage)

for i in range(n):
    gap = max(1, cooldown[i])
    current_damage = damage[i] * (1 + (T - 1) // gap)
    max_damage = max(max_damage, current_damage)

print(max_damage)

Javascript

js 复制代码

const readline = require("readline");

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

const input = [];

rl.on("line", line => {
    input.push(line);
});

rl.on("close", () => {
    const T = parseInt(input[0]);

    // 读取伤害数组
    const damage = input[1].split(" ").map(Number);

    // 读取冷却数组
    const cooldown = input[2].split(" ").map(Number);

    let maxDamage = -1;
    const n = damage.length;

    for (let i = 0; i < n; i++) {
        const gap = Math.max(1, cooldown[i]);
        const currentDamage = damage[i] * (1 + Math.floor((T - 1) / gap));
        maxDamage = Math.max(maxDamage, currentDamage);
    }

    console.log(maxDamage);
});

Go

go 复制代码

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	in := bufio.NewReader(os.Stdin)

	var T int
	fmt.Fscan(in, &T)

	// 忽略第一行后的换行符
	in.ReadByte()

	input1, _ := in.ReadString('\n')
	input2, _ := in.ReadString('\n')

	input1 = strings.TrimSpace(input1)
	input2 = strings.TrimSpace(input2)

	// 读取伤害数组
	damageStr := strings.Split(input1, " ")

	// 读取冷却数组
	cooldownStr := strings.Split(input2, " ")

	maxDamage := int64(-1)
	n := len(damageStr)

	for i := 0; i < n; i++ {
		damage, _ := strconv.Atoi(damageStr[i])
		cooldown, _ := strconv.Atoi(cooldownStr[i])

		gap := cooldown
		if gap < 1 {
			gap = 1
		}

		currentDamage := int64(damage) * int64(1+(T-1)/gap)
		if currentDamage > maxDamage {
			maxDamage = currentDamage
		}
	}

	fmt.Println(maxDamage)
}