图论初步

通过上网课的方式，我今天了解了什么是图论，以及图论在c++中的应用方式和代码构成。

我们可以用数组的方式存储图像，如二维数组a【5】【5】；

        1      2      3      4

1      0      1      1     -1

2      1      0     -1     1 

3      1     -1     0     -1

4     -1      1     -1     0

可以表示图

 

 这类似于一个表格。

从左到右第一行表示点1到点2、3、4的距离（我们假设距离为1）。如果在图中无法到达（例如点1到点4）我们用-1或者正无穷表示。

向下以此类推。

另外，我们把图分为有向图和无向图；

上面的图就是无向图（点的连接中没有方向性）

有向图就是点的连接会有一定的方向性。

例如1——>2;

这个简单的图就是有向图，路径只能从点1到点2，而不能从点2到点1。

遍历

既然有了图和点之间的方向，我们会想到从一个点如何走才能走到每一个其它点呢？

这就涉及到图的遍历。

当我们一次就走完整张图，且不重复经过任意路径时，我们说这个图中存在“欧拉路”，如果我们此时回到了出发点，我们就把我们走过的路径叫“欧拉回路”。

也就是“一笔画”

利用图的遍历我们可以解决一些“一笔画”问题。

比如著名的七桥问题

有一个叫做哥尼斯堡的小镇，考虑到“哥尼斯堡”这个名字不好记，下文我们就称之为G镇。G镇的居民很爱锻炼身体，过着日出而作日落而息的生活，而他们睡前都喜欢到公园里遛弯消食。但是，G镇的居民不是只会享受生活的一群人，他们还热爱思考数学问题。
有一天，一个孩子提出了一个问题：
 "我们的公园里有一条河，河上有两个小岛，在两岸小岛之间一共建造了7座桥，如果我想走过所有的桥然后回到我出发的地方应该怎么走呢？”
听到这个问题，整个G镇的居民都陷入了沉思，有的还晚上不睡觉，一遍一遍的在桥上走来走去，但是没有找到答案。
相信有好奇的读者肯定曾经自己也在纸上画过很多遍，但是都没有找到答案。
本来这个问题委实不会影响到G镇居民的生活，毕竟这并不影响到他们的生活。幸运的是，据说，刚好有一位很厉害的数学家刚好就暂住在G镇，这个孩子的问题引起了数学家的注意。
（这段是网上抄下来的，如有侵权，立刻删除）

我们可以把这个问题简化一下

有一个简单图，有4个顶点，7条边，问：能否遍历所有的边最后回到起点且不会重复经过同一条边。

经欧拉证明，这是不可能的。

但是如何用计算机算一下呢

以下是代码（also是抄的，如有侵权，立刻删除）

/**

 *Author:Yuanhonglong

 *Date:2013-12-16

 *1948281915

 */

package mine.algorithm.graph;

 

import java.util.Vector;

 

class Land{

    public static int[][] g;

    //为四块陆地定义变量order,以示区别

    public int order;

    public Land(int Order){

        this.order=Order;

    }

    //定义方法go,每走一步则将两块陆地间的一座桥去除

    public void go(Land x){

        g[this.order][x.order]-=1;

        g[x.order][this.order]-=1;

    }

}

 

public class Bridge extends Land{

    /*

     * 用图论解决古老的7桥问题

     */

 

    public Bridge(int Order) {

        super(Order);

    }

    public static Vector<Land> l=new Vector<Land>();

    public static int Result=0,turn;

    public static void main(String[] args) {

        //抽象出四块陆地

        Land land1=new Land(0);

        Land land2=new Land(1);

        Land land3=new Land(2);

        Land land4=new Land(3);

        //为方便管理,将陆地加入到向量l中

        l.add(land1);

        l.add(land2);

        l.add(land3);

        l.add(land4);

        int n=l.size();

        /*

         * 将四块陆地间的联系-桥抽象出来

         */

        g=new int[n][n];

        for(int i=0;i<n;i++){

            for(int j=0;j<n;j++){

                g[i][j]=0;

            }

        }

        /*

         * 如果第i到第j块陆地有m座桥

         * 则g[i][j]=m;

         */

        g[0][1]=1;

        g[0][2]=1;

        g[0][3]=1;

        g[1][0]=1;

        g[1][2]=2;

        g[1][3]=2;

        g[2][0]=1;

        g[2][1]=2;

        g[3][0]=1;

        g[3][1]=2;

        System.out.println("各陆地之间的桥的数量:");

        System.out.println("   A B C D");

        for(int i=0;i<n;i++){

            if(i==0){

                System.out.print("A ");

            }

            if(i==1){

                System.out.print("B ");

            }

            if(i==2){

                System.out.print("C ");

            }

            if(i==3){

                System.out.print("D ");

            }

            for(int j=0;j<n;j++){

                System.out.print(g[i][j]+"  ");

            }

            System.out.println();

        }

        //N用来记录有几种成功的可能

        int N=0;

        //All用来记录一共尝试了几次

        int All=0;

        //以下是通过嵌套循环实现遍历

        for(int begin=0;begin<n;begin++){

            //由于可以从不同的桥开始,所有用begin代表从哪一座桥开始

            //一共有7座桥,所以内部一共嵌套了7层循环,每层循环代表一步

            for(int a=0;a<n;a++){

                if(begin!=a&&g[begin][a]>0){

                    l.get(begin).go(l.get(a));

                    for(int b=0;b<n;b++){

                        if(a!=b&&g[a][b]>0){

                            l.get(a).go(l.get(b));

                            for(int c=0;c<n;c++){

                                if(b!=c&&g[b][c]>0){

                                    l.get(b).go(l.get(c));

                                    for(int d=0;d<n;d++){

                                        if(c!=d&&g[c][d]>0){

                                            l.get(c).go(l.get(d));

                                            for(int e=0;e<n;e++){

                                                if(d!=e&&g[d][e]>0){

                                                    l.get(d).go(l.get(e));

                                                    for(int f=0;f<n;f++){

                                                        if(e!=f&&g[e][f]>0){

                                                            l.get(e).go(l.get(f));

                                                            for(int g1=0;g1<n;g1++){

                                                                if(f!=g1&&g[f][g1]>0){

                                                                    l.get(f).go(l.get(g1));

                                                                    //如果7步走完，则N加1,代表一次成功的尝试

                                                                    N+=1;

                                                                    g[f][g1]+=1;

                                                                    g[g1][f]+=1;

                                                                    //不管成功或失败,All都要加1

                                                                    All++;

                                                                }

                                                            }

                                                            g[e][f]+=1;

                                                            g[f][e]+=1;

                                                            All++;

                                                        }

                                                    }

                                                    g[d][e]+=1;

                                                    g[e][d]+=1;

                                                    All++;

                                                }

                                            }

                                            g[c][d]+=1;

                                            g[d][c]+=1;

                                            All++;

                                        }

                                    }

                                    g[b][c]+=1;

                                    g[c][b]+=1;

                                    All++;

                                }

                            }

                            g[a][b]+=1;

                            g[b][a]+=1;

                            All++;

                        }

                    }

                    g[begin][a]+=1;

                    g[a][begin]+=1;

                    All++;

                }

            }

            //输出结果

            System.out.println("从第"+begin+"块陆地开始,一共进行了"+All+"次尝试共有"+N+"种方法可以完成。");

            //N与All归零,换另一块陆地开始

            N=0;

            All=0;

        }

         

    }  

         

}    

说实话这个代码我没看懂，但是它确实解决了七桥问题。

图论这个东西很高端，基础我还没弄明白。所以就不和大家装X了，今天发文只是和大家分享一下学习经历。

以后我还要努力把这个东西弄会的。