제출 #1268713

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
1268713		MMihalev	Bulldozer (JOI17_bulldozer)	C++20	60 / 100	617 ms	33412 KiB

bulldozer

#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
using namespace std;
const int MAX_N=2e3+2;
const long long INF=(1LL<<62);
int n;
long long x[MAX_N];
long long y[MAX_N];
long long cost[MAX_N];
int pos[MAX_N];
bool allzero=1;
vector<pair<pair<long long,int>,long long>>order;
long long distance(long long A,long long B,long long x0,long long y0)
{
    return A*x0+B*y0;
}
long long solvefor()
{
    long long curbest=0;
    for(int i=0;i<order.size();i++)
    {
        long long cur=0;
        for(int j=i;j<order.size();j++)
        {
            cur+=order[j].second;
            curbest=max(curbest,cur);
        }
    }
    return curbest;
}
vector<pair<pair<long long,int>,long long>>norder;
void normalize()
{
    norder.clear();
    norder.push_back(order[0]);
    for(int i=1;i<order.size();i++)
    {
        if(order[i].first==norder.back().first)
        {
            norder.back().second+=order[i].second;
            continue;
        }
        norder.push_back(order[i]);
    }
    swap(order,norder);
}

struct V
{
    long long pref,suf,sum,sub;
};
V tree[4*MAX_N];
void Update(int node,int l,int r,int idx,long long val)
{
    if(l==r)
    {
        tree[node].pref=val;tree[node].suf=val;tree[node].sum=val;tree[node].sub=val;
        return;
    }
    int mid=(l+r)/2;
    if(idx<=mid)Update(2*node,l,mid,idx,val);
    else Update(2*node+1,mid+1,r,idx,val);

    tree[node].sum=tree[2*node].sum+tree[2*node+1].sum;
    tree[node].pref=max(tree[2*node].pref,tree[2*node].sum+tree[2*node+1].pref);
    tree[node].suf=max(tree[2*node+1].suf,tree[2*node+1].sum+tree[2*node].suf);
    tree[node].sub=max(tree[2*node].sub,tree[2*node+1].sub);
    tree[node].sub=max(tree[node].sub,tree[2*node].suf+tree[2*node+1].pref);
}
long long query()
{
    return tree[1].sub;
}
void solve()
{
    for(int i=1;i<=n;i++)
    {
        order.push_back({{x[i],i},cost[i]});
    }
    sort(order.begin(),order.end());
    normalize();

    long long ans=max(0LL,solvefor());

    if(!allzero)
    {
        bool first=1;
        int pi,pj;bool one=1;

        vector<pair<double,pair<int,int>>>lines;

        for(int i=1;i<=n;i++)
        {
            for(int j=i+1;j<=n;j++)
            {
                double A=1.0*y[i]-1.0*y[j];
                double B=1.0*x[j]-1.0*x[i];
                if(B==0 && one)
                {
                    one=0;
                    long long C=-A*x[i]-B*y[i];
                    order.clear();
                    for(int idx=1;idx<=n;idx++)
                    {
                        order.push_back({{distance(A,B,x[idx],y[idx]),idx},cost[idx]});
                    }
                    sort(order.begin(),order.end());

                    int idi=-1,idj;

                    for(int idx=0;idx<order.size();idx++)
                    {
                        if(order[idx].first.first==-C)
                        {
                            if(idi==-1)idi=idx;
                            else idj=idx;
                        }
                    }
                    ans=max(ans,solvefor());
                    swap(order[idi],order[idj]);
                    ans=max(ans,solvefor());
                    continue;
                }
                lines.push_back({-(A/B),{i,j}});
            }
        }

        sort(lines.begin(),lines.end());

        for(auto line:lines)
        {
            int i=line.second.first;
            int j=line.second.second;

            if(first)
            {
                long long A=y[i]-y[j];
                long long B=x[j]-x[i];
                order.clear();
                for(int idx=1;idx<=n;idx++)
                {
                    order.push_back({{distance(A,B,x[idx],y[idx]),idx},cost[idx]});
                }
                sort(order.begin(),order.end());
                for(int idx=0;idx<n;idx++)
                {
                    Update(1,1,n,idx+1,order[idx].second);
                    pos[order[idx].first.second]=idx;
                }
                first=0;
            }

            int idi=pos[i],idj=pos[j];

            ans=max(ans,query());
            Update(1,1,n,idi+1,cost[j]);
            Update(1,1,n,idj+1,cost[i]);
            swap(order[idi],order[idj]);
            swap(pos[i],pos[j]);
            ans=max(ans,query());

            pi=i;
            pj=j;
        }
    }

    cout<<ans<<"\n";
}
int main ()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>x[i]>>y[i]>>cost[i];
        if(y[i]!=0)allzero=0;
    }
    solve();
    return 0;
}

• Subtask 1: 5 / 5
• Subtask 2: 20 / 20
• Subtask 3: 35 / 35
• Subtask 4: 0 / 20
• Subtask 5: 0 / 20