程序员充电站（itcharge）

运用五种方式来实现图的存储，以适应不同的情况。方式1：邻接矩阵方式2：前向星方式3：邻接表——动态建表方式4：邻接表——vector模拟链表实现方式5：邻接表——链式前向星★

强连通分量：在有向图G中，如果两个顶点vi,vj间（vi>vj）有一条从vi到vj的有向路径，同时还有一条从vj到vi的有向路径，则称两个顶点强连通。如果有向图G的每两个顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量。 把一个图变为一个强连通图需要添加边数：先求出原图的强连通分量，缩点后变为有向无环图，计算新图入度为0的点的个数SumIn和出度为0的点的个数SumOut，

Tree[N] = A[N-2^k+1] + … + A[N] 单点更新，区间求值：树状数组代表区间的和。const int MAXN = 100010;int N,Tree[MAXN];int Lowbit(int i){ return i & (-i);}void Update(int i,int x){ while(i <= N) { Tree

问题描述有N件物品和一个容量为V 的背包。放入第i件物品耗费的空间是C[ i ]，得到的价值是W[ i ]。求解将哪些物品装入背包可使价值总和最大。 基本思路每种物品仅有一件，可以选择放或不放。用子问题定义状态：即F[i，v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：                     F[i，v] = m

摘自http://www.cnblogs.com/kuangbin/archive/2012/10/05/2712429.html 现有一个由N个布尔值组成的序列A，给出一些限制关系，比如A[x] && A[y] = 0、A[x] || A[y] || A[z]=1等，要确定A[0..N-1]的值，使得其满足所有限制关系。这个称为SAT问题，特别的，若每种限制关系中最多只对两个元素进行限制，则称为

二分图：原图G的顶点可以分类两个集合X和Y，所有的边关联的两个顶点恰好一个属于集合X，另一个属于集合Y，则称该图为二分图。 二分图匹配：给定一个二分图G，在G的一个子图M中，M的边集中的任意两条边都不依附于同一个顶点，即一个顶点最多只有一条边。则称M是一个匹配。 二分图最大匹配：图中包含边数最多的匹配称为图的最大匹配。 二分图完美匹配：如果所有点都在匹配边上，则称这个最大匹配是完美匹配。 二

扩展欧几里得，求一组解x，y，使得gcd(a，b) = d = a * x + b * y扩展欧几里得，求所有解x，y，使得c = a * x + b * y扩展欧几里得，求a关于n的逆元a^-1，使得a * a^-1 ≡ 1(mod n)扩展欧几里得，求解x，满足同余方程组x ≡ Ri(mod Ai)扩展欧几里得，求解x，满足高次同余方程A^x ≡ B(mod C)

EdmondKarp算法：const int MAXN = 220; //最大点个数int Map[MAXN][MAXN],pre[MAXN]; //Pre[]前驱数组int N,NP,NC,M;bool EkBFS(int start,int end) //宽度优先搜索寻找增广路{ queue<int> Q; //宽度优先搜索队列 bool vis[MAX

功能：求a和b的最大公约数传入参数：整数a、整数b传出参数：a和b的最大公约数算法1：欧几里得算法时间复杂度：O(n)实现原理：设两数为a、b(a>b），求a和b最大公约数(a，b）的步骤如下：用b除a，得a÷b=q......r1(0≤r1）。若r1=0，则（a，b)=b；若r1≠0，则再用r1除b，得b÷r1=q......r2 (0≤r2）.若r2=0，则（a，b)=r1，若r2≠0，则继续用r2除r1，……如此下去，直到能整除为止。其最后一个非零除数即为（a，b）。算法2：s

普通素数判断筛法求素数[1，N]二次筛法求素数[L，R]Miller素数测试方法

二分查找：int a[110],N;int BinarySearch(int *a,int x){ int Left = a[1]; int Right = a[N]; while(Left <= Right) { int mid = (Left+Right)>>1; if(a[mid] == x) retu

试除法整数分解 筛法整数分解 PollardRho大整数分解【模板】

普通母函数 1.根据题目要求得到母函数(生成函数) 2.把第一个括号的表达式的系数赋值到c1中。 3.从第二个括号开始计算每一项乘积。 4.迭代得到最终母函数结果。#include<iostream>#include<algorithm>#include<cstdio>#include<cstring>using namespace std;int c1[1100],c2[1100]

容斥原理：在计数时，必须注意无一重复，无一遗漏。为了使重叠部分不被重复计算，人们研究出一种新的计数方法，这种方法的基本思想是：先不考虑重叠的情况，把包含于某内容中的所有对象的数目先计算出来，然后再把计数时重复计算的数目排斥出去，使得计算的结果既无遗漏又无重复，这种计数的方法称为容斥原理。LL Q[100010],factor[110],num;//Q数组存放的就是右边边各项的因子数以及正负情况，f

当字符串匹配失败时，模式串的指针并没有指向0从头比较，而是指向了一个特定的位置，因为这个Next[j]指向的位置pos前长度为Next[pos]的子串，同模式串第j位前的长度为Next[j]的子串是相同的。 即S[0]~S[Next[j]]一定与S[len-1-Next[j]]~S[j-1]匹配。 1.既能做前缀又能做后缀的子串长度 ans[0] = len; int id

char str[1000010],pat[1000010];//pat为模式串，str为主串int Next[1000010]; //Next[x]下标x表示匹配失败处字符下标//模式串pat的前缀与x位置的后缀的最大匹配字符个数-1void GetNext(char *pat){ int LenPat = strlen(pat); int i = 0,j = -1;

差分约束系统：如果一个系统由n个变量和m个约束条件组成，其中每个约束条件形如 xj - xi例如如下的约束条件： X1 - X2 X2 - X5 X4 - X1 X5 - X3 全都是两个未知数的差小于等于某个常数（大于等于也可以，因为左右乘以-1就可以化成小于等于）。这样的不等式组就称作差分约束系统。 差分约束系统求解过程： 1.新建一个图，N个变量看作N个顶点，M个约束条件作为

问题描述有N件物品和一个容量为V 的背包。放入第i件物品耗费的空间是Ci，得到的价值是Wi。求解将哪些物品装入背包可使价值总和最大。基本思路每种物品仅有一件，可以选择放或不放。用子问题定义状态：即F[i; v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：F[i，v] = max { F[i-1，v]，F[i-1，v-Ci] + Wi}

最小支配集：指从所有顶点中取尽量少的点组成一个集合，使得剩下的所有点都与取出来的点有边相连。顶点个数最小的支配集被称为最小支配集。最小点覆盖：指从所有顶点中取尽量少的点组成一个集合，使得集合中所有的边都与取出来的点有边相连。顶点个数最小的覆盖集被称为最小点覆盖。最大独立集：指从所有顶点中取尽量多的点组成一个集合，使得这些点之间没有边相连。顶点个数最多的独立集被称为最大独立集。

直接欧拉函数int Euler(int n) { int ret = n; for(int i = 2; i*i <= n; ++i) { if(n % i == 0) { n /= i; ret = ret - ret/i; }

LL QuickMod(LL a,LL b,LL m) //a^b % m{ LL ans = 1%m; a %= m; while(b > 0) { if(b&1) ans = ans*a%m; a = a*a%m; b >>= 1; } return ans;}

const int MAXN = 110;struct Matrax{ int m[MAXN][MAXN];}a,per;int N,M;void Init(){ for(int i = 0; i < N; ++i) for(int j = 0; j < N; ++j) { scanf("%d",&a.m[i]

最长递增子序列最大连续子序列和最大连续子矩阵和最大M个连续子段的和最大不连续子序列和最长公共子序列最长回文子序列最长回文子串最小编辑距离01背包完全背包多重背包二维费用背包切割钢条最大矩形问题

拓扑排序【模板】1.普通判断拓扑排序、输出路径：queue<int> Q 2.满足字典序的拓扑排序：priority_queue<int,vector<int>, greater<int> > Q; 保证了权值小的优先级高，取出的时候保证序号是队列中最小的。 3.满足最小的尽量在前面(不保证是字典序)：priority_queue<int> Q;反向建图，用优先队列存储将入度为0的点，再遍

Kruskal算法struct Edge { int from; int to; int w; }; Edge Edges[200200]; int father[200200],N,M; int find(int x) { if(x != father[x]) father[x] = find(father[x]

给一个图，判断图的最小生成树是否唯一。 End[]记录邻接表尾节点的位置。MST表示最小生成树的大小，SecMST表示次小生成树的大小。#include<iostream>#include<algorithm>#include<cstdio>#include<cstring>using namespace std;const int MAXN = 1010;const int MAXM

问题描述：给出一个数列，找出其中最长的单调递减（或递增）子序列。例如，{10，22，9，33，21，50，41，60，80}  LIS的长度是6和 LIS为{10，22，33，50，60，80}。最优子结构：对于长度为N的数组A[N] = {a0, a1, a2, …, an-1}，假设假设我们想求以aj结尾的最大递增子序列长度，设为L[j]，那么L[j] = max(L[

Tarjan-LCA算法： 对于每一点u： 1.建立以u为代表元素的集合。 2.遍历与u相连的节点v，如果没有被访问过，对于v使用Tarjan-LCA算法，结束后，将v的集合并入u的集合。 3.对于与节点u相关的询问(u，v)，如果v被访问过，则结果就是v所在集合的所代表的元素。求(u,v)的最近公共祖先节点，则询问时调用QEdges[k].lca = find(QEdges[k].to);

Dijkstra算法： 将所有点分为两个集合。如果源点s到u的最短路径已经确定，点u就属于集合Va，否则属于集合Vb。 1.将源点s到图中各点的直接距离当做初始值记录为s到各点的最短距离，不能到达的记为INF。S到S距离为0。 2.在集合Vb中的点中找一个点u，使得源点s到该点u路径长度最短，将u从Vb中除去，加到V1中。这时候求出了当前S到u的最短路径。 3.把新确定的点u更新s到集合Vb

基于贪心和缩点的思想。 假设根的顶点是V0。 (1)除了根结点外，所有的点Vi，找到以Vi为终点的最短的边，加入集合中 （pre[v]存放的是终点v的起点,In[v]存放终点为v的最短的边） (2)检查集合中有没有有向环和收缩点。若没有有向环和收缩点，结束计算；若没有有向环、但含收缩边，则跳至步骤(4)；若含有有向环，则跳至步骤(3)。Ps：如果出现重边，将忽略权值较高的 (3)含有有向环

//仅适合纯数字输入int Scan()     //输入外挂{    int res=0,ch,flag=0;    if((ch=getchar())=='-')        flag=1;    else if(ch>='0'&&ch        res=ch-'0';    while((ch=getchar())>='0'&&ch        r

Floyd算法：用来找出每对点之间的最短距离。图可以是无向图，也可以是有向图，边权可为正，也可以为负，唯一要求是不能有负环。 1.初始化：将Map[][]中的数据复制到Dist[][]中作为每对顶点之间的最短路径的初值，Pre[i][j] = i 表示 i 到 j 路径中 j 的前一节点。 2. k 从 1 到 N 循环 N 次，每次循环中，枚举图中不同的两点 i，j，如果Dist[i][j]

A*+SPFA算法： (1)将有向图的所有边正向、反向分别存入两个不同的边集(Edges，Edges1)中。用反向边集，以所求终点t为源点，利用SPFA或Dijkstra求解出所有点到t的最短路径，用Dist[i]数组来表示点i到点t的最短距离。 (2)建立一个优先队列，将源点s加入到队列中。 (3)从优先队列中取出最小的点p，如果点p == t，则计算t出队的次数。如果当前路径长度就是s到t

并查集是一种树型的数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。常常在使用中以森林来表示。INPUT第一行：三个整数n,m,p，（n主要操作1.初始化把每个点所在集合初始化为其自身。通常来说，这个步骤在每次使用该数据结构时只需要执行一次，无论何种实现方式，时间复杂度均为O(N)。 for(i=1;i<=N;i++

struct TrieNode{ int Count; struct TrieNode* Next[26];}Tree,*Trie;TrieNode *root;void Create() //初始化{ root = new TrieNode; memset(root->Next,NULL,sizeof(root->Next)); root-