常用函数模板

字符串

KMP算法

int nextTable[MAXM];
int pattern[MAXM];			// 模式串长度为m
int text[MAXN];				// 匹配串长度为n

void getNextTable(int m) {
    int i = 0, j = -1;
    nextTable[i] = j;
    while(i < m) {
        if(j == -1 || pattern[i] == pattern[j]) {
            i++;
            j++;
            nextTable[i] = j;
        }
        else {
            j = nextTable[j];
        }
    }
}

int KMP(int n, int m) {
    getNextTable(m);		// 初始化nextTable
    int i = 0, j = 0;
    while(i < n && j < m) {
        if(j == -1 || text[i] == pattern[j]) {
            i++;
            j++;
        }
        else {
            j = nextTable[j];
        }
    }
    if(j == m) {
        return i - j + 1;	// 匹配。返回值视题意而定。
    }
    else {
    	return -1; 			// 不匹配
    }
}

图论

并查集

int parent[MAXN]; // 父节点
int height[MAXN]; // 节点高度

void init(int n) {  // 初始化
    for(int i=0; i<=n; i++) {
        parent[i] = i; // 每个节点的父节点为自己
        height[i] = 0; // 每个节点的高度为零
    }
}

int find(int x) {			// 查找根节点
    if(x != parent[x]) {	// 路径压缩
        parent[x] = find(parent[x]);
    }
    return parent[x];
}

void uni(int x, int y) { // 合并集合
    x = find(x);
    y = find(y);
    if(x != y) {		   // 矮树作为高树的子树
        if(parent[x] < parent[y]) {
            parent[x] = y;
        }
        else if(parent[x] > parent[y]) {
            parent[y] = x;
        }
        else {
            parent[y] = x;
            height[x]++;
        }
    }
}

最小生成树

Kruskal

struct Edge {
    int from;	// 边的起点
    int to;		// 边的终点
    int length;	// 边的长度
    bool operator< (const Edge& e) const {
        return length < e.length;
    }
};

Edge edge[MAXN*MAXN];	// 边集
int parent[MAXN];		// 父节点
int height[MAXN];		// 节点高度

void init(int n) {		// 初始化
    for(int i=0; i<=n; i++) {
        parent[i] = i;
        height[i] = 0;
    }
}

int find(int x) {		// 查找根节点
    if(x != parent[x]) {
        parent[x] = find(parent[x]);
    }
    return parent[x];
}

void uni(int x, int y) {// 合并集合
    x = find(x);
    y = find(y);
    if(x != y) {
        if(height[x] < height[y]) {
            parent[x] = y;
        }
        else if(height[x] > height[y]) {
            parent[y] = x;
        }
        else {
            parent[y] = x;
            height[x]++;
        }
    }
}

int Kruskal(int n, int edgeNumber) {
    init(n);
    sort(edge, edge + edgeNumber); // 按权值排序
    int sum = 0;
    for(int i=0; i<edgeNumber; i++) {
        Edge current = edge[i];
        if(Find(curren.from) != Find(current.to)) {
            uni(current.from, current.to);
            sum += current.length;
        }
    }
    return sum;
}

最短路径

Dijkstra

struct Edge {
    int to;		// 终点
    int length; // 长度
    Edge(int t, int l): to(t), length(l) {}
}

struct Point {
    int number;		// 点的编号
    int distance;	// 源点到该点距离
    Point(int n, int d): number(n), distance(d) {}
    bool operator< (const Point& p) const {
        return distance > p.distance; // 距离小的优先级高
    }
}

vector<Edge> graph[MAXN];	// 邻接表实现的图
int dis[MAXN];				// 源点到各点距离，初始化为INF

void Dijkstra(int s) {
    priority_queue<Point> q;
    dis[s] = 0;
    q.push(Point(s, dis[0]));
    while(!q.empty()) { // 最多循环n-1次，每次循环确定一个点的状态，共n-1个点状态待确认
        int u = q.top().number; // 离源点最近的点
        q.pop();
        for(int i=0; i<graph[u].size(); i++) {
            int v = graph[u][i].to;
            int d = graph[u][i].length;
            if(dis[v] > dis[u] + d) {
                dis[v] = dis[u] + d;
                q.push(Point(v, dis[v]));
            }
        }
    }
}

拓扑排序

vector<int> graph[MAXN];
itn inDegree[MAXN];	// 入度

bool TopologicalSort(int n) {
    queue<int> node;
    for(int i=0; i<n; i++) {
        if(inDegree[i] == 0) {
            node.push(i);
        }
    }
    int number = 0;				// 拓扑序列顶点个数
    while(!node.empty()) {
        int u = node.front();
        node.pop();
        number++;				// 拓扑序列顶点加1
        for(int i=0; i<graph[u].size(); i++) {
            int v = graph[u][i];
            inDegree[v]--;		// 后继顶点入度减1
            if(inDegree[v] == 0) {
                node.push(v);
            }
        }
    }
    return n == number;			// 判断能否产生拓扑排序
}

关键路径

struct Edge {
    int to;		// 终点
    int length;	// 距离
    Edge(int t, int l): to(t), length(l) {}
};

vector<Edge> graph[MAXN];
int earliset[MAXN];	// 最早开始时间
int latest[MAXN];	// 最晚开始时间
int inDegree[MAXN];	// 入度

int CriticalPath(int n) {
    vector<int> topology;		// 拓扑序列
    queue<int> node;
    for(int i=0; i<n; i++) {
        if(inDegree[i] == 0) {
            node.push(i);
            earliest[i] = 1;	// 初始化为1
        }
    }
    int totalTime = 0;			// 总耗时
    while(!node.empty()) {
        int u = node.front();
        topology.push_back(u);
        node.pop();
        for(int i=0; i<graph[u].size(); i++) {
            int v = graph[u][i].to;
            int l = graph[u][i].length;
            earliest[v] = max(earliest[v], earliest[u] + l); // 全部先序活动的最晚完成时间
            inDegree[v]--;
            if(inDegree[v] == 0) {
                node.push(v);
                totalTime = max(totalTime, earliest[v] + l);
            }
        }
    }
    for(int i=topology.size()-1; i>=0; i--) {
        int u = topology[i];
        if(graph[u].size() == 0) {
            latest[u] = earliest[u];	// 汇点的最晚开始时间初始化
        } else {
            latest[u] = INF;			// 非汇点的最晚开始时间初始化
        }
        for(int j=0; j<graph[u].size(); j++) {
            int v = graph[u][j].to;
            int l = graph[u][j].length;
            latest[u] = min(latest[u], latest[j] - l); // 全部后序活动的最早开始时间
        }
    }
    return totalTime;
}