图论算法c

㈠ 求图论的生成子图算法，要求生成尽可能多的子图

在图论的历史中，还有一个最着名的问题－－四色猜想。这个猜想说，在一个平面或球面上的任何地图能够只用四种颜色来着色，使得没有两个相邻的国家有相同的颜色。每个国家必须由一个单连通域构成，而两个国家相邻是指它们有一段公共的边界，而不仅仅只有一个公共点。20世纪80-90年代曾邦哲的综合系统论（结构论）观将“四色猜想”命题转换等价为“互邻面最大的多面体是四面体”。四色猜想有一段有趣的历史。每个地图可以导出一个图，其中国家都是点，当相应的两个国家相邻时这两个点用一条线来连接。所以四色猜想是图论中的一个问题。它对图的着色理论、平面图理论、代数拓扑图论等分支的发展起到推动作用。 （下图是在上下对折再左右对折以后形成一个轮胎形状，有7个区域两两相连，就是说在一个环面上作图，需要7种颜色，外国数学家构造林格证明：Np=[(7+√1+48p)/2]，p=1，N1=7。
图论中最着名的四色猜想解决办法 韩世君利用三角形性质和数学归纳法解决了四色猜想 摘要：将平面图的不相连点使其相连（这样增加着色难度），形成有许多三角形相连的平面图，根据三角形的稳定性，利用数学归纳法，平面图进行着色最多需4种颜色。 定理：在平面图中,对不同顶点进行着色,相邻顶点着不同颜色,不相邻顶点着相同颜色,则最多需4种颜色。 证明：在平面图中，不在同一直线上的三点决定一个平面，那么三点构成的三角形是平面图中最基本、最简单、最稳定、密闭的图形。 由于在对地图着色过程中不考虑图的具体形状只考虑点是否相邻，将平面图的不相连点使其相连（这样增加着色难度），形成有许多三角形相连的平面图（三点以下肯定成立）。如图1：添加辅助线（不相邻的点使其相邻，这样就增加了着色的色数，有利于证明），将图1分解为4个△ABC。 在平面图中的无数点中，任取相邻三点构成各点相邻的△ABC（见图2），则需3种颜色A B C,在平面图中再任取一点 D 与 A B C 三点相邻,同时D又与A B C三点相连后形成三角形。任取一点E与 A、B、C、D四色相连，E必与四色之一色相同即E点在△ABD中与C色相同、在△ACD中与B色相同、在△BCD中与A色相同、在△ABC外与D色相同，E与另外三色相连形成新的三角形。 在三角形的三点之外任取一点只有在三角形的内部和外部两种情况且这两种情况的点不会相邻，该点最多与三角形的三点相连且又形成新的三角形。 继续选取一点进行着色，该点同样最多与三角形的三点相连且又形成新的三角形，该点至少为四色中的一色。逐点（第n点）着色至将所有点（第n+1点）着色只须A、B、C、D四色其中一色。 图的着色方法：任意一张地图，将孤立的点用一种颜色着色（A色），不能形成密闭图形的相连的点用两种颜色（A、B色）。将剩余的点不相连的用虚线使其相连形成许多三角形，完全不相连的图不进行相连。任取相连三点着三种颜色（A、B、C色），再取与其相连的点，如果与A、B、C三色的点都相连着D色，否则着与其不相连的其中一色，用虚线相连的点可以用同一种颜色也可以用两种颜色，依次取与着色的点相连的点用以上方法进行着色。这样对所有的点进行着色最多用四色（A、B、C、D色）。 图论的广泛应用，促进了它自身的发展。20世纪40-60年代，拟阵理论、超图理论 、极图理论，以及代数图论、拓扑图论等都有很大的发展 拓扑学在泛函分析、李群论、微分几何、微分方程和其他许多数学分支中都有广泛的应用。 （右图是：下面的三叉安在上面的环面上，就是有3个洞的9个两两相连区域，上面的图上下对折再左右对折就是一个轮胎形状环面图2）
左图是亏格为4时10个两两相连区域构造，上图上下对折，再左右对折，形成一个轮胎形状，再把下面的四叉按照A,B,C,D编号安上，就是有4个洞的两两相连区域图3（王晓明构造）。

㈡ 图论算法的论证

有向无回路图又称为dag。对这种有向无回路图的拓扑排序的结果为该图所有顶点的一个线性序列，满足如果G包含(u,v)，则在序列中u出现在v之前（如果图是有回路的就不可能存在这样的线性序列）。一个图的拓扑排序可以看成是图的所有顶点沿水平线排成的一个序列，使得所有的有向边均从左指向右。因此，拓扑排序不同于通常意义上对于线性表的排序。
有向无回路图经常用于说明事件发生的先后次序，图1给出一个实例说明早晨穿衣的过程。必须先穿某一衣物才能再穿其他衣物（如先穿袜子后穿鞋），也有一些衣物可以按任意次序穿戴（如袜子和短裤）。
图中说明经拓扑排序的结点以与其完成时刻相反的顺序出现。因为深度优先搜索的运行时间为θ(V+E)，每一个v中结点插入链表需占用的时间为θ(1)，因此进行拓扑排序的运行时间θ(V+E)。
为了证明算法的正确性，我们运用了下面有关有向无回路图的重要引理。 有向图G无回路当且仅当对G进行深度优先搜索没有得到反向边。
证明：→：假设有一条反向边(u,v)，那么在深度优先森林中结点v必为结点u的祖先，因此G中从v到u必存在一通路，这一通路和边(u,v)构成一个回路。
←：假设G中包含一回路C，我们证明对G的深度优先搜索将产生一条反向边。设v是回路C中第一个被发现的结点且边(u,v)是C中的优先边，在时刻d[v]从v到u存在一条由白色结点组成的通路，根据白色路径定理可知在深度优先森林中结点u必是结点v的后裔，因而(u,v)是一条反向边。（证毕） Topological_Sort(G)算法可产生有向无回路图G的拓扑排序
证明
假设对一已知有问无回路图G=(V,E)运行过程DFS以确定其结点的完成时刻。那么只要证明对任一对不同结点u,v∈V，若G中存在一条从u到v的有向边，则f[v]<F[U]即可。考虑过程DFS(G)所探寻的任何边(U,V)，当探寻到该边时，结点V不可能为灰色，否则V将成为U的祖先，(U,V)将是一条反向边，和引理1矛盾。
因此，v必定是白色或黑色结点。若v是白色，它就成为u的后裔，因此f[v]<F[U]。若V是黑色，同样F[V]<F[U]。这样一来对于图中任意边(U,V)，都有F[V]<F[U]，从而定理得证。（证毕）

㈢ c语言算法求解：对任意给定的网络（顶点数和边数自定），设计算法生成它的最小生成树。

上一个图和代码：

图1为要创建的图，图2为对应的最小生成树

代码为：

//图论之最小生成树：prim算法实现

#include"stdio.h"

#include"malloc.h"

//声明

voidoutput(structadjacentlisthead*alh,intmapsize);

structadjacentlistson//邻接表项结构体

{

intsonelement;

intquanvalue;

structadjacentlistson*next;

};

structadjacentlisthead//邻接表头结构体

{

charflag;

intelement;

intcurqvalue;

structadjacentlisthead*previous;

structadjacentlistson*startson;

};

structadjacentlisthead*mapinitialnize(intmapsize)//初始化图函数

{

structadjacentlisthead*alh=NULL;

structadjacentlistson*newnode=NULL;

inti,x,y,z;

alh=malloc(sizeof(structadjacentlisthead)*mapsize);

if(alh==NULL)

returnNULL;

for(i=0;i<mapsize;i++)

{

alh[i].flag=0;

alh[i].element=i+1;

alh[i].curqvalue=0;

alh[i].previous=NULL;

alh[i].startson=NULL;

}

scanf("%d%d%d",&x,&y,&z);

while(x&&y)//直到输入的x,y中至少有一个0为止

{

newnode=malloc(sizeof(structadjacentlistson));

newnode->sonelement=y;

newnode->quanvalue=z;

newnode->next=alh[x-1].startson;

alh[x-1].startson=newnode;

scanf("%d%d%d",&x,&y,&z);

}

returnalh;

}

intfindminnode(structadjacentlisthead*alh,intmapsize)//找到最小权值对应的结点

{

inti,minvalue=~(1<<(sizeof(int)*8-1)),minplace=0;

for(i=0;i<mapsize;i++)

{

if(alh[i].flag==0&&alh[i].curqvalue!=0)

{

if(alh[i].curqvalue<minvalue)

{

minvalue=alh[i].curqvalue;

minplace=i+1;//

}

}

}

returnminplace;

}

voidfindthemintree(structadjacentlisthead*alh,intstartplace,intmapsize)//找到最小生成树

{

structadjacentlistson*alstmp=NULL;

intcurplace=startplace;

while(curplace)

{

alstmp=alh[curplace-1].startson;

alh[curplace-1].flag=1;//正在访问

while(alstmp)

{

if(alh[alstmp->sonelement-1].flag==0)

{

if(alh[alstmp->sonelement-1].curqvalue==0||(alh[alstmp->sonelement-1].curqvalue>alstmp->quanvalue))//比较方法与有权图有一点不同

{

alh[alstmp->sonelement-1].curqvalue=alstmp->quanvalue;

alh[alstmp->sonelement-1].previous=&alh[curplace-1];

}

}

alstmp=alstmp->next;

}

curplace=findminnode(alh,mapsize);//通过函数找到最小的一个结点

}

}

voidoutput(structadjacentlisthead*alh,intmapsize)

{

inti;

for(i=0;i<mapsize;i++)

{

printf("%d点的权值为：%d ",i+1,alh[i].curqvalue);

}

printf("................................................... ");

}

intmain()

{

structadjacentlisthead*alh=NULL;

intmapsize=7,startplace=1;

alh=mapinitialnize(mapsize);

findthemintree(alh,startplace,mapsize);

output(alh,mapsize);

}

输入数据对应第一图：

122

134

141

212

243

2510

314

342

365

411

423

432

457

468

474

5210

547

576

635

648

671

744

756

761

000

㈣ 数据结构c语言版图论题目

给你个模板
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#include<vector>
#include<stack>
using namespace std;
const int maxn=10005;
vector<int>g[maxn];
stack<int>s;
int dfs_clk,scc_cnt;
int pre[maxn],lowlink[maxn],scc[maxn];
void dfs(int u)
{
pre[u]=lowlink[u]=++dfs_clk;
s.push(u);
for(int i=0;i<g[u].size();i++)
{
int v=g[u][i];
if(!pre[v])
{
dfs(v);
lowlink[u]=min(lowlink[u],lowlink[v]);
}
else if(!scc[v])
{
lowlink[u]=min(lowlink[u],pre[v]);
}
}
if(lowlink[u]==pre[u])
{
scc_cnt++;
for(;;)
{
int x=s.top();s.pop();
scc[x]=scc_cnt;
if(x==u) break;
}
}
}
void find_scc(int n)
{
dfs_clk=scc_cnt=0;
memset(scc,0,sizeof scc);
memset(pre,0,sizeof pre);
for(int i=1;i<=n;i++)
if(!pre[i]) dfs(i);
}
int main()
{
int n,m;
while(cin>>n>>m)
{
if(n==0&&m==0) break;
for(int i=1;i<=10000;i++)
g[i].clear();
for(int i=1;i<=m;i++)
{
int x,y;
scanf("%d%d",&x,&y);
g[x].push_back(y);
}
find_scc(n);
cout<<scc_cnt<<endl;
}
}

scc_cnt就是连通子图的个数

㈤ c语言算法

离散数学离散数学作为计算机学科的基础是竞赛中涉及最多的数学分支，重中之重又在于图论和组合数学，尤其是图论。图论之所以运用最多是因为它的变化最多，而且可以轻易地结合基本数据结构和许多算法的基本思想，较多用到的知识包括连通性判断、DFS和BFS，关节点和关键路径、欧拉回路、最小生成树、最短路径、二部图匹配和网络流等等。虽然这部分的比重很大，但是往往也是竞赛中的难题所在，如果有初学者对于这部分的某些具体内容暂时感到力不从心，也不必着急，可以慢慢积累。组合数学竞赛中设计的组合计数问题大都需要用组合数学来解决，组合数学中的知识相比于图论要简单一些，很多知识对于小学上过奥校的同学来说已经十分熟悉，但是也有一些部分需要先对代数结构中的群论有初步了解才能进行学习。组合数学在竞赛中很少以难题的形式出现，但是如果积累不够，任何一道这方面的题目却都有可能成为难题。数论以素数判断和同余为模型构造出来的题目往往需要较多的数论知识来解决，这部分在竞赛中的比重并不大，但只要来上一道，也足以使知识不足的人冥思苦想上一阵时间。素数判断和同余最常见的是在以密码学为背景的题目中出现，在运用密码学常识确定大概的过程之后，核心算法往往要涉及数论的内容。计算几何计算几何相比于其它部分来说是比较独立的，就是说它和其它的知识点很少有过多的结合，较常用到的部分包括—线段相交的判断、多边形面积的计算、内点外点的判断、凸包等等。计算几何的题目难度不会很大，但也永远不会成为最弱的题。线性代数对线性代数的应用都是围绕矩阵展开的，一些表面上是模拟的题目往往可以借助于矩阵来找到更好的算法。 ~

㈥ 这是一个图论的问题

Dijkstra算法是很有代表性的最短路算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等

注意：你的指定点开始的问题，直接从把下面的东西看完后，应用（6）就可以解决，任意开始点的话，就把所有点都指定一下就行了。。。

再补充一个，这个算法一般图论书上都有，但是写的非常之高深莫测，看不懂的。。。建议去看清华大学的数据结构与算法这本书上的算法，（蓝色封皮的）

设S为最短距离已确定的顶点集（看作红点集），V-S是最短距离尚未确定的顶点集（看作蓝点集）。
①初始化
初始化时，只有源点s的最短距离是已知的(SD(s)=0)，故红点集S={s}，蓝点集为空。
②重复以下工作，按路径长度递增次序产生各顶点最短路径
在当前蓝点集中选择一个最短距离最小的蓝点来扩充红点集，以保证算法按路径长度递增的次序产生各顶点的最短路径。
当蓝点集中仅剩下最短距离为∞的蓝点，或者所有蓝点已扩充到红点集时，s到所有顶点的最短路径就求出来了。
注意：
①若从源点到蓝点的路径不存在，则可假设该蓝点的最短路径是一条长度为无穷大的虚拟路径。
②从源点s到终点v的最短路径简称为v的最短路径；s到v的最短路径长度简称为v的最短距离，并记为SD(v)。

（3）在蓝点集中选择一个最短距离最小的蓝点k来扩充红点集
根据按长度递增序产生最短路径的思想，当前最短距离最小的蓝点k的最短路径是：
源点，红点1，红点2，…，红点n，蓝点k
距离为：源点到红点n最短距离+<红点n,蓝点k>边长
为求解方便，设置一个向量D[0．．n-1]，对于每个蓝点v∈ V-S，用D[v]记录从源点s到达v且除v外中间不经过任何蓝点(若有中间点，则必为红点)的"最短"路径长度（简称估计距离）。
若k是蓝点集中估计距离最小的顶点，则k的估计距离就是最短距离，即若D[k]=min{D[i] i∈V-S}，则D[k]=SD(k)。
初始时，每个蓝点v的D[c]值应为权w<s，v>，且从s到v的路径上没有中间点，因为该路径仅含一条边<s，v>。
注意：
在蓝点集中选择一个最短距离最小的蓝点k来扩充红点集是Dijkstra算法的关键

（4）k扩充红点集s后，蓝点集估计距离的修改
将k扩充到红点后，剩余蓝点集的估计距离可能由于增加了新红点k而减小，此时必须调整相应蓝点的估计距离。
对于任意的蓝点j，若k由蓝变红后使D[j]变小，则必定是由于存在一条从s到j且包含新红点k的更短路径：P=<s，…，k，j>。且D[j]减小的新路径P只可能是由于路径<s，…，k>和边<k，j>组成。
所以，当length(P)=D[k]+w<k，j>小于D[j]时，应该用P的长度来修改D[j]的值。

（5）Dijkstra算法

Dijkstra(G，D，s){
//用Dijkstra算法求有向网G的源点s到各顶点的最短路径长度
//以下是初始化操作
S={s}；D[s]=0； //设置初始的红点集及最短距离
for( all i∈ V-S )do //对蓝点集中每个顶点i
D[i]=G[s][i]； //设置i初始的估计距离为w<s，i>
//以下是扩充红点集
for(i=0;i<n-1;i++)do{//最多扩充n-1个蓝点到红点集
D[k]=min{D[i]：all i V-S}； //在当前蓝点集中选估计距离最小的顶点k
if(D[k]等于∞)
return； //蓝点集中所有蓝点的估计距离均为∞时，
//表示这些顶点的最短路径不存在。
S=S∪{k}； //将蓝点k涂红后扩充到红点集
for( all j∈V-S )do //调整剩余蓝点的估计距离
if(D[j]>D[k]+G[k][j])
//新红点k使原D[j]值变小时，用新路径的长度修改D[j]，
//使j离s更近。
D[j]=D[k]+G[k][j]；
}
}

（6）保存最短路径的Dijkstra算法
设置记录顶点双亲的向量P[0．．n-1]保存最短路径：
当顶点i无双亲时，令P[i]=-1。
当算法结束时，可从任一P[i]反复上溯至根(源点)求得顶点i的最短路径，只不过路径方向正好与从s到i的路径相反。
。
Dijkstra算法的时间复杂度为O(n2)
参考资料：http://student.zjzk.cn/course_ware/data_structure/web/tu/tu7.5.2.htm

㈦ c语言在图论中的应用

我研究的是电力系统的网络拓扑问题，它就是基于图论的，把电网中的连接方式映射为图，可以采用c语言编程来实现这个算法，，

㈧ 用图论做一个求迷宫最短路径的算法

01.#include <stdio.h>
02.#define MAXN 10
03.int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};
04.char name[] = {'U', 'D', 'L', 'R'};
05.int q[MAXN * MAXN]; //队列，保存当前结点编号
06.int vis[MAXN][MAXN], nMap[MAXN][MAXN];
07.int m, n; //行、列数
08.int dir[MAXN * MAXN];
09.int fa[MAXN][MAXN], dis[MAXN][MAXN], last_dir[MAXN][MAXN];
10.void funcInit();
11.void bfs(int x, int y);
12.void funcInput();
13.void print_path(int x, int y);
14.int main()
15.{
16. funcInput();
17. funcInit();
18. bfs(0, 0);
19. print_path(m - 1, n - 1);
20. return 0;
21.}
22.void funcInit()
23.{
24. int i, j;
25. for (i = 0; i != m; ++i)
26. {
27. for (j = 0; j != n; ++j)
28. {
29. vis[i][j] = 0;
30. dis[i][j] = 0;
31. }
32. }
33.}
34.void funcInput()
35.{
36. int i, j;
37. scanf("%d %d", &m, &n);
38. for (i = 0; i != m; ++i)
39. {
40. for (j = 0; j != n; ++j)
41. {
42. scanf("%d", &nMap[i][j]);
43. }
44. }
45.}
46.void bfs(int x, int y)
47.{
48. int front = 0, rear = 0;
49. int d, u; //方向标记、结点编号
50.
51. u = x * m + y;
52. vis[x][y] = 1;
53. fa[x][y] = u;
54. q[rear++] = u; //将当前结点编好放入队列
55.
56. while (front != rear)
57. {
58. u = q[front++];
59. x = u / m; y = u % m;
60. for (d = 0; d != 4; ++d)
61. {
62. int nx = x + dx[d], ny = y + dy[d];
63. if (nx >= 0 && nx < m && ny >= 0 && ny < n && !vis[nx][ny] && !nMap[nx][ny])
64. {
65. int v = nx * m + ny;
66. q[rear++] = v;
67. vis[nx][ny] = 1;
68. fa[nx][ny] = u;
69. dis[nx][ny] = dis[x][y] + 1; //记录路径长度
70. last_dir[nx][ny] = d; //记录移动方向标记
71. }
72. }
73. }
74.}
75.void print_path(int x, int y)
76.{
77. int c = 0;
78.
79. while (1)
80. {
81. int fx = fa[x][y] / m;
82. int fy = fa[x][y] % m;
83. if (fx == x && fy == y) break;
84. dir[c++] = last_dir[x][y];
85. x = fx; y = fy;
86. }
87. while (c--)
88. {
89. putchar(name[dir[c]]);
90. putchar('/n');
91. }
92. printf("最短路径长度为:%d/n", dis[m-1][n-1]);
93.}

㈨ 求解：图论中常见的最短路径算法有几种都是什么

主要是有三种、、

第一种是最直接的贪心dijkstra算法、、可以利用堆数据结构进行优化、、缺点就是不能求有负权的最短路与判断负环、、

第二种是bellman-ford算法、、根据松弛操作的性质是可以来判断负环的、、时间复杂度是O(nm)的、、

第三种是SPFA算法、、把他单独拿出来作为一种算法并不是非常好的、、他的实质应该是上面的bellman-ford算法的队列优化时间复杂度更低、O(KE)、K的值约等于2、、

㈩ 请C语言大神帮个忙

我们学校的竞赛题是n*n的，可以参考一下
#include<stdio.h>
#include<string.h>
#define max 100
int mat[max][max],vis[max][max];
void dfs(int x,int y)
{
if(!mat[x][y] || vis[x][y]) return;
vis[x][y]=1;
dfs(x-1,y-1);
dfs(x-1,y+1);
dfs(x-1,y);
dfs(x,y-1);
dfs(x,y+1);
dfs(x+1,y-1);
dfs(x+1,y+1);
dfs(x+1,y);
}
void main()
{ int i,j,n;
char s[100];
memset(mat,0,sizeof(mat));
memset(vis,0,sizeof(vis));
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%s",s);
for(j=0;j<n;j++)
mat[i+1][j+1]=s[j]-'0';
}
int count=0;
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
if(!vis[i][j] && mat[i][j]) {count++;dfs(i,j);}
printf("%d\n",count);
}
很久以前的