/**
 * [2861] Maximum Number of Alloys
 */
pub struct Solution {}

// submission codes start here

impl Solution {
    fn check(
        n: usize,
        count: i32,
        budget: i32,
        composition: &Vec<i32>,
        stock: &Vec<i32>,
        cost: &Vec<i32>,
    ) -> bool {
        let mut need = 0i64;

        for i in 0..n {
            let number = composition[i] * count - stock[i];

            if number > 0 {
                need += number as i64 * cost[i] as i64;
            }
        }

        need <= budget as i64
    }

    pub fn max_number_of_alloys(
        n: i32,
        k: i32,
        budget: i32,
        composition: Vec<Vec<i32>>,
        stock: Vec<i32>,
        cost: Vec<i32>,
    ) -> i32 {
        let mut result = 0;
        let (n, k) = (n as usize, k as usize);

        for m in 0..k {
            let mut left = 0;
            let mut right = vec![0; n];

            for i in 0..n {
                right[i] = (stock[i] + budget / cost[i]) / composition[m][i];
            }

            let mut right = *right.iter().max().unwrap();

            while left < right {
                let mid = (left + right) / 2;

                if Solution::check(n, mid, budget, &composition[m], &stock, &cost) {
                    left = mid + 1;
                } else {
                    right = mid;
                }

                dbg!(left, right);
            }

            if !Solution::check(n, left, budget, &composition[m], &stock, &cost) {
                left = left - 1;
            }

            result = result.max(left);
        }
        result
    }
}

// submission codes end

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_2861() {
        assert_eq!(
            Solution::max_number_of_alloys(
                3,
                2,
                15,
                vec![vec![1, 1, 1], vec![1, 1, 10]],
                vec![0, 0, 0],
                vec![1, 2, 3]
            ),
            2
        );
    }
}