Problem:
Lights of Apartment
Problem
エーちゃんとリカちゃんとハルトくんはマンションに遊びに来た。
3人は全ての部屋の電気を管理できる部屋に忍び込みいたずらをすることにした。
このマンションは
n
個の立方体が1列に並んでいる形をしている。
各立方体は西から順に1辺の長さが1ずつ増えていて(1,2,3,...,
n
)、
i
番目の立方体は
i
階あり、各階に縦
i
×横
i
個の部屋がある。
2番目以降の立方体の西側は1つ西の立方体の東側と接していて、全ての立方体の南側は真っ直ぐな道路に面している。
初め全ての部屋に電気がついている。
3人はそれぞれ次の行動をした。
エーちゃんは西から
k
番目の全ての部屋の電気を消した。
リカちゃんは南から
k
番目の全ての部屋の電気を消した。
ハルトくんは
k
階の全ての部屋の電気を消した。
このようないたずらが
m
回行われた後に電気がついている部屋の数を求めよ。
Input
n
m
q
1
k
1
...
q
m
k
m
入力は全て整数で与えられる。
1行目に立方体の数
n
、行動の数
m
が与えられる。
2行目以降
m
行に行動した人の番号
q
と
k
が与えられる。
q
i
が0の場合エーちゃん、 1の場合リカちゃん、2の場合ハルトくんが行動したことを表す。
3人は部屋がない場所の電気を消そうとすることもある。
Constraints
1 ≤
n
,
m
≤ 50000
0 ≤
q
i
≤ 2
1 ≤
k
i
≤ 2×10
9
同じ行動は一度しか与えられない
Output
電気がついている部屋の数を1行に出力せよ。
Sample Input 1
3 1
0 4
Sample Output 1
27
Sample Input 2
3 2
2 2
2 3
Sample Output 2
14

Submitted solutions:

code_snippet: #include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <limits>
#include <climits>
#include <cfloat>
#include <functional>
using namespace std;

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

    vector<vector<int> > v(3, vector<int>(n+1, 0));
    while(--m >= 0){
        int q, k;
        cin >> q >> k;

        if(q == 0){
            long long a = 1;
            long long b = n + 1;
            while(a < b){
                long long c = (a + b) / 2;
                if(c * (c + 1) / 2 < k)
                    a = c + 1;
                else
                    b = c;
            }
            if(a <= n)
                ++ v[q][a];
        }
        else{
            if(k <= n)
                ++ v[q][k];
        }
    }

    long long ans = 0;
    for(int i=1; i<=n; ++i){
        for(int j=1; j<3; ++j)
            v[j][i] += v[j][i-1];

        long long cnt = 1;
        for(int j=0; j<3; ++j)
            cnt *= i - v[j][i];
        ans += cnt;
    }
    cout << ans << endl;

    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3700
final_rank: 3

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

typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;

#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcount

#define INF 1e16
#define mod 1000000007

ll sum(ll a){
  return a*(a+1)/2;
}

ll sqsum(ll a){
  return a*(a+1)*(2*a+1)/6;
}

ll qsum(ll a){
  return sum(a)*sum(a);
}

ll n,m;
vector<P> qs;
ll cnt[3][50001],cntjust[3][50001];

int main(){
  cin>>n>>m;
  rep(i,m){
    ll q,k;
    cin>>q>>k;
    if(q==0){
      ll lb=0,ub=n+1;
      while(ub-lb>1){
        ll mid=(ub+lb)/2;
        if(sum(mid)<k)lb=mid;
        else ub=mid;
      }
      k=ub;
    }
    if(k>n)continue;
    qs.push_back(P(q,k));
    cnt[q][k]++;
    cntjust[q][k]++;
  }
  rep(i,3)rep(j,n)cnt[i][j+1]+=cnt[i][j];
  m=qs.size();
  ll add=0,sub=0;
  rep(i,m){
    ll q=qs[i].fi,k=qs[i].se;
    if(q==0){
      sub+=k*k;
    }else{
      sub+=sqsum(n)-sqsum(k-1);
    }
  }

  rep(i,m){
    ll q=qs[i].fi,k=qs[i].se;
    if(q==0){
      add+=k*(cnt[1][k]+cnt[2][k]);
    }else if(q==1){
      add+=(sum(n)-sum(k-1))*cnt[2][k-1];
      add+=(sum(n)-sum(k-1))*cntjust[2][k];
    }else if(q==2){
      add+=(sum(n)-sum(k-1))*cnt[1][k-1];
    }
  }

  rep(i,m){
    ll q=qs[i].fi,k=qs[i].se;
    if(q==0){
      sub+=cnt[1][k]*cnt[2][k];
    }
  }

  cout<<qsum(n)+add-sub<<endl;
  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 5588
final_rank: 6

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}

using vi = vector<int>;

ll f(ll x){
    return x*(x+1)/2;
}

int main(){
    int n,m;
    scanf(" %d %d", &n, &m);

    vector<vi> add(n+1,vi(3));
    rep(i,m){
        int q;
        ll k;
        scanf(" %d %lld", &q, &k);
        if(q==0){
            ll l=0, r=100000;
            while(r-l>1){
                ll mid = (l+r)/2;
                if(f(mid)<k) l=mid;
                else r=mid;
            }
            if(r<=n) ++add[r][q];
        }
        else{
            if(k<=n) ++add[k][q];
        }
    }

    ll ans = 0;
    ll a[3]={};
    for(ll i=1; i<=n; ++i){
        a[0] = add[i][0];
        for(int j=1; j<3; ++j) a[j] += add[i][j];

        ans += i*i*i;
        ans -= i*i*(a[0]+a[1]+a[2]);
        ans += i*(a[0]*a[1]+a[1]*a[2]+a[2]*a[0]);
        ans -= a[0]*a[1]*a[2];
    }
    printf("%lld\n", ans);
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 5508
final_rank: 2

code_snippet: #include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;

int n,m;
vector<ll> tate;
vector<ll> yoko;
bool flag[50005];
ll len[50005];
ll rect[50005];

int main(void){
	for(ll i=1;i<=50000;i++){
		len[i]=len[i-1]+i;
	}
	for(ll i=1;i<=50000;i++){
		rect[i]=rect[i-1]+i*i;
	}
	scanf("%d%d",&n,&m);
	for(int i=0;i<m;i++){
		ll q,k;
		scanf("%lld%lld",&q,&k);
		k--;
		if(q==2){
			if(k<n)flag[k]=true;
		}
		if(q==0){
			if(k<len[n])tate.push_back(k);
		}
		if(q==1){
			if(k<n)yoko.push_back(k);
		}
	}
	sort(tate.begin(),tate.end());
	sort(yoko.begin(),yoko.end());
	ll dec=0;
	ll ans=0;
	ll cnt_ty=(ll)0;
	for(int i=0;i<tate.size();i++){
		int lv=upper_bound(len,len+n,tate[i])-len;
		int l2=lower_bound(yoko.begin(),yoko.end(),lv)-yoko.begin();
		dec+=lv;
		cnt_ty+=l2;
	}
	for(int i=0;i<yoko.size();i++){
		dec+=len[n]-len[yoko[i]];
	}
	ll po=0;
	int i_t=0,i_y=0;
	for(int i=0;i<n;i++){
		while(i_t<tate.size() && tate[i_t]<len[i]){
			int lv=upper_bound(len,len+n,tate[i_t])-len;
			int l2=lower_bound(yoko.begin(),yoko.end(),lv)-yoko.begin();
			dec-=lv;
			cnt_ty-=l2;
			i_t++;
		}
		while(i_y<yoko.size() && yoko[i_y]<i){
			i_y++;
		}
		dec-=(ll)(i)*i_y;
		if(flag[i])continue;
		ll val=rect[n]-rect[i];
		val-=dec;
		val+=cnt_ty;
		ans+=val;
		//printf("%lld %lld %lld\n",rect[n]-rect[i],dec,(ll)cnt_ty);
	}
	printf("%lld\n",ans);
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 4332
final_rank: 1

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

using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;

#define ALL(a)  begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))

#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)

#define FF first
#define SS second

#define DUMP(x) cout<<#x<<":"<<(x)<<endl
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
  return is >> p.FF >> p.SS;
}
template<class T>
istream& operator>>(istream& is, vector<T>& xs){
  for(auto& x: xs)
	is >> x;
  return is;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
  return os << p.FF << " " << p.SS;
}
template<class T>
ostream& operator<<(ostream& os, const vector<T>& xs){
  for(unsigned int i=0;i<xs.size();++i)
	os << (i?" ":"") << xs[i];
  return os;
}
template<class T>
void maxi(T& x, T y){
  if(x < y) x = y;
}
template<class T>
void mini(T& x, T y){
  if(x > y) x = y;
}


const double EPS = 1e-10;
const double PI  = acos(-1.0);
const LL MOD = 1e9+7;

int main(){
  cin.tie(0);
  ios_base::sync_with_stdio(false);

  LL N, M;
  cin >> N >> M;

  LL ans = 0;
  VL idx = {0ll};
  for(LL i=1,j=1;i<=N;++i){
	ans += i*i*i;
	idx.PB(j);
	j += i;
  }

  VVL qs(3);
  REP(i,M){
	LL Q, K;
	cin >> Q >> K;
	qs[Q].PB(K);
  }
  REP(q,3) SORT(qs[q]);

  VL blk_x;
  REP(i,N+1) blk_x.PB(i);

  for(LL x: qs[0]){
	if(x > N*(N+1)/2) continue;
	LL ix = (--upper_bound(ALL(idx), x)) - begin(idx);
	blk_x[ix]--;
	ans -= ix*ix;
  }

  VL blk_y(N+1);
  for(LL i=1;i<=N;++i)
	blk_y[i] = blk_y[i-1] + i * blk_x[i];

  VL del_y(N+1);
  for(LL y:qs[1]){
	if(y > N) continue;
	ans -= blk_y[N] - blk_y[y-1];
	++del_y[y];
  }

  LL acc = 0;
  VL blk_z(N+1);
  for(LL i=1;i<=N;++i){
	acc += del_y[i];
	blk_z[i] = blk_z[i-1] + (i - acc) * blk_x[i];
  }
  for(LL z: qs[2]){
	if(z > N) continue;
	ans -= blk_z[N] - blk_z[z-1];
  }
  cout << ans << endl;

  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 5664
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll d[50010],x[50010],y[50010],z[50010],ans,n,m;
    
int main() {
  cin >> n >> m;
  for(ll i=1; i<=n; i++) d[i]=d[i-1]+i;
  for(int i=0,a,b; i<m; i++) {
    cin >> a >> b;
    if(!a) b=lower_bound(d,d+n+1,b)-d;
    if(b>n) continue;
    if(!a) x[b]++;
    else if(a==1) y[b]++;
    else z[b]++;
  }
  for(ll i=1; i<=n; i++) {
    y[i]+=y[i-1];
    z[i]+=z[i-1];
    ans+=(i-x[i])*(i-y[i])*(i-z[i]);
  }
  cout << ans << endl;
  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 4572
final_rank: 5