Lưu ý: Các code mẫu dưới đây chỉ mang tính tham khảo và có thể không AC được bài tập này

Code mẫu của flashmt

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <utility>
#include <queue>
using namespace std;
const int dx[]={-1,0,1,0};
const int dy[]={0,1,0,-1};

struct cell
{
    int x,y,val;
    void load(int _x,int _y,int _val)
    {
        x=_x; y=_y; val=_val;
    }
};

int m,n,k,ans,a[505][505],lab[250250],mx[250250];
cell b[250250];

bool cmp(cell i,cell j)
{
    return i.val>j.val;
}

int get(int x)
{
    if (lab[x]!=x) lab[x]=get(lab[x]);
    return lab[x];
}

void join(int x,int y)
{
    int u=x*n+y;
    for (int i=0;i<4;i++)
    {
        int xx=x+dx[i], yy=y+dy[i], uu=xx*n+yy;
        if (xx<0 || yy<0 || xx>=m || yy>=n || a[xx][yy]<a[x][y]) continue;
        int v=get(u), vv=get(uu);
        if (v==vv) continue;
        if (mx[v]>mx[vv]) lab[vv]=v;
        else lab[v]=vv;
    }
}

int main()
{
    cin >> m >> n >> k;
    for (int i=0;i<m;i++) 
        for (int j=0;j<n;j++) 
        {
            scanf("%d",&a[i][j]); 
            b[i*n+j].load(i,j,a[i][j]);
            lab[i*n+j]=i*n+j;
            mx[i*n+j]=a[i][j];
        }
    sort(b,b+m*n,cmp);
    for (int i=0,j=0;i<m*n;i++)
    {
        while (j<m*n && b[j].val+k>b[i].val) join(b[j].x,b[j].y), j++;
        int v=get(b[i].x*n+b[i].y);
        ans+=(mx[v]==b[i].val);
    }
    cout << ans << endl;
}

Code mẫu của ladpro98

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <queue>

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define REP(i, a, b) for(int i = (a); i <=(b); i++)
#define TR(it, a) for(typeof((a).begin()) it = (a).begin(); it != (a).end(); ++it)
#define ALL(a) (a).begin(), (a).end()
#define II pair<int, int>
#define X first
#define Y second
#define MP make_pair
#define PB push_back

const int N  = 505;
const int NN = N * N;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};

using namespace std;

int lab[NN], maxH[NN];

int root(int u) {
    if (lab[u] <= 0) return u;
    return lab[u] = root(lab[u]);
}

void join(int u, int v) {
    if (u == v) return;
    if (lab[u] > lab[v]) swap(u, v);
    if (lab[u] == lab[v]) lab[u]--;
    lab[v] = u;
    maxH[u] = max(maxH[u], maxH[v]);
}

int a[N][N], id[N][N];
bool was[N][N];
int n, m, d;

void bfs(int sx, int sy, int lim) {
    queue<II> Q;
    Q.push(MP(sx, sy));
    was[sx][sy] = 1;
    while (!Q.empty()) {
        II u = Q.front(); Q.pop();
        FOR(i, 0, 4) {
            int x = u.X + dx[i];
            int y = u.Y + dy[i];
            if (x < 1 || y < 1 || x > m || y > n || a[x][y] <= lim) continue;
            if (!was[x][y]) {
                was[x][y] = 1;
                Q.push(MP(x, y));
            }
            join(root(id[u.X][u.Y]), root(id[x][y]));
        }
    }
}

vector<pair<int, II> > lst;

int main() {
    ios :: sync_with_stdio(0); cin.tie(0);
    cin >> m >> n >> d;
    int cnt = 0;
    REP(i, 1, m) REP(j, 1, n) {
        cin >> a[i][j]; a[i][j] += d;
        id[i][j] = ++cnt;
        lst.PB(MP(a[i][j], MP(i, j)));
    }
    sort(ALL(lst), greater<pair<int, II> > ());
    REP(i, 1, m) REP(j, 1, n) maxH[id[i][j]] = a[i][j];
    int ans = 0;
    TR(it, lst) {
        int lim = (it -> X) - d;
        int x = (*it).Y.X, y = (*it).Y.Y;
        bfs(x, y, lim);
        ans += maxH[root(id[x][y])] <= (it -> X);
    }
    cout << ans;
    return 0;
}

Code mẫu của RR

#include <sstream>
#include <iomanip>
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <string>
#include <deque>
#include <complex>

#define FOR(i,a,b) for(int i=(a),_b=(b); i<=_b; i++)
#define FORD(i,a,b) for(int i=(a),_b=(b); i>=_b; i--)
#define REP(i,a) for(int i=0,_a=(a); i<_a; i++)
#define FORN(i,a,b) for(int i=(a),_b=(b);i<_b;i++)
#define DOWN(i,a,b) for(int i=a,_b=(b);i>=_b;i--)
#define SET(a,v) memset(a,v,sizeof(a))
#define sqr(x) ((x)*(x))
#define ll long long
#define F first
#define S second
#define PB push_back
#define MP make_pair

#define DEBUG(x) cout << #x << " = "; cout << x << endl;
#define PR(a,n) cout << #a << " = "; FOR(_,1,n) cout << a[_] << ' '; cout << endl;
#define PR0(a,n) cout << #a << " = "; REP(_,n) cout << a[_] << ' '; cout << endl;
using namespace std;

//Buffer reading
int INP,AM,REACHEOF;
#define BUFSIZE (1<<12)
char BUF[BUFSIZE+1], *inp=BUF;
#define GETCHAR(INP) { \
    if(!*inp) { \
        if (REACHEOF) return 0;\
        memset(BUF,0,sizeof BUF);\
        int inpzzz = fread(BUF,1,BUFSIZE,stdin);\
        if (inpzzz != BUFSIZE) REACHEOF = true;\
        inp=BUF; \
    } \
    INP=*inp++; \
}
#define DIG(a) (((a)>='0')&&((a)<='9'))
#define GN(j) { \
    AM=0;\
    GETCHAR(INP); while(!DIG(INP) && INP!='-') GETCHAR(INP);\
    if (INP=='-') {AM=1;GETCHAR(INP);} \
    j=INP-'0'; GETCHAR(INP); \
    while(DIG(INP)){j=10*j+(INP-'0');GETCHAR(INP);} \
    if (AM) j=-j;\
}
//End of buffer reading

const long double PI = acos((long double) -1.0);

int m, n, d, a[511][511];
pair<int, pair<int,int> > x[511*511];
int lab[511*511], id[511][511], ln[511*511];

const int di[] = {-1,1,0,0};
const int dj[] = {0,0,-1,1};

int getRoot(int u) {
    if (lab[u] < 0) return u;
    return lab[u] = getRoot(lab[u]);
}

void merge(int u, int v) {
    u = getRoot(u); v = getRoot(v);
    if (u == v) return ;
    int x = lab[u] + lab[v];
    if (lab[u] < lab[v]) {
        ln[u] = max(ln[u], ln[v]);
        lab[u] = x;
        lab[v] = u;
    }
    else {
        ln[v] = max(ln[u], ln[v]);
        lab[v] = x;
        lab[u] = v;
    }
}

void add(int u, int v) {
    REP(dir,4) {
        int uu = u + di[dir], vv = v + dj[dir];
        if (uu > 0 && vv > 0 && uu <= m && vv <= n && a[uu][vv] >= a[u][v])
            merge(id[u][v], id[uu][vv]);
    }
}

int main() {
    scanf("%d%d%d", &m, &n, &d);
    int now = 0;
    FOR(i,1,m) FOR(j,1,n) {
        scanf("%d", &a[i][j]);

        id[i][j] = ++now;
        x[now] = MP(a[i][j], MP(i,j));
        ln[now] = a[i][j];
    }
    memset(lab, -1, sizeof lab);

    sort(x+1, x+now+1);

    int j = now, res = 0;
    FORD(i,now,1) {
        while (j > 0 && x[j].F > x[i].F - d) {
            add(x[j].S.F, x[j].S.S);
            --j;
        }
        int u = getRoot(id[x[i].S.F][x[i].S.S]);
        if (ln[u] <= x[i].F) {
            ++res;
        }
    }
    cout << res << endl;
    return 0;
}

Code mẫu của hieult

#include<cstdio>
#include<cmath>
#include<math.h>
#include<cstring>
#include<cstdlib>
#include<cassert>
#include<ctime>
#include<algorithm>
#include<iterator>
#include<iostream>
#include<cctype>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<sstream>
#include<list>
#define fi first
#define se second
#define PB push_back
#define MP make_pair
#define ep 0.00001
#define oo 111111111
#define mod 790972
#define TR(c, it) for(typeof((c).begin()) it=(c).begin(); it!=(c).end(); it++)
#define rep(i, n) for(int i = 0; i < n; i++)
#define FOR(i, a, b) for(int i = a; i <= b; i++)
#define FORD(i, a, b) for(int i = a; i >= b; i--)
#define MS(a, x) memset(a, x, sizeof(a))
#define SZ(a) (int)(a.size())
#define maxn 505
//#define g 9.81
double const PI=4*atan(1.0);

using namespace std;

typedef pair<int, int> II;
typedef vector<int> VI;
typedef vector<II> VII;
typedef vector<VI> VVI;
typedef vector<VII> VVII;
typedef long long ll;
int dx[] = {+1, 0, -1, 0};
int dy[] = {0, -1, 0, +1};

void OPEN(){
    freopen("A.in","r",stdin);
    freopen("A.out","w",stdout);
}

int n, m, a[maxn][maxn], d, fl[maxn][maxn]; 
vector<II> g;
II que[maxn * maxn];

typedef struct compare{
    bool operator() (const II &A, const II &B){
        return a[A.fi][A.se] > a[B.fi][B.se];
    }
} comp;

int main(){
   // OPEN();
    scanf("%d %d %d", &n, &m, &d);
    rep(i, n) rep(j, m){
        scanf("%d", &a[i][j]);
        g.PB(MP(i, j));
    }

    sort(g.begin(), g.end(), comp());
    MS(fl, -1);

    int res = 0;
    rep(i, SZ(g)){
        int sx = g[i].fi, sy = g[i].se;
        if(fl[sx][sy] != -1) continue;
        fl[sx][sy] = i;
        bool check = true;
        int size = 0, num = 0; que[size++] = g[i];
        rep(j, size){
            int x = que[j].fi, y = que[j].se;
            if(a[x][y] == a[sx][sy]) num++;
            rep(h, 4){
                int xx = x + dx[h], yy = y + dy[h];
                if(xx < 0 || xx >= n || yy < 0 || yy >= m) continue;
                if(a[xx][yy] <= a[sx][sy] - d) continue;
                if(fl[xx][yy] == i) continue;
                if(fl[xx][yy] != -1) {
                    check = false;
                    continue;
                }
                fl[xx][yy] = i;
                que[size++] = MP(xx, yy);
            }
        }
       // cout << size << endl;
        if(check) res += num;
    }

    printf("%d", res);

}