「SNOI2019」通信 分治优化费用流建图

题意：

n 个排成一列的哨站要进行通信。第 $\mathrm{i 个哨站的频段为 ai。}$

每个哨站 $\mathrm{ii 需要选择以下二者之一：}$

1.直接连接到控制中心，代价为 $\mathrm{W；2.连接到前面的某个哨站 j(j<i)，代价为 |ai-aj|。\; 每个哨站只能被后面的至多一个哨站连接。}$

请你求出最小可能的代价和。

题解：

显然的费用流

然后我耿直的n^2建边，觉得我的费用流很快，应该可以过

然后返回了TLE 

然后google了一下题解：发现这题卡了n^2建图,需要优化建边

我这里是通过分治优化的

就是类似与建立一个虚点

一个x要向y的一个前缀建图，所以就可以类似前缀和优化建图那样，

按权值排序然后建出一条链，链上两个点之间的流量为INF，费用为权值之差，然后每个点向对应的点连边
但这样建图是错误的，原因在于我们把点排了序，改变了编号顺序，

所以一个点能到达的点不一定是它可以到达的
所以我们要固定在固定编号顺序的情况下这样连边，也就是说x的一个区间和y的一个区间之间这样连边，

要求两个区间不重合，且x的区间比y的区间小
那么很容易想到分治建图，每次让[l,mid]向[mid+1,r]连边，剩下的递归下去就行了

#include <set>
#include <map>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <cstdio>
#include <string>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <unordered_map>

#define pi acos(-1.0)
#define eps 1e-9
#define fi first
#define se second
#define rtl rt << 1
#define rtr rt << 1 | 1
#define bug printf("******
")
#define mem(a, b) memset(a, b, sizeof(a))
#define name2str(x) #x
#define fuck(x) cout << #x " = " << x << endl
#define sfi(a) scanf("%d", &a)
#define sffi(a, b) scanf("%d %d", &a, &b)
#define sfffi(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define sffffi(a, b, c, d) scanf("%d %d %d %d", &a, &b, &c, &d)
#define sfL(a) scanf("%lld", &a)
#define sffL(a, b) scanf("%lld %lld", &a, &b)
#define sfffL(a, b, c) scanf("%lld %lld %lld", &a, &b, &c)
#define sffffL(a, b, c, d) scanf("%lld %lld %lld %lld", &a, &b, &c, &d)
#define sfs(a) scanf("%s", a)
#define sffs(a, b) scanf("%s %s", a, b)
#define sfffs(a, b, c) scanf("%s %s %s", a, b, c)
#define sffffs(a, b, c, d) scanf("%s %s %s %s", a, b, c, d)
#define FIN freopen("../in.txt", "r", stdin)
#define gcd(a, b) __gcd(a, b)
#define lowbit(x) x & -x
#define IO iOS::sync_with_stdio(false)

using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const ULL seed = 13331;
const LL INFLL = 0x3f3f3f3f3f3f3f3fLL;
const int maxn = 1e6 + 7;
const int maxm = 8e6 + 10;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;

struct Cost_MaxFlow {
    int s, t, tot, maxflow, head[maxn], vis[maxn], pre[maxn], last[maxn];
    LL mincost, maxcost, dis[maxn], disf[maxn];
    struct Edge {
        int v, w, nxt;
        int cost;
    } edge[maxm];
    queue<int> q;

    void init() {
        tot = 1;
        mincost = maxcost = 0;
        memset(head, -1, sizeof(head));
    }

    void add(int u, int v, int f, int e) {
        edge[++tot].v = v, edge[tot].nxt = head[u], head[u] = tot, edge[tot].w = f, edge[tot].cost = e;
        edge[++tot].v = u, edge[tot].nxt = head[v], head[v] = tot, edge[tot].w = 0, edge[tot].cost = -e;
    }

    bool spfa_max() {
        memset(dis, 0xef, sizeof(dis));
        q.push(s), dis[s] = 0, disf[s] = INFLL, pre[t] = -1;
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            vis[u] = 0;
            for (int i = head[u]; ~i; i = edge[i].nxt) {
                int v = edge[i].v;
                if (edge[i].w && dis[v] < dis[u] + edge[i].cost) {
                    dis[v] = dis[u] + edge[i].cost, last[v] = i, pre[v] = u;
                    disf[v] = min(disf[u], 1LL * edge[i].w);
                    if (!vis[v])
                        vis[v] = 1, q.push(v);
                }
            }
        }
        return ~pre[t];
    }

    void dinic_max() {
        while (spfa_max()) {
            int u = t;
            maxflow += disf[t];
            maxcost += disf[t] * dis[t];
            while (u != s) {
                edge[last[u]].w -= disf[t];
                edge[last[u] ^ 1].w += disf[t];
                u = pre[u];
            }
        }
    }

    bool spfa_min() {
        memset(dis, 0x3f, sizeof(dis));
        memset(vis, 0, sizeof(vis));
        memset(disf, 0x3f, sizeof(disf));
        q.push(s), dis[s] = 0, vis[s] = 1, pre[t] = -1;
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            vis[u] = 0;
            for (int i = head[u]; ~i; i = edge[i].nxt) {
                int v = edge[i].v;
                if (edge[i].w > 0 && dis[v] > dis[u] + edge[i].cost) {
                    dis[v] = dis[u] + edge[i].cost, pre[v] = u;
                    last[v] = i, disf[v] = min(disf[u], 1LL * edge[i].w);
                    if (!vis[v])
                        vis[v] = 1, q.push(v);
                }
            }
        }
        return pre[t] != -1;
    }

    void dinic_min() {
        while (spfa_min()) {
            int u = t;
            maxflow += disf[t];
            mincost += disf[t] * dis[t];
            while (u != s) {
                edge[last[u]].w -= disf[t];
                edge[last[u] ^ 1].w += disf[t];
                u = pre[u];
            }
        }
    }
} F;

int n, W, a[maxn], cnt[maxn], sum;

void link(int L, int R) {
    if (L == R) return;
    int num = 0, mid = (L + R) / 2;
    for (int i = L; i <= R; i++) cnt[++num] = a[i];
    sort(cnt + 1, cnt + 1 + num);
    num = unique(cnt + 1, cnt + 1 + num) - cnt - 1;
    for (int i = 1; i < num; i++) {
        F.add(sum + i, sum + i + 1, INF, cnt[i + 1] - cnt[i]);
        F.add(sum + i + 1, sum + i, INF, cnt[i + 1] - cnt[i]);
    }
    for (int i = L; i <= R; i++) {
        if (i <= mid) {
            int pos = lower_bound(cnt + 1, cnt + 1 + num, a[i]) - cnt;
            F.add(sum + pos, i + n, 1, 0);
        } else {
            int pos = lower_bound(cnt + 1, cnt + 1 + num, a[i]) - cnt;
            F.add(i, sum + pos, 1, 0);
        }
    }
    sum += num;
    link(L, mid), link(mid + 1, R);
}

int main() {
#ifndef ONLINE_JUDGE
    FIN;
#endif
    while (~sffi(n, W)) {
        for (int i = 1; i <= n; i++) sfi(a[i]);
        F.init();
        F.s = 0, F.t = 2 * n + 1;
        sum = 2 * n + 1;
        for (int i = 1; i <= n; i++) {
            F.add(F.s, i, 1, 0);
            F.add(i + n, F.t, 1, 0);
            F.add(i, F.t, 1, W);
        }
        link(1, n);
        F.dinic_min();
        printf("%lld
", F.mincost);
    }
#ifndef ONLINE_JUDGE
    cout << "Totle Time : " << (double) clock() / CLOCKS_PER_SEC << "s" << endl;
#endif
    return 0;
}