rust 解法, 执行用时: 28 ms, 内存消耗: 2.5 MB, 提交时间: 2023-09-13 15:42:09

impl Solution {
    // 基于hash
    pub fn minimum_switching_times(source: Vec<Vec<i32>>, target: Vec<Vec<i32>>) -> i32 {
        let mut map = std::collections::HashMap::new();
        let mut acc = 0;
        for i in source.iter() {
            for j in i.iter() {
                let cnt = map.entry(j).or_insert(0);
                *cnt += 1;
            }
        }
        for i in target.iter() {
            for j in i.iter() {
                if !map.contains_key(j) {
                    acc += 1;
                } else {
                    let cnt = map.entry(j).or_insert(0);
                    *cnt -= 1;
                }                
            }
        }
        -1 * map.iter().map(|(_, &val)| val).filter(|x| x < &0).sum::<i32>() + acc
    }

    // 简单模拟
    pub fn minimum_switching_times2(source: Vec<Vec<i32>>, target: Vec<Vec<i32>>) -> i32 {
        let n = source.len();
        let m = source[0].len();
        let mut cnt = vec![0;10005];

        for i in 0..n*m {
            cnt[source[i/m][i%m] as usize] += 1;
            cnt[target[i/m][i%m] as usize] -= 1;
        }

        cnt.into_iter().fold(0, |acc, x| if x > 0 { acc + x } else { acc })
    }


}

golang 解法, 执行用时: 116 ms, 内存消耗: 7.8 MB, 提交时间: 2023-09-13 15:40:56

func minimumSwitchingTimes(source, target [][]int) (ans int) {
	cnt := map[int]int{}
	for i, row := range source {
		for j, v := range row {
			cnt[v]++
			cnt[target[i][j]]--
		}
	}
	for _, c := range cnt {
		ans += abs(c)
	}
	return ans / 2
}

func abs(x int) int { if x < 0 { return -x }; return x }

cpp 解法, 执行用时: 108 ms, 内存消耗: 34.9 MB, 提交时间: 2023-09-13 15:39:55

class Solution {
public:
    int minimumSwitchingTimes(vector<vector<int>>& source, vector<vector<int>>& target) {
        int ans = 0;
        vector<int> p(10006, 0);
        int m = source.size(), n = source[0].size();
        for ( int i = 0; i < n * m; ++i ) {
            p[source[i/n][i%n]]++;
            p[target[i/n][i%n]]--;
        }
        
        for ( int i = 0; i < 10006; ++i ) {
            if ( p[i] > 0 ) {
                ans += p[i];
            }
        }
    
        return ans;
    }
};

java 解法, 执行用时: 4 ms, 内存消耗: 42.9 MB, 提交时间: 2023-09-13 15:36:59

class Solution {
    public int minimumSwitchingTimes(int[][] source, int[][] target) {
        int ans = 0;
        int[] p = new int[10006];
        int m = source.length, n = source[0].length;
        for ( int i = 0; i < n * m; ++i ) {
            p[source[i/n][i%n]]++;
            p[target[i/n][i%n]]--;
        }
        
        for ( int i = 0; i < 10006; ++i ) {
            if ( p[i] > 0 ) {
                ans += p[i];
            }
        }
    
        return ans;
    }
}

php 解法, 执行用时: 224 ms, 内存消耗: 22.9 MB, 提交时间: 2023-09-13 15:34:11

class Solution {

    /**
     * @param Integer[][] $source
     * @param Integer[][] $target
     * @return Integer
     */
    function minimumSwitchingTimes($source, $target) {
        $ans = 0;
        $p = array_fill(0, 10006, 0);
        $m = count($source);
        $n = count($source[0]);
        for ( $i = 0; $i < $n * $m; $i++ ) {
            $p[$source[intval($i/$n)][$i%$n]]++;
            $p[$target[intval($i/$n)][$i%$n]]--;
        }
        
        for ( $i = 0; $i < 10006; $i++ ) {
            if ( $p[$i] > 0 ) $ans += $p[$i];
        }
    
        return $ans;
    }
}

python3 解法, 执行用时: 144 ms, 内存消耗: 17.7 MB, 提交时间: 2023-09-13 15:31:11

class Solution:
    def minimumSwitchingTimes(self, source: List[List[int]], target: List[List[int]]) -> int:
        ans = 0
        p = [0 for _ in range(10006)]
        m, n = len(source), len(source[0])
        for i in range(m * n):
            p[source[i//n][i%n]] += 1
            p[target[i//n][i%n]] -= 1
        
        
        for i in range(10006):
            if p[i] > 0: ans += p[i]
    
        return ans

golang 解法, 执行用时: 140 ms, 内存消耗: 7.3 MB, 提交时间: 2021-09-22 16:26:49

func minimumSwitchingTimes(source [][]int, target [][]int) int {
	ans := 0
	p := make([]int, 1e4+6)
	m, n := len(source), len(source[0])
	for i := 0; i < n * m; i ++ {
		p[source[i/n][i%n]]++
		p[target[i/n][i%n]]--
	}
	
	for i := 0; i < 1e4 + 6; i++ {
		if p[i] > 0 {
			ans += p[i]
		}
	}

	return ans
}