Problem:
釘(Nails)
JOI くんは板に釘を刺して遊んでいる．下図のように，JOI くんは一辺
N
本の正三角形の形に釘を並べて刺した．上から
a
行目(1 ≤
a
≤
N
) には
a
本の釘が並んでいる．そのうち左から
b
本目(1 ≤
b
≤
a
) の釘を(
a
,
b
) で表す．
図1: 釘の並び方（
N
= 5 の場合）
釘を頂点とする正三角形が，「各辺が全体の正三角形の辺のいずれかと平行で，全体の正三角形と同じ向き」であるとき，この正三角形を「
よい正三角形
」と呼ぶ．すなわち，「よい正三角形」とは，3 本の釘(
a
,
b
), (
a
+
x
,
b
), (
a
+
x
,
b
+
x
) を頂点とする正三角形のことである（ただし
a
,
b
,
x
は1 ≤
a
<
N
, 1 ≤
b
≤
a
, 1 ≤
x
≤
N
-
a
) をみたす）．
JOI くんは，輪ゴムを使って，「よい正三角形」の周りを囲うことにした．
図2: 輪ゴムによる「よい正三角形」の囲い方の例
課題
正三角形の一辺に並んでいる釘の本数
N
と，JOI くんが持っている輪ゴムの数
M
と，
M
本の輪ゴムによる「よい正三角形」の囲い方が与えられたとき，1 本以上の輪ゴムで囲われた釘の本数を求めるプログラムを作成せよ．
制限
2 ≤
N
≤ 5000     一辺に並んでいる釘の本数
1 ≤
M
≤ 500000 (= 5 × 10
5
)     輪ゴムの数
入力
標準入力から以下のデータを読み込め．
1 行目には整数
N
,
M
が空白を区切りとして書かれている．
N
は正三角形の一辺に並んでいる釘の本数を，
M
はJOI くんの持っている輪ゴムの数をそれぞれ表す．
続く
M
行は輪ゴムによる「よい正三角形」の囲い方の情報を表す．
i
+ 1 行目(1 ≤
i
≤
M
) には整数
A
i
,
B
i
,
X
i
(1 ≤
A
i
<
N
, 1 ≤
B
i
≤
A
i
, 1 ≤
X
i
≤
N
-
A
i
) が空白を区切りとして書かれている．これは，
i
本目の輪ゴムは3 本の釘(
A
i
,
B
i
), (
A
i
+
X
i
,
B
i
), (
A
i
+
X
i
,
B
i
+
X
i
) を頂点とする「よい正三角形」を囲っていることを表す．
出力
標準出力に，1 本以上の輪ゴムに囲われている釘の本数を1 行で出力せよ．
採点基準
採点用データのうち，配点の30% 分については，
M
≤ 10000 を満たす．
入出力例
入力例 1
5 2
2 2 1
2 1 3
出力例 1
12
この例は図2 のような「よい正三角形」の囲い方に対応している．この例において，(1, 1), (4, 4), (5, 5) 以外の12 本の釘が1 本以上の輪ゴムで囲われている．
問題文と自動審判に使われるデータは、
情報オリンピック日本委員会
が作成し公開している問題文と採点用テストデータです。

Submitted solutions:

code_snippet: #include <bits/stdc++.h>
using namespace std;

using P = pair<int, char>;

int main() {
    int N, M;
    cin >> N >> M;
    vector<vector<int>> sum(N+3, vector<int>(N+3));
    for(int i=0; i<M; ++i) {
        int A, B, X;
        cin >> A >> B >> X;
        sum[A][B] += 1;
        sum[A][B+1] += -1;
        sum[A+X+1][B] += -1;
        sum[A+X+2][B+1] += 1;
        sum[A+X+1][B+X+2] += 1;
        sum[A+X+2][B+X+2] += -1;
    }
    for(int i=0; i<N+3; ++i) {
        for(int j=0; j<=i; ++j) {
            sum[i][j+1] += sum[i][j];
        }
    }
    for(int i=0; i<N+2; ++i) {
        for(int j=0; j<=i; ++j) {
            sum[i+1][j] += sum[i][j];
        }
    }
    for(int i=0; i<N+2; ++i) {
        for(int j=0; j<=i; ++j) {
            sum[i+1][j+1] += sum[i][j];
        }
    }
    int res = 0;
    for(int i=0; i<N+3; ++i) {
        for(int j=0; j<N+3; ++j) {
            res += sum[i][j] > 0;
        }
    }
    cout << res << endl;
}
accuracy: 1
time_ms: 290
memory_kb: 101060
final_rank: 9

code_snippet: #include <bits/stdc++.h>
#define ll long long
#define rep(i,n,m) for(int i=(int)(n);i < (int)(m); i++)
#define repm(i,n,m) for(int i=(int)(n);i >= (int)(m); i--)
// #define _GLIBCXX_DEBUG
using namespace std;

int main(){
    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);
    int n,m;
    cin >> n >> m;
    vector<vector<int>> Adj(n);
    rep(i,0,n){
        rep(j,0,i+1){
            Adj[i].push_back(0);
        }
    }
    int a,b,x;
    rep(i,0,m){
        cin >> a >> b >> x;
        a--;
        b--;
        Adj[a][b]++;
        int p = a + x + 1, p2 = b + x + 2;
        if(b < a) Adj[a][b + 1]--;
        if(p < n){
            Adj[p][b]--;
            if(p2 < p + 1) Adj[p][p2]++;
        }
        if(p + 1 < n){
            Adj[p + 1][b + 1]++;
            if(p2 < p + 2) Adj[p+1][p2]--;
        }
    }
    rep(i,0,n)rep(j,1,i+1){
        Adj[i][j] += Adj[i][j-1];
    }
    rep(i,0,n)rep(j,i+1,n){
        Adj[j][i] += Adj[j-1][i];
    }
    rep(i,0,n)rep(j,i+1,n){
        Adj[j][j-i] += Adj[j-1][j-i-1];
    }
    int ans = 0;
    rep(i,0,n)rep(j,0,i+1){
        if(Adj[i][j] > 0) ans++;
    }
    cout << ans << endl;
}
accuracy: 1
time_ms: 290
memory_kb: 64588
final_rank: 8

code_snippet: #include<bits/stdc++.h>
using namespace std;
using ll=long long;

int main() {
    ll N,M;
    cin>>N>>M;
    vector<vector<ll>> A(N+2,vector<ll>(N+2,0));
    vector<vector<ll>> B(N+2,vector<ll>(N+2,0));
    for(int i=0;i<M;i++){
        ll a,b,x;
        cin>>a>>b>>x;
        a--;b--;
        A[a][b]++;
        A[a+x+1][b]--;
        B[a][b+1]--;
        B[a+x+1][b+x+2]++;
    }

    for(int b=0;b<=N+1;b++){
        for(int a=0;a<N+1;a++)A[a+1][b]+=A[a][b];
    }
    for(int a=0;a<=N+1;a++){
        for(int b=0;b<=N+1;b++){
            if(a<N+1&&b<N+1)B[a+1][b+1]+=B[a][b];
        }
    }
    for(int a=0;a<=N+1;a++){
        for(int b=0;b<=N+1;b++)A[a][b]+=B[a][b];
    }
    ll an=0;
    for(int a=0;a<=N+1;a++){
        for(int b=0;b<N+1;b++){
            A[a][b+1]+=A[a][b];
            if(A[a][b]>0)an++;
        }
    }
    cout<<an<<endl;
}
accuracy: 1
time_ms: 640
memory_kb: 394372
final_rank: 20

code_snippet: #include <stdio.h>
#include <algorithm>  // std::sort を使用するために必要
using namespace std;

// 最大500,000個の区間を保持する配列
pair<pair<int, int>, int> Q[500000];

// 各行に対する最大値を保持する配列
int val[2][5001];

int main() {
    int a, b;
    // 行数(a)と区間数(b)を入力
    scanf("%d%d", &a, &b);

    // 各区間の情報を入力
    for (int i = 0; i < b; i++) {
        int c, d, e;
        scanf("%d%d%d", &c, &d, &e);
        // Qに区間の始点(c)、終点(d)、値(e)を格納
        Q[i] = make_pair(make_pair(c, d), e);
    }

    // Qを区間の始点(c)でソート
    std::sort(Q, Q + b);

    int ret = 0;  // 結果を格納する変数
    int at = 0;   // 現在処理中のQのインデックス

    // 各行について処理
    for (int i = 0; i < a; i++) {
        int e = i & 1;  // 偶数行か奇数行かで配列を切り替える

        // 現在の行(i+1)に対応する区間情報を処理
        while (at < b && Q[at].first.first == i + 1) {
            // 区間の終点に対応する列の値を最大化
            val[e][Q[at].first.second - 1] = max(val[e][Q[at].first.second - 1], Q[at].second + 1);
            at++;
        }

        // この行で条件を満たす列の数をカウント
        for (int j = 0; j <= i; j++) {
            if (val[e][j]) ret++;
        }

        // 次の行に備えて配列を初期化
        for (int j = 0; j <= i + 1; j++) {
            val[!e][j] = 0;
        }

        // 現在の行の結果を次の行に反映
        for (int j = 0; j <= i; j++) {
            val[!e][j] = max(val[!e][j], val[e][j] - 1);      // 同じ列に反映
            val[!e][j + 1] = max(val[!e][j + 1], val[e][j] - 1); // 隣接する列に反映
        }
    }

    // 結果を出力
    printf("%d\n", ret);

    return 0;
}
accuracy: 1
time_ms: 110
memory_kb: 8860
final_rank: 1

code_snippet: #include <bits/stdc++.h>

std::mt19937 mt{std::random_device{}()};

void solve() {
    int N, M;
    // N = mt() % 10 + 2;
    // M = 1;
    std::cin >> N >> M;
    std::vector<std::vector<int>> P(N + 1); //, Q(N + 1);
    for (int i{} ; i < N + 1 ; i++) {
        P[i] = std::move(std::vector<int>(i));
        // Q[i] = std::move(std::vector<int>(i));
    }
    // std::cout << N << ' ' << M << std::endl;
    for (int i{} ; i < M ; i++) {
        int A, B, X;
        // A = mt() % (N - 1) + 1;
        // B = mt() % A + 1;
        // X = mt() % (N - A) + 1;
        // std::cout << A << ' ' << B << ' ' << X << std::endl;
        std::cin >> A >> B >> X;
        B--;
        P[A][B]++;
        if (B + 1 < A) {
            P[A][B + 1]--;
        }
        if (A + X + 1 <= N) {
            P[A + X + 1][B]--;
        }
        if (A + X + 2 <= N and B + 1 < A + X + 2) {
            P[A + X + 2][B + 1]++;
        }
        if (A + X + 1 <= N and B + X + 2 < A + X + 1) {
            P[A + X + 1][B + X + 2]++;
        }
        if (A + X + 2 <= N and B + X + 2 < A + X + 2) {
            P[A + X + 2][B + X + 2]--;
        }

        // for (int j{} ; j <= X ; j++) {
        //     for (int k{} ; k <= j ; k++) {
        //         Q[A + j][B + k]++;
        //     }
        // }
    }
    for (int i{2} ; i <= N ; i++) {
        for (int j{1} ; j < i ; j++) {
            P[i][j] += P[i - 1][j - 1];
        }
    }     
    for (int i{1} ; i <= N ; i++) {
        for (int j{1} ; j < i ; j++) {
            P[i][j] += P[i][j - 1];
        }
    }
    for (int i{} ; i <= N ; i++) {
        for (int j{} ; j < i ; j++) {
            if (j < i - 1) {
                P[i][j] += P[i - 1][j];
            }
        }
    }
    int ans{};
    for (int i{} ; i <= N ; i++) {
        for (int j{} ; j < i ; j++) {
            ans += (P[i][j] >= 1);
        }
    }
    std::cout << ans << std::endl;
    // if (P != Q) {
    //     for (int i{} ; i <= N ; i++) {
    //         for (int j{} ; j < i ; j++) {
    //             std::cout << P[i][j] << (j + 1 == i ? '\n' : ' ');
    //         }
    //     }
    //     for (int i{} ; i <= N ; i++) {
    //         for (int j{} ; j < i ; j++) {
    //             std::cout << Q[i][j] << (j + 1 == i ? '\n' : ' ');
    //         }
    //     }
    //     return false;
    // }
    // return true;
}

int main() {
    solve();
    // while (solve()) ;
}
accuracy: 1
time_ms: 290
memory_kb: 52464
final_rank: 6

code_snippet: #include <bits/stdc++.h>
using namespace std;

int main() {
  int n, m, al[5003][5003] {}, an{};
  cin >> n >> m;
  for (int i = 0; i < m; ++i) {
    int a, b, x;
    cin >> a >> b >> x;
    --a;
    --b;
    ++al[a][b];
    --al[a][b+1];
    --al[a+x+1][b];
    ++al[a+x+2][b+1];
    ++al[a+x+1][b+x+2];
    --al[a+x+2][b+x+2];
  }
  // for (int i = 0; i < n + 1; ++i) {
  //   for (int j = 0; j <= i + 1; ++j) cout << al[i][j] << ' ';
  //   cout << '\n';
  // }
  for (int i = 0; i < n + 2; ++i) {
    for (int j = 0; j < i + 1; ++j) {
      al[i][j+1] = al[i][j] + al[i][j+1];
    }
  }
  // for (int i = 0; i < n + 1; ++i) {
  //   for (int j = 0; j <= i + 1; ++j) cout << al[i][j] << ' ';
  //   cout << '\n';
  // }
  for (int i = 0; i < n + 1; ++i) {
    for (int j = 0; j < i + 2; ++j) {
      al[i+1][j] += al[i][j];
    }
  }
  // for (int i = 0; i < n + 1; ++i) {
  //   for (int j = 0; j <= i + 1; ++j) cout << al[i][j] << ' ';
  //   cout << '\n';
  // }
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < i + 1; ++j) al[i+1][j+1] += al[i][j];
  }
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < i + 1; j++) {
      if (0 < al[i][j]) ++an;
    }
  }
  cout << an << '\n';
  // for (int i = 0; i < n; ++i) {
  //   for (int j = 0; j <= i + 1; ++j) cout << al[i][j] << ' ';
  //   cout << '\n';
  // }
}
accuracy: 1
time_ms: 350
memory_kb: 100868
final_rank: 12

code_snippet: #include <bits/stdc++.h>

int main() {
  int n, m;
  std::cin >> n >> m;

  // auto print = [](std::vector< std::vector< int > > &vs) {
  //   for (auto &v: vs) {
  //     for (auto &a: v) {
  //       std::cerr << a << " ";
  //     }
  //     std::cerr << std::endl;
  //   }
  //     std::cerr << std::endl;
  // };

  auto pimos = std::vector(n + 1, std::vector(n + 1, 0));
  auto nimos = std::vector(n + 1, std::vector(n + 1, 0));
  for (int i = 0; i < m; i++) {
    int a, b, x;
    std::cin >> a >> b >> x;

    a--; b--;
    x++;
    
    pimos[a][b]++;
    pimos[a + x][b + x]--;

    nimos[a + x][b]--;
    nimos[a + x][b + x]++;
  }

  // pimos
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      pimos[i + 1][j + 1] += pimos[i][j];
    }
  }
  // print(pimos);

  // nimos
  for (int i = 0; i < n + 1; i++) {
    for (int j = 0; j < n; j++) {
      nimos[i][j + 1] += nimos[i][j];
    }
  }
  // print(nimos);

  auto imos = pimos;
  for (int i = 0; i < n + 1; i++) {
    for (int j = 0; j < n + 1; j++) {
      imos[i][j] += nimos[i][j];
    }
  }
  // print(imos);

  int ans = 0;
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      imos[i + 1][j] += imos[i][j];
      if (imos[i][j] > 0) ans++;
    }
  }

  std::cout << ans << std::endl;
}
accuracy: 1
time_ms: 380
memory_kb: 297060
final_rank: 18

code_snippet: #include<bits/stdc++.h>

using namespace std;

int func(){
    int n;
    cin >> n;
    vector<vector<int>> table1(n,vector<int>(n,0));
    vector<vector<int>> table2(n,vector<int>(n,0));
    auto add = [&](int y,int x,int v,vector<vector<int>> &table){
        if(y < 0 or x < 0)return;
        if(x > y)return;
        if(y >= n)return;
        table[y][x] += v;
    };
    auto get = [&](int y,int x, vector<vector<int>> &table){
        if(y < 0 or x < 0)return 0;
        if(x > y)return 0;
        if(y >= n)return 0;
        return table[y][x];
    };
    int m;
    cin >> m;
    for(int i=0;i<m;++i){
        int a;
        int b;
        int x;
        cin >> a >> b >> x;
        --a;
        --b;
        add(a,b,1,table1);
        add(a+x+1,b,-1,table1);
        add(a,b+1,-1,table2);
        add(a+x+1,b+1+x+1,1,table2);
    }
    for(int i=0;i<n;++i){
        for(int j=0;j<n;++j){
            add(i+1,j,get(i,j,table1),table1);
        }
    }
    for(int i=0;i<n;++i){
        for(int j=0;j<n;++j){
            add(i+1,j+1,get(i,j,table2),table2);
        }
    }
    for(int i=0;i<n;++i){
        for(int j=0;j<n;++j){
            add(i,j,get(i,j,table2),table1);
        }
    }
    for(int i=0;i<n;++i){
        for(int j=0;j<n;++j){
            add(i,j+1,get(i,j,table1),table1);
        }
    }
    int res = 0;
    for(int i=0;i<n;++i){
        for(int j=0;j<=i;++j){
            if(get(i,j,table1)){
                ++res;
            }
        }
    }
    return res;
}

int main(){
    cout << func() << endl;
}
accuracy: 1
time_ms: 400
memory_kb: 198708
final_rank: 16

code_snippet: #include <bits/stdc++.h>
using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> dp(n + 1, vector<int>(n + 1, -1));
    for (int i = 0; i < m; i++) {
        int a, b, x;
        cin >> a >> b >> x;
        dp[a][b] = x;
    }
    for (int i = 1; i < n; i++) {
        for (int j = 1; j <= i; j++) {
            dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] - 1); 
            dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] - 1);
        }
    }
    int ans = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= i; j++) {
            if (dp[i][j] >= 0) {
                ans++;
            }
        }
    }
    cout << ans << endl;
}
accuracy: 1
time_ms: 220
memory_kb: 101028
final_rank: 5

code_snippet: #include<iostream>
#include<vector>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
int imos1[5001][5001],imos2[5001][5002];
int main(){
	int n,m,a,b,x;
	cin>>n>>m;
	while(cin>>a>>b>>x){
		a--,b--,x++;
		imos1[a][b]++;
		imos1[a+x][b]--;
		imos2[a+x][b+1]--;
		imos2[a+x][b+x+1]++;
	}
	for(int i=1;i<n;i++)
		for(int j=0;j<=i;j++)
			imos1[i][j]+=imos1[i-1][j];
	for(int i=0;i<n;i++)
		for(int j=1;j<=i;j++)
			imos2[i][j]+=imos2[i][j-1];
	for(int i=1;i<n;i++){
		for(int j=1;j<=i;j++){
			imos1[i][j]+=imos1[i-1][j-1];
			imos2[i][j]+=imos2[i-1][j-1];
		}
	}
	int ans=0;
	for(int i=0;i<n;i++)
		for(int j=0;j<=i;j++)
			if(imos1[i][j]+imos2[i][j]>0)
				ans++;
	cout<<ans<<endl;
}
accuracy: 1
time_ms: 270
memory_kb: 197220
final_rank: 13

code_snippet: #include <bits/stdc++.h>

using namespace std;



#define ll long long
#define rep(i,a,b) for(int i = a; i < b; i++)
#define REP(i,a,b) for(int i = a; i <=b; i++)
#define fore(i,a) for(auto &i : a)
#define all(x) (x).begin(),(x).end()
#define fix(i) fixed << setprecision(i)
#define nextp(v) next_permutation(all(v))



template<class T>bool chmax(T& a, const T& b) { if(a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if(b < a) { a = b; return 1; } return 0; }

using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pq = priority_queue<int>;
using pqll = priority_queue<ll>;



const ll INF = LLONG_MAX/2;
const ll MOD = 1000000007;


void debug(vector<vector<int>> t, int N) {
  rep(i,0,N+3) {
    rep(j,0,N+3-i) cout << " ";
    rep(j,0,i+1) cout << (t[i][j] == 0 ? ' ' : (t[i][j] > 0 ? '+' : '-')) << " ";
    cout << endl;
  }
  
  return;
}


int main() {
  int N, M; cin >> N >> M;
  
  vector<vector<int>> t(N+3, vector<int>(N+3));
  
  rep(i,0,M) {
    int A, B, X; cin >> A >> B >> X;
    
    t[A][B-1]++; t[A][B]--;
    t[A+X+2][B]++; t[A+X+1][B-1]--;
    t[A+X+1][B+X+1]++; t[A+X+2][B+X+1]--;
  }
  
 // debug(t, N);
  
  rep(i,0,N+3) {
    int Sum = 0;
    rep(j,0,i+1) {
      Sum += t[i][j];
      t[i][j] = Sum;
    }
  }
  
 // debug(t, N);
  
  rep(i,0,N+3) {
    int Sum = 0;
    rep(j,0,N+3-i) {
      Sum += t[i+j][i];
      t[i+j][i] = Sum;
    }
  }
  
 // debug(t, N);
  
  rep(i,0,N+3) {
    int Sum = 0;
    rep(j,0,N+3-i) {
      Sum += t[i+j][j];
      t[i+j][j] = Sum;
    }
  }
  
 // debug(t, N);
  
  
  int Ans = 0;
  rep(i,0,N+3) {
    rep(j,0,i+1) {
      if(t[i][j] > 0) Ans++;
    }
  }
  
  printf("%d\n", Ans);
}
accuracy: 1
time_ms: 410
memory_kb: 101040
final_rank: 14

code_snippet: #include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define drep(i,j,n) for(int i=0;i<(int)(n-1);i++)for(int j=i+1;j<(int)(n);j++)
#define trep(i,j,k,n) for(int i=0;i<(int)(n-2);i++)for(int j=i+1;j<(int)(n-1);j++)for(int k=j+1;k<(int)(n);k++)
#define codefor int test;scanf("%d",&test);while(test--)
#define INT(...) int __VA_ARGS__;in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)
#define yes(ans) if(ans)printf("yes\n");else printf("no\n")
#define Yes(ans) if(ans)printf("Yes\n");else printf("No\n")
#define YES(ans) if(ans)printf("YES\n");else printf("NO\n")
#define popcount(v) __builtin_popcountll(v)
#define vector2d(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))
#define vector3d(type,name,h,w,...) vector<vector<vector<type>>>name(h,vector<vector<type>>(w,vector<type>(__VA_ARGS__)))
#define vector4d(type,name,h,w,d,...) vector<vector<vector<vector<type>>>>name(h,vector<vector<vector<type>>>(w,vector<vector<type>>(d,vector<type>(__VA_ARGS__))))
using namespace std;
using ll = long long;
template<class T> using rpriority_queue = priority_queue<T, vector<T>, greater<T>>;
const int MOD=1000000007;
const int MOD2=998244353;
const int INF=1<<30;
const ll INF2=1LL<<60;
void scan(int& a){scanf("%d",&a);}
void scan(long long& a){scanf("%lld",&a);}
template<class T,class L>void scan(pair<T, L>& p){scan(p.first);scan(p.second);}
template<class T,class U,class V>void scan(tuple<T,U,V>& p){scan(get<0>(p));scan(get<1>(p));scan(get<2>(p));}
template<class T, size_t size> void scan(array<T, size>& a){ for(auto&& i : a) scan(i);}
template<class T> void scan(T& a){cin>>a;}
template<class T> void scan(vector<T>& vec){for(auto&& it:vec)scan(it);}
void in(){}
template <class Head, class... Tail> void in(Head& head, Tail&... tail){scan(head);in(tail...);}
void print(const int& a){printf("%d",a);}
void print(const long long& a){printf("%lld",a);}
void print(const double& a){printf("%.15lf",a);}
template<class T,class L>void print(const pair<T, L>& p){print(p.first);putchar(' ');print(p.second);}
template<class T> void print(const T& a){cout<<a;}
template<class T> void print(const vector<T>& vec){if(vec.empty())return;print(vec[0]);for(auto it=vec.begin();++it!= vec.end();){putchar(' ');print(*it);}}
void out(){putchar('\n');}
template<class T> void out(const T& t){print(t);putchar('\n');}
template <class Head, class... Tail> void out(const Head& head,const Tail&... tail){print(head);putchar(' ');out(tail...);}
template<class T> void dprint(const T& a){cerr<<a;}
template<class T> void dprint(const vector<T>& vec){if(vec.empty())return;cerr<<vec[0];for(auto it=vec.begin();++it!= vec.end();){cerr<<" "<<*it;}}
void debug(){cerr<<endl;}
template<class T> void debug(const T& t){dprint(t);cerr<<endl;}
template <class Head, class... Tail> void debug(const Head& head, const Tail&... tail){dprint(head);cerr<<" ";debug(tail...);}
ll intpow(ll a, ll b){ ll ans = 1; while(b){ if(b & 1) ans *= a; a *= a; b /= 2; } return ans; }
ll modpow(ll a, ll b, ll p){ ll ans = 1; while(b){ if(b & 1) (ans *= a) %= p; (a *= a) %= p; b /= 2; } return ans; }
ll modinv(ll a, ll m) {ll b = m, u = 1, v = 0;while (b) {ll t = a / b;a -= t * b; swap(a, b);u -= t * v; swap(u, v);}u %= m;if (u < 0) u += m;return u;}
ll updivide(ll a,ll b){return (a+b-1)/b;}
int msb(ll v){return 63-__builtin_clzll(v);}
template<class T> void chmax(T &a,const T b){if(b>a)a=b;}
template<class T> void chmin(T &a,const T b){if(b<a)a=b;}

int main(){
    INT(n,m);
    vector<vector<int>> t(n);
    for(int i=0;i<n;i++){
        t[i].resize(i+1,-1);
    }
    int a,b,x;
    while(m--){
        in(a,b,x);
        a--,b--;
        chmax(t[a][b],x);
    }
    int ans=0;
    for(int i=0;i<n;i++){
        for(int j=0;j<=i;j++){
            if(i+1<n){
                chmax(t[i+1][j],t[i][j]-1);
                chmax(t[i+1][j+1],t[i][j]-1);
            }
            if(t[i][j]>=0)ans++;
        }
    }
    out(ans);
}
accuracy: 1
time_ms: 140
memory_kb: 52600
final_rank: 2

code_snippet: #include <bits/stdc++.h>
using namespace std;
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
typedef long long ll;
//typedef int ll;
typedef pair<ll, ll> P;
const long long INF = 1e17;
template <typename T>
void input_arr(vector<T>& A, ll N) {
	for (ll i = 0; i < N; i++) {
		cin >> A[i];
	}
}
template <typename T, typename Q>
void input_arr(vector<pair<T, Q>>& A, ll N) {
	for (ll i = 0; i < N; i++) {
		cin >> A[i].first >> A[i].second;
	}
}
template <typename T>
void input_arr(vector<vector<T>>& A, ll H, ll W) {
	for (ll i = 0; i < H; i++) {
		for (ll j = 0; j < W; j++) {
			cin >> A[i][j];
		}
	}
}
void solve() {
    ll N, M; cin >> N >> M;
    vector<vector<ll>>A(N, vector<ll>(N, 0)), B(N, vector<ll>(N, 0));
    vector<ll>X(M), Y(M), Z(M);
    for (ll i = 0; i < M; i++) {
        ll a, b, x; cin >> a >> b >> x;
        X[i] = a; Y[i] = b; Z[i] = x;
        a--; b--;
        A[a][b]++;
        if (a + x + 1 < N) {
            A[a + x + 1][b]--;
        }
        B[a][b + 1]--;
        if (a + x + 1 < N && b + x + 2 < N) B[a + x + 1][b + x + 2]++;
    }
    for (ll i = 1; i < N; i++) {
        for (ll j = 1; j < N; j++) {
            B[i][j] += B[i - 1][j - 1];
        }
    }
    for (ll i = 1; i < N; i++) {
        for (ll j = 0; j < N; j++) {
            A[i][j] += A[i - 1][j];
        }
    }
    for (ll i = 0; i < N; i++) {
        for (ll j = 1; j < N; j++) {
            A[i][j] += A[i][j - 1] + B[i][j];
        }
    }
    ll ans = 0;
    for (ll i = 0; i < N; i++) {
        for (ll j = 0; j < N; j++) {
            ans += (A[i][j] > 0);
        }
    }
    cout << ans << endl;
}
int main() {
    ll T = 1; //cin >> T; 
    while (T--) solve();
}
accuracy: 1
time_ms: 450
memory_kb: 405736
final_rank: 19

code_snippet: #define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <iostream>
#include <stack>
#include <queue>
#include <algorithm>
#include <functional>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <cmath>
#include<sstream>
#include<list>
#include<iomanip>
#include <cstdlib>
#include <cstring>
#include <stack>
#include <bitset>
#include <cassert>
#include <stdlib.h>
#include <stdio.h>
using namespace std;
const int INF = 100000000;
const long long LINF = 3e18 + 7;
const int MAX_N = 600010;
const int MAX_W = 10002;
const int MAX_ARRAYK = 100000;
double PI = 3.14159265358979323846;
//using ll = long long;


int N, M;
int table[MAX_W][MAX_W];
int X;

int main() {

	cin >> N >> M;
	for (int i = 0; i < M; i++) {
		int A, B, X;
		cin >> A >> B >> X;
		A--;
		B--;
		table[A][B] = X + 1;
	}

	int ans = 0;
	for (int i = 0; i < N; i++) {
		for (int j = 0; j <= i; j++) {
			if (i > 0){
				table[i][j] = max(table[i][j], table[i - 1][j] - 1);
			}
			if (i > 0 && j > 0) {
				table[i][j] = max(table[i][j], table[i - 1][j - 1] - 1);
			}
			if (table[i][j] > 0) {
				ans++;
			}
		}
	}

	cout << ans << endl;

	return 0;
}
accuracy: 1
time_ms: 280
memory_kb: 71900
final_rank: 7

code_snippet: #include <bits/stdc++.h>
using namespace std;
vector<vector<int> >A(5009);
int main(){
  int sum=0,n,m,a,b,c;
  for(int i=0;i<5009;i++){
    A[i].assign(i+7,0);
  }
  cin>>n>>m;
  while(m--){
    cin>>a>>b>>c;
    A[a][b]++;
    A[a][b+1]--;
    A[a+c+1][b]--;
    A[a+c+1][b+c+2]++;
    A[a+c+2][b+1]++;
    A[a+c+2][b+c+2]--;
  }
  for(int i=0;i<=n+3;i++){
    for(int j=0;j<i+2;j++){
      if(j) A[i][j]+=A[i][j-1];
    }
  }
  for(int i=0;i<=n+3;i++){
    for(int j=0;j<=i+3;j++){
      if(i) A[i][j]+=A[i-1][j];
    }
  }
  for(int i=0;i<=n+3;i++){
    for(int j=0;j<=i+3;j++){
      if(i&&j) A[i][j]+=A[i-1][j-1];
    }
  }
  for(int i=0;i<=n+3;i++){
    for(int j=0;j<=i+5;j++){
      if(A[i][j]>0) sum++;
    }
  }
  cout<<sum<<endl;
}
accuracy: 1
time_ms: 280
memory_kb: 52760
final_rank: 4

code_snippet: #include <bits/stdc++.h>
using namespace std;
using lint = long long;
#define rep(i, n) for(int i = 0; i < int(n); i++)
void chmin(int &a, int b){ if(a > b) a = b; }
void chmax(int &a, int b){ if(a < b) a = b; }

int tate[5050][5050];
int naname[5050][5050];
int imos[5050][5050];

int main(){
    int n, m;
    cin >> n >> m;
    rep(i, m){
        int a, b, l;
        cin >> a >> b >> l;
        a--, b--;
        
        int y = a - b;
        int x = b;
        l++;
//        cout << y << " " << x << endl;
        
        tate[y][x]++;
        tate[y + l][x]--;
        naname[y][x + l]--;
        naname[y + l][x]++;
    }
    
    rep(i, n){
        rep(j, n){
            tate[i + 1][j] += tate[i][j];
            naname[i + 1][j] += naname[i][j + 1];
        }
    }
    
    rep(i, n){
        rep(j, n){
            imos[i][j] = tate[i][j] + naname[i][j];
        }
    }
    
    rep(i, n){
        rep(j, n){
            imos[i][j + 1] += imos[i][j];
        }
    }
    
    int ans = 0;
    rep(i, n){
        rep(j, n){
            ans += !!imos[i][j];
//            cout << imos[i][j] << " ";
        }
//        cout << endl;
    }
    cout << ans << endl;
}
accuracy: 1
time_ms: 280
memory_kb: 301328
final_rank: 17

code_snippet: #include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<map>
using namespace std;

int main() {
	int n, m;
	int a, b, c;
	cin >> n >> m;
	int** num = new int* [n+2];
	for (int i = 0;i < n + 2;i++) {
		num[i] = new int[i + 2];
		for (int j = 0;j <= i + 1;j++) {
			num[i][j] = 0;
		}
	}
	for (int i = 0;i < m;i++) {
		cin >> a >> b >> c;
		a--;
		b--;
		num[a][b]++;
		
		num[a + c + 1][b]--;
			
		
		
		num[a + c + 2][b + 1]++;
		
		
		
		
		
		num[a][b + 1]--;
		
		num[a + c + 1][b + c + 2]++;
			
		
		num[a + c + 2][b + c + 2]--;
			
	}
	for (int i = 1;i < n+2;i++) {
		for (int j = 0;j < i + 1;j++) {
			num[i][j] += num[i - 1][j];
		}
	}
	for (int i = 1;i < n+2;i++) {
		for (int j = 1;j <= i + 1;j++) {
			num[i][j] += num[i - 1][j - 1];
		}
	}
	for (int i = 1;i < n + 2;i++) {
		for (int j = 1;j <= i + 1;j++) {
			num[i][j] += num[i][j-1];
		}
	}
	int ans = 0;
	for (int i = 0;i < n;i++) {
		for (int j = 0;j <= i;j++) {
			if (num[i][j] > 0) {
				ans++;
			}
		}
	}
	cout << ans << endl;
}
accuracy: 1
time_ms: 280
memory_kb: 52448
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
using P = pair<int, int>;

int main(){
    int n,m; cin>>n>>m;
    vector<vector<int>> wa(n+4,vector<int>(n+4));
    while(m--){
        int a,b,x; cin>>a>>b>>x;
        wa[a][b]++;
        wa[a][b+1]--;
        wa[a+x+1][b]--;
        wa[a+x+1][b+x+2]++;
        wa[a+x+2][b+1]++;
        wa[a+x+2][b+x+2]--;
    }
    for(int i=0; i<n+3; i++){
        for(int j=0; j<n+3; j++){
            wa[i+1][j+1] += wa[i+1][j];
        }
    }
    for (int i = 0; i < n + 3; i++) {
        for (int j = 0; j < n + 3; j++) {
            wa[j+1][i+1] += wa[j][i+1];  // ＊itr 順番
        }
    }
    for (int i = 0; i < n + 3; i++) {
        for (int j = 0; j < n + 3; j++) {
            wa[i + 1][j + 1] += wa[i][j];
        }
    }
    int ans = 0;
    for(int i=1; i<=n; i++){
        for(int j=1; j<=i; j++){
            if(wa[i][j]>=1) ans++;
        }
    }
    cout << ans << endl;
    return 0;
}
accuracy: 1
time_ms: 450
memory_kb: 100988
final_rank: 15

code_snippet: #define rep(i, s, e) for (int i = s; i < e; ++i)
 
#include <bits/stdc++.h>
//#include <atcoder/all>
 
using namespace std;
//using namespace atcoder;
 
int INF = 1<<20;
 
int main() {
        int N, M; cin >> N >> M;
        vector<vector<int>> num(N+2, vector<int>(N+2, 0));
        rep (i, 0, M) {
            int a, b, x; cin >> a >> b >> x;
            --a;
            --b;
            ++num[a][b]; ++num[a+x+1][b+x+2]; ++num[a+x+2][b+1];
            --num[a][b+1]; --num[a+x+1][b]; --num[a+x+2][b+x+2];
        }
        rep (A, 0, N) {
            rep (B, 0, A+1) {
                num[A][B+1] += num[A][B];
            } 
        }
        rep (A, 0, N) {
            rep (B, 0, A+1) {
                num[A+1][B] += num[A][B];
            }
        }
        rep (A, 0, N) {
            rep (B, 0, A+1) {
                num[A+1][B+1] += num[A][B];
            } 
        }

        int res = 0;
        rep(A, 0, N) {
            rep (B, 0, A+1) {
                if (num[A][B] >= 1) ++res;
            }
        }

        cout << res << endl;
}
accuracy: 1
time_ms: 350
memory_kb: 100816
final_rank: 11

code_snippet: #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;

int imos[5050][5050];
int naname[5050][5050];

int main(){
	cin.tie(nullptr);
	ios::sync_with_stdio(false);
	int n,m; cin >> n >> m;
	for(int i=0;i<m;i++){
		int a,b,x; cin >> a >> b >> x;
		a--; b--;
		imos[a][b]++;
		imos[a+x+1][b]--;
		naname[a][b+1]--;
		naname[a+x+1][b+x+2]++;
	}
	for(int i=1;i<n+1;i++){
		for(int j=0;j<=i;j++){
			imos[i][j]+=imos[i-1][j];
		}
	}
	for(int i=1;i<n+1;i++){
		for(int j=1;j<=i+1;j++){
			naname[i][j]+=naname[i-1][j-1];
		}
	}
	for(int i=0;i<5050;i++){
		for(int j=0;j<5050;j++){
			imos[i][j]+=(j>0?imos[i][j-1]:0)+naname[i][j];
		}
	}
	int res=0;
	for(int i=0;i<n;i++){
		for(int j=0;j<=i;j++){
			// cout << imos[i][j] << " ";
			res+=(imos[i][j]>0?1:0);
		}
		// cout << endl;
	}
	cout << res << endl;
}
accuracy: 1
time_ms: 250
memory_kb: 169800
final_rank: 10