Problem:
 Score : 500 points    Problem Statement We have a two-dimensional grid with H \times W squares. There are M targets to destroy in this grid - the position of the i -th target is \left(h_i, w_i \right) .  Takahashi will choose one square in this grid, place a bomb there, and ignite it. The bomb will destroy all targets that are in the row or the column where the bomb is placed. It is possible to place the bomb at a square with a target.  Takahashi is trying to maximize the number of targets to destroy. Find the maximum number of targets that can be destroyed.      Constraints  All values in input are integers.  1 \leq H, W \leq 3 \times 10^5  1 \leq M \leq \min\left(H\times W, 3 \times 10^5\right)  1 \leq h_i \leq H  1 \leq w_i \leq W  \left(h_i, w_i\right) \neq \left(h_j, w_j\right) \left(i \neq j\right)         Input Input is given from Standard Input in the following format:  H  W  M  h_1  w_1  \vdots  h_M  w_M       Output Print the answer.        Sample Input 1 2 3 3
2 2
1 1
1 3      Sample Output 1 3  We can destroy all the targets by placing the bomb at \left(1, 2\right) .       Sample Input 2 3 3 4
3 3
3 1
1 1
1 2      Sample Output 2 3       Sample Input 3 5 5 10
2 5
4 3
2 3
5 5
2 2
5 4
5 3
5 1
3 5
1 4      Sample Output 3 6

Solution (Python):
H, W, M = map(int, input().split())
Hdst = [0]*H
Wdst = [0]*W
DST = [[0] * M for i in range(2)]
for i in range(M):
    hi, wi = map(int, input().split())
    Hdst[hi-1] += 1
    Wdst[wi-1] += 1
    DST[0][i] = hi-1
    DST[1][i] = wi-1

Hdstmax = max(Hdst)
Wdstmax = max(Wdst)
Hbomb = [i for i, x in enumerate(Hdst) if x == Hdstmax]
Wbomb = [i for i, x in enumerate(Wdst) if x == Wdstmax]

Hchk = [False]*H
Wchk = [False]*W
for i in Hbomb:
    Hchk[i] = True
for i in Wbomb:
    Wchk[i] = True

tmp = 0
for i in range(M):
    if Hchk[DST[0][i]] and Wchk[DST[1][i]]:
        tmp += 1

if len(Hbomb)*len(Wbomb) == tmp:
    print(Hdstmax + Wdstmax - 1)
else:
    print(Hdstmax + Wdstmax)

Solution (Python):
from sys import stdin, setrecursionlimit
input = stdin.buffer.readline

from collections import deque, defaultdict, Counter

H, W, M = map(int, input().split())
hw = [list(map(int, input().split())) for _ in range(M)]

cnt = defaultdict(int)
cnt_h = defaultdict(int)
cnt_w = defaultdict(int)

for h, w in hw:
    cnt[(h, w)] += 1

for h, w in hw:
    cnt_h[h] += 1
    cnt_w[w] += 1
cnt_h = list(cnt_h.items())
cnt_w = list(cnt_w.items())
cnt_h.sort(key = lambda x: -x[1])
cnt_w.sort(key = lambda x: -x[1])

max_h = []
max_w = []
for h, n in cnt_h:
    if n == cnt_h[0][1]:
        max_h.append(h)
for w, n in cnt_w:
    if n == cnt_w[0][1]:
        max_w.append(w)

answer = cnt_h[0][1] + cnt_w[0][1]
for mh in max_h:
    for mw in max_w:
        if cnt[(mh, mw)] == 0:
            print(answer)
            exit()

print(answer - 1)

Solution (Python):
H,W,M = map(int,input().split(" "))

bomb = set()
RMAX = 0
CMAX = 0
rmax = []
cmax = []
row = [0]*(H+1)
col = [0]*(W+1)

for _ in range(M) :
    bi, bj = map(int,input().split(" "))
    bomb.add((bi,bj))
    row[bi]+=1
    if row[bi] > RMAX :
        RMAX = row[bi]
        rmax = [bi]
    elif row[bi] == RMAX:
        rmax.append(bi)
    
    col[bj] += 1
    if col[bj] > CMAX:
        CMAX = col[bj]
        cmax = [bj]
    elif col[bj] == CMAX:
        cmax.append(bj)



if M < len(cmax)*len(rmax):
    print(CMAX+RMAX)
else:
    res = CMAX+RMAX-1
    done = False
    for i in rmax :
        for j in cmax : 
            if (i,j) not in bomb:
                res+=1
                done = True
                break
            
        if done :
            break
    print(res)

Solution (Python):

"""

import numpy as np
i4 = np.int32
i8 = np.int64


def solve(h, w, s, H, W):
    h_max = []
    w_max = []
    hm = h.max()
    wm = w.max()
    for i in range(H + 1):
        if h[i] == hm:
            h_max.append(i)
    for i in range(W + 1):
        if w[i] == wm:
            w_max.append(i)

    for hj in h_max:
        for wj in w_max:
            if not (hj, wj) in s:
                return hm + wm
    return hm + wm - 1


def main(in_file):
    stdin = open(in_file)
    data_in = np.array([int(x) for x in stdin.read().split()])
    H, W, M = data_in[:3]
    hw = data_in[3:]
    h = np.zeros(H + 1, i8)
    w = np.zeros(W + 1, i8)
    s = set()
    for i in range(M):
        h[hw[2 * i]] += 1
        w[hw[2 * i + 1]] += 1
        s.add((hw[2 * i], hw[2 * i + 1]))
    ans = solve(h, w, s, H, W)
    print(ans)


def main2():
    main('/dev/stdin')
"""
import os, sys
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
if len(sys.argv) == 1:
    import subprocess
    if p == "":
        pymain = "./" + pymain
    subprocess.call(pymain)
else:
    import gzip, base64, stat
    gz = b'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'
    bin = gzip.decompress(base64.b64decode(gz))
    with open(pymain, "wb") as f:
        f.write(bin)
    os.chmod(pymain, 0o775)

Solution (Python):
import sys
input = sys.stdin.readline
 
h,w,m = list(map(int,input().split()))

R = [0]*h
C = [0]*w
G = {}

for _ in range(m):
  a,b = list(map(int,input().split()))
  a,b = a-1, b-1
  R[a] += 1
  C[b] += 1
  G[(a,b)] = 1
  
hhh = max(R)
ccc = max(C)
hei,wei = [],[]

for i in range(h):
  if R[i]==hhh:
    hei.append(i)
    
for i in range(w):
  if C[i]==ccc:
    wei.append(i)
  
  
best = 0
for i in hei:
  for j in wei:
    cor = 0
    if (i,j) in G:
      cor = 1
    best = max(best,R[i]+C[j] - cor)
    if cor==0:
      break
  if cor==0:
      break
      
print(best)

Solution (Python):
h,w,m = map(int,input().split())
hli = [0]*h
wli = [0]*w
li = []
liset = set()
for i in range(m):
    a,b = map(int,input().split())
    li.append([a,b])
    liset.add((a,b))
    hli[a-1] += 1
    wli[b-1] += 1
a = max(hli)
b = max(wli)
hli2 = []
wli2 = []
for i in range(h):
    if hli[i] == a:
        hli2.append(i+1)
for i in range(w):
    if wli[i] == b:
        wli2.append(i+1)
for i in hli2:
    for j in wli2:
        if (i,j) not in liset:
            print(a + b)
            exit()
print(a + b - 1)

Solution (Python):
def main():
    H, W, M = map(int, input().split())
    bombs = [list(map(int, input().split())) for i in range(M)]
    
    if M == 1:
        return 1
    
    hw = [0] * H
    wh = [0] * W
    
    for i in range(len(bombs)):
        [h, w] = bombs[i]
        hw[h-1] += 1
        wh[w-1] += 1
    
    hw_tuple_list = []
    for i in range(len(hw)):
        hw_tuple_list.append((hw[i], i+1))
    
    wh_tuple_list = []
    for i in range(len(wh)):
        wh_tuple_list.append((wh[i], i+1))

    h_list = sorted(hw_tuple_list, reverse = True)
    w_list = sorted(wh_tuple_list, reverse = True)

    h_max = h_list[0][0]
    h_idx_list = []
    check_h = [0] * H
    for i in range(len(h_list)):
        if h_max > h_list[i][0]:
            break
        h_idx_list.append(h_list[i][1])
        check_h[h_list[i][1]-1] = 1

    w_max = w_list[0][0]
    w_idx_list = []
    check_w = [0] * W
    for i in range(len(w_list)):
        if w_max > w_list[i][0]:
            break
        w_idx_list.append(w_list[i][1])
        check_w[w_list[i][1]-1] = 1
    
    cnt = 0
    for [h, w] in bombs:
        if check_h[h-1] == 1 and check_w[w-1] == 1:
            cnt += 1
    return h_max + w_max if cnt != len(h_idx_list) * len(w_idx_list) else h_max + w_max - 1

if __name__ == '__main__':
    print(main())

Solution (Python):
H,W,M = map(int,input().split())
Hinx = [0 for _ in range(H+1)]
Winx = [0 for _ in range(W+1)]
isExist = []
for i in range(M):
    h,w = map(int,input().split())
    Hinx[h] += 1
    Winx[w] += 1
    isExist.append((h,w))

HMinx = []
WMinx = []
Hmax = max(Hinx)
Wmax = max(Winx)
ans = Hmax + Wmax

isExist = set(isExist)
for i in range(1,H+1):
    if Hinx[i] == Hmax:
        HMinx.append(i)
for i in range(1,W+1):
    if Winx[i] == Wmax:
        WMinx.append(i)

cross = 0
not_cross = 0

flag = True
for i in HMinx:
    for j in WMinx:
        if (i,j) not in isExist:
            flag = False
            break
    if flag == False:
        break
if flag == False:
    print(ans)
else:
    print(ans-1)

Solution (Python):
import sys

h, w, m = map(int, input().split())
row = [0]*h
col = [0]*w
bomb = set()
for x in range(m):
    H, W = map(int, input().split())
    bomb.add((H-1, W-1))
    row[H-1] += 1
    col[W-1] += 1

maxrow = max(row)
maxcol = max(col)
ans = maxcol + maxrow - 1
p, q = [], []
for i in range(h):
    if row[i] == maxrow:
        p.append(i)
for i in range(w):
    if col[i] == maxcol:
        q.append(i)

for i in p:
    for j in q:
        if (i, j) not in bomb:
            print(ans + 1)
            exit()
print(ans)

Solution (Python):
import sys
readline=sys.stdin.readline

H,W,M = map(int,readline().split())

hcol = [[0,i] for i in range(H)]
wcol = [[0,i] for i in range(W)]

P = set()
for i in range(M):
  h,w = map(int,readline().split())
  h -= 1
  w -= 1
  hcol[h][0] += 1
  wcol[w][0] += 1
  P.add((h,w))
  
hcol = sorted(hcol, key = lambda x:x[0], reverse = True)
wcol = sorted(wcol, key = lambda x:x[0], reverse = True)

hmax = hcol[0][0]
wmax = wcol[0][0]

ans = 0
hind = 0
wind = 0


found = False
while hind < H:
  while wind < W:
    val = hcol[hind][0] + wcol[wind][0]
    if (hcol[hind][1],wcol[wind][1]) in P:
      val -= 1
    else:
      found = True
      ans = val
      break
    if ans < val:
      ans = val
    wind += 1
    if wind == W or wcol[wind][0] < wmax:
      wind = 0
      break
  if found:
    break
  hind += 1
  if hind == H or hcol[hind][0] < hmax:
    break
    
print(ans)

Solution (Python):
from collections import defaultdict

h, w, m = map(int, input().split())

row_dict = defaultdict(int)
col_dict = defaultdict(int)
row_col_dict = defaultdict(set)
for _ in range(m):
    row, col = map(int, input().split())
    row_dict[row] += 1
    col_dict[col] += 1
    row_col_dict[row].add(col)

max_row = max(row_dict.values())
max_col = max(col_dict.values())

max_rows = [k for k, v in row_dict.items() if v == max_row]
max_cols = [k for k, v in col_dict.items() if v == max_col]
ans = max_row + max_col - 1
flg = False
if ans < m:
    for row in max_rows:
        for col in max_cols:
            if not col in row_col_dict[row]:
                ans += 1
                flg = True
                break
        if flg:
            break

print(ans)

Solution (Python):

(h, w, m), *s = [[*map(int, i.split())] for i in open(0)]
r = [0] * (h + 1)
c = [0] * (w + 1)
for x, y in s:
    r[x] += 1
    c[y] += 1
R = max(r)
nr = {i for i, x in enumerate(r) if x == R}
C = max(c)
nc = {i for i, x in enumerate(c) if x == C}
count = sum(x in nr and y in nc for x, y in s)
print(R + C - (len(nr) * len(nc) == count))

Solution (Python):
import sys
import collections

sys.setrecursionlimit(10**6)
input = sys.stdin.readline


def main():
    H, W, M = map(int, input().split())
    bombs = []
    for _ in range(M):
        h, w = map(int, input().split())
        bombs.append((h, w))
    bombs_set = set(bombs)
    g = list(zip(*bombs))
    g0 = collections.Counter(g[0])
    g1 = collections.Counter(g[1])
    g0items = list(g0.items()); g0items.sort(key=lambda x: x[1], reverse=True)
    g1items = list(g1.items()); g1items.sort(key=lambda x: x[1], reverse=True)
    x = g0items[0][0];countx = g0items[0][1]
    y = g1items[0][0];county = g1items[0][1]
    for xx, s in g0items:
        if s != countx:
            continue
        for yy, t in g1items:
            if t != county:
                break
            if (xx, yy) not in bombs_set:
                x, y = xx, yy
                break
    ans = countx + county - ((x, y) in bombs)
    print(ans)


if __name__ == "__main__":
    main()