逐梦者

vector在STL的<vector>头文件中定义了vector（向量容器模版类），vector容器以连续数组的方式存储元素序列，可以将vector看作是以顺序结构实现的线性表。当我们在程序中需要使用动态数组时，vector将会是理想的选择，vector可以在使用过程中动态地增长存储空间。 vector模版类需要两个模版参数，第一个参数是存储元素的数据类型，第二个参数是存储分配器的类型，其中第二个

ACM模版string字符串是程序中经常要表达和处理的数据，我们通常是采用字符数组或字符指针表示字符串。STL为我们提供了另一种使用起来更为便捷的字符串的表达方式：string。string类的定义在头文件<string>中。string类其实可以看作是一个字符的vector，vector上的各种操作都可以适用于string，另外，string类对对象还支持字符串的拼合、转换等操作。 Exampl

ACM模版stack（栈）和queue（队列）是在程序设计中经常会用到的数据容器，STL为我们提供了方便的stack（栈）和queue（队列）的实现。准确的说，STL中的stack和queue不同于vector、list等容器，而是对这些容器进行了重新的包装。这里我们不去深入讨论STL的stack和queue的实现细节，而是来了解一些他们的基本使用。stackstack模版类的定义在<stack>头

ACM模版algorithm<algorithm>无疑是STL中最大的一个头文件,它是由一大堆模板函数组成的。以下列举出<algorithm>中的模版函数： A adjacent_findB binary_searchC copy / copy_backward / count / count_ifE equal / equal_rangeF fill / fill_n

Dijkstra/* * Dijkstra变形，可以证明每个点经过的次数为小于等于K， * 所有Dijkstra的数组dist由一维变为二维，记录经过该点 * 1次、2次......k次的最小值 * 输出dist[n - 1][k]即可 */int g[1010][1010];int n, m, x;const int INF = 0x3f3f3f3f;int vis[1010];

O(V^2)结论次小生成树可由最小生成树转换一条边得到证明T是某一棵最小生成树，T0是任一棵异于T的树，通过变换T0->T1->T2->…->Tn(T)变成最小生成树，所谓的变换是，每次把T_i中的某条边换成T中的一条边，而且树T_(i + 1)的权小于等于T_i的权。 具体操作是： step1. 在T_i中任取一条不在T中的边u_V； step2. 把边u_v去掉，就剩下两个连通分量A和B，

曼哈顿最小生成树POJ 3241 Object Clustering曼哈顿距离 简单说，他指两点之间的横纵坐标的差的绝对值之和。题意 查找平面上的点的曼哈顿距离最小生成树的第n－k小边的长度，点数在100000以内。解析 对于曼哈顿距离的最小生成树，朴素算法需要建立n^(n - 1)条边进行kruskal算法处理，这样子做一定会TLE的。所以需要做特殊的优化，将边数优化为4 *

ACM模版自适应simpson积分const double eps = 1e-6; // 积分精度// 被积函数double F(double x){ double ans; // 被积函数 // ...// ans = x * exp(x); // 椭圆为例 return ans;}// 三点simpson法，这里要求F是

ACM模版多项式求根（牛顿法）/* * 牛顿法解多项式的根 * 输入:多项式系数c[],多项式度数n,求在[a,b]间的根 * 输出:根 要求保证[a,b]间有根 */double fabs(double x){ return (x < 0) ? -x : x;}double f(int m, double c[], double x){ int i;

ACM模版DAG && DFS/* * DAG(有向无环图)的深度优先搜索标记 * INIT:edge[][]邻接矩阵；pre[], post[], tag全置0 * CALL:dfsTag(i, n); pre/post:开始/结束时间 */const int V = 1010;int edge[V][V];int pre[V];int post[V];int tag;void

ACM模版Polya计数/* * c种颜色的珠子，组成长为s的项链，项链没有方向和起始位置 */int gcd(int a, int b){ return b ? gcd(b, a % b) : a;}int main(int argc, const char * argv[]){ int c, s; while (cin >> c >> s) {

ACM模版最大1矩阵const int N = 1000;bool a[N][N];int Run(const int &m, const int &n) // a[1...m][1...n]{ // O(m*n) int i, j, k, l, r, max=0; int col[N];

ACM模版[点连通度与边连通度] 在一个无向连通图中,如果有一个顶点集合,删除这个顶点集合,以及这个集合中所有顶点相关联的边以后,原图变成多个连通块,就称这个点集为割点集合。一个图的点连通度的定义为,最小割点集合中的顶 点数。 类似的,如果有一个边集合,删除这个边集合以后,原图变成多个连通块,就称这个点集为割边集合。一个图的边连通度的定义为,最小割边集合中的边数。[双连通图、割点与桥]

ACM模版无向图找桥/* * 无向图找桥 * INIT: edge[][]邻接矩阵；vis[],pre[],ans[],bridge置0； * CALL: dfs(0, -1, 1, n); */const int V = 1010;int bridge; //桥int edge[V][V];int ans[V];int pre[V];int vis[V];void dfs(int

ACM模版归并排序求逆序数/* * 也可以用树状数组做 * a[0...n-1] cnt=0; call: MergeSort(0, n) */const int N = 1010;int a[N];int c[N];int cnt = 0;void MergeSort(int l, int r){ int mid, i, j, tmp; if (r > l +

ACM模版带权值的并查集/* * INIT: makeset(n); * CALL: findset(x); unin(x, y); */const int N = 1010;struct lset{ int p[N], rank[N], sz; void link(int x, int y) { if (x == y) {

ACM模版快排void ksort(int l, int h, int a[]){ if (h < l + 2) { return ; } int e = h, p = l; while (l < h) { while (++l < e && a[l] <= a[p]); while (--h > p

ACM模版最长公共递增子序列/* * 最长公共递增子序列 O(n^2) * f记录路径,DP记录长度, 用a对b扫描,逐步最优化。 */const int N = 1010;int f[N][N], dp[N];int gcis(int a[], int la, int b[], int lb, int ans[]){ // a[1...la], b[1...lb] in

ACM模版最长公共子序列const int N = 1010;int a[N][N];int LCS(const char *s1, const char *s2){ // s1:0...m, s2:0...n int m = (int)strlen(s1), n = (int)strlen(s2); int i, j; a[0][0] = 0; for (i

ACM模版最少找硬币问题/* * 贪心策略-深度搜索 */int value[7] = {100, 50, 20, 10, 5, 2, 1};int count[7]; // count[i]:value[i]硬币的个数int res[7];bool flag;void DFS(int total, int p);int main(){ int pay = 0;

ACM模版棋盘分割/* * 棋盘分割 * 将一个8*8的棋盘进行如下分割:将原棋盘割下一块矩形棋盘并使剩下部 * 分也是矩形,再将剩下的部分继续如此分割,这样割了(n-1)次后,连同最 * 后剩下的矩形棋盘共有n块矩形棋盘。(每次切割都只能沿着棋盘格子的边 * 进行) 原棋盘上每一格有一个分值,一块矩形棋盘的总分为其所含各格分 * 值之和。现在需要把棋盘按上述规则分割成

ACM模版汉诺塔1,2,…,n表示n个盘子.数字大盘子就大. n个盘子放在第1根柱子上.大盘不能放在小盘上. 在第1根柱子上的盘子是a[1],a[2],…,a[n].a[1]=n,a[2]=n-1,…,a[n]=1. 即a[1]是最下面的盘子.把n个盘子移动到第3根柱子. 每次只能移动1个盘子,且大盘不能放在小盘上.问第m次移动的是哪一个盘子,从哪根柱子移到哪根柱子. 例如:n=3,m=2

ACM模版区间最大频率参考题目链接： POJ 3368 Frequent values/* * 求区间中数出现的最大频率 * 方法一:线段树. * 先离散化。因为序列是升序,所以先将所有值相同的点缩成一点。这样n规模就缩小了。建立一个数据结构 * 记录缩点的属性:在原序列中的值id,和该值有多少个num比如序列 * 10 * -1 -1 1 1 1 1 3 10 10 10

ACM模版堆栈const int MAXSIZE = 10000;int a[MAXSIZE], heapsize;inline void swap(int i, int j){ int temp = a[i]; a[i] = a[j]; a[j] = temp; return ;}inline int Parent(int i){ return i

ACM模版BM算法改进的算法：Sunday AlgorithmBM算法优于KMPSUNDAY 算法描述:字符串查找算法中,最著名的两个是KMP算法(Knuth-Morris-Pratt)和BM算法(Boyer-Moore)。两个算法在最坏情 况下均具有线性的查找时间。但是在实用上,KMP算法并不比最简单的c库函数strstr()快多少,而BM算法则往往比KMP算法快上3-5倍。但是BM算法还

ACM模版Graham/* * Graham 求凸包 O(N * logN) * CALL: nr = graham(pnt, int n, res); res[]为凸包点集; */struct point{ double x, y;};bool mult(point sp, point ep, point op){ return (sp.x - op.x) *

ACM模版无向图连通度（割）/* * INIT: edge[][]邻接矩阵；vis[],pre[],anc[],deg[]置为0； * CALL: dfs(0, -1, 1, n); * k = deg[0], deg[i] + 1(i = 1...n - 1)为删除该节点后得到的连通图个数 * 注意: 0作为根比较特殊 */const int V = 1010;int edge[V][

ACM模版两个长字符串参考题目链接：HDU 1841 Find the Shortest Common Superstring题解将KMP进行略微的改动，依然是查找匹配段，要求要么一个串包含另一个串，要么一个串的前缀等于另一个串的后缀。代码/* * The shortest common superstring of 2 strings S1 and S2 is * a string S

ACM模版求多边形重心/* * 求多边形重心 * INIT: pnt[]已按顺时针(或逆时针)排好序; | CALL: res = bcenter(pnt, n); */struct point{ double x, y;};point bcenter(point pnt[], int n){ point p, s; double tp, area = 0,

ACM模版平面最近点对/* * O(N * logN) */const int N = 100005;const double MAX = 10e100, eps = 0.00001;struct Point{ double x, y; int index;};Point a[N], b[N], c[N];double closest(Point *, Point *,

ACM模版AC自动机参考题目链接HDU 2222 Keywords Search代码/* * 求目标串中出现了几个模式串 */struct Trie{ int next[500010][26], fail[500010], end[500010]; int root, L; int newnode() { for (int i = 0; i

ACM模版后缀自动机const int CHAR = 26;const int MAXN = 250010;struct SAM_Node{ SAM_Node *fa, *next[CHAR]; int len; int id, pos; SAM_Node(){} SAM_Node(int _len) { fa = 0;

ACM模版DP + DFS/* * INIT: g[][]邻接矩阵 * CALL: res = clique(n); */const int V = 10010;int g[V][V];int dp[V];int stk[V][V];int mx;int dfs(int n, int ns, int dep){ if (0 == ns) { if

ACM模版题目链接POJ 2689 Prime Distance题解素数排查问题，问题的关键在于如何找出给定区间中的所有素数，涉及到一个预处理。代码#include <iostream>using namespace std;const int MAXN = 100010;int prime[MAXN + 1];// 预处理void getPrime(){ memset(prime,

ACM模版堆栈实现参考题目链接POJ 3159 Candies代码const int INF = 0x3F3F3F3F;const int V = 30001;const int E = 150001;int pnt[E], cost[E], nxt[E];int e, head[V]; int dist[V]; bool vis[V];int relax(int u, int v, int

ACM模版字符串 HASH/* * 字符串 Hash * 注意：mod选择足够大的质数（至少大于字符串个数） */unsigned int hashA(char *url, int mod){ unsigned int n = 0; char *b = (char *)&n; for (int i = 0; url[i]; i++) { b[i

一种加速输入外挂……空格作为分隔输入,读取一行的整数:gets(buf);int v;char *p = strtok(but, " "); while(p){ sscanf(p, "%d", &v); p = strtok(NULL," "); }当然，还有别的输入外挂。

今天忽然遇见了一行很牛逼的代码：#pragma comment(linker, “/STACK:1024000000,1024000000”) 据说是手动加栈的，作为小白的我自然是只好各种查资料。然后牵扯到了很多基础概念，C、C++、GCC、G++、把我搞得晕头转向，都分不清谁是谁了。 经查阅资料： G++和C++都是C++语言的编译器，二者基本相同。 而GCC和C都是C语言编译器，而这差别

ACM模版莫队算法可以解决一类静态,离线区间查询问题。参考题目链接： BZOJ 2038 [2009国家集训队]小Z的袜子(hose) 题解： 只需要统计区间内各个数出现次数的平方和。莫队算法,两种方法,一种是直接分成sqrt(n)块,分块排序。 另外一种是求得曼哈顿距离最小生成树,根据manhattan MST的dfs序求解。分块const int MAXN = 50010;cons

ACM模版求解平面最远点对参考题目链接： POJ 2187 Beauty Conteststruct Point{ int x, y; Point(int _x = 0, int _y = 0) { x = _x; y = _y; } Point operator - (const Point &b)const {