[poj 1364]King[差分约束详解(续篇)][超级源点][SPFA][Bellman-Ford]
题意
有n个数的序列, 下标为[1.. N ], 限制条件为: 下标从 si 到 si+ni 的项求和 < 或 > ki. 一共有m个限制条件. 问是否存在满足条件的序列.
思路
转化为差分约束, 就是
即 Si 为第 i 项的前缀和, 特别的 So 为0. 转化不等式(连续子段和变为前缀和之差 > < 变为 >= <= ),求最短路, 判断有没有负权回路.
注意
由于并不知道图是否连通
(不像是之前的那道Candies图一定是联通的,选择班长所代表的点即可)
所以正常情况下是要另设一个"超级源点", 连接图上的每个点, 从这个点出发就一定可以遍历到每一个点.
"超级源点"到每个点的边权是任意的,而它自己的点权自然是0.
这样的话,就求出了一组满足每对点的差尽可能大, 并且其中的d[0] = 0的解.
1. 将所有点(包括"超级源点")同时平移, 均为满足所有约束的可行解(包括新加入的边权们)
2. 将原图中的所有点同时平移, 得到所有满足原有约束的可行解. 但是仍有d[0] = 0的此时, 与超级源点的这些约束有可能不满足. 但是显然这是无所谓的.
3. 由此可知, 超级源点的作用就在于确保图的连通性,使得每一个点都有一个"距离". 而"超级源点"带来的额外约束一是d[0] = 0, 二是新加的边权. 二者影响的都是d[1]到d[n]的浮动情况(d[0]是参考零点, 额外的边权约束则是起到了限制d[1]到d[n]与d[0]的距离的作用,一堆不等式同样是选择了限制最严的那些并且距离尽可能大....没有实际意义...)
总之参考零点就是这样~
但是用SPFA只是判断负环的话,只需要初始时将所有点入队(而非只将源点入队), 然后判断每个点的入队次数. 如果超过点的总数, 说明存在负环.否则不存在.
数值上是从INF开始减, 有负环的话就会一直减... 没有的话就会正常退出, 当然这个时候d[ ] 值会很大..
SFPA + stack
//132K 16MS
#include <cstdio>
#include <cstring>
#include <stack>
using namespace std;
const int MAXN = 105;
const int MAXE = 105;
const int INF = 0x3f3f3f3f;
struct pool
{
int v,pre,w;
} p[MAXE];
int num,head[MAXN],d[MAXN],n,m,enq[MAXN];
bool inq[MAXN];
stack<int> s;
void clear()
{
while(!s.empty()) s.pop();
memset(head,0,sizeof(head));
memset(d,0x3f,sizeof(d));
memset(inq,false,sizeof(inq));
memset(enq,0,sizeof(enq));
num = 0;
}
bool SPFA()
{
for(int i=0;i<=n;i++)
{
s.push(i);
inq[i] = true;
enq[i]++;
}
d[0] = 0;
while(!s.empty())
{
int u = s.top();
s.pop();
inq[u] = false;
for(int tmp=head[u],v;v=p[tmp].v,tmp;tmp=p[tmp].pre)
{
int w = p[tmp].w;
if(d[v]>d[u]+w)
{
d[v] = d[u] + w;
if(!inq[v])
{
inq[v] = true;
enq[v]++;
if(enq[v]>n+1) return false;
s.push(v);
}
}
}
}
return true;
}
void add(int u, int v ,int w)
{
p[++num].v = v;
p[num].w = w;
p[num].pre = head[u];
head[u] = num;
}
int main()
{
while(scanf("%d",&n)==1 && n)
{
clear();
scanf("%d",&m);
while(m--)
{
int si,ni,ki;
char o,p;
scanf("%d %d %c%c %d",&si,&ni,&o,&p,&ki);
if(o=='g') add(si+ni,si-1,-ki-1);
else add(si-1,si+ni,ki-1);
}
printf(SPFA()?"lamentable kingdom\n":"successful conspiracy\n");
}
}
用Bellman-Ford也可以.这个时候就要用到超级源点啦
//120K 0MS
#include <cstdio>
#include <cstring>
using namespace std;
const int MAXN = 105;
const int MAXE = 210;
const int INF = 0x3f3f3f3f;
int s[MAXE],e[MAXE],w[MAXE];
int num,d[MAXN],n,m;
void clear()
{
memset(d,0x3f,sizeof(d));
num = 0;
}
bool Bellman_Ford()
{
d[n+1] = 0;
for(int i=0;i<=n+1;i++)
{
for(int j=1;j<=num;j++)
{
if(d[e[j]]>d[s[j]]+w[j]) d[e[j]] = d[s[j]] + w[j];
}
}
for(int j=1;j<=num;j++)
{
if(d[e[j]]>d[s[j]]+w[j]) return false;
}
return true;
}
void add(int u, int v ,int c)
{
s[++num] = u;
e[num] = v;
w[num] = c;
}
int main()
{
while(scanf("%d",&n)==1 && n)
{
clear();
scanf("%d",&m);
while(m--)
{
int si,ni,ki;
char o,p;
scanf("%d %d %c%c %d",&si,&ni,&o,&p,&ki);
if(o=='g') add(si+ni,si-1,-ki-1);
else add(si-1,si+ni,ki-1);
}
for(int i=0;i<=n;i++)
{
add(n+1,i,0);
}
printf(Bellman_Ford()?"lamentable kingdom\n":"successful conspiracy\n");
}
}
