C++博客-HooLee-随笔分类-图论

hdu3549--网络流

小鼠标 — Fri, 07 Sep 2012 14:13:00 GMT

摘要: 网络流算法描述如下：
1.利用残留网络寻找增广路
2.将这一条增广路在图中去除，并修改残留网络
3.重复1、2步，直到找不到残留网络阅读全文

小鼠标 2012-09-07 22:13 发表评论

poj1273--网络流

小鼠标 — Fri, 07 Sep 2012 13:29:00 GMT

摘要: 最赤裸的网络流，不断找出增广路增广即可。找增广路时，这里用的深度优先搜索。阅读全文

小鼠标 2012-09-07 21:29 发表评论

hdu3118Arbiter

小鼠标 — Tue, 04 Sep 2012 14:39:00 GMT

http://acm.hdu.edu.cn/showproblem.php?pid=3118
二分图的性质：一个图十二分图，当且仅当图中不存在奇数环。
把点分成两个集合，把每个集合中相连的边删除即可。枚举所有集合，找出删除边最小的那个。

小鼠标 2012-09-04 22:39 发表评论

poj2488--回溯

小鼠标 — Mon, 20 Aug 2012 08:09:00 GMT

摘要: 简单说一下回溯法，回溯跟深度优先遍历是分不开的，我们倾向于把回溯看做深度优先遍历的延伸。我们知道，图的深度优先遍历每个节点只会被访问一次，因为我们一旦走过一个点，我们就会做相应的标记，避免重复经过同一个点。而回溯的做法是，当走过某一个点时，标记走过，并把该点压栈；当该节点出栈时，我们再把它标记为没有走过，这样就能保证另外一条路也能经过该点了阅读全文

小鼠标 2012-08-20 16:09 发表评论

poj2386--图的遍历

小鼠标 — Mon, 20 Aug 2012 04:23:00 GMT

摘要: 图的常见遍历方式有两种：深度优先遍历和广度优先遍历，他们的作用是将图中的每个点都访问一遍，只不过是顺序不同。
如果把图中的每条边长都相等（比如都是1）的话，深度优先遍历的过程是：
1.任意选定一个点p0作为遍历的起点
2.从未访问节点中任选一个距离p0最近的点进行访问，并标记该点被访问过
3.重复第2步，直到该连通分支中的所有节点都被访问过阅读全文

小鼠标 2012-08-20 12:23 发表评论

hdu3342--拓扑排序

小鼠标 — Sat, 18 Aug 2012 09:39:00 GMT

感谢杭电的水题，A水题，涨自信！
题意描述：
给出M组两个人之间的师徒关系，问是否存在悖论，即某个人的徒弟又是自己的师傅。
解题思路：
用拓扑排序判断图中是否存在环路即可。
拓扑排序参阅：http://www.cppblog.com/hoolee/archive/2012/08/16/187400.html
以下是本题代码：

小鼠标 2012-08-18 17:39 发表评论

hdu1285--拓扑排序

小鼠标 — Sat, 18 Aug 2012 09:17:00 GMT

这两天看拓扑排序，A题很不顺利，桑心啊，桑心啊~~
题意描述：
N个人参加比才，给出M组两个队员之间的胜负情况，要求输出总体的比赛名次。如果有多种情况，输出字典序最小的那组结果。
拓扑排序参阅：http://www.cppblog.com/hoolee/archive/2012/08/16/187400.html
以下是本题代码；

小鼠标 2012-08-18 17:17 发表评论

zoj1060，poj1094--拓扑排序

小鼠标 — Thu, 16 Aug 2012 11:19:00 GMT

摘要: 下面我先说以下拓扑排序：
严蔚敏《数据结构》上的定义是：由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。
直观的说偏序指集合中仅有部分成员之间可比较，而全序指集合中全体成员之间均可比较。
拓扑排序的具体做法是：
1.在有向图中选择一个没有前驱（入度为0）的顶点，输出
2.从图中删除该顶点和所有以它为尾的弧，并更新相关点的入度
3.重复1，2步，直到所有顶点都被输出，或者发现图中存在回路。阅读全文

小鼠标 2012-08-16 19:19 发表评论

poj1135--Dijkstra

小鼠标 — Thu, 09 Aug 2012 12:04:00 GMT

题意描述：求出多米诺骨牌中从开始到最后那一块骨牌倒下所花费的时间。
解题思路：先用Dijkstra算法求出每一个关键点倒下时花的时间，然后判断最后一块骨牌倒下的位置，以确定其倒下的时间。我们知道最后一块骨牌要么就是关键点，要么在两个关键点之间。如果是在关键点之间的情况，假设这两个关键点的时间为t1和题t2，两点之间的边长为t3，则最后一块骨牌倒下所花时间为(t1+t2+t3)/2。
以下是本题代码：
（渐渐发现，做题不仅仅是比着书上已有的代码抄一遍那么简单）

小鼠标 2012-08-09 20:04 发表评论

poj3268--Dijkstra

小鼠标 — Thu, 09 Aug 2012 08:18:00 GMT

题意描述：N头牛要从不同的节点赶到一个节点开会，开完会返回原处，所有的道路都是有向路，求出往返花费时间最长的那头牛花费的时间。
看到这题，第一感觉就是对每个节点用一次Dijkstra，1000的数据量，无情的超时了。看网上大神们的代码，发现用两遍Dijkstra就行了，第一遍是求出从目的地X出发，到达其余点的时间，第二遍还是从X出发，不过要把所有边反向使用。把每个节点两次的时间加一起，求出最大的那个即可。
代码如下：

小鼠标 2012-08-09 16:18 发表评论

单源最短路径Dijkstra算法

小鼠标 — Wed, 08 Aug 2012 08:27:00 GMT

摘要: dijkstra算法是解决单源最短路径问题的经典算法，具有O(N^2)的时间复杂度（N为节点个数），这种算法采用的是贪心策略，它与最小生成树的Prim算法极其相似，这两种算法仅仅是cost[]代表的含义不同…… 阅读全文

小鼠标 2012-08-08 16:27 发表评论

poj2253--最短路Dijkstra

小鼠标 — Tue, 07 Aug 2012 15:51:00 GMT

题意描述：
公青蛙a要找到母青蛙b，他要跳过若干块石头到达b处，他并不关心走过总路程的长短，但是希望单次跳动的长度最短。
最短路Dijkstra算法。

小鼠标 2012-08-07 23:51 发表评论

poj2966--最小生成树Prim

小鼠标 — Tue, 07 Aug 2012 03:23:00 GMT

最小生成树，Prim算法。
具体可参阅：http://www.cppblog.com/hoolee/archive/2012/08/06/186482.html
代码如下：

小鼠标 2012-08-07 11:23 发表评论

zoj1372--最小生成树

小鼠标 — Tue, 07 Aug 2012 02:47:00 GMT

最小生成树，Prim算法。
具体可参阅：http://www.cppblog.com/hoolee/archive/2012/08/06/186482.html
代码如下：

小鼠标 2012-08-07 10:47 发表评论

最小生成树Prim算法

小鼠标 — Mon, 06 Aug 2012 09:46:00 GMT

最小生成树有两个经典算法：Prim算法和Kruskal算法，Prim适合于点较少的图，对于一个节点数为N的连通图来说，其时间复杂度为O(N^2)；Kruskal适合于边较少的图，对一个边为E的连通图来说，其时间复杂度为O(ElogE)，因此要根据不同情况选择合适的算法。
这里说一下Prim算法。
Prim的具体步骤为把所有点分为两个部分：属于集合S，或不属于S，当所有点都属于S时，算法结束。
1.初始条件先将第一个点p0划到S中，然后利用p0关联的所有边更新cost[]（sost[i]表示pi与S中点相连的最短的那条边长）
2.每次从sost[]中选出最小的那一个cost[i]（i不能属于S），将i加入到S中，并利用与i相关的边更新cost[]（已加入到S中的点不用再更新）
3.反复执行第二步，直到图连通。（我们知道一个有n个节点的图，最少只需要n-1条边就可以连通了，所以第二步会执行n-1次，每次都会在图中加入一条边）
关于Kruskal请参阅：http://www.cppblog.com/hoolee/archive/2012/08/04/186253.html
下面是zoj1203的Prim算法代码：

小鼠标 2012-08-06 17:46 发表评论

poj2560--最小生成树

小鼠标 — Sat, 04 Aug 2012 08:40:00 GMT

这里不再赘述了，关于最小生成树Kruskal算法可以参阅：http://www.cppblog.com/hoolee/archive/2012/08/04/186253.html
以下是本题代码：

小鼠标 2012-08-04 16:40 发表评论

poj2349--最小生成树

小鼠标 — Sat, 04 Aug 2012 08:21:00 GMT

这两天在做最小生成树，用的一直是Kruskal，不知道用Prim能把代码写的短点儿。。。
这是有些被催的一题，题中两个卫星连接的点之间可以理解为没有长度，偶错误的将卫星个数S理解为没有长度的边的个数，忘记了它们之间是有1之差的。O_O
关于Kruskal，可以先参阅：http://www.cppblog.com/hoolee/archive/2012/08/04/186253.html
以下是本题代码：

小鼠标 2012-08-04 16:21 发表评论

poj1258--最小生成树-Kruskal

小鼠标 — Sat, 04 Aug 2012 06:24:00 GMT

最小生成树有两种算法：Prim和Kruskal，这里说一下Kruskal算法。
其具体算法描述为（我们假设给定的图是连通的）：
1.初始化总花费allcost=0
2.将所有边按边长len从小到大的顺序排序
3.从头到尾依次遍历个边edge[i], 如果该边关联的两个定点不属于同一个集合，则将这两个集合合并，并更新allcost。
Kruskal算法牵涉到集合操作，包括集合的建立和集合的合并，这里用并查集解决，下面简单介绍以下并查集。
并查集用森林来表示，他有以下操作：
初始化：把每个节点所在结合初始化为自身。
查找：查找元素所在的集合，即根节点
合并：将两个在不同集合的元素合并为一个集合，为了保持数的深度的平衡性，在合并之前，应判断两个集合树的深度，如果深度不同，应将深度小的合并到深度大的上面。
关于维持集合树深度的问题，还有另一种做法，就是合并集合的时候并不考虑树的深度，而是在查询的时候改变树的深度。因为没有写过，这里不多说了。
下面是poj1258的代码，最直接的最小生成树。

小鼠标 2012-08-04 14:24 发表评论

poj3984--广度优先搜索

小鼠标 — Thu, 02 Aug 2012 11:51:00 GMT

最直接的广度优先搜索题。求最短路一般用广搜，广搜要用到队列；与广搜对应的是深搜，深搜要用到栈，它能找到所有路，这里不展开说了。刚入门的同学可以先看看队列这种数据结构。
无论广搜还是深搜，走过的节点一定要标记，以免多次走过同一个节点。
以下是本题代码：

小鼠标 2012-08-02 19:51 发表评论

一道广度优先搜索题poj2251

小鼠标 — Tue, 05 Jun 2012 04:55:00 GMT

摘要: http://poj.org/problem?id=2251一道三维的迷宫题，要求求出最短路径。广度优先搜索的框架是很清晰的，就是在code的时候一些细节注意不到，就只好调啊，调啊，就这样两个小时就过去了%>_<%说一下代码思路吧：1.读入数据2.预处理迷宫，主要是给迷宫周围加一道墙，便于统一处理3.找到起点'S'，和终点'E'的坐标分别记录在p0、p1中4.从起点开始进行广搜，直到队... 阅读全文

小鼠标 2012-06-05 12:55 发表评论

zoj3204最小生成树Kruskal

小鼠标 — Thu, 26 Apr 2012 02:01:00 GMT

摘要: http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3204一道很直接的最小生成树，题中给出了权值矩阵，本应给用Prim的，但是为了练习一下并查集的使用，选择了Kruskal。前面我写过Kruskal，但是集合的表示用的是线性表，每次合并都要花费O(N)的时间，效率较低。这次用了并查集——集合的树形表示，... 阅读全文

小鼠标 2012-04-26 10:01 发表评论

zoj1914最小生成树prim

小鼠标 — Wed, 25 Apr 2012 13:58:00 GMT

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=914
最小生成树prim算法。
最近刚学过Dijkstra的最短路算法，仔细分析一下，Dijkstra与Prim算法十分相似，区别在于更新点时的标准不同。前者是该点到起点的距离（用dist[]记录）最小，则将该点加入s，并更新相应的dist[]，后者是该点到s中任意一点的距离（用lowcost[]记录）最小，则将该点加入s，并更新相应的lowcost[]。
说来惭愧，这一题错在了格式上，没有认真读题，多保留了一位小数。
经验总结：认真读题。

小鼠标 2012-04-25 21:58 发表评论

zoj2750--Dijkstra最短路径

小鼠标 — Wed, 25 Apr 2012 10:08:00 GMT

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2750
成语接龙问题，抽象出来就是简单的最简单的单源最短路径问题，Dijkstra算法。
算法设计课上刚讲过贪心算法，Dijkstra算法书上有代码实现，比着书上的代码copy了一遍，提交后居然奇迹般的出现了段错误！这叫我情何以堪啊。FAQ上说段错误有两种情况：数组下标越界和栈溢出。算法中没有递归，不可能爆栈，认真检查每一个用到下标的地方、每个for的起始点，看不出任何毛病。难道代码比着书上抄错了，对照了一下，发现第二个循环开始时没有初始化u，问题就出在这里，u是用来记录下一个可加入集合s的节点的，它的更新来自于所有可利用的dist[]中最下的那个。
经验总结：变量不要忘记初始化。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define LENID 1050
#define RMAX 10000
#define LENS 8
typedef struct
{
    char *a;
    char *b;
    int t;
}Idiom;
int N;
int dist[LENID];
int c[LENID][LENID];
int Dijkstra()
{
    int i, j;
    int s[LENID];

    for(i = 0; i < N; i++)// init
    {
        dist[i] = c[0][i];
        s[i] = 0;
    }
    dist[0] = 0;
    s[0] = 1;

    int u = 0;// remeber to init u!!
    for(i = 0; i < N - 1; i++)
    {
        int temp = RMAX;
        for(j = 0; j < N; j++)
        {
            if(s[j] == 0 && dist[j] < temp)
            {
                u = j;
                temp = dist[j];
            }
        }
        s[u] = 1;
        if(u == N - 1)
        {
            return dist[u];
        }
        for(j = 0; j < N; j++)
        {
            if(s[j] == 0 && c[u][j] < RMAX)
            {
                int newdist = dist[u] + c[u][j];
                if(newdist < dist[j])
                    dist[j] = newdist;
            }
        }
    }
    return dist[N - 1];
}
int main()
{
    int T;
    int i, j;
    Idiom id[LENID];
    char str[100], sa[8], sb[LENS];
    scanf("%d", &N);
    while(N != 0)
    {
        for(i = 0; i < N; i++)
        {
            scanf("%d%s", &T, str);
            int len = strlen(str);
            for(j = 0; j < 4; j++)
            {
                sa[j] = str[j];
                sb[j] = str[len - 4 + j];
            }
            sa[j] = sb[j] = '\0';
            id[i].a = (char *)malloc(sizeof(char) * LENS);
            id[i].b = (char *)malloc(sizeof(char) * LENS);
            strcpy(id[i].a, sa);
            strcpy(id[i].b, sb);
            id[i].t = T;
        }
        for(i = 0; i < N; i++)// init c[][]
            for(j = 0; j < N; j++)
                c[i][j] = RMAX;
        for(i = 0; i < N; i++)
            for(j = i + 1; j < N; j++)
            {
                if(strcmp(id[i].b, id[j].a) == 0)
                    c[i][j] = id[i].t;
                else if(strcmp(id[j].b, id[i].a) == 0)
                    c[j][i] = id[j].t;
            }
        int r = Dijkstra();

        if(r == RMAX)
            printf("-1\n");
        else
            printf("%d\n", r);
        scanf("%d", &N);
    }
}

小鼠标 2012-04-25 18:08 发表评论

poj1751Highways最小生成树

小鼠标 — Thu, 19 Apr 2012 09:28:00 GMT

最小生成树，Kruskal算法。
算法很简单，先把边排序，依次找链接不同集合的最小边，合并集合，当只有一个集合的时候结束。问题在于如何实现集合合并，学长们说合并时用并查集效率较高。我这里用不同的数字代表不同的集合，每次合并都要遍历所有集合，改变集合数字，时间复杂度O(n)。
Ege结构体中刚开始把b、d两个变量定义成了char，数据小的时候没问题，当数据大于127时就会爆掉，纠结了很久。
qsort()函数用法：void qsort(void *base, int nelem, int width, int (*fcmp)(const void *,const void *));
base是数组起始下标；
nelem是元素个数；
width是单个元素的大小；
fcmp是比较函数。

小鼠标 2012-04-19 17:28 发表评论