2023-08-06：小青蛙住在一条河边, 它想到河对岸的学校去学习

小青蛙打算经过河里 的石头跳到对岸

河里的石头排成了一条直线, 小青蛙每次跳跃必须落在一块石头或者岸上

给定一个长度为n的数组arr，表示每块儿石头的高度数值

每块石头有一个高度, 每次小青蛙从一块石头起跳

这块石头的高度就会下降1, 当石头的高度下降到0时

小青蛙不能再跳到这块石头上(跳跃后使石头高度下降到0是允许的)

小青蛙一共需要去学校上x天课, 所以它需要往返x次(去x次，回x次)

当小青蛙具有 一个跳跃能力y时, 它能跳不超过y的距离。

请问小青蛙的跳跃能力至少是多少才能用这些石头上完x次课？

1 <= n <= 10^5，

1 <= arr[i] <= 10^4，

1 <= x <= 10^9。

来自蓝桥杯练习题。

来自左神

答案2023-08-06：

#大体步骤如下：

1.读取输入：从输入中读取每块石头的高度数值和小青蛙需要上课的天数x。

2.初始化变量和数组：定义一个长度为n的数组help用于保存每块石头的高度数值的累积和。初始化变量ans为0。

3.计算累积和：遍历数组arr中的每个元素，计算它们的累积和，并保存到数组help中。

4.计算最小跳跃能力：使用双指针法逐个计算每个起点石头l到终点石头r的跳跃能力。在每次迭代中，通过移动r指针使得help[r] - help[l-1] >= 2*x，即小青蛙能从起点石头跳跃到终点石头。同时，更新ans为当前最大的能连续跳跃的石头数量。

5.返回结果：返回ans作为小青蛙的最小跳跃能力。

总的时间复杂度为O(n)，总的空间复杂度为O(n)。

go完整代码如下：

package main

import (
	"fmt"
)

const MAXN = 100001

var help [MAXN]int
var n, x int
var sc = []int{5, 1, 1, 0, 1, 0}
var ii = 0

func next() int {
	ii++
	return sc[ii-1]
}

func hasNext() bool {
	return ii < len(sc)
}

func main() {
	for hasNext() {
		n = next()
		x = next()

		for i := 1; i < n; i++ {
			val := next()
			help[i] = help[i-1] + val
		}
		fmt.Println(minAbility())
	}
}

// O(N)的最优解
func minAbility() int {
	ans := 0
	for l, r := 1, 1; l < n; l++ {
		for r < n && help[r]-help[l-1] < 2*x {
			r++
		}
		ans = max(ans, r-l+1)
	}
	return ans
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

rust完整代码如下：

const MAXN: usize = 100001;

static mut HELP: [i64; MAXN] = [0; MAXN];
static mut N: i64 = 0;
static mut X: i64 = 0;
static mut SC: [i64; 6] = [5, 1, 1, 0, 1, 0];
static mut II: usize = 0;

fn next() -> i64 {
    unsafe {
        II += 1;
        SC[II - 1]
    }
}

fn has_next() -> bool {
    unsafe { II < SC.len() }
}

fn main() {
    unsafe {
        while has_next() {
            N = next();
            X = next();

            for i in 1..N {
                let val = next();
                HELP[i as usize] = HELP[i as usize - 1] + val;
            }
            println!("{}", min_ability());
        }
    }
}

// O(N)的最优解
fn min_ability() -> i64 {
    let mut ans: i64 = 0;
    unsafe {
        let mut l: i64 = 1;
        let mut r: i64 = 1;
        while l < N {
            while r < N && HELP[r as usize] - HELP[(l - 1) as usize] < 2 * X {
                r += 1;
            }
            ans = max(ans, r - l + 1);
            l += 1;
        }
    }
    ans
}

fn max(a: i64, b: i64) -> i64 {
    if a > b {
        a
    } else {
        b
    }
}

c++完整代码如下：

#include <stdio.h>

#define MAXN 100001

int help[MAXN];
int n, x;
int sc[] = { 5, 1, 1, 0, 1, 0 };
int ii = 0;

int next() {
    ii++;
    return sc[ii - 1];
}

int hasNext() {
    return ii < sizeof(sc) / sizeof(sc[0]);
}

int min(int a, int b) {
    return (a < b) ? a : b;
}

int max(int a, int b) {
    return (a > b) ? a : b;
}

int minAbility() {
    int ans = 0;
    for (int l = 1, r = 1; l < n; l++) {
        while (r < n && help[r] - help[l - 1] < 2 * x) {
            r++;
        }
        ans = max(ans, r - l + 1);
    }
    return ans;
}

int main() {
    while (hasNext()) {
        n = next();
        x = next();

        for (int i = 1; i < n; i++) {
            int val = next();
            help[i] = help[i - 1] + val;
        }
        printf("%d\n", minAbility());
    }

    return 0;
}

c完整代码如下：

#include <stdio.h>

#define MAXN 100001

int help[MAXN];
int n, x;
int sc[] = { 5, 1, 1, 0, 1, 0 };
int ii = 0;

int next() {
    ii++;
    return sc[ii - 1];
}

int hasNext() {
    return ii < sizeof(sc) / sizeof(sc[0]);
}

int min(int a, int b) {
    return (a < b) ? a : b;
}

int max(int a, int b) {
    return (a > b) ? a : b;
}

int minAbility() {
    int ans = 0;
    for (int l = 1, r = 1; l < n; l++) {
        while (r < n && help[r] - help[l - 1] < 2 * x) {
            r++;
        }
        ans = max(ans, r - l + 1);
    }
    return ans;
}

int main() {
    while (hasNext()) {
        n = next();
        x = next();

        for (int i = 1; i < n; i++) {
            int val = next();
            help[i] = help[i - 1] + val;
        }
        printf("%d\n", minAbility());
    }

    return 0;
}