差分约束

差分约束通常用来求不等式组的可行解。

差分约束的步骤：

1.先将每个不等式$x_i\leq x_j + w$，转化成一条从$x_j$走到$x_i$的长度为$w$的一条边。

2.找一个超级源点，使得从该源点开始可以遍历所有边。

3.从源点开始求一遍单源最短路，如果存在负环，则原不等式无解，如果没有负环，则$dis[i]$就是原不等式的一个可行解。

差分约束求不等式组最大值最小值：

如果求最小值，则应该求最长路，求最大值，应该求最短路。

如果没有一个超级源点可以遍历所有边，就自己设置一个超级源点。

求xi的最大值：求所有从$x_i$出发，形成不等式$x_i\leq x_j + w_1\leq x_k + w_1 \cdot \cdot \cdot \leq w_1 + w_2 + w_3 ...+ w$所计算出的上界，$x_i$的最大值等于所有上界的最小值。

 

银河

由题求得是最小值。所以用最长路。

根据题意：

1.当$T  = 1，A \geq  B, B >= A$。

2.当$T = 2,  B \geq  A + 1$。

3.当$T = 3，A \geq  B$。

4.当$T = 4,  A \geq  B + 1$。

5.当$T = 5，B \geq  A$。

从0向所有的点连一条长度为1的 边，即$X_i \geq  0 + 1$。

代码：

#include <algorithm>
#include <cstring>
#include <stack>

using namespace std;

typedef long long LL;

const int N = 100010, M = 300010;
int e[M], ne[M], h[M], w[M], idx;
int  st[N], cnt[N];
LL dis[N];
int n, m;

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

bool spfa()
{
    memset(dis, -0x3f, sizeof dis);
    stack<int> q;

    dis[0] = 0;
    st[0] = true;
    q.push(0);

    while(q.size())
    {
        int t = q.top();
        q.pop();

        st[t] = false;

        for(int i = h[t] ; ~i ; i = ne[i])
        {
            int j = e[i];
            if(dis[j] < dis[t] + w[i])
            {
                dis[j] = dis[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if(cnt[j] >= n + 1)return false;
                if(!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    return true;
}

int main(){
    cin >> n >> m;
    memset(h, -1, sizeof h);

    while(m --)
    {
        int c, a, b;
        cin >> c >> a >> b;
        if(c == 1)add(a, b, 0), add(b, a, 0);
        else if(c == 2)add(a, b, 1);
        else if(c == 3)add(b, a, 0);
        else if(c == 4)add(b, a, 1);
        else add(a, b, 0);
    }

    for(int i = 1 ; i <= n ; i ++)add(0, i, 1);//从0向所有点连边

    if(!spfa())puts("-1");
    else
    {
        LL ans = 0;
        for(int i = 1 ; i <= n ; i ++)ans += dis[i];
        cout << ans << endl;
    }

    return 0;
}