/*
3
0 1
0 2
1 2
-1 -1

NO

4
0 1
0 3
1 2
2 3
-1 -1
YES
*/
#include <iostream>
#include<vector>
#include<cstring>
using namespace std;
#define maxv 1000
vector<int> G[maxv];//圖
int V;//頂點數
int color[maxv];//頂點i的顏色
//將頂點染成1或-1
bool dfs(int v,int c)
{
    color[v]=c;//把頂點v染成顏色c
    for(int i=0;i<G[v].size();i++){
        int u=G[v][i];
        //相鄰頂點同色，返回false
        if(color[u]==c) return false;
        //相鄰頂點還未染色，染成-c
        if(!color[u]&&!dfs(u,-c)) return false;
    }
    //如果所有的頂點都染過色了，則返回true
    return true;
}
void solve()
{
    for(int i=0;i<V;i++){
        if(color[i]==0){
            //頂點i未被染色，染成1
            if(!dfs(i,1)){
                cout<<"NO\n"<<endl;
                return;
            }
        }
    }
    cout<<"YES\n"<<endl;
}
int main()
{
    cin>>V;
    int u,v;
    cin>>u>>v;
    while(u>=0&&v>=0){
        G[u].push_back(v);
        G[v].push_back(u);
        cin>>u>>v;
    }
    memset(color,0,sizeof(color));
    solve();
    return 0;
}
 

2.最短路徑問題

最短路是給定兩個頂點，在以這兩個頂點為起點和終點的路徑中，邊的權值之和最小的路徑。智力遊戲中的最小步數，也可以看作最短路徑問題。

1.單源最短路徑1(Bellman-Ford演算法)

1.演算法原理

記從起點s出發到頂點i的最短距離為d[i]，則有d[i]=min{d[j]+(從j到i的邊的權值)|e=(j,i)屬於E}

如果給定的圖是DAG，就可以按拓撲序給頂點編號，按照上述遞推關係式計算出d。但是圖中如果有圈，就不可以依賴這樣的順序計算。在這種情況下，設初值d[s]=0，d[i]=INF(足夠大的常數)，在不斷利用這個遞推關係式就可以解決。只要圖中不存在負圈，操作就是有限的。

2.程式碼及樣例:

/*
5 10
0 1 6
0 3 7
1 2 5
1 3 8
1 4 -4
2 1 -2
3 2 -3
3 4 9
4 0 2
4 2 7

0 2 4 7 -2
*/
#include <iostream>
#include<vector>
#include<cstring>
using namespace std;
#define maxn 1000
#define INF 0x7fffffff
int V,E;
struct edge
{
    int from;
    int to;
    int cost;
};
edge es[maxn];//邊
int d[maxn];//最短距離
//求解從頂點s出發到所有頂點的最短距離
void shortest_path(int s)
{
    for(int i=0;i<V;i++){
        d[i]=INF;
    }
    d[s]=0;
    while(true){
        bool update=false;
        for(int i=0;i<E;i++){
            edge e=es[i];
            int u=e.from,v=e.to;
            if(d[u]!=INF&&d[v]>d[u]+e.cost){
                d[v]=d[u]+e.cost;
                update=true;
            }
        }
        if(!update) break;
    }
}
int main()
{
    cin>>V>>E;
    for(int i=0;i<E;i++){
        int u,v,c;
        cin>>u>>v>>c;
        es[i]=(edge){u,v,c};//這個感覺好6，以前沒見過……
    }
    shortest_path(0);
    for(int i=0;i<V;i++){
        cout<<d[i]<<" ";
    }
    cout<<endl;
    return 0;
}
 

3.時間複雜度分析

4.負圈檢查

//檢查是否存在負圈
bool find_negative_loop()
{
    memset(d,0,sizeof(d));
    for(int i=0;i<V;i++){
        for(int j=0;j<E;j++){
            edge e=es[i];
            if(d[e.to]>d[e.from]+e.cost){
                d[e.to]=d[e.from]+e.cost;
                //如果第n次仍然更新了，則存在負圈
                if(i==V-1) return false;
            }
        }
    }
    return true;
}

3.最小生成樹

2.Kruscal演算法

1.演算法原理

Kruscal演算法按照邊的權值的順序從小到大檢視一遍，如果不產生圈，就把這條邊加入到生成樹中。

現在介紹如何判斷是否產生邊。假設現在要把連線頂點u和v的邊e加入到生成樹中，如果之前u和v不在同一個連通分量中，那麼加入e不會產生圈，否則會。可以用並查集高效地判斷是否屬於同一個連通分量。

Kruscal演算法在邊的排序上最花時間，演算法的時間複雜度為O(ElogV)。

2.程式碼模板

/*
9 14
0 1 4
0 7 8
1 2 8
1 7 11
2 3 7
2 5 4
2 8 2
3 4 9
3 5 14
4 5 10
5 6 2
6 7 1
6 8 6
7 8 7

37
*/
#include<iostream>
#include<cstdio>
#include<set>
#include<algorithm>
using namespace std;
#define maxn 1005
int par[maxn];//父親
int Rank[maxn];//樹的高度
//初始化
void init(int n)
{
    for(int i=0;i<n;i++){
        par[i]=-1;
        Rank[i]=0;
    }
}
//查詢父親，路徑壓縮
int Find(int x)
{
    int s;
    for(s=x;par[s]!=-1;s=par[s]);
    while(s!=x){
        int temp=par[x];
        par[x]=s;
        x=temp;
    }
    return s;
}
//合併x，y屬於的集合
void unite(int x,int y)
{
    x=Find(x);y=Find(y);
    if(x==y) return;
    if(Rank[x]<Rank[y]){
        par[x]=y;
    }
    else{
        par[y]=x;
        if(Rank[x]==Rank[y]) Rank[x]++;
    }
}
bool same(int x,int y)
{
    return Find(x)==Find(y);
}
struct edge
{
    int from;
    int to;
    int cost;
} ;
bool cmp(const edge& e1,const edge& e2)
{
    return e1.cost<e2.cost;
}
int V,E;
edge es[maxn];
int kruscal()
{
    sort(es,es+E,cmp);//按照edge.cost從小到大的順序進行排序
    init(V);
    int res=0;
    for(int i=0;i<E;i++){
        edge e=es[i];
        if(!same(e.from,e.to)){
            unite(e.from,e.to);
            res+=e.cost;
        }
    }
    return res;
}
int main()
{
    cin>>V>>E;
    for(int i=0;i<E;i++){
        int u,v,c;
        cin>>u>>v>>c;
        es[i]=(edge){u,v,c};
    }
    printf("%d\n",kruscal());
    return 0;
}