HDU4109 Instrction Arrangement（差分约束）

题意：一台电脑需要执行N条指令（0到N-1），每条指令都要花费一单位时间，可以同时执行无限条指令。有M个约束条件（X,Y,Z），表示指令Y必须在指令X执行后过Z单位时间才能执行。问执行完所有的指令需要的最短时间。

思路：显然就是差分约束嘛，设Si为指令i的开始时间，对每条约束可以得到不等式 Sy >= Sx + Z。

这道题目建的图不一定是连通的，采用初始时将所有结点加入队列的方法代替超级源点，将图变成虚连通的。

求最短时间所有跑最长路，因为图中不含负边，所以可以直接将初始的距离dis置为1，不用置为-inf。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <cmath>
#include <list>
#include <cstdlib>
#include <set>
#include <string>

using namespace std;

typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn = 10005;
struct edg{
    int v, d, nxt;
}G[maxn];
int pre[maxn], tot, dis[maxn];
bool vis[maxn];
void add(int u, int v, int w) {
    G[tot].v = v;
    G[tot].d = w;
    G[tot].nxt = pre[u];
    pre[u] = tot++;
}
int n, m;
int spfa() {
    memset(vis, 0, sizeof(vis));
    queue<int> que;
    for (int i = 0; i < n; ++i) {
        dis[i] = 1; //所有指令都要占一单位时间，所以初始为1
        que.push(i);
        vis[i] = true;
    }
    while (!que.empty()) {
        int u = que.front();
        que.pop();
        vis[u] = false;
        for (int i = pre[u]; ~i; i = G[i].nxt) {
            int v = G[i].v, w = G[i].d;
            if (dis[u] + w > dis[v]) {
                dis[v] = dis[u] + w;
                if (!vis[v]) {
                    vis[v] = true;
                    que.push(v);
                }
            }
        }
    }
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        if (dis[i] > ans) {
            ans = dis[i]; //找出最晚的时间
        }
    }
    return ans;
}
int main(){
    int x, y, z;
    while (~scanf("%d%d", &n, &m)) {
        tot = 0;
        memset(pre, -1, sizeof(pre));
        while (m--) {
            scanf("%d%d%d", &x, &y, &z);
            add(x, y, z);
        }
        printf("%d\n", spfa());
    }
    return 0;
}