输入格式 Input Format
第一行是两个整数n，m(1<=n<=200，1<=m<=100000)，分别表示弯道数和直道数。接下来n行，第i行是一个整数ai(1<=ai<=1000)，表示通过第i个弯道所消耗的时间。接下来m行，第j行是三个整数xj，yj，bj(1& lt;=xj，yj<=n，1<=bj<=1000)，表示从弯道xj到弯道yj有一条单向直道，且通过该直道所消耗的时间为bj。

输出格式 Output Format
一个整数s，表示单圈时间最短的赛道的单圈时间，若无解则输出-1。

样例输入 Sample Input
【样例输入1】
3 6
1
1
2
1 2 3
2 3 5
3 1 1
3 2 1
2 1 10
1 3 15

【样例输入2】
3 4
1 1 2
1 2 4
1 3 5
2 3 5
3 2 10

样例输出 Sample Output
【样例输出1】
13

【样例输出2】
-1

时间限制 Time Limitation
各个测试点1s

分析：
删边+dijkstra

【参考程序】：

描述 Description
面对OIBH组织的嚣张气焰, 柯南决定深入牛棚, 一探虚实.他经过深思熟虑, 决定从OIBH组织大门进入...........
OIBH组织的大门有一个很神奇的锁.锁是由M*N个格子组成, 其中某些格子凸起(灰色的格子). 每一次操作可以把某一行或某一列的格子给按下去.

如果柯南能在组织限定的次数内将所有格子都按下去, 那么他就能够进入总部. 但是OIBH组织不是吃素的, 他们的限定次数恰是最少次数.

请您帮助柯南计算出开给定的锁所需的最少次数.

输入格式 Input Format
第一行 两个不超过100的正整数N, M表示矩阵的长和宽
以下N行 每行M个数 非0即1 1为凸起方格

输出格式 Output Format
一个整数 所需最少次数

样例输入 Sample Input
4 4
0000
0101
0000
0100

样例输出 Sample Output
2

时间限制 Time Limitation 
全部1秒

分析：
仔细看题后发现就是求二分图最小覆盖点集，可以用“匈牙利算法”解决，因为二分图最小覆盖点集==最大匹配数.
证明：matrix67博客 http://www.matrix67.com/blog/archives/116

【参考程序】：

描述 Description
给你云朵的个数N，再给你M个关系，表示哪些云朵可以连在一起。
现在小杉要把所有云朵连成K个棉花糖，一个棉花糖最少要用掉一朵云，小杉想知道他怎么连，花费的代价最小。

输入格式 Input Format
每组测试数据的
第一行有三个数N,M,K(1<=N<=1000,1<=M<=10000,1<=K<=10)
接下来M个数每行三个数X,Y,L，表示X云和Y云可以通过L的代价连在一起。(1<=X,Y<=N,0<=L<10000)
30%的数据N<=100,M<=1000

输出格式 Output Format
对每组数据输出一行，仅有一个整数，表示最小的代价。
如果怎么连都连不出K个棉花糖，请输出'No Answer'。

样例输入 Sample Input
3 1 2
1 2 1

样例输出 Sample Output
1

时间限制 Time Limitatio
每个测试点1s
  
注释 Hint  
样例2：
Input:
3 1 1
1 2 1

Output:
No Answer

分析：
这个题其实很简单，就是尽量生成最小生成树（用克鲁斯卡尔算法，PS：传说中的kruskal，先排序，后贪心的算法），有可能图不是连通的，也就是，给的数据是好几个图，这样，我们将要求的最小生成树的个数设为k，我们生成的最小生成树的个数是m，若m=k，则直接输出代价就可以了，如果m>k则说明图的个数比要求的最小生成树个数小，怎么也无法构成k个最小生成树，也就是输出"No Answer"
如果m<k说明，求出的最小生成树个数比要求的最小生成树少，这里，我们可以用剪断枝的方法来将一棵树砍成两棵（PS：刚才是剪，现在怎么砍了？），此时，用贪心将用过的边最长的砍掉，然后，判断砍断后的树的数量是否与要求的数量相同，如果不相同就再砍掉当前的最长边，直到现在树的数目与所求数目相同时就输出，当然，还存在着如果把所有的用到的枝都砍掉还是不能凑够k时再输出"No Answer"

【参考程序】：

描述 Description
小杉家族r个人正在一片空地上散步，突然，外星人来了……留给小杉家族脱逃的时间只有t秒，每个小杉都有一个跑的速度v总共有a个传送点，小杉们必须在t秒内到达传送点才能脱逃另外一个小杉进入一个传送点以后，该传送点就会消失现在请你安排一种方案，使脱逃的小杉尽可能的多

输入格式 Input Format
每组测试数据的
第一行有三个整数r和a和t(0<a,r,t<=1000)
第二行有a对实数，第i对数表示第i个传送点的坐标，这些坐标绝对值均不超过1e6
接下来r行，每行有三个实数x,y,v，表示第i个小杉的坐标和奔跑的速度

输出格式 Output Format
对每组测试数据输出一行
仅有一个整数s表示最多有多少个小杉能成功脱逃

样例输入 Sample Input
1 1 1
1 1
1 1 1

样例输出 Sample Output
1

分析:
其实就是一个"匈牙利算法"(二分图的最大匹配),重点就是在于如何构图，其实也是很简单：对于每个传送点J，如果有第i个小彬的坐标到此点(传送点)的距离(dis)小于等于第i个小彬所走的路程(即：dis<=t*v(第i小彬的速度))则可以连边，这样就可以构造出图来啦. 最后就是用一个朴素的"匈牙利"即可。

【参考程序】：

一年一度的xuzhenyiOI2006在风景如画的大同中学举行。按照以往惯例，在激烈的比赛过程后，选手们会应邀去风景名胜区游览。今年当然也不例外。为了确定一条最佳的旅游路线，组委会请各位选手编一程序帮忙寻找。假设所有的风景点都集中在一个C列R行的矩阵中，矩阵的每一元素代表风景点或者障碍物。现在你要寻找一条满足下列条件的最佳旅游路线：
　　●这条路线上的每一点结点必须是风景点（即不能为障碍物）
　　●每个风景点最多游览一次
　　●这条路线必须是连续的相邻风景点的序列（若风景点A和B分别位于矩阵的位置（a1，a2）及（b1，b2），且|a1-b1|+|a2-b2|=1，则风景点A和B是相邻的）
　　●在满足上述条件下，游览的风景点尽可能多
假设任意的两个风景点都有且仅有一条路径（无回路）相连。显然，任意一个风景点都可以作为游览路线的起点或者终点。

输入格式 Input Format
第一行是两个整数C和R（3≤C，R≤1000），表示矩阵的列数和行数。
接下来有R行，每行有C个字符，每个字符都只能是‘#’或‘．’，‘#’表示障碍物，‘．’表示风景点。行手行末无多余空格。

输出格式 Output Format
只有一行，输出最佳路线的长度。

样例输入 Sample Input
3 3
###
#.#
###

样例输出 Sample Output  
0

分析：
    第一次从任意的一个可行点DFS找到一条最长的路径，再以最后找到的那个点再DFS找最长的一段路径即可。

【参考程序】：

描述 Description
一场洪水即将到来，笨笨要想方设法堵截它！
堵截洪水的唯一办法是在洪水经过河流的岔道口放上石头！（笨笨在将小石头一颗一颗地磊好……囧）
对于不同的岔道口，需要的石头量不同，而笨笨所要消耗的体力也不同。
为了不太累，笨笨决定要用最少的体力来堵截这场洪水，洪水从岔道0出发，笨笨要防止洪水冲到岔道n。 

输入格式 Input Format  
输入有多组，输入第一行为组数（组数小于15）。
每组输入格式如下。
第一行两个数n,m（0<n<=50,0<=m<=200）。
第二行n-1个数，第i个数表示堵截该岔道需要消耗笨笨k[i]的体力。(i=1 to n-1，每个k[i]都是正整数)
接下来m行，每行两个数a,b，表示岔道a和岔道b之间有河道连接。

输出格式 Output Format
对于每一组输入一个输出。
每组输入输出一行，表示笨笨所需要消耗的最小体力。
若洪水不可能冲到岔道n，则输出“Min!”，若洪水无法阻止，则输出“Max!”。

样例输入 Sample Input
1
4 5
2 3 4
0 1
0 3
1 2
2 4
3 4 

样例输出 Sample Output
6

时间限制 Time Limitation
1s
注释 Hint
对样例的解释：

洪水从0出发。
而笨笨要阻止洪水流到n。
耗体力最少的堵截方式就是将岔道1和岔道3堵上即可。
消耗体力最小总和为2+4=6。

【参考程序】：

你要写一个程序计算，根据协议，为了让网络中所有的学校都用上新软件，必须接受新软件副本的最少学校数目（子任务 A）。更进一步，我们想要确定通过给任意一个学校发送新软件，这个软件就会分发到网络中的所有学校。为了完成这个任务，我们可能必须扩展接收学校列表，使其加入新成员。计算最少需要增加几个扩展，使得不论我们给哪个学校发送新软件，它都会到达其余所有的学校（子任务 B）。一个扩展就是在一个学校的接收学校列表中引入一个新成员。

格式
PROGRAM NAME: schlnet
INPUT FORMAT输入文件的第一行包括一个整数 N：网络中的学校数目（2 <= N <= 100）。学校用前 N 个正整数标识。接下来 N 行中每行都表示一个接收学校列表（分发列表）。第 i+1 行包括学校 i 的接收学校的标识符。每个列表用 0 结束。空列表只用一个 0 表示。

OUTPUT FORMAT
你的程序应该在输出文件中输出两行。第一行应该包括一个正整数：子任务 A 的解。第二行应该包括子任务 B 的解。

SAMPLE INPUT (file schlnet.in)
5
2 4 3 0
4 5 0
0
0
1 0

SAMPLE OUTPUT (file schlnet.out)
1
2

分析：(转byvoid)

  这是一道收缩强连通分量的题。

该题描述的是一个有向图。我们都知道，在一个有向图强连通分量中从任意一个顶点开始，可以到达强连通分量的每个顶点。由此可以把该题中所有强连通分量收缩成分别一个顶点，则入度为0的顶点就是最少要接受新软件副本的学校。

第二问就是，问至少添加多少条边，才能使原图强连通。也就问在收缩后的图至少添加多少条边，才能使之强连通。

可以知道，当存在一个顶点入度为0或者出度为0的时候，该图一定不是强连通的。为了使添加的边最少，则应该把入度为0顶点和出度为0的顶点每个顶点添加1条边，使图中不存在入度为0顶点和出度为0的顶点。

当入度为0的顶点多于出度为0的顶点，则应添加的边数应为入度为0的顶点的个数。当出度为0的顶点多于出入度为0的顶点，则应添加的边数应为出度为0的顶点的个数。

这样就可以解决问题了。但是不要忘了还有特殊的情况，当原图本身就是强连通分量时，收缩成一个顶点，该顶点入度和出度都为0，但第一问应为1，第二问应为0。

求强连通分量，我用的两遍深搜的Kosaraju算法，时间复杂度为O(n)。把找到的每个强连通分量收缩为一的顶点，组成新图。设r(x)为x所在的强连同分量的代表节点，如果原图中存在边e(x,y)，那么新图中有边e(r(x),r(y)) 。然后根据点的邻接关系统计出度和入度即可。

【参考程序】：

{批注：先前不知是哪个写了一个要不得的翻译，这才是正常的翻译，读起来也觉得比较健康——Cow-Tsc} {修改下，更现实——pyh119}

格式
PROGRAM NAME: milk6
INPUT FORMAT:(file milk6.in)

  第一行: 两个整数N(2<=N<=32)、M(0<=M<=1000), N表示仓库的数目，M表示运输卡车的数量。仓库1代 表发货工厂，仓库N代表有三聚氰胺的牛奶要发往的零售商。 第2..M+1行: 每行3个整数Si,Ei,Ci。其中Si,Ei表示这 辆卡车的出发仓库，目的仓库。Ci(0 <= C i <= 2,000,000) 表示让这辆卡车停止运输的损失。

OUTPUT FORMAT:(file milk6.out)

  第1行两个整数c、t,c表示最小的损失，T表示要停止的最少卡车数。接下来t 行表示你要停止哪几条线路。如果有多种方案使损失最小，输出停止的线路最少的方案。如果仍然还有相同的方案，请选择开始输入顺序最小的。

SAMPLE INPUT
4 5
1 3 100
3 2 50
2 4 60
1 2 40
2 3 80

SAMPLE OUTPUT
60 1
3

分析：
     要用到最小割最大流定理。
 首先求出最大流，那么最小割的容量就是最大流的流量。然后找有没有容量=最小割容量的“桥”（这里的桥就是去掉这条边后，由源点出发无法到达汇点），如果有那么这个桥就是答案。然后对每条容量不大于最小割的边，去掉后求一次最大流（估计这里我的算法太麻烦了）。如果流量的减少量=这条边的容量，那么这条边一定属于最小割。找出这样所有的边后，如果这些边的容量和=最小割容量，那么符合题目条件的最小割已求出。剩下的工作就是搜索了。我用的是枚举每一条满足上述的边。

对于*1001+1的解释：orz P〇〇н
         对于一个网络，已知它的弧的数量不超过1000，那么经过一定的技术处理，直接用基本的网络流算法就能实现了。
         在读入每条弧c[i,j]时，将其容量c[i,j]乘以1001加1存到f[i,j]中，即f[i,j]=c[i,j]*1001+1(这里不考虑两条弧连接相同两个结点的情况)，然后就用朴素的方法在f上求最大流得到maxflow。那么真实的最大流就是maxflow div 1001，元素最少最小割的元素个数就是maxflow mod 1001。为什么呢？我试试看能不能稍微讲清楚一点：
        首先，为什么maxflow div 1001就是原最大流呢？回想一下，每次我们求到一条增广轨后，进行track_back操作时，必然会由已求得的路径上的某条弧的容量，确定这个可行流的流量flow，假设这条弧为<i,j>。那么这条可行流的流量flow1=f[i1,j1]=c[i1,j1]*1001+1。依此类推，会得到flow2=f[i2,j2]=c[i2,j2]*1001+1、flow3=f[i3,j3]=c[i3,j3]*1001+1……最后找到了k条增广轨，得到的最大流maxflow=flow1+flow2+flow3……+flowk=(c[i1,j1]+c[i2,j2]+c[i3,c3]+……+c[ik,jk])*1001+1*k。 （其实，这段叙述很不准确，因为f[i,j]的值在前面找增广轨的过程中，有可能改变，这里只能算是孤立起来辅助理解吧）
        显然，k<=1000，当取maxflow div 1001时，得到的就是最大流，因为k在div过程中必然被忽略
        另一方面，每找到一条增广轨，必然比原有流量*1001多加上一个1（因为flow=f[i,j]=c[i,j]*1001+1，但回过头看看第一行红字，如果两条弧连接了相同两个结点，这里多加的就不是一个1，而是两个1了）。对于每个多加上的1，都是由一条增广轨的某条弧决定的，只要删除这条弧后，这个流就不通了。于是，maxflow mod 1001就是需要删的弧的个数。
       那么为什么这样求到的割集元素最少呢？因为，如果原图存在一个最大流量相等，但割集元素多一个 的情况时，那么在新图中，如果多找了一次增广轨，那么就多加了一个1，会超出已知最大流上限了（不能理解？尽量想象一下嘛，感觉是这样），这样的最大流是求不出来的。求到的自然而然的就是最少的那一个了。

【参考程序】：

图一：有 10 个路口的街道 一个良好的跑道具有如下几个特点：

    * 每一个路口都可以由起点到达。
    * 从任意一个路口都可以到达终点。
    * 终点不通往任何路口。
    * 运动员不必经过所有的路口来完成比赛。有些路口却是选择任意一条路线都必须到达的（称为“不可避免”的）。在上面的例子中，这些路口是 0，3，6，9。对于给出的良好的跑道，你的程序要确定“不可避免”的路口的集合，不包括起点和终点。

假设比赛要分两天进行。为了达到这个目的，原来的跑道必须分为两个跑道，每天使用一个跑道。第一天，起点为路口 0，终点为一个“中间路口”；第二天，起点是那个中间路口，而终点为路口 N。对于给出的良好的跑道，你的程序要确定“中间路口”的集合。如果良好的跑道 C 可以被路口 S 分成两部分，这两部分都是良好的，并且 S 不同于起点也不同于终点，同时被分割的两个部分满足下列条件：（1）它们之间没有共同的街道（2）S 为它们唯一的公共点，并且 S 作为其中一个的终点和另外一个的起点。那么我们称 S 为“中间路口 ”。在例子中只有路口 3 是中间路口。

格式
PROGRAM NAME: race3
INPUT FORMAT:(file race3.in)

输入文件包括一个良好的跑道，最多有 50 个路口，100 条单行道。

一共有 N+2 行，前面 N+1 行中第 i 行表示以编号为(i-1)的路口作为起点的街道，每个数字表示一个终点。行末用 -2 作为结束。最后一行只有一个数字 -1。

OUTPUT FORMAT:(file race3.out)

你的程序要有两行输出：

第一行包括：跑道中“不可避免的”路口的数量，接着是这些路口的序号，序号按照升序排列。

第二行包括：跑道中“中间路口”的数量，接着是这些路口的序号，序号按照升序排列。

SAMPLE INPUT
1 2 -2
3 -2
3 -2
5 4 -2
6 4 -2
6 -2
7 8 -2
9 -2
5 9 -2
-2
-1

SAMPLE OUTPUT
2 3 6
1 3

分析(nocow)：

    1.一道基础的连通分量的图论题。这个题默认了0为起点，N为终点。(如果不放心可以再读入的时候判断起点和终点，即入度为0的点为起点，出度为0的点为终点。)

    2.该题有两问，第一问很简单，可以尝试去掉每一个点，判断从起点到终点是否有通路，如果没有则该点为“必经点”。

    3.第二问重点在于理解题意。首先可以确定第二问的解集是第一问的子集，所以我们可以第一问得出的每个点深搜，记录下可以到达的点。然后去掉该点，从起点深搜。如果不存在两次深搜皆可到达的点，就说明它是分割点。

【参考程序】：

给出奶牛们的爱好的信息，计算最大分配方案。

格式
PROGRAM NAME: stall4
INPUT FORMAT:(file stall4.in)

第一行 两个整数，N (0 <= N <= 200) 和 M (0 <= M <= 200) 。N 是农夫约翰的奶牛数量，M 是新牛棚的牛栏数量。

第二行到第N+1行 一共 N 行，每行对应一只奶牛。第一个数字 (Si) 是这头奶牛愿意在其中产奶的牛栏的数目 (0 <= Si <= M) 。后面的 Si 个数表示这些牛栏的编号。牛栏的编号限定在区间 (1..M) 中，在同一行，一个牛栏不会被列出两次。

OUTPUT FORMAT:(file stall4.out)

只有一行。输出一个整数，表示最多能分配到的牛栏的数量。

SAMPLE INPUT
5 5
2 2 5
3 2 3 4
2 1 5
3 1 2 5
1 2

SAMPLE OUTPUT
4

参考资料：匈牙利算法(by Beyond the Void)

【参考程序】：

格式
PROGRAM NAME: agrinet

INPUT FORMAT:
(file agrinet.in)

第一行： 农场的个数，N（3<=N<=100）。

第二行..结尾: 后来的行包含了一个N*N的矩阵,表示每个农场之间的距离。理论上，他们是N行，每行由N个用空格分隔的数组成，实际上，他们限制在80个字符，因此，某些行会紧接着另一些行。当然，对角线将会是0，因为不会有线路从第i个农场到它本身。

OUTPUT FORMAT:
(file agrinet.out)

只有一个输出，其中包含连接到每个农场的光纤的最小长度。

SAMPLE INPUT
4
0 4 9 21
4 0 8 17
9 8 0 16
21 17 16 0

SAMPLE OUTPUT
28

【参考程序】：

格式
PROGRAM NAME: comehome
INPUT FORMAT
(file comehome.in)

第 1 行: 整数 P(1<= P<=10000),表示连接牧场(谷仓)的道路的数目。

第 2 ..P+1行: 用空格分开的两个字母和一个整数:

被道路连接牧场的标记和道路的长度(1<=长度<=1000)。

SAMPLE OUTPUT
(file comehome.out)

单独的一行包含二个项目: 最先到达谷仓的母牛所在的牧场的标记,和这只母牛走过的路径的长度。

SAMPLE INPUT
5
A d 6
B d 3
C e 9
d Z 8
e Z 3

SAMPLE OUTPUT
B 11

【参考程序】：

John想在农场里添加一条路径(注意，恰好一条)。对这条路径有以下限制：

一个牧场的直径就是牧场中最远的两个牧区的距离(本题中所提到的所有距离指的都是最短的距离)。考虑如下的有5个牧区的牧场，牧区用“*”表示，路径用直线表示。每一个牧区都有自己的坐标：

               15,15   20,15
                 D       E
                 *-------*
                 |     _/|
                 |   _/  |
                 | _/    |
                 |/      |
        *--------*-------*
        A        B       C
        10,10   15,10   20,10

这个牧场的直径大约是12.07106, 最远的两个牧区是A和E，它们之间的最短路径是A-B-E。

这里是另一个牧场：

                             *F 30,15
                        /
                      _/ 
                    _/   
                   /     
                  *------*
                  G      H
                  25,10   30,10

这两个牧场都在John的农场上。John将会在两个牧场中各选一个牧区，然后用一条路径连起来，使得连通后这个新的更大的牧场有最小的直径。

注意，如果两条路径中途相交，我们不认为它们是连通的。只有两条路径在同一个牧区相交，我们才认为它们是连通的。

输入文件包括牧区、它们各自的坐标，还有一个如下的对称邻接矩阵：

　 A  B  C  D  E  F  G  H
A  0  1  0  0  0  0  0  0
B  1  0  1  1  1  0  0  0
C  0  1  0  0  1  0  0  0
D  0  1  0  0  1  0  0  0
E  0  1  1  1  0  0  0  0
F  0  0  0  0  0  0  1  0
G  0  0  0  0  0  1  0  1
H  0  0  0  0  0  0  1  0

输入文件至少包括两个不连通的牧区。
请编程找出一条连接两个不同牧场的路径，使得连上这条路径后，这个更大的新牧场有最小的直径。

格式
PROGRAM NAME: cowtour

INPUT FORMAT:
(file cowtour.in)

第1行: 一个整数N (1 <= N <= 150), 表示牧区数

第2到N+1行: 每行两个整数X,Y (0 <= X ,Y<= 100000), 表示N个牧区的坐标。注意每个 牧区的坐标都是不一样的。

第N+2行到第2*N+1行: 每行包括N个数字(0或1) 表示如上文描述的对称邻接矩阵。

OUTPUT FORMAT:
(file cowtour.out)

只有一行，包括一个实数，表示所求直径。数字保留六位小数。

SAMPLE INPUT
8
10 10
15 10
20 10
15 15
20 15
30 15
25 10
30 10
01000000
10111000
01001000
01001000
01110000
00000010
00000101
00000010

SAMPLE OUTPUT
22.071068

【参考程序】：

output：
输出仅有一个整数，即要破坏这n个城市的连通性，所需要的最小总代价

input：
4
0911
9011
1109
1190

output：
4

思路：
           一看此题便知道是最小割问题，对于最小割问题可以等价于最大流来求解，本人正是运用了最大流来求解的。刚开始做的时后看着哪个 <邻接矩阵>就知道了是无向图，但是网络流是对于有向图而言，但是无向的就把我个搞的有点糊里糊涂，而且再“后悔”哪个步骤那里（c[pre[i]][i]+=minflow;c[i][pre[i]]-=minflow）那里我加了c[i][pre[i]]-=minflow此句话也AC，不加也AC，于是我就反糊涂了，对于有向图而言“后悔”是必定要的，但是无向图是否也有必要了，这个问题打扰了我好久。

请前来浏览者，如果知道无向图是否需要“反悔”这个道理，请告诉我，我什么的谢谢。

【参考程序】：

input：
测试输入包含若干测试用例。每个测试用例的第1行给出两个正整数，分别是节点数N ( 1 < N < 1000 )和边数M；随后的M行对应M条边，每行给出一对正整数，分别是该条边直接连通的两个节点的编号（节点从1到N编号）。当N为0时输入结束

output：
每个测试用例的输出占一行，若欧拉回路存在则输出1，否则输出0

input:
3 3
1 2
1 3
2 3
3 2
1 2
2 3
0

output:
1
0

分析：
   欧拉回路：若存在一条路，经过图中每条边一次且仅一次，且回到原来位置，则称此路为欧拉回路。
存在欧拉回路的条件：图是连通的，且存在0个奇点。

预处理：
首先判断每个点的度数（出度+入度）是否为偶数，如果不是那一定不是欧拉回路，

求法：
1、首先判断这个图是否有欧拉路（每条边走且仅走一遍，不一定回来）。
    即看每个点的度是否为偶数.
2、因为欧拉回路对于每个点都是等效的，所以随便选取一个点，把这点压入Stack,从这个点向外引一条边，到达另一个点，把新点也压入Stack,然后看栈顶元素是否在栈内出现过，如果出现过那么重复元素以上的所有元素都出栈进入Res队列.
3、重复2，直到Stack内没有元素。
4、Res队列即为一个欧拉回路。

【参考程序】：

output:
对每个测试用例，在1行里输出全省畅通需要的最低成本。若统计数据不足以保证畅通，则输出“?”。

input:
3 3
1 2 1
1 3 2
2 3 4
1 3
2 3 2
0 100

output：
3
?

【参考程序】：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct edge
{
    long x,y,c;
};
edge elist[50051];
long n,m,maxn,zu[1101];
int cmp(const void *s,const void *t)
{
    edge i=*(edge *)s,j=*(edge *)t;
    return i.c-j.c;
}
long find(long x)
{
    if (zu[x]!=x) zu[x]=find(zu[x]);
    return zu[x];
}
void kruskal()
{
    long mincost=0,a,b,i,num=0;
    for (i=1;i<=n;i++) zu[i]=i;
    for (i=1;i<=m;i++)
    {
        a=find(elist[i].x);
        b=find(elist[i].y);
        if (a!=b)
        {
            num++;
            mincost+=elist[i].c;
            zu[b]=a;
            if (num==n-1) break;
        }
    }
    if (num!=n-1) printf("?\n");
    else printf("%d\n",mincost);
}
int main()
{
    while (scanf("%ld%ld",&m,&n)!=EOF)
    {
        if (m==0) break;
        if (n==0) break;
        for (int i=1;i<=m;i++)
          scanf("%ld%ld%ld",&elist[i].x,&elist[i].y,&elist[i].c);
        qsort(elist+1,m,sizeof(edge),cmp);
        kruskal();
    }
    return 0;
}

1. Relaxation(松弛操作)：
procedure relax(u,v,w:integer);//多数情况下不需要单独写成procedure。
begin
   if dis[u]+w<dis[v] then
     begin
       dis[v]:=dis[u]+w;
       pre[v]:=u;
     end
end;



2. Dijkstra
1) 适用条件&范围：
a) 单源最短路径(从源点s到其它所有顶点v);
b) 有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图)
c) 所有边权非负(任取(i,j)∈E都有Wij≥0);
2) 算法描述：
a) 初始化：dis[v]=maxint(v∈V,v≠s); dis[s]=0; pre[s]=s; S={s};
b) For i:=1 to n
1.取V-S中的一顶点u使得dis[u]=min{dis[v]|v∈V-S}
2.S=S+{u}
3.For V-S中每个顶点v do Relax(u,v,Wu,v)
c) 算法结束：dis[i]为s到i的最短距离；pre[i]为i的前驱节点
3) 算法优化：
使用二叉堆(Binary Heap)来实现每步的DeleteMin(ExtractMin，即算法步骤b中第1步)操作，算法复杂度从O(V^2)降到O((V+E)㏒V)。推荐对稀疏图使用。
使用Fibonacci Heap(或其他Decrease操作O(1),DeleteMin操作O(logn)的数据结构)可以将复杂度降到O(E+V㏒V)；如果边权值均为不大于C的正整数，则使用Radix Heap可以达到O(E+V㏒C)。但因为它们编程复杂度太高，不推荐在信息学竞赛中使用。


3. Bellman-Ford
1) 适用条件&范围：
a) 单源最短路径(从源点s到其它所有顶点v);
b) 有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图);
c) 边权可正可负(如有负权回路输出错误提示);
d) 差分约束系统;
2) 算法描述：
对每条边进行|V|次Relax操作;
完成后，如果存在(u,v)∈E使得dis[u]+w<dis[v],则存在负权回路;否则dis[v]即为s到v的最短距离,pre[v]为前驱。
3) 算法实现：
For i:=1 to |V| do
For 每条边(u,v)∈E do
        Relax(u,v,w);
For每条边(u,v)∈E do
If dis[u]+w<dis[v] Then Exit(False)

算法时间复杂度O(VE)。因为算法简单，适用范围又广，虽然复杂度稍高，但因为它实践中的效果不错，仍不失为一个很实用的算法。



4. Topological Sort(拓扑排序)
1) 适用条件&范围：
a) AOV网(Activity On Vertex Network);
b) 有向图;
c) 作为某些算法的预处理过程(如DP)
2) 算法描述：
很简单的算法：每次挑选入度为0的顶点输出(不计次序)。
如果最后发现输出的顶点数小于|V|，则表明有回路存在
3) 算法实现：
a) 数据结构： adj:邻接表;有4个域{u,v,w,next}
indgr[i]:顶点i的入度;
stack[]:栈
b) 初始化:top=0 (栈顶指针)
c) 将初始状态所有入度为0的顶点压栈
d) I=0 (计数器)
e) While 栈非空(top>0) do
i. 顶点v出栈；输出v；计数器增1；
ii. For 与v邻接的顶点u do
1. dec(indgr[u]);
2. If indgr[u]=0 then 顶点u入栈
f) EXIT(I=|V|)

简单&高效&实用的算法。上述实现方法复杂度O(V+E)


5. SSSP On DAG
1) 适用条件&范围：
a) DAG(Directed Acyclic Graph,有向无环图);
b) 边权可正可负
2) 算法描述：
a) Toposort;
b) If Toposort=False Then HALT(Not a DAG)
c) For 拓扑序的每个顶点u do
For u的每个邻接点v do
Relax(u,v,w);

算法结束后：如有环则输出错误信息；否则dis[i]为s到i的最短距离，pre[i]为前驱顶点。
3) 算法实现：
基本从略。此算法时间复杂度O(V+E)，时间&编程 复杂度低，如遇到符合条件的题目(DAG)，推荐使用。
还有，此算法的步骤c可以在toposort中实现，这样即减小了此算法复杂度的一个系数。

6. Floyd-Warshall
1) 适用范围：
a) APSP(All Pairs Shortest Paths)
b) 稠密图效果最佳
c) 边权可正可负
2) 算法描述：
a) 初始化：dis[u,v]=w[u,v]
b) For k:=1 to n
For i:=1 to n
For j:=1 to n
If dis[i,j]>dis[i,k]+dis[k,j] Then

Dis[I,j]:=dis[I,k]+dis[k,j];
c) 算法结束：dis即为所有点对的最短路径矩阵
3) 算法小结：
此算法简单有效，由于三重循环结构紧凑，对于稠密图，效率要高于执行|V|次Dijkstra算法。时间复杂度O(n^3)。
考虑下列变形：如(I,j)∈E则dis[I,j]初始为1,else初始为0，这样的Floyd算法最后的最短路径矩阵即成为一个判断I,j是否有通路的矩阵。更简单的，我们可以把dis设成boolean类型，则每次可以用“dis[I,j]:=dis[I,j]or(dis[I,k]and dis[k,j])”来代替算法描述中的蓝色部分，可以更直观地得到I,j的连通情况。
与Dijkstra算法类似地，算法中蓝色的部分可以加上对Pre数组的更新，不再赘述。

7. Prim （Dijksta的推广）
1) 适用范围：
a) MST(Minimum Spanning Tree,最小生成树)
b) 无向图(有向图的是最小树形图)
c) 多用于稠密图
2) 算法描述：
a) 初始化：dis[v]=maxint(v∈V,v≠s); dis[s]=0; pre[s]=s; S={s};tot=0
b) For i:=1 to n
1.取顶点v∈V-S使得W(u,v)=min{W(u,v)|u∈S,v∈V-S,(u,v)∈E}
2.S=S+{v};tot=tot+W(u,v);输出边(u,v)
3.For V-S中每个顶点v do Relax(u,v,Wu,v)
c) 算法结束：tot为MST的总权值

注意：这里的Relax不同于求最短路径时的松弛操作。它的代码如下：
procedure relax(u,v,w:integer);         //松弛操作
begin
   if w<dis[v] then
     begin
       pre[v]:=u;
       dis[v]:=w;
     end;
end;
可以看到，虽然不同，却也十分相似。
3) 算法优化：
使用二叉堆(Binary Heap)来实现每步的DeleteMin(ExtractMin)操作
算法复杂度从O(V^2)降到O((V+E)㏒V)。推荐对稀疏图使用。
使用Fibonacci Heap可以将复杂度降到O(E+V㏒V)，但因为编程复杂度太高，不推荐在信息学竞赛中使用。
（不要问我为什么和Dijkstra一样……观察我的prim和dijkstra程序，会发现基本上只有relax和输出不一样……）

8 Kruskal
1) 适用范围：
a) MST(Minimum Spanning Tree,最小生成树)
b) 无向图(有向图的是最小树形图)
c) 多用于稀疏图
d) 边已经按权值排好序给出
2) 算法描述：
基本思想：每次选不属于同一连通分量(保证无圈)且边权值最小的2个顶点，将边加入MST，并将所在的2个连通分量合并，直到只剩一个连通分量
3) 算法实现：
a) 将边按非降序排列(Quicksort,O(E㏒E))
b) While 合并次数少于|V|-1
i. 取一条边(u,v)(因为已经排序，所以必为最小)
ii. If u,v不属于同一连通分量 then
1) 合并u,v所在的连通分量
2) 输出边(u,v)
3) 合并次数增1；tot=tot+W(u,v)
c) 算法结束：tot为MST的总权值
4) 分析总结：
检查2个顶点是否在同一连通分量可以使用并查集实现(连通分量看作等价类)。
我们可以看到，算法主要耗时在将边排序上。如果边已经按照权值顺序给出，那太棒了……
另外一种可以想到的实现方法为：O(n)时间关于边权建二叉小根堆；每次挑选符合条件的边时使用堆的DelMin操作。这种方法比用Qsort预排序的方法稍微快一些，编程复杂度基本一样。附程序。
另外，如果边权有一定限制，即<=某常数c，则可以使用线性时间排序以获得更好的时间效率。

SPFA算法
求单源最短路的SPFA算法的全称是：Shortest Path Faster Algorithm。
从名字我们就可以看出，这种算法在效率上一定有过人之处。
很多时候，给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。
简洁起见，我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。
我们用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。

定理: 只要最短路径存在，上述SPFA算法必定能求出最小值。
证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。（证毕）

SPFA(G,w,s)
1. INITIALIZE-SINGLE-SOURCE(G,s)
2. INITIALIZE-QUEUE(Q)
3. ENQUEUE(Q,s)
4. While Not EMPTY(Q)
5. Do u<-DLQUEUE(Q)
6. For 每条边(u,v) in E[G]
7. Do tmp<-d[v]
8. Relax(u,v,w)
9. If (d[v] < tmp) and (v不在Q中)
10. ENQUEUE(Q,v)

OUTPUT:
每组输入数据输出一行，代表建桥的最小花费，结果保留一位小数。如果无法实现工程以达到全部畅通，输出”oh!”.

INPUT:
2
2
10 10
20 20
3
1 1
2 2
1000 1000

OUTPUT:
1414.2
oh!

【参考程序】：                     

output：
对于每组输入，输出一行，表示工作人员从商店走到赛场的最短时间  

input：
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0

output：
3
2

【参考程序】：