Language: C++

#ifdef _DEBUG
#include "../../library/library/debug_template.cpp"
#define DMP(...) dump(#__VA_ARGS__, __VA_ARGS__)
#else
#define DMP(...) ((void)0)
#endif

#include <cassert>
#include <cstdio>
#include <cmath>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <unordered_set>
#include <map>
#include <queue>
#include <numeric>
#include <algorithm>

using namespace std;
using lint = long long;
constexpr int MOD = 1000000007, INF = 1010101010;
constexpr lint LINF = 1LL << 60;

struct init {
	init() {
		cin.tie(nullptr); ios::sync_with_stdio(false);
		cout << fixed << setprecision(10);
	}
} init_;

template<class T>
struct Point2D {
	T x, y;
	constexpr Point2D(T x = 0, T y = 0) noexcept : x(x), y(y) {};
	constexpr Point2D(pair<T, T>& p) noexcept : x(p.first), y(p.second) {};
	constexpr bool operator==(const Point2D& rhs) const noexcept { return x == rhs.x && y == rhs.y; }
	constexpr bool operator!=(const Point2D& rhs) const noexcept { return !((*this) == rhs); }
	constexpr bool operator< (const Point2D& rhs) const noexcept { return x < rhs.x || (x == rhs.x && y < rhs.y); }
	constexpr bool operator> (const Point2D& rhs) const noexcept { return rhs < (*this); }
	constexpr bool operator<=(const Point2D& rhs) const noexcept { return !((*this) > rhs); }
	constexpr bool operator>=(const Point2D& rhs) const noexcept { return !((*this) < rhs); }
	constexpr Point2D  operator+ (const Point2D& rhs) const noexcept { return { x + rhs.x, y + rhs.y }; }
	constexpr Point2D  operator- (const Point2D& rhs) const noexcept { return { x - rhs.x, y - rhs.y }; }
	constexpr Point2D  operator* (const T& k) const noexcept { return { k * x, k * y }; }
	constexpr Point2D  operator/ (const T& k) const noexcept { return { x / k, y / k }; }
	constexpr Point2D& operator+=(const Point2D& rhs) noexcept { return ((*this) = (*this) + rhs); }
	constexpr Point2D& operator-=(const Point2D& rhs) noexcept { return ((*this) = (*this) - rhs); }
	constexpr Point2D& operator*=(const T& k) noexcept { return ((*this) = (*this) * k); }
	constexpr Point2D& operator/=(const T& k) noexcept { return ((*this) = (*this) / k); }
	constexpr Point2D  operator- () const noexcept { return { -x, -y }; }
	constexpr T operator* (const Point2D& rhs) const noexcept { return x * rhs.x + y * rhs.y; }
	constexpr Point2D nor() const noexcept { return { y, -x }; }
	constexpr long double hypot() const noexcept { return ::hypotl(x, y); }
	friend istream& operator>>(istream& is, Point2D& p) { return is >> p.x >> p.y; }
	friend ostream& operator<<(ostream& os, const Point2D& p) { return os << p.x << " " << p.y; }
	template<class U> U& operator[](vector<vector<U>>& v) { return v[x][y]; }
};

using pnt = Point2D<lint>;

inline size_t fnv1a_64(string data) {

	uint64_t hash = 0xcbf29ce484222325;
	uint64_t prime = 0x100000001b3;

	for (int i = 0; i < (int)data.size(); ++i) {
		hash = hash ^ data[i];
		hash *= prime;
	}

	return hash;

}

namespace std {
	template<>
	struct hash<pnt> {
	public:
		size_t operator()(const pnt& data) const {
			auto key = data.x * 1000000 + data.y;
			return fnv1a_64(to_string(key));
		}
	};
}


template<class T>
inline bool chmax(T& a, const T b) { return a < b && (a = b, true); }

int main() {

	int h, w, m;
	cin >> h >> w >> m;

	set<pnt> p;
	map<int, int> row, col;
	for (int i = 0; i < m; i++) {
		int r, c;
		cin >> r >> c;
		r--, c-- ;
		p.emplace(r, c);
		row[r]++;
		col[c]++;
	}

	vector<int> indr;
	int max_r = 0;
	for (const auto [r, nr] : row) {
		if (chmax(max_r, nr)) {
			indr.clear();
		}
		if (max_r == nr) {
			indr.emplace_back(r);
		}
	}

	vector<int> indc;
	int max_c = 0;
	for (const auto [c, nc] : col) {
		if (chmax(max_c, nc)) {
			indc.clear();
		}
		if (max_c == nc) {
			indc.emplace_back(c);
		}
	}

	DMP(indr, indc);

	if (indr.size() * indc.size() < m) {
		for (const auto& r : indr) {
			for (const auto& c : indc) {
				DMP(r, c);
				if (p.find(pnt(r, c)) != p.end()) {
					cout << max_r + max_c - 1 << "\n";
					return 0;
				}
			}
		}
	}

	cout << max_r + max_c << "\n";

	return 0;
}


Compiler output:
a.cc: In function 'size_t fnv1a_64(std::string)':
a.cc:65:9: error: 'uint64_t' was not declared in this scope
   65 |         uint64_t hash = 0xcbf29ce484222325;
      |         ^~~~~~~~
a.cc:20:1: note: 'uint64_t' is defined in header '<cstdint>'; this is probably fixable by adding '#include <cstdint>'
   19 | #include <algorithm>
  +++ |+#include <cstdint>
   20 | 
a.cc:66:17: error: expected ';' before 'prime'
   66 |         uint64_t prime = 0x100000001b3;
      |                 ^~~~~~
      |                 ;
a.cc:69:22: error: expected unqualified-id before '=' token
   69 |                 hash = hash ^ data[i];
      |                      ^
a.cc:70:22: error: expected unqualified-id before '*=' token
   70 |                 hash *= prime;
      |                      ^~
a.cc:73:20: error: missing template arguments before ';' token
   73 |         return hash;
      |                    ^
a.cc: In function 'int main()':
a.cc:97:9: error: 'set' was not declared in this scope
   97 |         set<pnt> p;
      |         ^~~
a.cc:20:1: note: 'std::set' is defined in header '<set>'; this is probably fixable by adding '#include <set>'
   19 | #include <algorithm>
  +++ |+#include <set>
   20 | 
a.cc:97:16: error: expected primary-expression before '>' token
   97 |         set<pnt> p;
      |                ^
a.cc:97:18: error: 'p' was not declared in this scope
   97 |         set<pnt> p;
      |                  ^