Submission #39391605

---

Source Code Expand

#include <iostream>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <random>
#include <climits>
#include <bitset>
//#include <bit>
//#include <tuple>
//#include <atcoder/modint>

namespace my_template
{
#define flush fflush(stdout)
#define endl '\n'
#define all(v) v.begin(), v.end()
using namespace std;
//using namespace atcoder;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<ll, ll> Pl;
const int mod1 = (int)1e9 + 7, mod2 = (int)998244353;
const int INF = 1e9 + 1e6;
const ll LINF = 1e18 + 1e9;
//const int INF = INT32_MAX - 100;
//const ll LINF = LLONG_MAX - 100;
const int di[9] = {1, 0, -1, 0, 1, 1, -1, -1, 0}, dj[9] = {0, 1, 0, -1, -1, 1, -1, 1, 0};

#define rep0(i, n) for (i = 0; i < n; i++)
#define rep1(i, a, b) for (i = a; i < b; i++)
#define reprev(i, n) for (i = n - 1; i >= 0; i--)

#define cumsum(v, l, r) (l <= 0)? v[r - 1] : (v[r - 1] - v[l - 1])

#define lnprint(b) if (b){cout << endl;}else{cout << ' ';}

template <typename T>
T my_abs(T x){
    return (x >= 0) ? x : -x;
}

template <typename T>
bool chmax(T &a, T b){
    if (a < b){
        a = b;
        return true;
    }
    return false;
}

template <typename T>
bool chmin(T &a, T b){
    if (a > b){
        a = b;
        return true;
    }
    return false;
}

ll safe_mod(ll a, ll m){
    return (a % m + m) % m;
}

template<class S, class T>
void add(S &a, T b, int mod){
    assert(mod > 0);
    b = safe_mod(b, mod);
    a = (a + b) % mod;
}

ll extgcd(ll a, ll b, ll &p, ll &q){
    if (b == 0){
        p = 1;
        q = 0;
        return a;
    }
    ll d;
    d = extgcd(b, a % b, q, p);
    q -= a / b * p;
    return d;
}

ll gcd(ll a, ll b){
    ll p, q;
    return extgcd(a, b, p, q);
}

bool incld_bit(ll bit, int i){
    return ((bit >> i) & 1) == 1;
}

template<class T>
int my_popcount(T x, int dig = 100){
    int res;
    res = 0;
    while (x > 0 && dig > 0){
        res += (x&1);
        x >>= 1;
        dig--;
    }
    return res;
}

ll sttoint(string s){
    ll res;
    res = 0;
    for (char c: s){
        res = res * 10 + c - '0';
    }
    return res;
}

string inttost(ll x){
    string res;
    if (x == 0) return "0";
    while (x){
        res += '0' + x % 10;
        x /= 10;
    }
    reverse(res.begin(), res.end());
    return res;
}

double my_dist(P a, P b){
    ll dx, dy;
    dx = a.first - b.first;
    dy = a.second - b.second;
    return sqrt(dx * dx + dy * dy);
}

template<class T>
T multiset_max(multiset<T> &ms){
    assert(ms.empty() == false);
    auto back = ms.end();
    back--;
    return *back;
}

template<class T>
bool multiset_erase_one(multiset<T> &ms, T element){
    auto ite = ms.find(element);
    if (ite != ms.end()){
        ms.erase(ite);
        return true;
    }
    return false;
}

}

// --------------------------------------------------------------------------------

using namespace my_template;

int main(void){
    int i, j;
    int h, w, n;
    vector<int> x, y;

    cin >> h >> w >> n;
    x.resize(n);
    y.resize(n);
    rep0(i, n){
        cin >> x[i] >> y[i];
        x[i]--;
        y[i]--;
    }

    set<P> ps, testps;
    const int dip[4] = {0, 0, 1, 1};
    const int djp[4] = {0, 1, 0, 1};
    rep0(i, n){
        ps.insert(P(x[i], y[i]));
        rep0(j, 4){
            int tx, ty;
            tx = x[i] - dip[j];
            ty = y[i] - djp[j];
            if (tx >= 0 && ty >= 0){
                testps.insert(P(tx, ty));
            }
        }
    }

    int ans;
    ans = 0;
    for (P p: testps){
        int tmp;
        int tx, ty;
        tmp = 0;
        tx = p.first;
        ty = p.second;
        rep0(j, 4){
            if (ps.find(P(tx + dip[j], ty + djp[j])) != ps.end()) tmp ^= 1;
        }
        ans += tmp;
    }

    cout << ans << endl;

    return 0;
}

Submission Info

Judge Result