Auto comment: topic has been updated by bus_u_he (previous revision, new revision, compare).

Share your code

If you managed to take some minimum value from the first array, that does not mean that it is the best idea to use that value. Ex: first array: [1, 2], second array: [2, 2]. If you take 1 from the first array because it is smaller, then you get the answer of 3, but the minimum value is 2.

One corect solution is as follows:

For each bit from most signifficant to least signifficant check if there is some element in each array that has that bit off. If so, then there is some way to pick the numbers so you don't have this bit set in the answer. Then you need to reduce each array. Remove the numbers that have that bit set since if you take them, you break the minimality.

If however there is some array where no element has the bit off then there is no way to get this bit off in the final solution. No array reduction is required, as you can take either on or off numbers without influencing this bit.

This way you build both the minimum value, and (can then build) all the posibilities (each array only has "useful" values at the end so picking any one of them from each array constitutes a good solution)

The time complexity is $$$O(N\cdot M\cdot \log A)$$$ where $$$A$$$ is the biggest value in the input.

what were the constraints? I have an O(32 * n * m * log(m)) algorithm. Idea is similar to above comment but I use sets, so additional log(m) factor.

for the 2nd if statement return INT_MAX instead of 1e7.

Input : 

1
4 4
434581591  366413825  351340371  81099756
443064262  783025542  980413631  511982969
956581993  979244577  507833677  890948799
808418018  212545955  683065029  351233430

Expected Output : 520093695

Your Output : 10000000

Auto comment: topic has been updated by bus_u_he (previous revision, new revision, compare).

Implementing The-Winner's solution cuz I liked it. Other than that, maybe it can be useful for some people:

#include <bits/stdc++.h>

using namespace std;
using i64 = long long;

void solve() {
    int n, m; cin >> n >> m;
    vector<vector<int>> g (n, vector<int> (m));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> g[i][j];
        }
    }
    //checks if each array has atleast one element where the bth bit is off or not
    auto check = [&] (int b) -> bool { 
        vector<vector<int>> v (n);
        for (int i = 0; i < n; ++i) {
            for (int x: g[i]) {
                if ((x & (1 << b)) == 0) {
                    v[i].push_back(x);
                }
            }
            if (v[i].size() == 0) return false;
        }
        g = v;
        return true;
    };
    int ans = 0;
    for (int b = 16; b >= 0; --b) {
        if (!check(b)) ans |= (1 << b);
    }
    cout << ans << '\n';
}

signed main() {
    ios::sync_with_stdio(false); cin.tie(nullptr);
    solve();
    return 0;
}

If you want to solve another problem that uses an idea similar to the one suggested by The-Winner you can try this.

I think we can use a greedy idea.