[NOI2019]序列 题解 （模拟费用流）

题意：

有两个长度为n的序列，要求从每个序列中选k个，并且满足至少有l个位置都被选，问总和最大是多少。
\(1\leq l\leq k\leq n\leq 2*10^5\)。
首先，记录当前考虑到的位置i，第一个选的数量a， 第二个选的数量b，都被选的数量c，可以做到\(O(n^4)\)，
卡常后能过\(n\leq 150\)，有40分。
考虑正解：首先，看到这个范围，可以认为正解一定是贪心。
先看下\(n\leq 2000\)，这个是网络流的范围。我们可以先建出费用流，然后再变为模拟费用流，即贪心。
从源点向第一个序列连边，第二个序列向汇点连边。
然后，我们发现至少有l个位置都被选不太容易表示，因为左面向对应的右面连的边是分开的，无法放到一起考虑下限。
换一种思路：至少有l个位置都被选，就是剩的位置不超过\(k-l\)。
所以，我们可以这样建图：
1、从源点向第一个序列连边，第二个序列向汇点连边。
2、对应位置连流量为1的边。
3、第一个序列都向点a连边，点b向第二个序列连边。a到b连容量\(k-l\)的边。
求出流量为k的最大费用流即可。这样据说有64分。
考虑模拟费用流优化：
首先，记录s表示a到b的剩余流量。
1、若\(s>0\)，则可以通过a到b的边增广，即从两个序列中各选一个最大数，并把s减去1。

2、可以直接走左右的对应连边增广，即选一个左右相加最大的位置。
3、可以走S->x->x'->b->y'->T，走x'->b的前提是x在第二个序列中被选。
即在第一个序列中选一个第二个序列中被选的位置，再选一个第二个序列中没被选的作为y。
4、与3对称，即在第二个序列中选一个第一个序列中被选的位置，再选一个第一个序列中没被选的。
因为是最长路增广，所以在2,3,4中选最大的。以上操作可以用5个优先队列完成。

然而，我们发现过不去样例。
其实，算法是对的，但我们少了一些情况（特判）：
首先，还可以走S->x->x'->b->a->y->y'->T。（情况5）
就是在第二个序列中选一个第一个序列中被选的位置，再在第一个序列中选一个第二个序列中被选的位置，
因为退了a到b的流，要把s加1。

在1中，若选的两个位置相同，则不用减s。若选的位置在另一序列中已被选，则为情况3或4，不用减s。
若选的位置在另一序列中都已被选，则为情况5，把s加1。
在3,4中，可能会转移到情况5，此时要把s加1。

加上这些后就能过了，实现时要注意细节。

代码：

#include  
#include  
using namespace std;
struct SJd {
    int z,  i;
    SJd() {}
    SJd(int Z, int I) {
        z = Z;i = I;
    }
};
bool operator < (const SJd a, const SJd b) {
    return a.z < b.z;
}
#define prio priority_queue < SJd > 
#define ll long long 
int sa[200010],sb[200010],ba[200010],bb[200010];
prio pa,pb,pc,pd,pe,em;
inline int read() {
    char ch;
    while ((ch = getchar()) < '0' || ch > '9');
    int rt = ch - '0';
    while ((ch = getchar()) >= '0' && ch <= '9') rt = (rt << 3) + (rt << 1) + ch - '0';
    return rt;
}
int main() {
    int T;
    scanf("%d", &T);
    while (T--) {
        pa = pb = pc = pd = pe = em;
        int n,k,l;
        n = read();
        k = read();
        l = read();
        for (int i = 0; i < n; i++) sa[i] = read();
        for (int i = 0; i < n; i++) sb[i] = read();
        for (int i = 0; i < n; i++) {
            pa.push(SJd(sa[i], i));
            pb.push(SJd(sb[i], i));
            pe.push(SJd(sa[i] + sb[i], i));
            ba[i] = bb[i] = false;
        }
        int sy = k - l;
        ll ans = 0;
        for (int i = 0; i < k; i++) {
            SJd ra,rb,rc,rd,re;
            while (!pa.empty()) {
                ra = pa.top();
                if (!ba[ra.i]) break;
                pa.pop();
            }
            while (!pb.empty()) {
                rb = pb.top();
                if (!bb[rb.i]) break;
                pb.pop();
            }
            if (sy > 0) {
                if (bb[ra.i]) sy += 1;
                if (ba[rb.i]) sy += 1;
                if (ra.i == rb.i) sy += 1;
                ba[ra.i] = bb[rb.i] = true;
                pc.push(SJd(sa[rb.i], rb.i));
                pd.push(SJd(sb[ra.i], ra.i));
                sy -= 1;
                ans += ra.z + rb.z;
                continue;
            }
            while (!pc.empty()) {
                rc = pc.top();
                if (!ba[rc.i]) break;
                pc.pop();
            }
            while (!pd.empty()) {
                rd = pd.top();
                if (!bb[rd.i]) break;
                pd.pop();
            }
            while (!pe.empty()) {
                re = pe.top();
                if (!ba[re.i] && !bb[re.i]) break;
                pe.pop();
            }
            int ma = -1,
            lx = -1;
            if (!pc.empty() && !pb.empty() && rc.z + rb.z > ma) ma = rc.z + rb.z,lx = 1;
            if (!pd.empty() && !pa.empty() && rd.z + ra.z > ma) ma = rd.z + ra.z,lx = 2;
            if (!pe.empty() && re.z > ma) ma = re.z,lx = 3;
            ans += ma;
            if (lx == 1) {
                if (ba[rb.i]) sy += 1;
                ba[rc.i] = bb[rb.i] = true;
                pc.pop();
                pb.pop();
                pc.push(SJd(sa[rb.i], rb.i));
            } else if (lx == 2) {
                if (bb[ra.i]) sy += 1;
                ba[ra.i] = bb[rd.i] = true;
                pa.pop();
                pd.pop();
                pd.push(SJd(sb[ra.i], ra.i));
            } else if (lx == 3) {
                ba[re.i] = bb[re.i] = true;
                pe.pop();
            }
        }
        printf("%lld\n", ans);
    }
    return 0;
}