cf 424

Office Keys

首先显然有随人位置的递增，钥匙的位置也要递增，这样考虑两张做法：

1.$f(i,j)$ 表示前i个人，钥匙到第j个最少用的最大时间，然后$O(nK)$ dp

2.二分时间，对于每一个人选择当前能选择的最左面的钥匙 $O((n+K) logn)$

#include <bits/stdc++.h>

#define LL long long

const int N = ;

using namespace std;

int n,m,pre[N],a[N],b[N];

int Abs(int x)
{
    if(x<) return -x;
    return x;
}

int p;

bool check(int tim)
{
    int j = ;
    for(int i=;i<=n;i++)
    {
        while(j<=m && Abs(a[i]-b[j])+(LL)Abs(b[j]-p) > tim) j++;
        if(j>m) return ;
        else j++;
    }
    return ;
}

int main()
{
    int maxv = ;
    scanf("%d%d%d",&n,&m,&p);
    maxv = p;
    for(int i=;i<=n;i++) scanf("%d",&a[i]), maxv = max(maxv ,a[i]);
    for(int i=;i<=m;i++) scanf("%d",&b[i]), maxv = max(maxv, b[i]);
    sort(a+,a+n+);
    sort(b+,b+m+);
    int l=, r=;
    for(int i=;i<=n;i++) l = max(l, Abs(p-a[i]));
    for(int i=;i<=n;i++) r = max(r, Abs(b[i]-a[i]) + Abs(p-b[i]));
    while(r-l>)
    {
        int mid = (l+(LL)r)>>1LL;
        if(check(mid)) r = mid;
        else l = mid;
    }
    for(int i=l;i<=r;i++)
        if(check(i))
        {
            cout<<i<<endl;
            break;
        }
    return ;
}

Cards Sorting

方法1：直接用splay模拟。

方法2：考虑每次删掉当前最小数的代价是上一个最小数和它之间的循环dist，BIT或链表即可。

(取自CF)

#include <bits/stdc++.h>

const int N = ;
#define INF 0x3f3f3f3f
#define LL long long

using namespace std;

struct node
{
    node *ch[];
    int v, sum, minv;
    int cmp(int x)
    {
        if(ch[]->sum +  == x) return -;
        return x > ch[]->sum;
    }
    node* init(int x);
    void update()
    {
        sum = ch[]->sum + ch[]->sum + ;
        minv = min(v, min(ch[]->minv, ch[]->minv));
    }
}spT[N], Null, *root;

int tot=;

node* node::init(int x)
{
    v=x;
    minv=x;
    ch[]=ch[]=&Null;
    sum=;
    return this;
}

node* build(int src[],int l,int r)
{
    if(l==r) return spT[++tot].init(src[l]);
    int mid=(l+r)>>;
    node* tmp=spT[++tot].init(src[mid]);
    if(l<mid) tmp->ch[]=build(src,l,mid-);
    if(mid<r) tmp->ch[]=build(src,mid+,r);
    tmp->update();
    return tmp;
}

void rot(node* &o,int x)
{
    node* tmp=o->ch[x];
    o->ch[x]=tmp->ch[x^];
    tmp->ch[x^]=o;
    o->update();
    o=tmp;
    o->update();
}

void splay(node* &o,int k)
{
    int t=o->cmp(k);
    if(t==-) return;
    if(t) k-=o->ch[]->sum+;
    int t1=o->ch[t]->cmp(k);
    if(~t1)
    {
        if(t1) k-=o->ch[t]->ch[]->sum+;
        splay(o->ch[t]->ch[t1],k);
        if(t1==t) rot(o,t);
        else rot(o->ch[t],t1);
    }
    rot(o,t);
}

int find_min(node *&o,int minv,int now)
{
    if(o->ch[]->minv == minv) return find_min(o->ch[],minv,now);
    else
    {
        if(o->v == minv) return now+o->ch[]->sum;
        return find_min(o->ch[],minv,now+o->ch[]->sum+);
    }
}

int n,a[N];

int main()
{
    scanf("%d",&n);
    for(int i=;i<=n;i++) scanf("%d",&a[i]);
    Null.minv = INF;
    a[]=INF;
    a[n+]=INF;
    root = build(a,,n+);
    int len = n+;
    LL ans = ;
    for(int i=;i<=n;i++)
    {
        int tmp = find_min(root,root->minv,);
        ans += (LL)tmp;
        splay(root,);
        splay(root->ch[],tmp+);
        node* tp = root->ch[]->ch[];
        root->ch[]->ch[] = &Null;
        root->ch[]->update();
        root->update();

        splay(tp,tp->sum);
        tp = tp->ch[];
        len--;

        splay(root,len-tp->sum);
        splay(root->ch[],len-tp->sum-);
        root->ch[]->ch[] = tp;
        root->ch[]->update();
        root->update();
    }
    cout << ans << endl;
    return ;
}

Bamboo Partition

显然要满足的条件等价于

$\sum_{i=1}^n { [\frac{a_i + d - 1}{d}] \cdot d - a_i} \leq K$

$F(d) = \sum_{i=1}^n { [\frac{a_i - 1}{d}] + 1} \cdot d  \leq K + \sum {a_i}$

固定 $\sum_{i=1}^n { [\frac{a_i - 1}{d}] + 1}$，从而 $F(d)$ 单调。

对于前者直接找出所有得数相同的 $d$ 的区间，逐一计算即可。

复杂度$O(n^2 \sqrt {a_i} )$

通过调参可以 $O(n \sqrt {a_{max} n})$

#include <bits/stdc++.h>

#define LL long long

const int N = ;

using namespace std;

int n,tot,a[N];
LL K;
vector<int> v;

int main()
{
    cin>>n>>K;
    for(int i=;i<=n;i++)
    {
        scanf("%d",&a[i]);
        K += (LL)a[i];
        int j=;
        int tmp = a[i]-;
        if(tmp>)
        {
            for(int i=;i<=tmp;i=j+)
                j = tmp/(tmp/i), v.push_back(i);
            v.push_back(tmp+);
        }
    }
    v.push_back();
    sort(v.begin(),v.end());
    v.resize(distance(v.begin(), unique(v.begin(), v.end())));
    LL ans = , sum;
    for(int i=;i<(int)v.size() - ;i++)
    {
        int l = v[i], r = v[i+]-;
        sum = ;
        for(int j=;j<=n;j++) sum += (a[j]-1LL)/l + 1LL;
        LL tmp = min(K/sum, (LL)r);
        if(tmp>=l) ans = tmp;
    }
    LL l = v[v.size()-];
    LL tmp = K/n;
    if(tmp >= l) ans = tmp;
    cout << ans << endl;
}