leetcode周赛 299

经典 rust

wa 两次，一次是因为运算的最终结果没有取模，一次是因为初始值选的有问题，建议直接 i32::MAX/2

A

impl Solution {
    pub fn is_duijiao(n: usize, x: usize, y: usize) -> bool {
        if x==y {
            return true;
        }
        if x+y==n-1 {
            return true;
        }
        return false;
    }
    pub fn check_x_matrix(grid: Vec<Vec<i32>>) -> bool {
        for i in 0..grid.len() {
            for j in 0..grid[0].len() {
                if (grid[i][j] == 0) == Solution::is_duijiao(grid.len(), i, j) {
                    return false;
                }
            }
        }
        true
    }
}

B

impl Solution {
    pub fn count_house_placements(n: i32) -> i32 {
        let n = n as usize;
        // enum State {
        //     Empty,
        //     Left,
        //     Right,
        //     Both
        // }
        let m = 1000000007;
        let mut dp = vec![(1i64,1i64,1i64,1i64); n + 1];
        for i in 1..=n {
            dp[i].0 = dp[i-1].0 + dp[i-1].1 + dp[i-1].2 + dp[i-1].3;
            dp[i].1 = dp[i-1].0 + dp[i-1].2;
            dp[i].2 = dp[i-1].0 + dp[i-1].1;
            dp[i].3 = dp[i-1].0;

            dp[i].0 %= m;
            dp[i].1 %= m;
            dp[i].2 %= m;
            dp[i].3 %= m;
        }
        // println!("dp={:?}", dp);
        ((dp[n-1].0 + dp[n-1].1 + dp[n-1].2 + dp[n-1].3) % m) as i32
    }
}

C

impl Solution {
    fn solve(nums1: &Vec<i32>, nums2: &Vec<i32>) -> i32 {
        let mut dp = vec![vec![0; 3]; nums1.len() + 1];
        for i in 1..=nums1.len() {
            dp[i][0] = dp[i-1][0] + nums1[i-1];
            dp[i][1] = dp[i-1][0].max(dp[i-1][1]) + nums2[i-1];
            dp[i][2] = dp[i-1][1].max(dp[i-1][2]) + nums1[i-1];
        }
        // println!("dp={:?}", dp);
        *dp[nums1.len()].iter().max().unwrap()
    }

    pub fn maximums_spliced_array(nums1: Vec<i32>, nums2: Vec<i32>) -> i32 {
        Solution::solve(&nums1, &nums2).max(Solution::solve(&nums2, &nums1))
    }
}

D

impl Solution {
    fn dfs(sons: &Vec<Vec<usize>>, values: &Vec<i32>, sum: &mut Vec<i32>, curr_list: &mut Vec<usize>, ancestor: &mut Vec<Vec<bool>>, cur: usize, pre: usize) {
        curr_list.push(cur);
        for &anc in curr_list.iter() {
            ancestor[cur][anc] = true;
        }

        let mut cur_sum = 0;
        for &son in &sons[cur] {
            if son != pre {
                Solution::dfs(sons, values, sum, curr_list, ancestor, son, cur);
                cur_sum ^= sum[son];
            }
        }
        sum[cur] = cur_sum ^ values[cur];

        curr_list.pop();
    }


    pub fn minimum_score(values: Vec<i32>, edges: Vec<Vec<i32>>) -> i32 {
        let n = values.len();
        let mut sons = vec![vec![]; n];
        for edge in edges {
            let (a, b) = (edge[0] as usize, edge[1] as usize);
            sons[a].push(b);
            sons[b].push(a);
        }

        let mut sum = vec![0; n];
        let mut ancestor = vec![vec![false; n]; n];
        let mut curr_list = vec![0; 0];
        Solution::dfs(&sons, &values, &mut sum, &mut curr_list, &mut ancestor, 0, 0);
        // println!("sons={:?} sum={:?} ancestor={:?}", sons, sum, ancestor);
        let mut ans = i32::MAX/2;
        for a in 1..n {
            for b in a+1..n {
                let tmp_vec = if ancestor[a][b] == false && ancestor[b][a] == false {
                    vec![sum[0]^sum[a]^sum[b], sum[a], sum[b]]
                } else if ancestor[a][b] {
                    vec![sum[0]^sum[b], sum[a]^sum[b], sum[a]]
                } else {
                    vec![sum[0]^sum[a], sum[a]^sum[b], sum[b]]
                };
                let tmp = tmp_vec.iter().max().unwrap() - tmp_vec.iter().min().unwrap();
                ans = ans.min(tmp);
            }
        }

        ans
    }
}