模拟赛题解

P7382[COCI2018-2019#6] Simfonija

转化题意，就是钦定一个整数 $x$ ，选定 $n - k$ 个 $a_{i}$ 和 $b_{i}$ ，令 $\sum_{j = 1}^{n - k} | a_{j} + x - b_{j} |$ 最小。因此，我们只要钦定出最优方案下的 $x$ ，选定对于当前 $x$ 前 $n - k$ 小的 $| a_{i} + x - b_{i} |$ 即可。

思路

首先， $a_{i} - b_{i}$ 是定值，设 $c_{i} = a_{i} - b_{i}$ 。钦定一个 $x$ ，如果令答案最小，发现选定的所有 $c_{j}$ 一定是在 $x$ 两侧连续排布。于是对 $c$ 排序，保证选定的所有 $c_{j}$ 是连续的，枚举所有长度为 $n - k$ 的连续子区间即可。

如果直接枚举求的话时间复杂度为 $O (n^{2})$ ，需要用前缀和优化成 $O (n)$ 。对于用前缀和求中位数与每个值的差的绝对值之和的最小值是很有 trick 意味在里面的。思路来源于这道题以及这篇题解。

假设中位数为 $x$ ，分两种情况讨论。

$r - l$ 是奇数，求的是 $min {\sum_{i = l}^{r} | c_{i} + x |}$ 。
比 $x$ 小的数有 $c_{l}, c_{l + 1}, . . . c_{m i d}$ ，比 $x$ 大的数就有 $c_{m i d + 1}, c_{m i d + 2}, . . ., c_{r}$ ，其中 $m i d = \frac{l + r}{2}$ 。于是就可以转化成求 $\sum_{i = l}^{m i d} | c_{i} + x |$ 和 $\sum_{i = m i d + 1}^{r} | c_{i} + x |$ 的和的最小值。
我们取出两个式子中的两边一项 $c_{l}$ 和 $c_{r}$ ，求 $min {| c_{l} + x | + | c_{r} + x |}$ ，那么一定满足 $- c_{r} \leq x \leq - c_{l}$ 。
设 $c_{r} \geq c_{l} \geq 0$ 则有 $min {| c_{l} + x | + | c_{r} + x |} = x - c_{l} + c_{r} - x = c_{r} - c_{l}$ 。同理选出 $c_{l + 1}$ 和 $c_{r - 1}$ ，也能得出类似的结论...

因此最小值为 $\sum_{i = m i d + 1}^{r} c_{i} - \sum_{i = 1}^{m i d} c_{i}$ 。
同理如果 $r - l$ 是偶数，可以推得所求的值就是 $\sum_{i = m i d + 1}^{r} - \sum_{i = l}^{m i d - 1}$ 。

总复杂度为 $O (n \log n)$ ，瓶颈在排序。
代码很简单，就不贴了，应该也比较好写。

P6346[CCO2017]专业网络

思路

一个显然的思路是：直接根据 $a$ 排序，如果能免费交的朋友就直接交，如果必须花钱结交，那么就贪心的选择还没有结交的朋友中花费较小的来结交，但是会直接被第三个样例 hack 掉。

尝试改进这个思路，根据正难则反，我们可以从后往前考虑前面所有人都是花钱购买的这种前提下，当前这个人是否仍需花钱购买。

如果前面所有人加上后面必须购买的人的总和仍然小于当前这个人的 $a_{i}$ ，说明当前这个人暂时不能免费结交。我们有两种方式让他与我们结交：

直接购买他
购买那些本来可以免费结交的人，使得他可以免费结交。

最优方法一定是购买所有满足以上两种情况之一的人中，花钱最少的那个，这样当前这个人就可以结交了。这个过程可以用堆实现。

这种策略的好处是一直保持在一个既花钱少又能保持人数多的状态，如果这种状态仍然小于当前这个人的要求 $a_{i}$ ，就只能花钱通过两种方式之一才能邀请到当前这个人加入。通过从后往前不断地调整，就可以得到当前的最优解。

~~代码略过，很好写。~~

经验题

CF1251E1 Voting (Easy Version)
CF1251E2 Voting (Hard Version)

P5967[POI2016]Korale

参考 zzz 学长的博客

简单思路

分成两个问题解决：

求第 $k$ 小值
求第 $k$ 小值对应的集合

对于第一问：

由于我们只是求第 $k$ 小值，因此可以直接忽略编号大小带来的影响。
首先按照权值排序。设这个二元组为 $(s u m, i)$ ，表示前 $i - 1$ 个数选出若干数与第 $i$ 个数的和为 $s u m$ ，先将排序后的第一个数放入小根堆中，每次取出最小的一个，然后把 $(s u m + a_{i + 1}, i + 1)$ 和 $(s u m + a_{i + 1} - a_{i}, i + 1)$ 放入堆中，学长说这种方式可以不重不漏，但是蒟蒻太弱了，不知道为什么，有没有大佬知道的给蒟蒻讲讲呗。

对于第二位

设上一问求得的答案为 $a n s$ ，排名小于等于 $k$ 且和为 $a n s$ 的数的个数为 $c n t$ 。直接从前往后 dfs 取靠前的数，每次取的数要保证是区间最小值，这个东西可以用线段树在线维护，或者 st 表离线求也可以。

两部分时间复杂度都是 $O (k \log n)$ ，因此总复杂度就是 $O (k \log n)$ 。

代码

不开 $O_{2}$ 应该过不了，~~反正我没过去。~~

#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N=1e6+10;
int n,k,a[N],b[N];
typedef pair<ll,int>PLI;
#define x first
#define y second
priority_queue<PLI,vector<PLI>,greater<PLI>>q;
ll ans,cnt;
int read()
{
    int x=0;
    char ch=getchar();
    while(!isdigit(ch))ch=getchar();
    while(isdigit(ch))x=x*10+(ch^48),ch=getchar();
    return x;
}
void write(ll x)
{
    if(x>9)write(x/10);
    putchar(x%10+'0');
}
int mn[N<<2];
#define ls u<<1
#define rs u<<1|1
void build(int u,int l,int r)
{
    if(l==r)return mn[u]=a[l],void();
    int mid=(l+r)>>1;
    build(ls,l,mid);
    build(rs,mid+1,r);
    mn[u]=min(mn[ls],mn[rs]);
}
int query(int u,int l,int r,int pl,ll x)
{
    if(pl<=l)
    {
        if(mn[u]>x)return 0;
        if(l==r)return l;
    }
    int mid=(l+r)>>1;
    if(pl<=mid)
    {
        int t=query(ls,l,mid,pl,x);
        if(t)return t;
    }
    return query(rs,mid+1,r,pl,x);
}
int top,stk[N];
void dfs(int l,ll res)
{
    if(!res&&!--cnt)
    {
        write(ans),putchar('\n');
        for(int i=1;i<=top;i++)write(stk[i]),putchar(' ');
        exit(0);
    }
    for(int i=l+1;i<=n;i++)
    {
        i=query(1,1,n,i,res);
        if(!i)return;
        stk[++top]=i;
        dfs(i,res-a[i]);
        top--;
    }
}
int main()
{
    n=read(),k=read()-1;
    if(!k)return puts("0"),0;
    for(int i=1;i<=n;i++)b[i]=a[i]=read();
    sort(b+1,b+1+n);
    q.push({b[1],1});
    for(int i=1;i<=k;i++)
    {
        PLI t=q.top();q.pop();
        if(t.x==ans)cnt++;
        else ans=t.x,cnt=1;
        if(t.y==n)continue;
        t.x+=b[++t.y];
        q.push(t);
        t.x-=b[t.y-1];
        q.push(t);
    }
    build(1,1,n);
    dfs(0,ans);
    return 0;
}