total = (sum on main diagonal) + (sum on anti-diagonal) - (value of cell)

def solve():
    import sys
    input = sys.stdin.readline

    t = int(input())
    for _ in range(t):
        n, m = map(int, input().split())
        board = [list(map(int, input().split())) for _ in range(n)]
        
        diag_main = {}  # Sums for main diagonal (i - j)
        diag_anti = {}  # Sums for anti-diagonal (i + j)
        
        # Precompute the sums for both types of diagonals
        for i in range(n):
            for j in range(m):
                d1 = i - j
                d2 = i + j
                diag_main[d1] = diag_main.get(d1, 0) + board[i][j]
                diag_anti[d2] = diag_anti.get(d2, 0) + board[i][j]
        
        max_sum = 0
        # Evaluate maximum bishop sum for every possible cell placement
        for i in range(n):
            for j in range(m):
                d1 = i - j
                d2 = i + j
                # Sum of both diagonals minus the overlapping cell (i, j)
                total = diag_main[d1] + diag_anti[d2] - board[i][j]
                if total > max_sum:
                    max_sum = total
        print(max_sum)

if __name__ == "__main__":
    solve()

▎Summary of the Approach in Simple Terms:

1. For each cell, determine which main and anti-diagonals it belongs to.

2. Sum all values on each diagonal.

3. For each cell, the bishop's attack sum equals the sum of its main diagonal plus the sum of its anti-diagonal, minus the cell’s own value (to correct for double counting).

4. Find the maximum of these sums over all cells.

def findMaxLength(nums):
    # Replace 0 with -1 for transformation
    for i in range(len(nums)):
        if nums[i] == 0:
            nums[i] = -1

    cumulative_sum = 0
    max_length = 0
    sum_index_map = {}  # To store the first occurrence of each cumulative sum

    for i, num in enumerate(nums):
        cumulative_sum += num

        # Check if cumulative_sum is 0, which means subarray from index 0 to i is valid
        if cumulative_sum == 0:
            max_length = i + 1

        # If cumulative_sum has been seen before, update max_length accordingly
        if cumulative_sum in sum_index_map:
            max_length = max(max_length, i - sum_index_map[cumulative_sum])
        else:
            sum_index_map[cumulative_sum] = i

    return max_length

# Testing the function with provided examples
print(findMaxLength([0, 1]))    # Output: 2
print(findMaxLength([0, 1, 0])) # Output: 2

class Solution:
    def findMaxLength(self, nums: List[int]) -> int:
        s = {0:-1}
        t = 0
        maxm = 0
        c1 = 0
        c0 = 0
        for i in range(len(nums)):
            if nums[i]:
                c1+=1
            else:
                c0+=1
            if c1-c0 not in s:
                s[c1-c0] = i
            else:
                maxm = max(maxm,i-s[c1-c0])
        return maxm

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy = ListNode(0,head)
        p1 = dummy
        p2 = dummy.next
        while p2:
            if p2.val==val:
                p1.next = p2.next
                p2  = p2.next
            else:
                p1 = p1.next
                p2 = p2.next
        return dummy.next

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummy = ListNode(-1,head)
        p1 = dummy
        p2 = dummy.next
        count = 0
        while p2:
            if count <n:
                p2 = p2.next
                count+=1
            else:
                p1 = p1.next
                p2 = p2.next
        if p1:
            p1.next = p1.next.next
        return dummy.next

class Solution:
    def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]:
        p1 = head
        p2 = head
        while p2 and p2.next:
            p1=p1.next
            p2 = p2.next.next
        return p1