poj1201 Intervals（差分约束）
差分约束第一题，差分约束就是解一系列的形如x1-x2<=(>=)a的不等式，由于移项之后为x1<=(>=)x2+a和最短路径的dist[i] <(>) dist[u] + mapp[u][i]联系 起来，故可以用最短路bellmanford和SPFA求解
显然dist[i]和dist[u]都为方程的解，根据大于或者小于可以以最短路径或者最长路径求解
我们举最短路径为例
因为是求的最短路径，那么结果可以保证dist[i] <= dist[u]+mapp[u][i],那么对此不等式移向可以得到dist[i] - dist[u] <= mapp[u][i],在最短路中，i,u分别为两个节点，而且存在一条u->i的路径。
现在回到POJ1201，输入样例如下：
5
3 7 3
8 10 3
6 8 1
1 3 1
10 11 1
设第i个点以前被选中的数有Si个，那么对于输入的一段闭区间[a, b]中有c[i]个数被选中，就有以下不等式方程：
(1)Sb[i] - Sa[i] >= c[i];
(2)1 >= Si-S(i-1) >= 0；
由于我们是以最短路径为例，故将上述不等式改为
(1)Sa[i] - Sb[i] <= -1*c[i];
(2)Si - S(i-1) <= 1；
(3)S(i-1) - S(i) <= 0;
据上述差分约束方程求解可以建图，对第一个输入，可以建图7->2，权值为-3，这样依次将全部输入建图，但是因为最后的结果可能是一个非连通图，所以还要根据上述不等式对每一个[i, i+1]建图，建图完后一次SPFA就可以求解
注意：最终答案是-dist[minn-1]，最长路径则为dist[maxx+1]；
附AC代码：
(最短路径)
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
struct node
{
int num;
int value;
};
const int size = 51000;
bool inque[size];
int dist[size];
vector <node> mapp[size];
int minn, maxx;
void init()
{
for (int i = 0; i < size; i ++){
mapp[i].clear();
}
}
void SPFA(int s1)
{
queue <node> que;
for (int i = minn; i <= maxx; i ++){
inque[i] = false;
dist[i] = 100000000;
}
node s;
s.num = s1;
s.value = 0;
que.push(s);
dist[s.num] = 0;
inque[s.num] = true;
while (!que.empty()){
node e = que.front();
inque[e.num] = false;
que.pop();
for (int i = 0; i < mapp[e.num].size(); i ++){
node ee = mapp[e.num][i];
if (dist[ee.num] > dist[e.num] + ee.value){
dist[ee.num] = dist[e.num] + ee.value;
if (!inque[ee.num]){
ee.value = dist[ee.num];
que.push(ee);
inque[ee.num] = true;
}
}
}
}
}
int main()
{
int n;
while (scanf("%d", &n) != EOF){
init();
node a, b;
minn = INT_MAX, maxx = -1;
for (int i = 0; i < n; i ++){
scanf("%d%d%d", &a.num, &b.num, &a.value);
minn = minn > a.num? a.num : minn;
maxx = maxx < b.num? b.num : maxx;
a.num --;
a.value*=-1;
mapp[b.num].push_back(a);
}
for (int i = minn; i <= maxx; i ++){
a.num = i, a.value = 0;
mapp[i+1].push_back(a);
a.num = i+1, a.value = 1;
mapp[i].push_back(a);
}
SPFA(maxx);
printf("%d\n", -dist[minn-1]);
}
return 0;
}
/*(最长路径)*/
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
struct node
{
int num;
int value;
};
const int size = 51000;
bool inque[size];
int dist[size];
vector <node> mapp[size];
int minn, maxx;
void init()
{
for (int i = 0; i < size; i ++){
mapp[i].clear();
}
}
void SPFA(int n, int s1)
{
queue <node> que;
for (int i = minn; i <= maxx; i ++){
inque[i] = false;
dist[i] = -100000000;
}
node s;
s.num = s1;
s.value = 0;
que.push(s);
dist[s.num] = 0;
inque[s.num] = true;
while (!que.empty()){
node e = que.front();
inque[e.num] = false;
que.pop();
for (int i = 0; i < mapp[e.num].size(); i ++){
node ee = mapp[e.num][i];
if (dist[ee.num] < dist[e.num] + ee.value){
dist[ee.num] = dist[e.num] + ee.value;
if (!inque[ee.num]){
ee.value = dist[ee.num];
que.push(ee);
inque[ee.num] = true;
}
}
}
}
}
int main()
{
int n;
while (scanf("%d", &n) != EOF){
init();
node a, b;
minn = INT_MAX, maxx = -1;
for (int i = 0; i < n; i ++){
scanf("%d%d%d", &a.num, &b.num, &b.value);
minn = minn > a.num? a.num : minn;
maxx = maxx < b.num? b.num : maxx;
b.num ++;
mapp[a.num].push_back(b);
}
for (int i = minn; i <= maxx; i ++){
a.num = i+1, a.value = 0;
mapp[i].push_back(a);
a.num = i, a.value = -1;
mapp[i+1].push_back(a);
}
SPFA(maxx, minn);
printf("%d\n", dist[maxx+1]);
}
return 0;
}