题目描述
小K在MC里面建立很多很多的农场，总共n个，以至于他自己都忘记了每个农场中种植作物的具体数量了，他只记得一些含糊的信息（共m个），以下列三种形式描述：
农场a比农场b至少多种植了c个单位的作物，
农场a比农场b至多多种植了c个单位的作物，
农场a与农场b种植的作物数一样多。
但是，由于小K的记忆有些偏差，所以他想要知道存不存在一种情况，使得农场的种植作物数量与他记忆中的所有信息吻合。
输入输出格式
输入格式：
第一行包括两个整数 n 和 m，分别表示农场数目和小 K 记忆中的信息数目。
接下来 m 行：
如果每行的第一个数是 1，接下来有 3 个整数 a,b,c，表示农场 a 比农场 b 至少多种植了 c 个单位的作物。
如果每行的第一个数是 2，接下来有 3 个整数 a,b,c，表示农场 a 比农场 b 至多多种植了 c 个单位的作物。如果每行的第一个数是 3，接下来有 2 个整数 a,b，表示农场 a 种植的的数量和 b 一样多。
输出格式：
如果存在某种情况与小 K 的记忆吻合，输出“Yes”，否则输出“No”。
输入输出样例
输入样例#1：
3 3
3 1 2
1 1 3 1
2 2 3 2
输出样例#1：
Yes
说明
对于 100% 的数据保证：1 ≤ n，m，a，b，c ≤ 10000。
差分约束可以求解最短路和最长路。这道题也是差分约束的模板题。
根据：
农场a比农场b至少多种植了c个单位的作物，
农场a比农场b至多多种植了c个单位的作物，
农场a与农场b种植的作物数一样多。建立条件。
由题可知，农场a比农场b至少多种植了c个单位的作物，所以Xa-Xb>=c即Xb-Xa<=-c， 农场a比农场b至多多种植了c个单位的作物，所以Xa-Xb<=c,农场a与农场b种植的作物数一样多,所以Xa==Xb,则Xa-Xb<=c，Xb-Xa<=c。
然后用SPFA。（不要连错了权值）
#include<bits/stdc++.h>
using namespace std;
const int maxn=11000;
const int inf=0x3f3f3f3f;
int n,m;
struct node{
int v,w;
node(){ }
node(int _v,int _w){
v=_v;
w=_w;
}
};
vector <node> g[maxn];
int dst[maxn];
queue <int> qu;
bool inq[maxn];
int cnt[maxn];
int add(int u,int v,int w){
g[u].push_back(node(v,w));
}
bool spfa(int u){
memset(dst,inf,sizeof dst);
// memset(cnt,0,sizeof cnt);
dst[u]=0;
qu.push(u);
inq[u]=1;
while(!qu.empty()){
u=qu.front();
qu.pop();
inq[u]=0;
for(int i=0;i<g[u].size();i++){
int v=g[u][i].v;
int w=g[u][i].w;
if(dst[v]>dst[u]+w){
dst[v]=dst[u]+w;
if(!inq[v]){
qu.push(v);
inq[v]=1;
cnt[v]++;
if(cnt[v]>n){
return 0;
}
}
}
}
}
return 1;
}
int main(){
cin >> n >> m;
for(int i=1;i<=n;i++){
add(0,i,0);
}
for(int i=0;i<m;i++){
int d,a,b,c;
cin >> d;
if(d==1){
cin >>a>>b>>c;
g[a].push_back(node(b,-c));
}else if(d==2){
cin >>a>>b>>c;
g[b].push_back(node(a,c));
}else{
cin >>a>>b;
g[a].push_back(node(b,0));
g[b].push_back(node(a,0));
}
}
if(spfa(0)){
cout << "Yes";
}else{
cout << "No";
}
return 0;
}
但实际上，它只能得到60分。四组TLE。。。
于是，就涉及到另外一个数据结构，双向队列。双向队列有队列和栈的性质。可以从两端入队，弹出。在这道题里，我们用if判断，在队列后端放入较大的值，前端放入较小的值分别用back和front访问最后一个元素和第一个元素。
#include<bits/stdc++.h>
using namespace std;
const int maxn=11000;
const int inf=0x3f3f3f3f;
int n,m;
struct node{
int v,w;
node(){ }
node(int _v,int _w){
v=_v;
w=_w;
}
};
vector <node> g[maxn];
int dst[maxn];
deque<int> qu;//双向队列
bool inq[maxn];
int cnt[maxn];
int add(int u,int v,int w){
g[u].push_back(node(v,w));
}
bool spfa(int u){
memset(dst,inf,sizeof dst);//初始化
// memset(cnt,0,sizeof cnt);
dst[u]=0;
qu.push_back(u);//双向队列的访问最后一个元素写法
inq[u]=1;
while(!qu.empty()){
u=qu.front();//双向队列的访问第一个元素写法
qu.pop_front();
if(dst[qu.front()]>dst[qu.back()]){
swap(qu.front(),qu.back());//交换
}
inq[u]=0;
for(int i=0;i<g[u].size();i++){
int v=g[u][i].v;
int w=g[u][i].w;
if(dst[v]>dst[u]+w){
dst[v]=dst[u]+w;
if(!inq[v]){
if(dst[v]<dst[qu.front()]){//判断，比较大小
qu.push_front(v);//插入队首
}else{
qu.push_back(v);//插入队尾
}
inq[v]=1;
cnt[v]++;
if(cnt[v]>n){
return 0;
}
}
}
}
}
return 1;
}
int main(){
cin >> n >> m;
for(int i=1;i<=n;i++){
add(0,i,0);
}
for(int i=0;i<m;i++){
int d,a,b,c;
cin >> d;
if(d==1){//连权值
cin >>a>>b>>c;
g[a].push_back(node(b,-c));
}else if(d==2){
cin >>a>>b>>c;
g[b].push_back(node(a,c));
}else{
cin >>a>>b;
g[a].push_back(node(b,0));
g[b].push_back(node(a,0));
}
}
if(spfa(0)){
cout << "Yes";
}else{
cout << "No";
}
return 0;
}
原文：https://www.cnblogs.com/A-Konnyaku/p/10993063.html