枯荣

USER: Kevin Samuel [kevin_s1]TASK: comehomeLANG: C++Compiling...Compile: OKExecuting... Test 1: TEST OK [0.003 secs, 3376 KB] Test 2: TEST OK [0.005 secs, 3376 KB] Test 3: TEST OK [0.0

用FLOYD求出任意两点最小距离，用Dinic求最大流，用二分法搜索最大距离最小值#include #include #include using namespace std;#define MAX 300#define INF 1000000int dis[MAX][MAX];int map[MAX][MAX];bool sign[MAX][MAX];bool used[

//卧槽这种水题WA的泪流满面//floyd的中转点要放在最上层循环比较好#include #include #include using namespace std;#define MAXN 110int n,m;double dist[MAXN][MAXN];int a,b,p;void Floyd(){ for(int k = 1; k <= n; k

//求从起点到终点最大运输量//运输量取决于单条路径的最大容量//用floyd算法，动规#include #include #include using namespace std;#define MAXN 201#define INF 1000000map city;int weight[MAXN][MAXN];int Edge[MAXN][MAXN];int T;i

题目大意:一个农场有很多昆虫洞和一些路，路是双向连通，昆虫洞是单向连通，经过昆虫洞后时间会倒流，但是走路不会，问john是否可以经过一些路和昆虫洞后回到出发点并且时间早于出发时间，即判断是否存在负回路#include #include #include #include using namespace std;#define MAXN 501#define INF 1000000

//这是一条裸最大流，ford-fulkerson算法#include #include #include using namespace std;const int MAXN = 16;int T;int N,M;int X,Y,C;struct Matrix{ int c,f;};Matrix Edge[MAXN][MAXN];int s,t;int r

【HDU】1532 Drainage Ditches(入门)    [最大流]3549 Flow Problem(入门)    [最大流]3572 Task Schedule(基础)    [最大流]任务分配,判断满流2732 Leapin' Lizards(较难)    [最大流]3338 Kakuro Extension(较难，好题)    [最大流][数和]神奇最大流行进

//求一个回路，从一种货币兑换一圈回到自身，看一路上汇率之积是否大于1//扩展常规的最短路bellman,算到dist(n)，就是算到回路maxdist(k)[v] = max{maxdist(k-1)[v],maxdist(k-1)[u]*C(u,v)}#include #include #include #define maxn 50#define maxm 1000usi

//求所有节点之间的最短路#include #include using namespace std;#define MAXN 21int x,j;int n,a,b;int T;int dist[MAXN][MAXN];void Floyd(){ for(int k = 1; k <= 20; k++) { for(int i = 1; i

//可转换为二分匹配#include #include using namespace std;#define MAXN 122int T;int n,m;int G[MAXN][MAXN];int cx[MAXN],cy[MAXN];int sx[MAXN],sy[MAXN];int path(int u){ sx[u] = 1; for(int v = 1

#include //EK()算法。时间复杂度（VE^2）#include#includeusing namespace std;const int maxn = 100;const int INF = (1<<30)-1;int g[maxn][maxn];int flow[maxn],pre[maxn];bool vis[maxn];int n,m;in

14496k 10297MS C++ 数据量有点吓人,这题15s,真尼马神题构图方法：将两个处理器分别作为源点和汇点。然后将任务作为中间节点。从源点向所有的节点都连一条边，以Ai为权值。然后从所有的节点向汇点连边，以Bi为权值。然后读入M条a,b,w.从a节点向b节点连一条双向边,权值为w。要求消耗最小，就是求中间的边中的割最小，就是求最小割。用了EK算法和Dinic算法全

#include #include #include #include using namespace std;#define MAXN 100#define INF 0x3fffffffstruct edge{ int to,cap,rev;};vector G[MAXN];int level[MAXN];int iter[MAXN];void add

#include#include#includeusing namespace std;const int MAXN=20010;//点数的最大值const int MAXM=880010;//边数的最大值const int INF=0x7fffffff;struct Node{ int from,to,next; int cap;}edge[MAXM];

//男生和女生匹配//匈牙利算法#include #include using namespace std;#define MAXN 510int mk[MAXN];int n;int G[MAXN][MAXN];int cx[MAXN],cy[MAXN];int nx,ny;int ans;int path(int u){ for(int v = 0; v

//把小行星的x和y坐标匹配#include #include using namespace std;#define MAXN 501int N,K;int G[MAXN][MAXN];int cx[MAXN],cy[MAXN];int sx[MAXN],sy[MAXN];int path(int u){ sx[u] = 1; for(int v = 1; v <

//匈牙利算法//将机器A上的任务和机器B上的进行匹配//最大匹配即为问题的解#include #include #define MAXN 110using namespace std;int nx,ny;int G[MAXN][MAXN];int cx[MAXN],cy[MAXN];int mk[MAXN];int ans;int path(int u){ f

//这题很简单//最小生成树用prim//就是求生成树边长之和#include #include #define MAXN 101#define INF 100001using namespace std;int N;int Edge[MAXN][MAXN];int lowcost[MAXN];int sumlen;void prim(){ lowcost[0]

//就是求最小生成树//保证所有前哨之间能直接或间接相连就是最小生成树//由于有S个卫星，则将S个卫星应用于路径最长的S-1条路//那么就要求生成树所有边的去掉最长的S-1条边后的最大边的长度//即从生成树边中去掉最长的s-1条，然后剩余的最大边就是结果//我在fedora下用g++编译，之前把dis函数写成distance报了一堆错，原因是g++库里面 也有个//distance,真坑

//编码类型可以从一种派生出另一种，那么把美种编码看成一个顶点，每个编码之间都可能存在//继承关系，这个关系相当于一条路径，最优方案就是一条路径连接所有顶点而且路径和最小//那么就是求最小生成树，由于是稠密图，用prim比较好//不知道为什么g++超时然后c++就过了#include #include #include using namespace std;#define INF

使用并查集实现直接以边为目标构建最小生成树，构建时用并查集来考虑是否会形成环路typedef struct{ int begin; int end; int weight;}Edge;先根据边的权值排序，然后从最短边开始构造最小生成树只要会并查集就很简单void MiniSpanTree_Kruskal(MGraph){ int i,n

这是一个按路径长度递增的次序产生最短路径的算法。通过一步步求出它们之间顶点的最短路径，过程中都是基于已经求出的最短路径的基础上，求出更远点的最短路径。#define MAXVEX 9#define INFINITY 65535typedef int Pathmatrix[MAXVEX];//用于储存最短路径下标的数组typedef int ShortPathTable[MAXVEX]

DFS框架：          vector  G[maxn];     int vis[maxn];          void dfs(int u)     {          vis[u] = 1;          PREVISIT(u);          int d = G[u].size();          for(int  i

1.对原图进行DFS并将出栈顺序进行逆序，得到的顺序就是拓扑顺序 2.将原图每条边进行反向 3.按照1中生成顺序再进行DFS染色染成同色的是一个强连通块 合理性：如果是强连通子图，那么反向没有任何影响，依然是强连通子图。 但如果是单向的边连通，反向后再按原序就无法访问了（因此反向处理是对非强连通块的过滤）/*Kosaraju算法的简单演示，使用邻接矩阵储存图 */

基本思想：先访问顶点后访问与v0邻接的所有顶点v1,v2,v3……，再依次访问v1，v2，v3 的所有邻接的未访问的所有顶点，直到所有顶点被访问。借助队列来实现v0,bool visited[maxn];void BFS(int x){ int queue[maxn]; int iq=0; queue[iq++]=x; int i,k;

基本算法:每一步 总输出当前无前驱(入度=0)的顶点.1.从有向图中选择一个没有前驱(入度=0,起始点)的顶点并输出2.从网中删除这个点,并删除从这个顶点出发的所有有向边.3.重复上述步骤,直到网中不再存在没有前驱的顶点int queue[maxn];int iq=0;for(i=0;i<=n;i++){ if(indegree[

基本思想：访问顶点v0,然后访问v0邻接的未访问过的顶点v1,再从v1出发递归的按照深度优先的方式遍历。当遇到一个所有邻接于它的顶点都被访问过的顶点u时，则回到顶点序列中最后一个拥有未被访问过的相邻节点的顶点W，从W继续出发。最终当任何已被访问过的节点都没有未被访问的节点时，遍历结束。bool visited[maxn]={0};void DFS(int x){ visited[

在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。这一类问题近几年来反复出现在信息学的国际国内赛题中，其特点是看似并不复杂，但数据量极大，若用正常的数据结构来描述的话，往往在空间上过大，计算机无法承受；即使在空间上勉强通过，运行的时间复杂度也极高，根本就不可能在比赛规定的运行时间（

//注意陷阱，还有，尽量不要用memset初始化二维数组#include #include #include using namespace std;#define INFINITY 100000000const int maxn = 210;int N,M;int S,T;int G[maxn][maxn];int Dist[maxn];bool final[maxn];

Floyd算法本质上是一种动态规划先定义两个二维数组D[x][x],P[x][x], D 代表顶点到定点之间最短路径权值和的矩阵，P代表对应顶点最短路径的前驱矩阵。先将D初始化为图的邻接矩阵。其实就是中转点的问题。动归方程：D[v][w] = min{ D[v][w], D[v][k]+D[k][w]};typedef int Pathmtirx[maxv][maxv];typ

//这一题敲完直接AC，吓尿了//kruskal做的，prim也行#include #include #include using namespace std;const int MAXN = 28;const int MAXM = 76;int T;struct edge{ int u,v,w; }edges[MAXM];int Father[MAXN];in

#include #include #include #include #include #include using namespace std;const int MAXN = 1001;const int MAXM = 15001;struct edge{ int u,v,w;}edges[MAXM];int cmp(const void *a,const

//计算几何+最小生成树//注意精度//若两单元园心距离小与半径之和，则距离为0//反之，为距离-半径之和#include #include #include #include using namespace std;const int MAXN = 101;const int MAXM = 500000;int n;int M;double cost;double

#include #include #include using namespace std;int T;int N;typedef struct{ int degree; int index;}vertex;vertex vertexes[11];int G[11][11];bool flag;int cmp(const void *a,const voi

//4000多MS过的，数据应该比较大，还是比较简单的#include #include using namespace std;const int maxn = 1001;int n;float G[maxn][maxn];float Dist[maxn][maxn];int Q;int from,to;int main(){ while(cin>>n)

这题乍一看是个搜索，但是仔细一想用最短路来做更简单啊，图论就是有意思，把每层楼可能到每层楼的路径保存为一个图 1 2 3 4 51 M M M 1 M2 M M M M M 3 M 1 M 1 M 4 M 1 M M M 5 M

第三道最短路题目初始化的失误导致我WA 若干次，粗心啊，我的长处还是在管理啊，写程序和经管方面的能力比起来逊色不少#include #include using namespace std;const int maxn = 1002;#define inf 100000000int T,S,D;int a,b,c;int Dist[maxn];int

一次AC，so easy#include #include using namespace std;const int maxn = 110;const int INFINITY = 99999;int N,M;int G[maxn][maxn];int Dist[maxn];bool final[maxn];void Dijkstra(int v0){ in

有一个经典的七桥问题.是否存在一条路线,可以不重复的走过7座桥.用图论的语言改写后即为.能否从无向图的一个节点出发走出一条道路,每条边恰好经过一次.这样的路线叫做欧拉回路,俗称”一笔画”欧拉回路中进和出是对应的,除起始点外,其它点的进出次数应该相等,换句话说,除起始点外,其它店的度数都为偶数.如果一个无向图是连通的,最多有两个奇点,则一定存在欧拉回路.对于有向图,最多两个点的出度不