thảo luận Leetcode mỗi ngày

func rotateTheBox(box [][]byte) [][]byte {
    rows, cols := len(box), len(box[0])
    rotated := make([][]byte, cols)
    for i := range rotated {
        rotated[i] = make([]byte, rows)
    }

    for i := 0; i < rows; i++ {
        for j := 0; j < cols; j++ {
            rotated[j][rows-1-i] = box[i][j]
        }
    }

    for col := 0; col < rows; col++ {
        bottom := cols - 1

        for cur := cols - 1; cur >= 0; cur-- {
            switch rotated[cur][col] {
            case '#':
                if cur != bottom {
                    rotated[bottom][col] = '#'
                    rotated[cur][col] = '.'
                }
                bottom--
            case '*':
                bottom = cur - 1
            }
        }
    }

    return rotated
}

class Solution {
    public long maxMatrixSum(int[][] matrix) {
        long res = 0;
        int minAbsValue = Integer.MAX_VALUE;
        int countNeg = 0;

        for (int[] row : matrix) {
            for (int val : row) {
                res += Math.abs(val);
                if (val < 0) {
                    countNeg++;
                }

                minAbsValue = Math.min(minAbsValue, Math.abs(val));
            }
        }

        if (countNeg > 0 && countNeg % 2 == 1) {
            res -= 2 * minAbsValue;
        }

        return res;
    }
}

class Solution:
    def maxMatrixSum(self, matrix: List[List[int]]) -> int:
        total = 0
        minAbs = inf
        negativeCount = 0
        m = len(matrix)
        n = len(matrix[0])
        for i in range(m):
            for j in range(n):
                if matrix[i][j] < 0:
                    negativeCount += 1

                curr = abs(matrix[i][j])
                total += curr
                minAbs = min(minAbs, curr)

        if negativeCount % 2 != 0:
            total -= 2*minAbs

        return total

class Solution {
    public long maxMatrixSum(int[][] matrix) {
        int n = matrix.length;
        long ans=0;
        long min =10000005;
        int cnt =0;
        for(int i =0 ; i < n ;i++){
            for(int j =0 ; j<n;j++){
                long cell = Math.abs(matrix[i][j]);
                if(matrix[i][j]<0){
                    cnt++;
                }
                min=Math.min(min,cell);
                ans+= cell;
            }
        }
        if(cnt%2==1) ans-=2*min;
        return ans;
    }
}

class Solution:
    def maxMatrixSum(self, matrix: List[List[int]]) -> int:
        result = 0
        m, n = len(matrix), len(matrix[0])

        minAbsValue, countNegative = 100001, 0
        for row in matrix:
            for el in row:
                minAbsValue = min(minAbsValue, abs(el))
                if el < 0:
                    countNegative += 1
                result += abs(el)
        
        if countNegative % 2 != 0:
            result -= minAbsValue * 2
        
        return result

class Solution {
    fun maxMatrixSum(matrix: Array<IntArray>): Long {
        var min = Int.MAX_VALUE
        var ans = 0L
        var negativeCnt = 0
        for (row in matrix) {
            for (value in row) {
                val absValue = if (value < 0) {
                    ++negativeCnt
                    -value
                } else value
                ans += absValue
                min = minOf(min, absValue)
            }
        }
        return if (negativeCnt % 2 == 0) ans else ans - 2 * min
    }
}

var maxMatrixSum = function(matrix) {
    let sum = 0;
    let minAbsCell = +Infinity;
    let negativeCount = 0;
    for(const row of matrix){
        for(const cell of row){
            if(cell < 0) negativeCount++;
            minAbsCell = Math.min(Math.abs(cell), minAbsCell);
            sum += Math.abs(cell);
        }
    }
    return negativeCount % 2 === 0 ? sum : sum - 2 * minAbsCell;
};

class Solution {
    func maxMatrixSum(_ matrix: [[Int]]) -> Int {
        var isEven = true
        var numNeg = Int.max
        var result = 0
        for row in matrix {
            for num in row {
                var num = num
                if num <= 0 {
                    isEven.toggle()
                    num = -num
                }
                numNeg = min(numNeg, num)
                result += num
            }
        }
        if !isEven {
            result -= numNeg*2
        }
        return result
    }
}

class Solution:
    def maxMatrixSum(self, matrix: List[List[int]]) -> int:
        neg_count = sum(num <= 0 for row in matrix for num in row)
        min_abs = min(abs(num) for row in matrix for num in row)
        total_abs = sum(abs(num) for row in matrix for num in row)

        return total_abs - 2 * min_abs if neg_count%2 else total_abs

var maxMatrixSum = function (matrix) {
    let s = 0, min = +Infinity, nc = 0;
    for (const r of matrix) {
        for (const c of r) {
            s += Math.abs(c);
            min = Math.min(min, Math.abs(c));
            nc += c < 0;
        }
    }
    return s - (nc & 1) * (min << 1);
};

class Solution {
public:
    long long maxMatrixSum(vector<vector<int>>& matrix) {
        auto hasImpairNegElem = false; auto sum = 0ll; auto minElem = 100000;
        for (const auto& row : matrix) {
            for (const auto& elem : row) {
                auto absElem = elem;
                if (elem < 0) {
                    absElem = -elem; hasImpairNegElem = !hasImpairNegElem;
                }
                if (absElem < minElem) minElem = absElem;
                sum += absElem;
            }
        }
        if (hasImpairNegElem) return sum - 2 * minElem;
        return sum;
    }
};

class Solution {
  public long maxMatrixSum(int[][] m) {
    return s(m).mapToLong(Math::abs).sum()-((s(m).filter(n->n<0).count()&1)==0?0:s(m).map(Math::abs).min().orElse(0)*2);
  }

  static IntStream s(int[][] m) { return Arrays.stream(m).flatMapToInt(Arrays::stream); }
}

public class Solution
{
    public long MaxMatrixSum(int[][] matrix)
    {
        int n = matrix.Length;
        int min = int.MaxValue;
        long sum = 0;
        bool evenNegative = true;

        for (int row = 0; row < n; row++)
        {
            for (int col = 0; col < n; col++)
            {
                int num = matrix[row][col];
                int absNum = Math.Abs(num);
                min = Math.Min(min, absNum);
                sum += absNum;

                if (num < 0)
                {
                    evenNegative = !evenNegative;
                }
            }
        }

        return evenNegative ? sum : sum -  2 * min;
    }
}

    public long MaxMatrixSum(int[][] matrix) {
        long ans = 0;
        int min = int.MaxValue;
        int sign = 1;
        foreach(var r in matrix)
        {
            foreach(var rc in r)
            {
                ans += Math.Abs(rc);
                min = Math.Min(min, Math.Abs(rc));
                if (rc < 0) sign *= -1;
            }
        }
        return sign > 0 ? ans : ans - min*2;
    }

class Solution:
    def maximumTotalDamage(self, power: List[int]) -> int:
        c1 = Counter(power)
        arr = sorted(c1.keys())
        # print(arr)
        @cache
        def dfs(i, pick_i_1, pick_i_2):
            if i >= len(arr):
                return 0

            r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11 = 0,0,0,0,0,0,0,0,0,0,0
            if not pick_i_1 and not pick_i_2:
                # pick i
                r1 = arr[i] * c1[arr[i]] + dfs(i + 1, True, False)
                # not pick i
                r2 = dfs(i + 1, False, False)

            elif pick_i_1 and not pick_i_2:
                if arr[i-1] < arr[i] - 2:
                    # pick
                    r3 = arr[i] * c1[arr[i]] + dfs(i + 1, True, True)
                    # not pick:
                    r10 = dfs(i + 1, False, True)
                else:
                    r4 = dfs(i + 1, False, True)
            
            elif pick_i_2 and not pick_i_1:
                if arr[i-2] < arr[i] - 2:
                    # pick
                    r5 = arr[i] * c1[arr[i]] + dfs(i + 1, True, False)
                    # not pick
                    r11 = dfs(i + 1, False, False)
                else:
                    r6 = dfs(i + 1, False, False)

            else: #pick both
                if arr[i-2] < arr[i-1] < arr[i] - 2:
                    # can pick i
                    r7 = arr[i] * c1[arr[i]] + dfs(i + 1, True, True)
                    # not pick i
                    r8 = dfs(i + 1, False, True)
                else:
                    r9 = dfs(i + 1, False, True)
                    # not pick i

            return max(r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11)

            # r2 = dfs(i + 1, visited_mask)
            # return max(r1, r2)
        # print(dfs(2, False, True))
        return dfs(0, False, False)