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 ladpro98

#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <fstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <climits>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cassert>

#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 FORD(i, a, b) for(int i = (a); i > (b); --i)
#define REPD(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 RESET(a, v) memset(a, (v), sizeof(a))
#define SZ(a) (int(a.size()))
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define LL long long
#define LD long double
#define II pair<int, int>
#define X first
#define Y second
#define VI vector<int>
#define VII vector<II>
#define endl '\n'

const int N = 2020;

using namespace std;

struct range {
    int h, l, r, v;
    range(int _h = 0, int _l = 0, int _r = 0, int _v = 0) {
        h = _h; l = _l; r = _r; v = _v;
    }
    int len() {return r - l + 1;}
    bool operator < (const range &that) const {
        if (h != that.h) return h < that.h;
        if (l != that.l) return l < that.l;
        return r < that.r;
    }
} seg[N * N / 2];

int n, nSeg;

int main() {
    ios :: sync_with_stdio(0); cin.tie(0);
    cin >> n;
    int x, y, len;
    FOR(i, 0, n) {
        cin >> x >> y >> len;
        FOR(i, 1, len)
            seg[nSeg++] = range(x + y + i, x, x + i - 1, 2);
        seg[nSeg++] = range(x + y + len, x, x + len - 1, 1);
    }
    sort(seg, seg + nSeg);
    int j, ans = 0;
    for(int i = 0; i < nSeg; i = j) {
        ans += seg[i].v * seg[i].len();
        int maxR = seg[i].r, cntOne = 0;
        if (seg[i].v == 1) cntOne = seg[i].len();
        for(j = i + 1; j < nSeg && seg[j].h == seg[i].h; j++) {
            if (seg[j].r <= maxR) {
                if (seg[j].v == 2 && seg[j].r > maxR - cntOne) {
                    ans += min(seg[j].len(), seg[j].r - maxR + cntOne);
                    cntOne = maxR - seg[j].r;
                }
            }
            else if (seg[j].l > maxR) {
                ans += seg[j].v * seg[j].len();
                cntOne = (seg[j].v == 1) ? seg[j].len() : 0;
                maxR = seg[j].r;
            }
            else {
                ans += (seg[j].r - maxR) * seg[j].v;
                if (seg[j].v == 2) {
                    ans += min(cntOne, maxR - seg[j].l + 1);
                    cntOne = 0;
                }
                else if (seg[j].v == 1)
                    cntOne += seg[j].r - maxR;
                maxR = seg[j].r;
            }
        }
    }
    cout << ans / 2 << ((ans & 1) ? ".5" : ".0");
    return 0;
}

Code mẫu của RR

//Wishing myself a happy lunar new year with a lot of accept solutions
//Written by Nguyen Thanh Trung
{$R+,Q+}
uses math;
const
  FINP='';
  FOUT='';
  MAXN=10000;
var
  sl,n:longint;
  kq:int64;
  t,d,c,x,y,m:array[1..MAXN] of longint;
procedure inp;
var
  f:text;
  i:longint;
begin
  assign(f,FINP); reset(f);
  read(f,n);
  for i:=1 to n do
    read(f,x[i],y[i],m[i]);
  close(f);
end;
procedure ans;
var
  f:text;
begin
  assign(f,FOUT); rewrite(f);
  writeln(f,kq/2:0:1);
  close(f);
end;
procedure swap(var a,b:longint); inline;
var
  temp:longint;
begin
  temp:=a; a:=b; b:=temp;
end;
procedure sort1(l,r:longint); inline;
var
  mid,i,j:longint;
begin
  mid:=y[(l+r) shr 1]; i:=l; j:=r;
  repeat
    while y[i]<mid do inc(i);
    while y[j]>mid do dec(j);
    if i<=j then
      begin
        swap(x[i],x[j]);
        swap(y[i],y[j]);
        swap(m[i],m[j]);
        inc(i); dec(j);
      end;
  until i>j;
  if i<r then sort1(i,r);
  if l<j then sort1(l,j);
end;
procedure sort2(l,r:longint); inline;
var
  i,j,mid:longint;
begin
  mid:=c[(l+r) shr 1]; i:=l; j:=r;
  repeat
    while c[i]<mid do inc(i);
    while c[j]>mid do dec(j);
    if i<=j then
      begin
        swap(c[i],c[j]);
        inc(i); dec(j);
      end;
  until i>j;
  if i<r then sort2(i,r);
  if l<j then sort2(l,j);
end;
procedure init; inline;
var
  i,j,xx,yy:longint;
begin
  for i:=1 to n do c[i]:=x[i];
  for i:=1 to n do c[i+n]:=x[i]+m[i];
  sl:=n shl 1;
  for i:=1 to n do
  for j:=1 to n do
    begin
      yy:=y[i]; xx:=x[j]+y[j]+m[j]-yy;
      if (xx>=x[i]) and (xx<=x[i]+m[i]) then
      if (xx>=x[j]) and (xx<=x[j]+m[j]) then
        begin
          inc(sl);
          c[sl]:=xx;
        end;
    end;
  sort2(1,sl);
  j:=1;
  for i:=2 to sl do
    if c[i]>c[j] then
      begin
        inc(j);
        c[j]:=c[i];
      end;
  sl:=j;
end;
procedure solve;
var
  i,j,k:longint;
  count,sum:int64;
begin
  for i:=1 to sl-1 do
    begin
      count:=0;
      for j:=1 to n do
        begin
          if x[j]>=c[i+1] then continue;
          if x[j]+m[j]<=c[i] then continue;
          inc(count);
          t[count]:=y[j]+x[j]+m[j]-c[i];
          d[count]:=y[j];
        end;
      k:=1;
      if count=0 then continue;
      for j:=2 to count do
      if d[j]>=t[k] then
        begin
          inc(k);
          d[k]:=d[j];
          t[k]:=t[j];
        end
      else t[k]:=max(t[j],t[k]);
      count:=k;
      sum:=0;
      for j:=1 to count do
        inc(sum,t[j]-d[j]);
      kq:=kq+max((sum*2-count*(c[i+1]-c[i]))*(c[i+1]-c[i]),0);
    end;
end;
begin
  inp;
  sort1(1,n);
  init;
  solve;
  ans;
end.