【图论算法】Dijkstra&BFS

选择V-S中的点加入S时用了贪心思想，即求d[]中legth最小且未被标记（未加入加入S）的点。

一点都没优化的实现：

import java.lang.reflect.Array;

/**
 * Created by yueli on 2018/10/14.
 */
public class Dijkstra {
    boolean mark[]=new boolean[5];
    int v[][]={{0,10,-1,30,100}, {-1,0,50,-1,-1},{-1,-1,0,-1,10},{-1,10,20,0,60},{-1,-1,-1,-1,0}};
    class Dist{
        public int pre;
        public int length;
        public Dist(){}
        public Dist(int pre,int length){
            this.pre=pre;
            this.length=length;
        }
    }
    int maxInt=0xfffffff;
    public Dist D[]=new Dist[5];
    boolean AllMarked(){
        for(int i=0;i<mark.length;i++)
            if(!mark[i])
                return false;
        return true;
    }
    void dijkstra(final int s){
        for(int i=0;i<5;i++) {
            D[i]=new Dist();
            D[i].pre = s;
            D[i].length = v[s][i];
            mark[i]=false;
        }
        int u=s;
        mark[s]=true;
        while (!AllMarked()){
            int min=maxInt;
            for(int i=0;i<5;i++)
                if(!mark[i]&&D[i].length>0&&D[i].length<min){
                min=D[i].length;
                u=i;
                }
            System.out.print("{+"+u+"} ");
            printD();
            if(min==maxInt)break;
            mark[u]=true;
            for(int i=0;i<5;i++)
                if(v[u][i]>0&&(D[i].length>D[u].length+v[u][i]||D[i].length<0)){
                    D[i].length=D[u].length+v[u][i];
                    D[i].pre=u;
                }
        }
    }
    void printD(){
        for(int i=0;i<5;i++){
            System.out.print("pre:"+D[i].pre+" length:"+D[i].length+" ");
        }
        System.out.println();
    }
    void printV(){
        for(int i=0;i<5;i++) {
            for (int j = 0; j < 5; j++)
                System.out.print(v[i][j]+" ");
            System.out.println();
        }
    }
    public static void main(String[] args) {
        Dijkstra dijkstra=new Dijkstra();
        dijkstra.printV();
        dijkstra.dijkstra(0);
    }
}

 void dijkstra(final int s){
        for(int i=0;i<5;i++) {
            D[i]=new Dist();
            D[i].pre = s;
            D[i].length = v[s][i];
            mark[i]=false;
        }
        int u=s;
        mark[s]=true;
        while (!AllMarked()){
            int min=maxInt;
            for(int i=0;i<5;i++)
                if(!mark[i]&&D[i].length>0&&D[i].length<min){
                min=D[i].length;
                u=i;
                }
            System.out.print("{+"+u+"} ");
            printD();
            if(min==maxInt)break;
            mark[u]=true;
            for(int i=0;i<5;i++)
                if(v[u][i]>0&&(D[i].length>D[u].length+v[u][i]||D[i].length<0)){
                    D[i].length=D[u].length+v[u][i];
                    D[i].pre=u;
                }
        }
    }

0 10 -1 30 100 
-1 0 50 -1 -1 
-1 -1 0 -1 10 
-1 10 20 0 60 
-1 -1 -1 -1 0 
{+1} pre:0 length:0 pre:0 length:10 pre:0 length:-1 pre:0 length:30 pre:0 length:100 
{+3} pre:0 length:0 pre:0 length:10 pre:1 length:60 pre:0 length:30 pre:0 length:100 
{+2} pre:0 length:0 pre:0 length:10 pre:3 length:50 pre:0 length:30 pre:3 length:90 
{+4} pre:0 length:0 pre:0 length:10 pre:3 length:50 pre:0 length:30 pre:2 length:60 

Process finished with exit code 0

#include <iostream>
#include<Queue>
using namespace std; 
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
bool allMarked(bool *mark,const int n){
    for(int i=0;i<n;i++){
        if(!mark[i]){
            return false;
        }
    }
    return true;
}
int getFirstUnmarked(bool* mark,const int n){
    for(int i=0;i<n;i++){
        if(!mark[i]){
            return i;
        }
    }
    return -1;
}
void BFS(bool d[][5],const int n,int s){
    queue<int>q;
    bool *mark=new bool[n];
    q.push(s);mark[s]=1;
    while(!q.empty()||!allMarked(mark,n)){
        while(!q.empty()){
            s=q.front();
            q.pop();
            cout<<s<<" ";
            for(int i=0;i<n;i++){
                if(!mark[i]&&d[s][i]){
                    q.push(i);
                    mark[i]=1;
                }
            }
        }
        if(!allMarked(mark,n)){
            q.push(getFirstUnmarked(mark,n));
        }
    } 
}
void DFS(bool d[][5],const int n,int s){
    queue<int>q;
    bool *mark=new bool[n];
}
int main(int argc, char *argv[]) {
    bool v[][5]={
    {0,1,1,0,0}, 
    {0,0,1,1,1},
    {0,0,0,0,0},
    {0,0,0,0,1},
    {0,0,0,0,0}};
    BFS(v,5,0);
    return 0;
}