P1993 小K的農場（差分約束）

小K的農場

題目描述

小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;
}