Submission #145696

#	Time	Username	Problem	Language	Result	Execution time	Memory
145696		davitmarg	Hedgehog Daniyar and Algorithms (IZhO19_sortbooks)	C++17	64 / 100	3023 ms	262144 KiB

sortbooks

/*DavitMarg*/
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <cstring>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <iomanip>
#include <stack>
#include <cassert>
#include <iterator>
#include <bitset>
#include <fstream>
#define mod 1000000007ll
#define LL long long
#define LD long double
#define MP make_pair
#define PB push_back
#define all(v) v.begin(),v.end()
using namespace std;
char readchar() {
    char c = getchar();
    while (c <= 33) {
        c = getchar();
    }
    return c;
}
 
 
int readint() {
    char c = getchar();
    while (c <= 33) {
        c = getchar();
    }
    bool sign = false;
    if (c == '-') {
        sign = true;
        c = getchar();
    }
    int t = 0;
    while (c >= '0' && c <= '9') {
        t = (t << 3) + (t << 1) + c - '0';
        c = getchar();
    }
    return (sign ? -t: t);
}
 
 
 
int n,m,a[1000006],wmin;
int ans;
vector<int> g[4*1000006];
int t[4*1000006],mn[4*1000006],mx[4*1000006];
 
int mergeSerge(vector<int>& a,vector<int>& b,vector<int> &c)
{
    int p=0,q=0,d=0;
    for(int i=0;i<b.size();i++)
        if(b[i]<a.back())
            d=a.back()+b[i];
    while(p<a.size())
    {
        while(q<b.size() && b[q]<a[p])
            c.PB(b[q++]);
        c.PB(a[p++]);
    }
    while(q<b.size())
        c.PB(b[q++]);
 
    return d;
}
 
void build(int v,int l,int r)
{
    if(l==r)
    {
        t[v]=a[l];
        mn[v]=a[l];
        g[v].PB(a[l]);
        return;
    }
    int m=(l+r)/2;
    build(v*2,l,m);
    build(v*2+1,m+1,r);
    mx[v]=mergeSerge(g[v*2],g[v*2+1],g[v]);
    mx[v]=max(mx[v],max(mx[v*2],mx[v*2+1]));
    t[v]=max(t[v*2],t[v*2+1]);
    mn[v]=min(mn[v*2],mn[v*2+1]);
}
 
int get(int v,int l,int r,int i,int j,int lmax)
{
    if(i>j)
        return -1;
    if(l==i && r==j)
    {
        //cout<<"["<<l<<":"<<r<<"]"<<" "<<lmax<<endl;
        if(g[v][0]<lmax)
            ans=max(ans,lmax+(*(lower_bound(all(g[v]),lmax)-1)));
        ans=max(ans,mx[v]);
        return t[v];
    }
    int m=(l+r)>>1;
    
    int p1,p2;
 
    p1=get(v*2,l,m,i,min(j,m),lmax);
    lmax=max(lmax,p1);
 
    p2=get(v*2+1,m+1,r,max(m+1,i),j,lmax);
    lmax=max(lmax,p2);
 
    return lmax;
}
 
pair<int,int> get2(int v,int l,int r,int i,int j)
{
    if(i>j)
        return MP(-1,mod);
    if(l==i && r==j)
    {
        ans|=(bool)(mx[v]);
        return MP(t[v],mn[v]);
    }
    int m=(l+r)>>1;
    
    pair<int,int> p1,p2;
 
    p1=get2(v*2,l,m,i,min(j,m));
    p2=get2(v*2+1,m+1,r,max(m+1,i),j);
 
    if(j<=m)
        return p1;
    else if(i>=m+1)
        return p2;
    else
    {
        if(p1.first>p2.second)
            ans=1;
        return MP(max(p1.first,p2.first),min(p1.second,p2.second));
    }
    
}
 
int main()
{
    cin>>n>>m;
    wmin=mod*3;
    for(int i=1;i<=n;i++)
    {
        a[i]=readint();
        wmin=min(a[i],wmin);
    }
    build(1,1,n);
 
    while(m--)
    {
        int l,r,k;  
        ans=0;
       // scanf("%d%d%d",&l,&r,&k);
        l=readint();
        r=readint();
        k=readint();
 
        if(k>wmin)
        {
            get(1,1,n,l,r,-1);
            printf("%c",'0'+(k>=ans));
        }
        else
        {
            get2(1,1,n,l,r);
            printf("%d",(ans==0));
        }
        putchar(10);
    }
 
	return 0;
}
 
 
 
/*
 
 
5 10
2 1 1 1 2
1 5 0
2 5 0
1 4 0
2 4 0
1 5 3
 
*/

Compilation message (stderr)

sortbooks.cpp: In function 'int mergeSerge(std::vector<int>&, std::vector<int>&, std::vector<int>&)':
sortbooks.cpp:62:18: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
     for(int i=0;i<b.size();i++)
                 ~^~~~~~~~~
sortbooks.cpp:65:12: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
     while(p<a.size())
           ~^~~~~~~~~
sortbooks.cpp:67:16: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
         while(q<b.size() && b[q]<a[p])
               ~^~~~~~~~~
sortbooks.cpp:71:12: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
     while(q<b.size())
           ~^~~~~~~~~

• Subtask 1: 8 / 8
• Subtask 2: 9 / 9
• Subtask 3: 0 / 13
• Subtask 4: 17 / 17
• Subtask 5: 30 / 30
• Subtask 6: 0 / 23