oj.uz

Submission #120987

# Submission time Handle Problem Language Result Execution time Memory
120987 2019-06-25T21:39:23 Z TadijaSebez Pyramid Base (IOI08_pyramid_base) C++11
85 / 100
 2508 ms 139248 KB 
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
const int N=1000050;
const int M=2*N;
const int P=400050;
int root,tsz,mn[M],lzy[M],ls[M],rs[M];
void Set(int &c, int ss, int se, int qs, int qe, int f)
{
	if(qs>qe || qs>se || ss>qe) return;
	if(!c) c=++tsz;
	if(qs<=ss && qe>=se){ lzy[c]+=f;mn[c]+=f;return;}
	int mid=ss+se>>1;
	Set(ls[c],ss,mid,qs,qe,f);
	Set(rs[c],mid+1,se,qs,qe,f);
	mn[c]=min(mn[ls[c]],mn[rs[c]])+lzy[c];
}
void Clear(){ for(int i=1;i<=tsz;i++) ls[i]=rs[i]=mn[i]=lzy[i]=0;tsz=root=0;}
struct Event
{
	int tme,l,r,f;
	Event(int a, int b, int c, int d):tme(a),l(b),r(c),f(d){}
	bool operator < (Event b) const { return tme<b.tme;}
};
int X1[P],X2[P],Y1[P],Y2[P],cost[P],p,n,m,B;
bool Check(int sz)
{
	Clear();
	vector<Event> evs;
	for(int i=1;i<=p;i++)
	{
		evs.pb(Event(X1[i]-sz+1,Y1[i]-sz+1,Y2[i],cost[i]));
		evs.pb(Event(X2[i]+1,Y1[i]-sz+1,Y2[i],-cost[i]));
	}
	sort(evs.begin(),evs.end());
	int lst=0;
	for(int i=0;i<evs.size();i++)
	{
		int t=evs[i].tme-lst;
		lst=evs[i].tme;
		if(t>0 && lst>1 && mn[root]<=B) return 1;
		Set(root,1,m-sz+1,evs[i].l,evs[i].r,evs[i].f);
		if(lst>n-sz+1) break;
	}
	return 0;
}
struct Node
{
	int sum,l,r,mx,sz;
	Node(){}
	Node(int a, int b, int c, int d, int e):sum(a),l(b),r(c),mx(d),sz(e){}
	int Get(){ return sum?0:mx;}
	void Check(){ if(sum) l=r=mx=0;}
};
void Merge(Node &c, Node ls, Node rs)
{
	ls.Check();
	rs.Check();
	c=Node(c.sum,ls.l+(ls.l==ls.sz?rs.l:0),rs.r+(rs.r==rs.sz?ls.r:0),max(max(ls.mx,rs.mx),ls.r+rs.l),ls.sz+rs.sz);
}
struct STIntervals
{
	int ls[M],rs[M],tsz,root;
	Node node[M];
	STIntervals(){}
	void Build(int &c, int ss, int se)
	{
		c=++tsz;
		if(ss==se){ node[c]=Node(0,1,1,1,1);return;}
		int mid=ss+se>>1;
		Build(ls[c],ss,mid);
		Build(rs[c],mid+1,se);
		Merge(node[c],node[ls[c]],node[rs[c]]);
	}
	void Set(int &c, int ss, int se, int qs, int qe, int f)
	{
		if(qs>qe || qs>se || ss>qe) return;
		if(qs<=ss && qe>=se){ node[c].sum+=f;return;}
		int mid=ss+se>>1;
		Set(ls[c],ss,mid,qs,qe,f);
		Set(rs[c],mid+1,se,qs,qe,f);
		Merge(node[c],node[ls[c]],node[rs[c]]);
	}
	int Get(){ return node[root].Get();}
} ST;
vector<int> add[N],del[N];
void Solve()
{
	for(int i=1;i<=p;i++)
	{
		add[X1[i]].pb(i);
		del[X2[i]+1].pb(i);
	}
	ST.Build(ST.root,1,m);
	int ans=0;
	for(int i=1,j=1;i<=n;i++)
	{
		for(int k:del[i]) ST.Set(ST.root,1,m,Y1[k],Y2[k],-1);
		while(j<=n && ST.Get()>=j-i)
		{
			ans=max(ans,j-i);
			for(int k:add[j]) ST.Set(ST.root,1,m,Y1[k],Y2[k],1);
			j++;
		}
	}
	printf("%i\n",ans);
}
int main()
{
	scanf("%i %i %i %i",&n,&m,&B,&p);
	for(int i=1;i<=p;i++) scanf("%i %i %i %i %i",&X1[i],&Y1[i],&X2[i],&Y2[i],&cost[i]);
	if(B==0){ Solve();return 0;}
	int top=min(n,m),bot=1,mid,ans=0;
	while(top>=bot)
	{
		mid=top+bot>>1;
		if(Check(mid)) ans=mid,bot=mid+1;
		else top=mid-1;
	}
	printf("%i\n",ans);
	return 0;
}

Compilation message

pyramid_base.cpp: In function 'void Set(int&, int, int, int, int, int)':
pyramid_base.cpp:13:12: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
  int mid=ss+se>>1;
          ~~^~~
pyramid_base.cpp: In function 'bool Check(int)':
pyramid_base.cpp:37:15: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
  for(int i=0;i<evs.size();i++)
              ~^~~~~~~~~~~
pyramid_base.cpp: In member function 'void STIntervals::Build(int&, int, int)':
pyramid_base.cpp:70:13: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
   int mid=ss+se>>1;
           ~~^~~
pyramid_base.cpp: In member function 'void STIntervals::Set(int&, int, int, int, int, int)':
pyramid_base.cpp:79:13: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
   int mid=ss+se>>1;
           ~~^~~
pyramid_base.cpp: In function 'int main()':
pyramid_base.cpp:116:10: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
   mid=top+bot>>1;
       ~~~^~~~
pyramid_base.cpp:110:7: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
  scanf("%i %i %i %i",&n,&m,&B,&p);
  ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
pyramid_base.cpp:111:29: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
  for(int i=1;i<=p;i++) scanf("%i %i %i %i %i",&X1[i],&Y1[i],&X2[i],&Y2[i],&cost[i]);
                        ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Subtask #1
0 / 5.0

# Verdict Execution time Memory Grader output
1 Incorrect 42 ms 47352 KB Output isn't correct

Subtask #2
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 40 ms 47360 KB Output is correct

Subtask #3
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 42 ms 47352 KB Output is correct

Subtask #4
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 54 ms 47992 KB Output is correct

Subtask #5
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 52 ms 52972 KB Output is correct

Subtask #6
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 115 ms 102132 KB Output is correct
2 Correct 113 ms 102136 KB Output is correct

Subtask #7
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 113 ms 102248 KB Output is correct
2 Correct 110 ms 102128 KB Output is correct

Subtask #8
7.0 / 7.0

# Verdict Execution time Memory Grader output
1 Correct 58 ms 47988 KB Output is correct
2 Correct 86 ms 48128 KB Output is correct
3 Correct 84 ms 48272 KB Output is correct

Subtask #9
7.0 / 7.0

# Verdict Execution time Memory Grader output
1 Correct 192 ms 49512 KB Output is correct
2 Correct 321 ms 50068 KB Output is correct
3 Correct 267 ms 49824 KB Output is correct

Subtask #10
7.0 / 7.0

# Verdict Execution time Memory Grader output
1 Correct 231 ms 51032 KB Output is correct
2 Correct 79 ms 49456 KB Output is correct
3 Correct 177 ms 53124 KB Output is correct
4 Correct 363 ms 52816 KB Output is correct

Subtask #11
7.0 / 7.0

# Verdict Execution time Memory Grader output
1 Correct 369 ms 52020 KB Output is correct
2 Correct 728 ms 53628 KB Output is correct
3 Correct 187 ms 50828 KB Output is correct

Subtask #12
7.0 / 7.0

# Verdict Execution time Memory Grader output
1 Correct 319 ms 51520 KB Output is correct
2 Correct 930 ms 54892 KB Output is correct
3 Correct 831 ms 54616 KB Output is correct
4 Correct 889 ms 54704 KB Output is correct
5 Correct 884 ms 54620 KB Output is correct
6 Correct 181 ms 51228 KB Output is correct

Subtask #13
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 1171 ms 117532 KB Output is correct
2 Correct 436 ms 68248 KB Output is correct

Subtask #14
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 1438 ms 124256 KB Output is correct
2 Correct 1636 ms 128568 KB Output is correct
3 Correct 873 ms 120172 KB Output is correct

Subtask #15
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 1870 ms 130716 KB Output is correct
2 Correct 2508 ms 139248 KB Output is correct
3 Incorrect 2495 ms 139140 KB Output isn't correct
4 Halted 0 ms 0 KB -