fn main() {
    let mut arr: Vec<isize> = vec![5, 3, 4, 2, 1];
    let answer = num1(&mut arr);
    println!("answer = {}", answer);

    let mut arr: Vec<isize> = vec![5, 3, 4, 2, 1];
    let answer = num2(&mut arr);
    println!("answer = {}", answer);
}

fn num1(arr: &mut Vec<isize>) -> isize {
    if arr.len() < 3 {
        return 0;
    }
    let mut path: Vec<isize> = vec![0, 0, 0];
    return process(arr, 0, &mut path, 0);
}

fn process(arr: &mut Vec<isize>, index: isize, path: &mut Vec<isize>, size: isize) -> isize {
    if size == 3 {
        return if path[0] > path[1] && path[1] > path[2] {
            1
        } else {
            0
        };
    }
    let mut ans: isize = 0;
    if index < arr.len() as isize {
        ans = process(arr, index + 1, path, size);
        path[size as usize] = arr[index as usize];
        ans += process(arr, index + 1, path, size + 1);
    }
    return ans;
}

// 正式方法
// 时间复杂度O(N * logN)
// 利用index tree
fn num2(arr: &mut Vec<isize>) -> isize {
    if arr.len() < 3 {
        return 0;
    }
    let n: isize = arr.len() as isize;
    let mut sorted: Vec<isize> = vec![];
    for i in 0..n {
        sorted.push(arr[i as usize])
    }
    sorted.sort_unstable();
    let mut max: isize = -9223372036854775808;
    for i in 0..n {
        arr[i as usize] = rank(&mut sorted, arr[i as usize]);
        max = get_max(max, arr[i as usize]);
    }
    let mut it2: IndexTree = IndexTree::new(max);
    let mut it3: IndexTree = IndexTree::new(max);
    let mut ans: isize = 0;
    let mut i: isize = n - 1;
    while i >= 0 {
        ans += if arr[i as usize] == 1 {
            0
        } else {
            it3.sum(arr[i as usize] - 1)
        };
        it2.add(arr[i as usize], 1);
        it3.add(
            arr[i as usize],
            if arr[i as usize] == 1 {
                0
            } else {
                it2.sum(arr[i as usize] - 1)
            },
        );
        i -= 1;
    }
    return ans;
}

fn get_max(a: isize, b: isize) -> isize {
    if a > b {
        a
    } else {
        b
    }
}

// 返回>=num, 最左位置
fn rank(sorted: &mut Vec<isize>, num: isize) -> isize {
    let mut l: isize = 0;
    let mut r: isize = sorted.len() as isize - 1;
    let mut m: isize;
    let mut ans: isize = 0;
    while l <= r {
        m = (l + r) / 2;
        if sorted[m as usize] >= num {
            ans = m;
            r = m - 1;
        } else {
            l = m + 1;
        }
    }
    return ans + 1;
}

pub struct IndexTree {
    pub tree: Vec<isize>,
    pub n: isize,
}

// 下标从1开始
impl IndexTree {
    // 0位置弃而不用
    pub fn new(n: isize) -> IndexTree {
        let mut tree: Vec<isize> = vec![];
        for _i in 0..n + 1 {
            tree.push(0)
        }
        IndexTree { tree: tree, n: n }
    }
    // 1~index 累加和是多少？
    pub fn sum(&self, index: isize) -> isize {
        let mut index: isize = index;
        let mut ret: isize = 0;
        while index > 0 {
            ret += self.tree[index as usize];
            index -= index & -index;
        }
        return ret;
    }
    pub fn add(&mut self, index: isize, d: isize) {
        let mut index: isize = index;
        while index <= self.n {
            self.tree[index as usize] += d;
            index += index & -index;
        }
    }
}