Intervals（差分约束）

http://poj.org/problem?id=1201

题意：给出N个整数区间[ai,bi]，并且给出一个约束ci，（ 1<= ci <= bi-ai+1），使得数组Z在区间[ai,bj]的个数>= ci个，求出数组Z的最小长度。

思路：建立差分约束系统。因为这里要求数组长度的最小值，要变为 x-y>=k的标准形式。

设数组 s[j] 表示数组 Z 区间[0,j]里包含的元素个数。所以 s[bi+1] - s[ai] >= ci,注意是 j+1,

隐含条件   0 <= s[i+1]-s[i] <= 1;

故差分约束系统为：

s[bi+1] - s[ai] >= ci；

s[i+1] - s[i] >= 0;

s[i] - s[i+1] >= -1;

然后邻接表建图求最长路。

 1 #include<stdio.h>
 2 #include<string.h>
 3 #include<algorithm>
 4 #include<stack>
 5 using namespace std;
 6 
 7 const int maxn = 500100;
 8 const int INF = 0x3f3f3f3f;
 9 struct node
10 {
11     int u,v,w;
12     int next;
13 }edge[maxn];
14 
15 int n,p[maxn],cnt;
16 int Min,Max;
17 int dis[maxn],instack[maxn],vexcnt[maxn];
18 
19 void add(int u, int v, int w)
20 {
21     cnt++;
22     edge[cnt].u = u;
23     edge[cnt].v = v;
24     edge[cnt].w = w;
25     edge[cnt].next = p[u];
26     p[u] = cnt;
27 }
28 
29 bool SPFA()
30 {
31     stack<int>st;
32     while(!st.empty()) st.pop();
33     memset(instack,0,sizeof(instack));
34     memset(vexcnt,0,sizeof(vexcnt));
35     for(int i = Min; i <= Max; i++)
36         dis[i] = -INF;
37 
38     st.push(Min);
39     dis[Min] = 0;
40     instack[Min] = 1;
41     vexcnt[Min]++;
42 
43     while(!st.empty())
44     {
45         int u = st.top();
46         st.pop();
47         instack[u] = 0;
48 
49         for(int i = p[u]; i; i = edge[i].next)
50         {
51             if(dis[edge[i].v] < dis[u] + edge[i].w)
52             {
53                 dis[edge[i].v] = dis[u] + edge[i].w;
54                 if(!instack[edge[i].v])
55                 {
56                     instack[edge[i].v] = 1;
57                     st.push(edge[i].v);
58                     vexcnt[edge[i].v]++;
59                     if(vexcnt[edge[i].v] > n)
60                         return false;
61                 }
62             }
63         }
64     }
65     return true;
66 }
67 
68 int main()
69 {
70     int u,v,w;
71     scanf("%d",&n);
72 
73     cnt = 0;
74     memset(p,0,sizeof(p));
75     Min = INF,Max = -1;
76 
77     for(int i = 0; i < n; i++)
78     {
79         scanf("%d %d %d",&u,&v,&w);
80         add(u,v+1,w);
81         Min = min(Min,u);
82         Max = max(Max,v+1);
83     }
84     for(int i = Min; i < Max; i++)
85     {
86         add(i,i+1,0);
87         add(i+1,i,-1);
88     }
89     SPFA();
90     printf("%d\n",dis[Max]-dis[Min]);
91     return 0;
92 }

View Code

关于差分约束：

比如给出三个不等式,b-a<=k1,c-b<=k2,c-a<=k3,求出c-a的最大值,我们可以把a,b,c转换成三个点，k1，k2，k3是边上的权，如图

由题我们可以得知，这个有向图中，由题b-a<=k1,c-b<=k2,得出c-a<=k1+k2,因此比较k1+k2和k3的大小，求出最小的就是c-a的最大值了

根据以上的解法，我们可能会猜到求解过程实际就是求从a到c的最短路径，没错的....简单的说就是从a到c沿着某条路径后把所有权值和k求出就是c -a<=k的一个

推广的不等式约束，既然这样，满足题目的肯定是最小的k，也就是从a到c最短距离...

理解了这里之后，想做题还是比较有困难的，因为题目需要变形一下，不能单纯的算..

首先以poj3159为例,这个比较简单，就是给出两个点的最大差，然后让你求1到n的最大差，直接建图后用bellman或者spfa求最短路就可以过了

稍微难点的就是poj1364，因为他给出的不等式不是x-y<=k形式，有时候是大于号，这样需要我们去变形一下，并且给出的还是>,<没有等于，都要变形

再有就是poj1201，他要求出的是最长距离，那就要把形式变换成x-y>=k的标准形式

注意点:

1. 如果要求最大值想办法把每个不等式变为标准x-y<=k的形式,然后建立一条从y到x权值为k的边,变得时候注意x-y<k =>x-y<=k-1

   如果要求最小值的话,变为x-y>=k的标准形式，然后建立一条从y到x的k边，求出最长路径即可

2.如果权值为正，用dj，spfa，bellman都可以，如果为负不能用dj，并且需要判断是否有负环，有的话就不存在

 

转载于:https://www.cnblogs.com/LK1994/p/3440362.html