agc034

A：题意：你有一个1 * n的网格，有些地方是障碍。你有两个人，分别要从a到b和从c到d，一次只能向右跳1步或者两步。求是否可行。

解：先判断有没有2个连续的障碍，然后判断是否能错车。

#include <bits/stdc++.h>

const int N = 200010;

char str[N];

int main() {
    int n, a, b, c, d;
    scanf("%d%d%d%d%d", &n, &a, &b, &c, &d);
    scanf("%s", str + 1);
    if(c < d) {
        for(int i = a; i < d; i++) {
            if(str[i] == '#' && str[i + 1] == '#') {
                printf("No
");
                return 0;
            }
        }
        printf("Yes
");
        return 0;
    }
    else {
        for(int i = a; i < c; i++) {
            if(str[i] == '#' && str[i + 1] == '#') {
                printf("No
");
                return 0;
            }
        }
        for(int i = b; i <= d; i++) {
            if(str[i - 1] == '.' && str[i] == '.' && str[i + 1] == '.') {
                printf("Yes
");
                return 0;
            }
        }
        printf("No
");
        return 0;
    }
    return 0;
}

B：题意：你有一个ABC字符串，你能进行的操作就是把某个ABC变成BCA。求最多进行多少次操作。

解：发现可以把BC看做一个整体。单独的B和C看做障碍物。

那么对于每一段无障碍物的连续A，BC，求逆序对就好了。

#include <bits/stdc++.h>

typedef long long LL;
const int N = 200010;

char str[N];
bool vis[N];

int main() {
    
    scanf("%s", str + 1);
    int n = strlen(str + 1);
    for(int i = 1; i <= n; i++) {
        if(str[i] == 'C' && str[i - 1] != 'B') {
            vis[i] = 1;
        }
        if(str[i] == 'B' && str[i + 1] != 'C') {
            vis[i] = 1;
        }
    }
    LL ans = 0;
    for(int l = 1, r; l <= n; l = r + 1) {
        while(vis[l]) {
            ++l;
        }
        if(l > n) break;
        r = l;
        while(!vis[r + 1] && r < n) {
            ++r;
        }
        LL cnt = 0, t = 0;
        for(int i = l; i <= r; i++) {
            if(str[i] == 'A') {
                ++cnt;
            }
            else if(str[i] == 'B' && str[i + 1] == 'C') {
                ++i;
                t += cnt;
            }
        }
        ans += t;
    }
    printf("%lld
", ans);
    return 0;
}

C：题意：你有n场考试，满分X分。你的对手每场考试得了bi分。你每学习一个小时就能把某场考试提高1分。你能给每场考试选择一个li~ri之间的加权。求你最少花多少小时才能不比对手考的低。

解：发现加权要么是li要么是ri。且你比对手高就是ri，否则就是li。

然后发现如果有两场考试都没有满分，最优策略是把一场考试的分挪到另一场上。

然后就发现答案一定是若干场满分和一场非满分。这时候就可以排序了，然后二分答案，枚举非满分是哪一场。

#include <bits/stdc++.h>

typedef long long LL;
const int N = 100010;

struct Node {
    LL l, r, b, h;
    inline bool operator < (const Node &w) const {
        return h > w.h;
    }
}node[N];

LL X, D, sum[N];
int n;

inline LL cal(LL a, LL i) {
    if(a <= node[i].b) {
        return a * node[i].l;
    }
    return node[i].b * node[i].l + (a - node[i].b) * node[i].r;
}

inline bool check(LL k) {
    LL ans = 0, r = k % X, t = k / X;
    if(t >= n) {
        return sum[n];
    }
//    printf("r = %lld t = %lld 
", r, t);
    for(int i = 1; i <= n; i++) {
        if(i <= t) ans = std::max(ans, cal(r, i) + sum[t + 1] - node[i].h);
        else {
            ans = std::max(ans, cal(r, i) + sum[t]);
        }
    }
    //printf("k = %lld ans = %lld D = %lld 
", k, ans, D);
    return ans >= D;
}

int main() {
    
    scanf("%d%lld", &n, &X);
    for(int i = 1; i <= n; i++) {
        scanf("%lld%lld%lld", &node[i].b, &node[i].l, &node[i].r);
        node[i].h = node[i].b * node[i].l + (X - node[i].b) * node[i].r;
        D += node[i].b * node[i].l;
    }
    std::sort(node + 1, node + n + 1);
    for(int i = 1; i <= n; i++) {
        sum[i] = sum[i - 1] + node[i].h;
    }
    LL l = 0, r = 4e18;
    while(l < r) {
        LL mid = (l + r) >> 1;
        if(check(mid)) {
            r = mid;
        }
        else {
            l = mid + 1;
        }
    }
    printf("%lld
", r);
    return 0;
}

D：题意：给你平面上两组n个点，你要把它们配对，使得曼哈顿距离最大。n <= 1000。

解：曼哈顿距离有2个绝对值，拆开就是4种情况。直接建4个中转点表示这4种情况，跑最大费用最大流。

#include <bits/stdc++.h>

#define int LL

typedef long long LL;
const int N = 2010, INF = 0x3f3f3f3f3f3f3f3fll;

struct Edge {
    int nex, v, c, len;
    Edge(){}
    Edge(int N, int V, int C, int L) {
        nex = N, v = V, c = C, len = L;
    }
}edge[2000010]; int tp = 1;

int e[N], n, tot, d[N], pre[N], flow[N], Time, vis[N];
std::queue<int> Q;

inline void add(int x, int y, int z, int w) {
    edge[++tp] = Edge(e[x], y, z, w);
    e[x] = tp;
    edge[++tp] = Edge(e[y], x, 0, -w);
    e[y] = tp;
    return;
}

inline bool SPFA(int s, int t) {
    memset(d, 0x3f, sizeof(d));
    Q.push(s);
    ++Time;
    d[s] = 0;
    vis[s] = Time;
    flow[s] = INF;
    while(Q.size()) {
        int x = Q.front();
        Q.pop();
        vis[x] = 0;
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            if(edge[i].c && d[y] > d[x] + edge[i].len) {
                d[y] = d[x] + edge[i].len;
                pre[y] = i;
                flow[y] = std::min(flow[x], edge[i].c);
                if(vis[y] != Time) {
                    vis[y] = Time;
                    Q.push(y);
                }
            }
        }
    }
    return d[t] < INF;
}

inline void update(int s, int t) {
    int f = flow[t];
    while(s != t) {
        int i = pre[t];
        edge[i].c -= f;
        edge[i ^ 1].c += f;
        t = edge[i ^ 1].v;
    }
    return;
}

inline int solve(int s, int t, int &cost) {
    cost = 0;
    int ans = 0;
    while(SPFA(s, t)) {
        //printf("!");
        ans += flow[t];
        cost += flow[t] * d[t];
        update(s, t);
    }
    return ans;
}

signed main() {
    
    scanf("%lld", &n);
    int s = 2 * n + 5, t = s + 1, x, y, z;
    for(int i = 1; i <= n; i++) {
        scanf("%lld%lld%lld", &x, &y, &z);
        add(s, i, z, 0);
        add(i, 2 * n + 1, z, x + y);
        add(i, 2 * n + 2, z, y - x);
        add(i, 2 * n + 3, z, x - y);
        add(i, 2 * n + 4, z, -x - y);
    }
    for(int i = 1; i <= n; i++) {
        scanf("%lld%lld%lld", &x, &y, &z);
        add(n + i, t, z, 0);
        add(2 * n + 1, n + i, z, -x - y);
        add(2 * n + 2, n + i, z, x - y);
        add(2 * n + 3, n + i, z, y - x);
        add(2 * n + 4, n + i, z, x + y);
    }
    //puts("OVER");
    int cost = 0;
    solve(s, t, cost);
    printf("%lld
", -cost);
    return 0;
}