...#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define int 	     	  long long   // [9,223,372,036,854,775,807 to -9.....808] 19 digits
#define pb                push_back
#define all(x)            (x).begin(),(x).end()
#define mp                make_pair
#define vi                vector<int>
#define vpi               vector<pair<int,int>>
#define mii               map<int,int>
#define x                 first
#define y                 second
#define mem(a,x)          memset(a,x,sizeof(a))
#define rep(i,a,b)        for(int i=a;i<b;i++)
#define sz(x)             (int)((x).size())
 
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set; // find_by_order()  // order_of_key
 
//const int32_t hellhsh = 444440583533; const double pi=2*acos(0.0);
const int32_t mod = 1e9+7;
const int32_t maxn=2e5+5;
int inf=1e18;
 
int dx[5]={-2,-1,0,+1,+2},dy[5]={-2,-1,0,+1,+2};
int n,m,r1,c1,r2,c2,dp[1005][1005];
string s[1005];
 
 
void solve(){
    cin>>n>>m>>r1>>c1>>r2>>c2;
    rep(i,0,n) cin>>s[i];
    rep(i,0,n) rep(j,0,m) dp[i][j]=LLONG_MAX;
    r1--;r2--;c1--;c2--;
    dp[r2][c2]=0;
 
 
    priority_queue<pair<int,pair<int,int>>> q;
 
    q.push(mp(0,mp(r2,c2)));
 
    while(sz(q)){
        auto d=-q.top().x;
        auto pos=q.top().y;
        q.pop();
 
        rep(i,0,5){
            rep(j,0,5){
                if(!dx[i] and !dy[j]) continue;
 
                int x=dx[i]+pos.x;
                int y=dy[j]+pos.y;
                if(x<0 or y<0 or x>=n or y>=m or s[x][y]=='#') continue;
                
 
                if((abs(dx[i])==1 and !dy[j]) or (abs(dy[j])==1 and !dx[i])){
                    if(dp[x][y]>d){
                        dp[x][y]=d;
                        q.push(mp(-d,mp(x,y)));
                    }
                }
                else{
                    if(dp[x][y]>d+1){
                        dp[x][y]=d+1;
                        q.push(mp(-d-1,mp(x,y)));
                    }
                }
            }
        }
    }
 
    if(dp[r1][c1]==LLONG_MAX) cout<<-1;
    else cout<<dp[r1][c1];
}
 
signed main(){
    ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    int tc=1,k=1;
    //cin>>tc;
    while(tc--){
        //cout<<"Case #"<<k++<<": ";
        solve();
    }
    return 0;
}

answer is maximum number of bombs in a row + maximum number of bombs in a column
or
maximum number of bombs in a row + maximum number of bombs in a column — 1

You should choose a point with row has maximum number of bombs in a row and col maximum number of bombs in a column
because :
In this way you get atleast maximum number of bombs in a row + maximum number of bombs in a column — 1
otherwise you will get atmost maximum number of bombs in a row + maximum number of bombs in a column — 1
create two vectors with :
1. rows with maximum number of bombs
2. cols with maximum number of bombs

if size of first vector * size of second vector > 300000
then output maximum number of bombs in a row + maximum number of bombs in a column
otherwise :
bruteforce on every row with maximum number of bombs and every col with maximum number of bombs
hint in hint : Use a map to know you have a bomb in one cell or not

#include <bits/stdc++.h>

using namespace std;

const int N = 300004;
int cnth[N], cntw[N], x[N], y[N];
map <int, bool> mp[N];

int32_t main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int h, w, m;
    cin >> h >> w >> m;
    for (int i = 0; i < m; i++) {
        cin >> x[i] >> y[i];
        mp[x[i]][y[i]] = true;
        cnth[x[i]]++, cntw[y[i]]++;
    }
    int mxh = 0, mxw = 0;
    for (int i = 0; i < N; i++) {
        mxh = max(mxh, cnth[i]);
        mxw = max(mxw, cntw[i]);
    }
    vector <int> hall, wall;
    for (int i = 0; i < N; i++) {
        if (cnth[i] == mxh) {
            hall.push_back(i);
        }
        if (cntw[i] == mxw) {
            wall.push_back(i);
        }
    }
    int cnt = 0, mx = 0;
    for (int i = 0; i < hall.size(); i++) {
        for (int j = 0; j < wall.size(); j++) {
            cnt++;
            if (cnt > N * 2)
                break;
            mx = max(mx, mxh + mxw - mp[hall[i]][wall[j]]);
        }
        if (cnt > N * 2)
            break;
    }
    cout << mx;
}

import sys,bisect

from sys  import stdin,stdout

from bisect import bisect_left,bisect_right,bisect,insort,insort_left,insort_right

from math import gcd,ceil,floor,sqrt

from collections import Counter,defaultdict,deque,OrderedDict

from queue import Queue,PriorityQueue

from string import ascii_lowercase

sys.setrecursionlimit(10**6)
INF = float('inf')
MOD = 998244353
mod = 10**9+7

def mp():
    return map(int,stdin.readline().split())

def pr(n):
    stdout.write(str(n)+"\n")
    
def solve():
    r,c,m=mp()
    row={}
    col={}
    dd={}
    d={}
    for i in range(m):
        a,b=mp()
        row[a]=row.get(a,0)+1
        col[b]=col.get(b,0)+1
    
        if a in d:
            d[a].add(b)
        else:
            d[a]={b}

        if b in dd:
            dd[b].add(a)
        else:
            dd[b]={a}
    
    miR,miC=float('-inf'),float('-inf')
    
    for i in row:
        if row[i]>miR:
            miR=row[i]
            R=i
    for i in col:
        if col[i]>miC:
            miC=col[i]
            C=i

    ans=float('-inf')

    for i in col:
        c=miR+col[i]
        if i in d[R]:
            c-=1
        ans=max(ans,c)

    for  i in row:
        c=miC+row[i]
        if i in dd[C]:
            c-=1
        ans=max(ans,c)

    pr(ans)
        
for _ in range(1):
    solve()
    

We process the cards in groups of three — we hold two cards, pick the next three cards, then decide which two we want to keep. We can solve it in $$$O(N^3)$$$ using DP with states $$$dp(position, card1, card2)$$$, and optimize it to $$$O(N^2)$$$ with states $$$dp(card1, card2)$$$ with the additional constraint that either the first or second card must be at the last group of three we processed.

From the current state, we can either transition to the next immediate group of three, or find the next occurrence of the first (or second) card type and transition to that group of three, ignoring the groups in between. The intuition behind the second transition is that we decided to keep the first (or second) card type for future points, so we can ignore all groups not containing it.

My submission: https://atcoder.jp/contests/abc176/submissions/16141029

#include "bits/stdc++.h"
using namespace std;

#define sz(x) (int)(x.size())
#define FOR(i,L,R) for(int i = L; i <= R; i++)

const int N = 3e5 + 2;

int n, m, cnt_x[N], cnt_y[N];
set<pair<int,int>> given;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

int32_t main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

    cin >> n >> m;
    int t;
    cin >> t;
    while(t--) {
        int x, y;
        cin >> x >> y;
        given.insert({x, y});
        cnt_x[x]++;
        cnt_y[y]++;
    }
    int maxx = 0, maxy = 0;
    set<int> whichx, whichy;

    FOR(i,1,N-1) {
        maxx = max(maxx, cnt_x[i]);
        maxy = max(maxy, cnt_y[i]);
    }
    FOR(i,1,N-1) {
        if(cnt_x[i] == maxx) {
            whichx.insert(i);
        }
        if(cnt_y[i] == maxy) {
            whichy.insert(i);
        }
    }

    int cnt_pairs = 0;
    for(auto& p : given) {
        int x = p.first;
        int y = p.second;
        if(whichx.count(x) && whichy.count(y))
            cnt_pairs++;
    }

    if(cnt_pairs == sz(whichx) * sz(whichy)) 
        cout << maxx + maxy - 1;
    else cout << maxx + maxy;
}

import sys,bisect

from sys  import stdin,stdout

from bisect import bisect_left,bisect_right,bisect,insort,insort_left,insort_right

from math import gcd,ceil,floor,sqrt

from collections import Counter,defaultdict,deque,OrderedDict

from queue import Queue,PriorityQueue

from string import ascii_lowercase

sys.setrecursionlimit(10**6)
INF = float('inf')
MOD = 998244353
mod = 10**9+7

def mp():
    return map(int,stdin.readline().split())

def pr(n):
    stdout.write(str(n)+"\n")
    
def solve():
    r,c,m=mp()
    row={}
    col={}
    dd={}
    d={}
    for i in range(m):
        a,b=mp()
        row[a]=row.get(a,0)+1
        col[b]=col.get(b,0)+1
    
        if a in d:
            d[a].add(b)
        else:
            d[a]={b}

        if b in dd:
            dd[b].add(a)
        else:
            dd[b]={a}
    
    miR,miC=float('-inf'),float('-inf')
    
    for i in row:
        if row[i]>miR:
            miR=row[i]
            R=i
    for i in col:
        if col[i]>miC:
            miC=col[i]
            C=i

    ans=float('-inf')

    for i in col:
        c=miR+col[i]
        if i in d[R]:
            c-=1
        ans=max(ans,c)

    for  i in row:
        c=miC+row[i]
        if i in dd[C]:
            c-=1
        ans=max(ans,c)

    pr(ans)
        
for _ in range(1):
    solve()