2023-03-02：给定一个数组arr，长度为n，任意相邻的两个数里面至少要有一个被选出来，组成子序列，才是合法的！求所有可能

use rand::Rng;
use std::collections::HashMap;
use std::iter::repeat;
fn main() {
    let nn = 20;
    let vv = 1000;
    let test_times = 5000;
    println!("测试开始");
    for i in 0..test_times {
        let n = rand::thread_rng().gen_range(0, nn) + 1;
        let mut arr = random_array(n, vv);
        let ans1 = best_median1(&mut arr);
        let ans2 = best_median2(&mut arr);
        if ans1 != ans2 {
            println!("出错了!");
            return;
        }
    }
    println!("测试结束");
}

fn valid_sub_max_sum(arr: &mut Vec<i32>) -> i32 {
    return zuo(arr, 0, 1);
}

// 当前来到i位置
// 如果arr[i-1]位置的数选了，pre == 1
// 如果arr[i-1]位置的数没选，pre == 0
// arr[i....]最大合法子序列的累加和是多少
fn zuo(arr: &mut Vec<i32>, i: i32, pre: i32) -> i32 {
    if i == arr.len() as i32 {
        return 0;
    }
    // 还有数！
    // 可能性1 : 不要i位置的数
    let mut p1 = i32::MIN;
    if pre == 1 {
        p1 = zuo(arr, i + 1, 0);
    }
    // 可能性2 : 要i位置的数
    let mut p2 = i32::MIN;
    let mut next2 = zuo(arr, i + 1, 1);
    if next2 != i32::MIN {
        p2 = arr[i as usize] + next2;
    }
    return if p1 > p2 { p1 } else { p2 };
}

// 启发函数
// 如果数组中的值只有1和-1，
// 你可以从左往右选择数字组成子序列，
// 但是要求任何两个相邻的数，至少要选1个
// 请返回子序列的最大累加和
// arr : 数组
// i : 当前来到i位置
// pre : 前一个数字(i-1位置)，当初选了没有
// 如果pre == 0, 表示i-1位置的数字，当初没有选
// 如果pre == 1, 表示i-1位置的数字，当初选了
// 返回arr[i...]的子序列，最大累加和
fn max_sum(arr: &mut Vec<i32>, i: i32, pre: i32) -> i32 {
    if i == arr.len() as i32 {
        return 0;
    }
    // 可能性1 : 就是要选当前i位置的数
    let mut p1 = arr[i as usize] + max_sum(arr, i + 1, 1);
    // 可能性1 : 就是不选当前i位置的数
    let mut p2 = -1;
    if pre == 1 {
        // 只有前一个数字选了，当前才能不选
        p2 = max_sum(arr, i + 1, 0);
    }
    return if p1 > p2 { p1 } else { p2 };
}

// 暴力方法
// 为了验证
fn best_median1(arr: &mut Vec<i32>) -> i32 {
    let mut path: Vec<i32> = repeat(0).take(arr.len()).collect();
    return process(arr, 0, true, &mut path, 0);
}

fn process(arr: &mut Vec<i32>, i: i32, pre: bool, path: &mut Vec<i32>, size: i32) -> i32 {
    if i == arr.len() as i32 {
        if size == 0 {
            return 0;
        }
        let mut sort: Vec<i32> = repeat(0).take(size as usize).collect();
        for j in 0..size {
            sort[j as usize] = path[j as usize];
        }
        sort.sort();
        return sort[(sort.len() - 1) / 2];
    } else {
        path[size as usize] = arr[i as usize];
        let mut ans = process(arr, i + 1, true, path, size + 1);
        if pre {
            ans = get_max(ans, process(arr, i + 1, false, path, size));
        }
        return ans;
    }
}

fn get_max<T: Clone + Copy + std::cmp::PartialOrd>(a: T, b: T) -> T {
    if a > b {
        a
    } else {
        b
    }
}

// 正式方法
// 时间复杂度O(N*logN)
fn best_median2(arr: &mut Vec<i32>) -> i32 {
    let n = arr.len() as i32;
    let mut sort: Vec<i32> = repeat(0).take(n as usize).collect();
    for i in 0..n {
        sort[i as usize] = arr[i as usize];
    }
    sort.sort();
    //    int[] arr  = { 5, 3, 6, 2, 9, 7 };
    //    int[] sort = { 2, 3, 5, 6, 7, 9 };
    //                     0  1  2  3  4  5
    //                     l              r
    let mut l = 0;
    let mut r = n - 1;
    let mut m = 0;
    let mut ans = -1;
    let mut help: Vec<i32> = repeat(0).take(n as usize).collect();
    let mut dp: Vec<Vec<i32>> = repeat(repeat(0).take(2).collect())
        .take((n + 1) as usize)
        .collect();
    while l <= r {
        m = (l + r) / 2;
        if max_sum1(arr, &mut help, &mut dp, sort[m as usize], n) > 0 {
            ans = sort[m as usize];
            l = m + 1;
        } else {
            r = m - 1;
        }
    }
    return ans;
}

// 如果中位数定成median，
// 如果任意相邻的两数，至少选一个，来生成序列
// 所有这样的序列中，
// 到底有没有一个序列，其中>= median的数字，能达到一半以上
fn max_sum1(
    arr: &mut Vec<i32>,
    help: &mut Vec<i32>,
    dp: &mut Vec<Vec<i32>>,
    median: i32,
    n: i32,
) -> i32 {
    for i in 0..n {
        help[i as usize] = if arr[i as usize] >= median { 1 } else { -1 };
    }
    let mut i = n - 1;
    while i >= 0 {
        dp[i as usize][0] = help[i as usize] + dp[(i + 1) as usize][1];
        dp[i as usize][1] = get_max(
            help[i as usize] + dp[(i + 1) as usize][1],
            dp[(i + 1) as usize][0],
        );
        i -= 1;
    }
    return dp[0][1];
}

// 为了测试
fn random_array(n: i32, v: i32) -> Vec<i32> {
    let mut ans: Vec<i32> = repeat(0).take(n as usize).collect();
    for i in 0..n {
        ans[i as usize] = rand::thread_rng().gen_range(0, v);
    }
    return ans;
}