差分约束问题 ---- 2019ccpc哈尔滨A. Artful Paintings[二分+差分约束+建图剪枝]

题目链接

---

题目大意:

有$N\le 3e3$个格子，你可以任意给每个格子染色，但是要满足$M\le 3e3$限制条件，限制条件有两种类型：

1. 区间$[l,r]$中被染色的格子数量不少于$K$。
2. 区间$[l,r]$外被染色的格子数量不少于$K$。
   在满足所有限制条件下求染色格子数量的最小值。

---

题解思路:

1.首先我们知道全部涂完肯定是可以的，现在要求的是最小值，那么我们第一反应就是二分嘛！
2.上面对于区间的限制，这很容易联想到差分约束系统。
我们假设$Su{m}_i$是第i个点前面涂了多少个颜色的格子, $mid$是我们涂了多少个格子。
那么我们就有如下不等式:
对于限制1:
$Su{m}_r-Su{m}_{l-1}\ge K$
对于限制2:
$Su{m}_r-Su{m}_{l-1}\le mid-K$

还有隐藏限制就是$Su{m}_{i-1}\le Su{m}_i$
打模拟赛的时候忘记的条件:$Su{m}_i-Su{m}_{i-1}\le 1$
因为这两个隐藏条件，这个图是联通的。
那么很明显这不就是可以用差分约束解决吗？

但是这里直接跑是会T的，我们要根据建的图进行优化。

通过观察建图我们知道，在跑spfa的时候，如果某个点的$dist$数组变成负数了，那么一点存在负环，因为假如$l->r的最短路是负数，r->l是0，那么这里就可以构成负环了！$

加了这个优化就可以过了

---

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int maxn = 1e4 + 10;
int vis[maxn];
bool used[maxn];
vector<pair<int, int> > g[maxn];
int dist[maxn];
bool inQue[maxn];
queue<int> que;
int n, m1, m2;

void init(int n) {
    for(int i = 0; i <= n + 1; i++) {
        g[i].clear();
        dist[i] = INF;
        vis[i] = 0;
        used[i] = 0;
        inQue[i] = 0;
    }
}

bool spfa(int src) {//模板
    dist[src] = 0;
    while (!que.empty()) que.pop();
    que.push(src);
    inQue[src] = true;
    while (!que.empty()) {
        int u = que.front();
        used[u] = 1;
        que.pop();
        for (int i = 0; i < g[u].size(); i++) {
            if (dist[u] + g[u][i].second < dist[g[u][i].first]) {
                dist[g[u][i].first] = dist[u] + g[u][i].second;
                if( dist[g[u][i].first] < 0) return false;
				if (!inQue[g[u][i].first]) {
                    inQue[g[u][i].first] = true;
                    vis[g[u][i].first]++;
                    if(vis[g[u][i].first] > n) return false;
                    que.push(g[u][i].first);
                }
            }
        }
        inQue[u] = false;
    }
    return true;
}


struct edge {
    int l, r, w;
};
vector<edge> ed;
void build(int n, int mid) {
    init(n);
    for(int i = 0; i < m1; i++) {
        int l = ed[i].l, r = ed[i].r, w = ed[i].w;
        g[r].push_back({l - 1, -w});
    }
    for(int i = m1; i < m1 + m2; i++) {
        int l = ed[i].l, r = ed[i].r, w = ed[i].w;
        g[l - 1].push_back({r, mid - w});
    }
    for(int i = 1; i <= n; i++) {
        g[i].push_back({i - 1, 0});
    }
    for(int i = 1; i <= n; i++) {
        g[i - 1].push_back({i, 1});
    }
    g[n].push_back({0, -mid});
    g[0].push_back({n, mid});
}

int main() {
    int t;
    cin >> t;
    while(t--) {
        ed.clear();
        cin >> n >> m1 >> m2;
        for(int i = 0; i < m1 + m2; i++) {
            int l, r, w;
            cin >> l >> r >> w;
            ed.push_back({l, r, w});
        }
        int l = 0, r = n;
        while(l <= r) {
            int mid = (l + r) / 2;
            build(n, mid);//建图
            if(spfa(0)) {
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        cout << l << endl;
    }
}