图论总结

深度优先搜索算法（英语：Depth-First-Search，简称DFS）是一种用于遍历或搜索树或图的算法。沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。属于盲目搜索。

深度优先算法维基百科超链接：

深度优先算法

广度优先搜索算法（英语：Breadth-First-Search，缩写为BFS），又译作宽度优先搜索，或横向优先搜索，是一种图形搜索算法。简单的说，BFS是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。广度优先搜索的实现一般采用open-closed表。

广度优先算法维基百科超链接：

广度优先算法

Poj 1258 Agri-Net:

题目大意：Farmer John要竞选镇长，他的竞选承诺是让镇上的每一个农场都联上网，问题是怎样做到连接所有的农场且所需光纤最短。

问题提炼：在一个加权连通图中，以最短的路径连接所有节点。

根据问题，算法就是——prim算法（生成最小生成树）

如果图中任意两点都是连通的，那么图被称作连通图。

普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点，且其所有边的权值之和亦为最小。                                  ----转自维基百科

//Code:
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;

const int inf=0xFFFFFFF;
const int maxn=105;
int mat[maxn][maxn],dist[maxn];
bool visited[maxn];
int ans;

void init(int Size)
{
    ans=0;
    for(int i=1; i<=Size; i++)
    {
        dist[i]=inf;
        visited[i]=false;
    }
}

void prim(int Size)
{
    int now=1,min_node,min_edge;

    for(int i=1; i<=Size-1; i++)
    {
        visited[now]=true;
        min_edge=inf;
        for(int j=1; j<=Size; j++)
        {
            if(now!=j&&!visited[j])
            {
                dist[j]=min(dist[j],mat[now][j]);
                if(dist[j]<min_edge)
                {
                    min_edge=dist[j];
                    min_node=j;
                }
            }
        }
        now=min_node;
        ans+=min_edge;
    }
}

int main()
{
    //freopen("in.txt","r",stdin);
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                scanf("%d",&mat[i][j]);
        init(n);
        prim(n);
        printf("%d\n",ans);
    }
    return 0;
}

Poj 1125 StockbrokerGrapevine:

题目大意：炒股的人对股市的波动异常敏感，你要散布谣言，为了产生最大的影响力，你要尽快的散布谣言，但是炒股人只信任他所信任的几个同行的话，现在的任务就是计算出以哪个炒股人为谣言的传播起点可以在最短的时间里把谣言散布到整个股市市场，并求出最短时间。

问题提炼：在一个非负权多源有向图中求最短路径。

根据问题，有两种算法：（一）戴克斯特拉算法；（二）Floyd-Warshall算法。

戴克斯特拉算法（英语：Dijkstra's algorithm）是由荷兰计算机科学家艾兹赫尔·戴克斯特拉提出。迪科斯彻算法使用了广度优先搜索解决非负权有向图的单源最短路径问题，算法最终得到一个最短路径树。 

Floyd-Warshall算法（英语：Floyd-Warshall algorithm），中文亦称弗洛伊德算法，是解决任意两点间的最短路径的一种算法^[1]，可以正确处理有向图或负权（但不可存在负权回路)的最短路径问题，同时也被用于计算有向图的传递闭包。----转自维基百科

戴克斯特拉算法：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;

const int maxn=110;
const int inf=0xFFFFFFF;
int mat[maxn][maxn];
int dist[maxn];
bool visited[maxn];

struct Ans
{
    Ans(int o=0,int t=-inf){ori=o;time=t;}
    int ori;
    int time;
};

bool cmp(Ans &a,Ans &b)
{
    return a.time<b.time;
}

void init(int Size)
{
    for(int i=1; i<=Size; i++)
    {
        dist[i] = inf;
        visited[i] = false;
        for(int j=1; j<=Size; j++)
            mat[i][j] = (i==j)?0:inf;
    }
}

void Dijkstra(int Size,int start)
{
    memset(visited,false,sizeof(visited));
    int now = start;
    dist[now] = 0;
    visited[now] = true;
    for(int i=1; i<Size; i++)
    {
        for(int k=1; k<=Size; k++)
            if( mat[now][k] != inf && dist[now] + mat[now][k] < dist[k] )
                dist[k] = dist[now] + mat[now][k];
        int minn = inf;
        for(int k=1; k<=Size; k++)
            if( dist[k] < minn && !visited[k] )
                minn = dist[now = k];
        visited[now] = true;
    }
}

int main()
{
    //freopen("in.txt","r",stdin);
    int n,sta;
    while(scanf("%d",&n),n)
    {
        init(n);  //初始化数组元素
        int m;
        int to,len;
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&m);
            for(int j=1; j<=m; j++)
            {
                scanf("%d%d",&to,&len);
                    mat[i][to]=len;
            }
        }
        int cnt=0;
        Ans over[maxn];             //创建时调用构造函数Ans()，默认time赋值为无穷小
        for(int i=1; i<=n; i++)     //遍历所有节点
        {
            sta = i;                //以不同节点为起点
            for(int j=1; j<=n; j++)
                dist[j] = inf;       //对于每次不同的起点，在Dijkstra()运行之前要初始化dist[]数组
            Dijkstra(n,sta);
            for(int j=1;j<=n;j++)
            {
                if(dist[j]==inf) goto nex;     //以当前i为起点时，如果还有点不能到达，就不应以它为起点，直接跳过
            }
            for(int j=1;j<=n;j++)
            {
                over[cnt].time=max(over[cnt].time,dist[j]);         //找出以当前i为起点时，所需的最大时间
            }
            over[cnt].ori=i;                //记录起点
            cnt++;
            //printf("%d:\n",i);
            //for(int k=1;k<=n;k++)
            //    printf("%d %d\n",k,dist[k]);
            nex:
                ;
        }
        sort(over,over+cnt,cmp);
        printf("%d %d\n",over[0].ori,over[0].time);
    }
    return 0;
}

弗洛伊德算法：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;

const int maxn=110;
const int inf=0xFFFFFFF;
int mat[maxn][maxn];

bool cmp(int a,int b)
{
    return a>b;
}

void init(int Size)
{
    for(int i=1; i<=Size; i++)
    {
        for(int j=1; j<=Size; j++)
            mat[i][j] = (i==j)?0:inf;
    }
}

int main()
{
    //freopen("in.txt","r",stdin);
    int n;
    while(scanf("%d",&n),n)
    {
        init(n);  //初始化数组元素
        int m;
        int to,len;
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&m);
            for(int j=1; j<=m; j++)
            {
                scanf("%d%d",&to,&len);
                    mat[i][to]=len;
            }
        }
        for(int k=1;k<=n;k++)
            for(int i=1;i<=n;i++)
                for(int j=1;j<=n;j++)
                    mat[i][j]=min(mat[i][j],mat[i][k]+mat[k][j]);
        //经过弗洛伊德算法处理之后，mat[i][j]所存储的值的含义就是i->j的最短路程（时间）
        for(int i=1;i<=n;i++)
            sort(mat[i]+1,mat[i]+n+1,cmp);
        int sta=1;
        for(int i=1;i<=n;i++)
        {
            if(mat[i][1]<mat[1][1])
            {
                mat[1][1]=mat[i][1];
                sta=i;
            }
        }
        printf("%d %d\n",sta,mat[1][1]);
    }
    return 0;
}