通过上网课的方式，我今天了解了什么是图论，以及图论在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了，今天发文只是和大家分享一下学习经历。以后我还要努力把这个东西弄会的。