CF797F Mice and Holes 贪心、栈维护DP

传送门

---

首先\(\sum c\)有些大，考虑将其缩小降低难度

考虑一个贪心：第一次所有老鼠都进入其左边第一个容量未满的洞（如果左边没有就进入右边第一个未满的洞），第二次所有老鼠都进入其右边第一个容量未满的洞（如果右边没有就进入左边第一个未满的洞），我们只保留这\(2N\)个洞，答案也不会变，因为在最优情况下老鼠最多只会进入这些洞。通过这一步，我们的\(\sum c\)降低到了\(2N\)级别。

考虑将容量为\(c\)的洞拆分为\(c\)个容量为\(1\)的洞，将老鼠和洞放在一起按照\(dis\)即位置从小到大排序。然后不难想到一个\(DP\)：设\(f_{i,j}\)表示已经考虑前\(i\)个物体，其中老鼠的数量减去强制选定需要容纳一只老鼠的洞的数量为\(j\)时的最小距离，转移分当前为老鼠还是洞。

但是如果直接转移很难找到优化点，考虑简化DP过程。

如果当前是一只老鼠，那么我们的转移是固定的：\(j \geq 0\)则\(f_{i,j} - dis_i \rightarrow f_{i+1,j+1}\)，\(j<0\)则\(f_{i,j} + dis_i \rightarrow f_{i+1,j+1}\)

如果当前是一个洞，对于\(j>0\)的情况，因为之前的老鼠一定要往右边走，而当前的洞是右边最近的一个，所以它一定会容纳一只老鼠，也就是\(f_{i,j} + dis_i \rightarrow f_{i+1,j-1}\)

对于\(j<0\)的情况，之前有若干个洞还没有容纳老鼠，那么右边出现的老鼠一定会往左走，而这一个洞比它左边的洞相比于右边的老鼠更近，所以如果不选这一个洞，可以不选之前的某一个洞而改选这一个洞获得更优策略。这意味着当\(j<0\)是这一个洞是必须要选的，转移会是\(f_{i,j} - dis_i \rightarrow f_{i+1,j-1}\)。

那么唯独需要决策的只有\(j=0\)且当前是一个洞的情况，你可以选择这一个洞不容纳老鼠，那么会有一个特殊的转移：\(f_{i+1,0} = \min\{f_{i , 0} , f_{i , 1} + dis_i\}\)。

发现除了\(f_{i,0}\)的转移以外其他的转移都是平移数组和统一加上减去一个值的形式。我们通过两个栈维护\(DP\)数组，一个维护\(j>0\)，一个维护\(j<0\)，在栈外部打上整体加法标记，即可\(O(n)\)维护\(DP\)。

#include<bits/stdc++.h>
//This code is written by Itst
using namespace std;

inline int read(){
    int a = 0;
    char c = getchar();
    bool f = 0;
    while(!isdigit(c)){
        if(c == '-')
            f = 1;
        c = getchar();
    }
    while(isdigit(c)){
        a = a * 10 + c - 48;
        c = getchar();
    }
    return f ? -a : a;
}

const int MAXN = 1e5 + 7;
stack < long long > dp1 , dp2;
struct stg{
    int a , b;
    bool operator <(const stg t)const{
        return a < t.a;
    }
}now[MAXN];
int mice[MAXN] , hole[MAXN][2] , times[MAXN][2] , dp[MAXN * 3][2];
int N , M , cnt;
long long sum , tag1 , tag2 , dp0;

int main(){
    N = read();
    M = read();
    for(int i = 1 ; i <= N ; ++i)
        mice[i] = read();
    sort(mice + 1 , mice + N + 1);
    for(int i = 1 ; i <= M ; ++i){
        now[i].a = read();
        now[i].b = read();
        sum += now[i].b;
    }
    sort(now + 1 , now + M + 1);
    for(int i = 1 ; i <= M ; ++i){
        hole[i][0] = now[i].a;
        hole[i][1] = now[i].b;
    }
    if(sum < N){
        puts("-1");
        return 0;
    }
        int p1 = 1 , p2 = 1;
    while(p1 <= N || p2 <= M)
        if(p1 <= N && (p2 > M || hole[p2][0] > mice[p1])){
            ++p1;
            if(!dp1.empty()){
                int t = dp1.top();
                dp1.pop();
                if(++times[t][0] != hole[t][1])
                    dp1.push(t);
            }
            else
                ++cnt;
        }
        else
            if(cnt < hole[p2][1]){
                times[p2][0] = cnt;
                cnt = 0;
                dp1.push(p2++);
            }
            else{
                times[p2][0] = hole[p2][1];
                cnt -= hole[p2++][1];
            }
    p1 = N;
    p2 = M;
    cnt = 0;
    dp1 = dp2;
    while(p1 || p2)
        if(p1 && (!p2 || hole[p2][0] < mice[p1])){
            --p1;
            if(!dp1.empty()){
                int t = dp1.top();
                dp1.pop();
                if(++times[t][1] != hole[t][1])
                    dp1.push(t);
            }
            else
                ++cnt;
        }
        else
            if(cnt < hole[p2][1]){
                times[p2][1] = cnt;
                cnt = 0;
                dp1.push(p2--);
            }
            else{
                times[p2][1] = hole[p2][1];
                cnt -= hole[p2--][1];
            }
    p1 = 1;
    p2 = 1;
    cnt = 0;
    while(p1 <= N || p2 <= M)
        if(p1 <= N && (p2 > M || hole[p2][0] > mice[p1]))
            dp[++cnt][0] = mice[p1++];
        else{
            for(int i = min(times[p2][0] + times[p2][1] , hole[p2][1]) ; i ; --i){
                dp[++cnt][0] = hole[p2][0];
                dp[cnt][1] = 1;
                --times[p2][0];
            }
            ++p2;
        }
    dp1 = dp2;
    for(int i = 1 ; i <= cnt ; ++i)
        if(!dp[i][1]){
            dp1.push(dp0 - tag1);
            tag1 -= dp[i][0];
            tag2 += dp[i][0];
            if(!dp2.empty()){
                dp0 = dp2.top() + tag2;
                dp2.pop();
            }
            else
                dp0 = 1e15;
        }
        else{
            dp2.push(dp0 - tag2);
            tag1 += dp[i][0];
            tag2 -= dp[i][0];
            if(!dp1.empty()){
                dp0 = min(dp0 , dp1.top() + tag1);
                dp1.pop();
            }
        }
    cout << dp0;
    return 0;
}

转载于:https://www.cnblogs.com/Itst/p/10271244.html