2023-12-23：用go語言，一支n個士兵的軍隊正在趁夜色逃亡，途中遇到一條湍急的大河

敵軍在T的時長后到達河面，沒到過對岸的士兵都會被消滅

現在軍隊只找到了1只小船，這船最多能同時坐上2個士兵。

1. 當1個士兵劃船過河，用時為a[i]

2. 當2個士兵坐船同時劃船過河時, 用時為max(a[j],a[i])兩士兵中用時最長的

3. 當2個士兵坐船只有1個士兵劃船時, 用時為a[i] * 10, a[i]為劃船士兵用時

請幫忙給出一種解決方案，保證存活的士兵最多，且過河用時最短

我們先看一下如下的題，再講一下華為OD的擴展

來自洛谷的P1809，過河問題。

有一個大晴天, Oliver與同學們一共N人出游, 他們走到一條河的東岸邊，想要過河到西岸

而東岸邊有一條小船。船太小了，一次只能乘坐兩人，每個人都有一個渡河時間T

船劃到對岸的時間等于船上渡河時間較長的人所用時間

現在已知N個人的渡河時間Ti

Oliver 想要你告訴他，他們最少要花費多少時間，才能使所有人都過河

注意，只有船在東岸（西岸）的人才能坐上船劃到對岸。

來自華為OD。

答案2023-12-23：

來自左程云。

靈捷3.5

步驟描述如下：

1.初始化輸入數據：定義一個整型切片inputs，包含每個士兵的過河時間。初始化n為inputs的長度。

2.對士兵的過河時間進行排序：使用sort包對inputs進行排序，以便后續計算最小花費時間。

3.初始化動態規劃數組dp：定義一個大小為max(n, 3)的整型數組dp，用于存儲每個狀態下的最小花費時間。若n大于等于3，則初始化前三個元素dp[0]、dp[1]、dp[2]為對應士兵過河時間的和。

4.動態規劃求解最小花費時間：從第3個士兵開始遍歷到第n個士兵，對于每個士兵i，計算以下兩種情況的最小值，并更新dp[i]：

a) 兩個士兵同時過河：dp[i-2] + inputs[1] + inputs[0] + inputs[i] + inputs[1]

b) 一個士兵過河：dp[i-1] + inputs[i] + inputs[0]

5.返回最小花費時間：返回dp[n-1]作為最終的答案，即所有士兵都過河且花費時間最小的方案。

總的時間復雜度：排序士兵過河時間的時間復雜度為O(nlogn)，動態規劃遍歷的時間復雜度為O(n)，因此總的時間復雜度為O(nlogn)。

總的額外空間復雜度：除了輸入外，使用了一個大小為MAXN的整型數組arr和dp，因此額外空間復雜度為O(MAXN)。

go完整代碼如下：

package main

import (
	"fmt"
	"sort"
)

const MAXN = 100001

var arr [MAXN]int
var dp [MAXN]int
var n int

func main() {
	inputs := []int{4, 6, 7, 10, 15}
	ii := 0
	n = inputs[ii]
	ii++
	for i := 0; i < n; i++ {
		arr[i] = inputs[ii]
		ii++
	}
	ans := minCost()
	fmt.Println(ans)

}

func minCost() int {
	sort.Ints(arr[:n])
	if n >= 1 {
		dp[0] = arr[0]
	}
	if n >= 2 {
		dp[1] = arr[1]
	}
	if n >= 3 {
		dp[2] = arr[0] + arr[1] + arr[2]
	}
	for i := 3; i < n; i++ {
		dp[i] = min(
			dp[i-2]+arr[1]+arr[0]+arr[i]+arr[1],
			dp[i-1]+arr[i]+arr[0],
		)
	}
	return dp[n-1]
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

rust完整代碼如下：

use std::cmp;

const MAXN: usize = 100001;

static mut ARR: [i32; MAXN] = [0; MAXN];
static mut DP: [i32; MAXN] = [0; MAXN];
static mut N: usize = 0;

fn main() {
    let inputs: Vec<i32> = vec![4, 6, 7, 10, 15];

    unsafe {
        let mut ii: usize = 0;
        N = inputs[ii] as usize;
        ii += 1;

        for i in 0..N {
            ARR[i] = inputs[ii];
            ii += 1;
        }

        let ans = min_cost();
        println!("{}", ans);
    }
}

unsafe fn min_cost() -> i32 {
    ARR[0..N].sort();

    if N >= 1 {
        DP[0] = ARR[0];
    }
    if N >= 2 {
        DP[1] = ARR[1];
    }
    if N >= 3 {
        DP[2] = ARR[0] + ARR[1] + ARR[2];
    }

    for i in (3..N).step_by(1) {
        DP[i] = cmp::min(
            DP[i - 2] + ARR[1] + ARR[0] + ARR[i] + ARR[1],
            DP[i - 1] + ARR[i] + ARR[0],
        );
    }

    return DP[N - 1];
}

c++完整代碼如下：

#include <iostream>
#include <algorithm>

const int MAXN = 100001;

int arr[MAXN];
int dp[MAXN];
int n;

int minCost() {
    std::sort(arr, arr + n);

    if (n >= 1) {
        dp[0] = arr[0];
    }
    if (n >= 2) {
        dp[1] = arr[1];
    }
    if (n >= 3) {
        dp[2] = arr[0] + arr[1] + arr[2];
    }

    for (int i = 3; i < n; i++) {
        dp[i] = std::min(
            dp[i - 2] + arr[1] + arr[0] + arr[i] + arr[1],
            dp[i - 1] + arr[i] + arr[0]
        );
    }

    return dp[n - 1];
}

int main() {
    int inputs[] = { 4, 6, 7, 10, 15 };

    int ii = 0;
    n = inputs[ii++];

    for (int i = 0; i < n; i++) {
        arr[i] = inputs[ii++];
    }

    int ans = minCost();

    std::cout << ans << std::endl;

    return 0;
}

c完整代碼如下：

#include <stdio.h>
#include <stdlib.h>

#define MAXN 100001

int arr[MAXN];
int dp[MAXN];
int n;

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int minCost() {
    qsort(arr, n, sizeof(int), compare);

    if (n >= 1) {
        dp[0] = arr[0];
    }
    if (n >= 2) {
        dp[1] = arr[1];
    }
    if (n >= 3) {
        dp[2] = arr[0] + arr[1] + arr[2];
    }

    for (int i = 3; i < n; i++) {
        dp[i] = min(
            dp[i - 2] + arr[1] + arr[0] + arr[i] + arr[1],
            dp[i - 1] + arr[i] + arr[0]
        );
    }

    return dp[n - 1];
}

int main() {
    int inputs[] = { 4, 6, 7, 10, 15 };

    int ii = 0;
    n = inputs[ii++];

    for (int i = 0; i < n; i++) {
        arr[i] = inputs[ii++];
    }

    int ans = minCost();
    printf("%d\n", ans);

    return 0;
}

總結

以上是生活随笔為你收集整理的2023-12-23：用go语言，一支n个士兵的军队正在趁夜色逃亡，途中遇到一条湍急的大河 敌军在T的时长后到达河面，没到过对岸的士兵都会被消灭 现在军队只找到了1只小船，这船最多能同时坐上2个士兵。的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。