2026-06-28：按位或的最小值。用go语言，给你一个大小为 m × n 的二维整数表 grid。你需要从 每一行 里 各选出一个数（同一行只选一个，

package main

import (
    "fmt"
    "math/bits"
    "slices"
)

func minimumOR(grid [][]int) (ans int) {
    or := 0
    for _, row := range grid {
        // 每行选个最小值，计算 OR
        or |= slices.Min(row)
    }
    // 答案 <= or，那么答案的二进制长度也 <= or 的二进制长度

    // 试填法：ans 的第 i 位能不能是 0？
    // 如果在每一行的能选的数字中，都存在第 i 位是 0 的数，那么 ans 的第 i 位可以是 0，否则必须是 1
    for i := bits.Len(uint(or)) - 1; i >= 0; i-- {
        mask := ans | (1<<i - 1) // mask 低于 i 的比特位全是 1，表示 grid[i][j] 的低位是 0 还是 1 无所谓
    next:
        for _, row := range grid {
            for _, x := range row {
                // x 的高于 i 的比特位，如果 mask 是 0，那么 x 的这一位必须也是 0（注意 mask 继承了 ans 高位中的 0）
                // x 的低于 i 的比特位，随意
                // x 的第 i 个比特位，我们期望它是 0
                if x|mask == mask { // x 可以选，且第 i 位是 0
                    continue next
                }
            }
            // 这一行的可选数字中，第 i 位全是 1
            ans |= 1 << i // ans 第 i 位必须是 1
            break         // 填下一位
        }
    }
    return
}

func main() {
    grid := [][]int{{1, 5}, {2, 4}}
    result := minimumOR(grid)
    fmt.Println(result)
}

# -*-coding:utf-8-*-

from typing import List

def minimumOR(grid: List[List[int]]) -> int:
    # 计算每行最小值的 OR，作为答案的上界
    or_val = 0
    for row in grid:
        or_val |= min(row)

    ans = 0
    # 从最高位向最低位尝试填 0
    for i in range(or_val.bit_length() - 1, -1, -1):
        # mask: 高于 i 的位与 ans 一致，低于 i 的位全为 1（可任意），第 i 位为 0
        mask = ans | ((1 << i) - 1)
        for row in grid:
            for x in row:
                # 如果 x 满足：高位与 ans 已固定的 0 对齐，且第 i 位为 0
                if (x | mask) == mask:
                    break
            else:
                # 这一行找不到满足条件的数，第 i 位必须填 1
                ans |= (1 << i)
                break
    return ans


if __name__ == "__main__":
    grid = [[1, 5], [2, 4]]
    result = minimumOR(grid)
    print(result)

#include <iostream>
#include <vector>
#include <algorithm>

int minimumOR(const std::vector<std::vector<int>>& grid) {
    // 计算每行最小值的按位或，作为答案的上界
    int orVal = 0;
    for (const auto& row : grid) {
        orVal |= *std::min_element(row.begin(), row.end());
    }

    // 计算 orVal 的二进制长度（位数）
    int bits = 0;
    int tmp = orVal;
    while (tmp) {
        ++bits;
        tmp >>= 1;
    }

    int ans = 0;
    // 试填法：从高位到低位尝试让 ans 的第 i 位为 0
    for (int i = bits - 1; i >= 0; --i) {
        // mask: 低于 i 的位全为 1，第 i 位为 0，高于 i 的位与 ans 保持一致
        int mask = ans | ((1 << i) - 1);

        bool possible = true;
        for (const auto& row : grid) {
            bool rowOk = false;
            for (int x : row) {
                // 检查 x 是否满足：高位对齐 ans 的 0 位，且第 i 位为 0
                if ((x | mask) == mask) {
                    rowOk = true;
                    break;
                }
            }
            if (!rowOk) {
                possible = false;
                break;
            }
        }

        // 如果某一行无法选出第 i 位为 0 的数，则 ans 的第 i 位必须为 1
        if (!possible) {
            ans |= (1 << i);
        }
    }

    return ans;
}

int main() {
    std::vector<std::vector<int>> grid = {{1, 5}, {2, 4}};
    int result = minimumOR(grid);
    std::cout << result << std::endl;
    return0;
}