[Swift]LeetCode861. 翻转矩阵后的得分 | Score After Flipping Matrix

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10595500.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

We have a two dimensional matrix A where each value is 0 or 1.

A move consists of choosing any row or column, and toggling each value in that row or column: changing all 0s to 1s, and all 1s to 0s.

After making any number of moves, every row of this matrix is interpreted as a binary number, and the score of the matrix is the sum of these numbers.

Return the highest possible score. 

Example 1:

Input: [[0,0,1,1],[1,0,1,0],[1,1,0,0]]
Output: 39
Explanation:
Toggled to [[1,1,1,1],[1,0,0,1],[1,1,1,1]].
0b1111 + 0b1001 + 0b1111 = 15 + 9 + 15 = 39 

Note:

1. 1 <= A.length <= 20
2. 1 <= A[0].length <= 20
3. A[i][j] is 0 or 1.

---

有一个二维矩阵 A 其中每个元素的值为 0 或 1 。

移动是指选择任一行或列，并转换该行或列中的每一个值：将所有 0 都更改为 1，将所有 1 都更改为 0。

在做出任意次数的移动后，将该矩阵的每一行都按照二进制数来解释，矩阵的得分就是这些数字的总和。

返回尽可能高的分数。 

示例：

输入：[[0,0,1,1],[1,0,1,0],[1,1,0,0]]
输出：39
解释：
转换为 [[1,1,1,1],[1,0,0,1],[1,1,1,1]]
0b1111 + 0b1001 + 0b1111 = 15 + 9 + 15 = 39 

提示：

1. 1 <= A.length <= 20
2. 1 <= A[0].length <= 20
3. A[i][j] 是 0 或 1

---

Runtime: 12 ms

Memory Usage: 19 MB

class Solution {
    func matrixScore(_ A: [[Int]]) -> Int {
        var temp1 = A
        //先将第一咧都转为1
        for i in 0..<temp1.count {
            let arr = temp1[i]
            if arr[0] == 0{
                temp1[i] = arr.map({ 1 - $0 })
            }
        }
        //让之后的每列尽可能多的1 0的个数+1的个数 = 固定
        var res = 0
        for i in 0..<temp1[0].count{
            var s = 0
            for j in 0..<temp1.count{
                if temp1[j][i] == 1{
                    s += 1
                }
            }
            s = s > (temp1.count-s) ? s : temp1.count-s
            var more = 1 << (temp1[0].count-i-1)
            more = more * s
            res += more
        }
        return res
    }
}

---

Runtime: 12 ms

Memory Usage: 18.7 MB

class Solution {
    func matrixScore(_ A: [[Int]]) -> Int {
        var M:Int = A.count
        var N:Int = A[0].count
        var res:Int = (1 << (N - 1)) * M
        for j in 1..<N
        {
            var cur:Int = 0
            for i in 0..<M
            {
                cur += A[i][j] == A[i][0] ? 1 : 0
            }
            res += max(cur, M - cur) * (1 << (N - j - 1))
        }
        return res
    }
}

---

12ms

class Solution {
    func matrixScore(_ Z: [[Int]]) -> Int {
        var A = Z
        var sum = 0
        let M = A.count
        let N = A[0].count
        // Flip row if first item is 0
        for (i, a) in A.enumerated() {
            if a[0] == 0 {
                A[i] = a.map { x in
                    return 1 - x
                }
            }
        }
        // Flip column to get more 1s then 0s
        for j in 1..<N {
            var oneCount = 0
            for i in 0..<M {
                if A[i][j] == 1 {
                    oneCount += 1
                }
            }
            if oneCount < M - oneCount {
                for i in 0..<M {
                    A[i][j] = 1 - A[i][j]
                }
            }
        }
        for a in A {
            sum += arrayToNum(a)
        }
        return sum
    }
    
    private func arrayToNum(_ A: [Int]) -> Int {
        var sum = 0
        for a in A {
            sum = (sum << 1) + a
        }
        return sum
    }
}

---

16ms

class Solution {
    func matrixScore(_ Arr: [[Int]]) -> Int {
        var A = Arr
        for i in 0..<A.count {
            let row = A[i]
            if row[0] == 0 {
                A = flipMatrix(A, row: i)
            }
        }

        for i in 0..<A[0].count {
            let col = get(col: i, for: A)
            let total = col.reduce(0) { $0 + $1 }
            if total * 2 < col.count {
                A = flipMatrix(A, col: i)
            }
        }
        
        return A.reduce(0) { lastValue, row in
            lastValue + computeScore(row)
        }
    }
    
    private func computeScore(_ A: [Int]) -> Int {
        var val = 0
        for i in A  {
            val *= 2
            val += i
        }
        return val
    }
    
    private func flipMatrix(_ A: [[Int]], col: Int) -> [[Int]] {
        var newA = [[Int]]()
        for row in A {
            var newRow = row
            newRow[col] = newRow[col] == 0 ? 1 : 0
            newA.append(newRow)
        }
        
        return newA
    }
    
    private func flipMatrix(_ Arr: [[Int]], row: Int) -> [[Int]] {
        var A = Arr
        var copiedRow = A[row]
        copiedRow = copiedRow.map({ $0 == 0 ? 1 : 0})
        A[row] = copiedRow
        return A
    }
    
    private func get(col: Int, for A: [[Int]]) -> [Int] {
        return A.map({ $0[col] })
    }
}

---

20ms

class Solution {
    func matrixScore(_ A: [[Int]]) -> Int {
        var matrix = A
        for i in 0..<matrix.count {
            let row = matrix[i]
            if row.first == 0 {
                matrix[i] = row.map({ $0 == 0 ? 1 : 0})
            }
        }

        for j in 0..<matrix[0].count {
            var sum = 0
            for i in 0..<matrix.count where matrix[i][j] == 1 {
                sum += 1
            }
            if sum <= matrix.count / 2 {
                for i in 0..<matrix.count {
                    matrix[i][j] = matrix[i][j] == 0 ? 1 : 0
                }
            }
        }

        var result = 0
        for row in matrix {
            var v = 0
            for i in 0..<row.count {
                 v |= row[i] << (row.count-1-i)
            }
            result += v
        }

        return result
    }
}

---

20ms

class Solution {
    typealias IntArray = [Int]
    func flip(HorizontalOf Matrix:inout [IntArray] , at level : Int){
        for position in 0 ..<  Matrix[level].count {
            Matrix[level][position] ^= 1
        }
    }
    func flip(VerticalOf Matrix:inout [IntArray] , at position : Int){
        for level in 0 ..<  Matrix.count {
            Matrix[level][position] ^= 1
        }
    }
    //按照思路的解法,耗时很长
    func matrixScore(_ A: [IntArray]) -> Int {
        if A.count <= 1 {
            return A.count
        }

        var A = A

        //使最高位都变成1
        for vIdx in 0..<A.count {
            if A[vIdx][0] == 0 {
                //翻转水平列
                flip(HorizontalOf: &A, at: vIdx)
            }
        }

        var count = 0
        //根据每竖的0的个数判断是否需要翻转竖列
        for hIdx in 1..<A[0].count {
            count = 0
            for vIdx in 0..<A.count {
                if A[vIdx][hIdx] == 0 {
                    count += 1
                }
            }
            if count > A.count/2 {
                flip(VerticalOf: &A, at: hIdx)
            }
        }

        var result : Int = 0
        var carry :Int = 1
        //计算对应的十进制值
        for vIdx in (0..<A[0].count).reversed(){
            for hIdx in 0..<A.count {
                result += A[hIdx][vIdx] * carry
            }
            carry *= 2
        }
        return result
    }
}

---

24ms

class Solution {
    func matrixScore(_ A: [[Int]]) -> Int {
    var arr = A
    
    // 先将第一列转成1
    for i in 0..<arr.count {
        if arr[i][0] == 0 {
            arr[i] = arr[i].map{ $0 == 0 ? 1 : 0 }
        }
    }
    
    for j in 0..<arr[0].count {
        // 统计一列中为1的数量
        var sum = 0
        for i in 0..<arr.count where arr[i][j] == 1 {
            sum += 1
        }
        
        // 如果一列为1的数量少于一半，则该列反转
        if sum <= (arr.count/2) {
            for i in 0..<arr.count {
                arr[i][j] = arr[i][j] == 0 ? 1 : 0
            }
        }
    }
    
    // 计算
    var sum = 0
    for i in 0..<arr.count {
        let str = arr[i].map({ String($0) }).reduce("", +)
        sum += Int(str, radix: 2) ?? 0
    }
    
    return sum
   }
}