算法设计代码

  1. 斐波那契数列

    #include <stdio.h>
    
    double f(int n) {
    	if(n==1||n==2) {
    		return 1;
    	} else {
    		return f(n-1) + f(n-2);
    	}
    }
    
    int main() {
    	int n;
    	double result;
    	scanf("%d",&n);
    	result=f(n);
    	printf("%.0f\n",result);
    	return 0;
    }
  2. N的阶乘

    #include <stdio.h>
    
    int f(int n) {
    	if(n==0||n==1) {
    		return 1;
    	} else {
    		return f(n-1) * n;
    	}
    }
    
    int main() {
    	int n,result;
    	scanf("%d", &n);
    	result=f(n);
    	printf( "%d\n",result);
    	return 0;
    }
  3. 最大公约数

    #include <stdio.h>
    
    int f(int m,int n) {
    	if(m%n==0) {
    		return n;
    	} else {
    		return f(n,m%n);
    	}
    }
    
    int main() {
    	int a,b,result;
    	scanf("%d %d", &a,&b);
    	result=f(a,b);
    	printf("%d\n",result);
    	return 0;
    }
  4. 二分搜索技术

    #include <stdio.h>
    
    int binarySearch(int a[], int x, int left, int right) {
    	int mid;
    	if(left > right) {
    		return -1;
    	} else {
    		mid = (left+right)/2;
    		if(a[mid]==x)return mid;
    		if(x<a[mid])return binarySearch(a,x,left,mid-1);
    		else return binarySearch(a,x,mid+1,right);
    	}
    }
    
    int main() {
    	int a[20],n,x,i,index;
    	scanf("%d", &n);
    	for(i = 0; i < n; i++ ) {
    		scanf("%d", &a[i]);
    	}
    	scanf("%d", &x);
    	index = binarySearch(a, x, 0, n-1);
    	printf("%d\n", index);
    	return 0;
    }
  5.  合并排序
    #include<stdio.h>
    
    void copy(int a[],int b[],int left,int right) {
    	while(left<=right) {
    		a[left]=b[left];
    		left++;
    	}
    }
    
    void merge(int a[],int left,int mid,int right) {
    	int b[10];// 假设最大数组大小为10
    	int i=left;
    	int j=mid+1;
    	int k=left;
    	while(i<=mid && j<=right) {
    		if(a[i]<=a[j]) {
    			b[k] = a[i];
    			i++;
    		} else {
    			b[k] = a[j];
    			j++;
    		}
    		k++;
    	}
    	if(i<=mid)
    		while(i<=mid) {
    			b[k] = a[i];
    			i++;
    			k++;
    		}
    	else if(j<=right)
    		while(j<=right) {
    			b[k] = a[j];
    			j++;
    			k++;
    		}
    	copy(a,b,left,right);
    }
    
    void mergeSort(int a[],int left,int right) {
    	if(left<right) {
    		int mid=(left+right)/2;
    		mergeSort(a,left,mid);
    		mergeSort(a,mid+1,right);
    		merge(a,left,mid,right);
    	}
    }
    
    int main() {
    	int a[10],i,n;
    	scanf("%d",&n);// 输入一个正整数n,表示无序序列中的元素个数
    	for(i=0; i<=n-1; i++)scanf("%d",&a[i]);// 输入n个整数,每两个整数之间用空格隔开
    	mergeSort(a,0,n-1);
    	for(i=0; i<=n-1; i++)
    		if(i<n-1)printf("%d ",a[i]);
    		else printf("%d\n",a[i]);
    	return 0;
    }
  6.  快速排序
    #include <stdio.h>
    
    int partition(int a[], int low, int high) {
    	int i = low;
    	int j = high;
    	int c = a[low]; 
    	while (i<=j) {
    		// 从左到右找到第一个大于基准的元素
    		while(i<=high && a[i]<=c){
    		 	i++;
    		 }
    		// 从右到左找到第一个小于等于基准的元素
    		while(j>=low && a[j]>c){
    			j--;
    		}
    		// 交换 
    		if(i<j){
    			int temp = a[i];
    			a[i] = a[j];
    			a[j] = temp;
    		}
    	}
    	// 交换 
    	a[low] = a[j];
    	a[j] = c;
    	return j; // 注意返回的是j而不是i
    }
    
    void quickSort(int a[], int left, int right) {
    	if(left<right) {
    		int index = partition(a, left, right);
    		quickSort(a, left, index-1);
    		quickSort(a, index+1, right);
    	}
    }
    
    int main() {
    	int a[10],i,n;
    	scanf("%d",&n);// 输入一个整数n,表示无序序列中的元素个数
    	for(i = 0; i < n; i++ ) {
    		scanf("%d",&a[i]);// 输入n个整数,每两个整数之间用空格隔开
    	}
    	quickSort(a, 0, n-1);
    	for (i = 0; i < n; i++) {
    		if(i<n-1) printf("%d ",a[i]);
    		else printf("%d\n",a[i]);
    	}
    	return 0;
    }
  7.  线性时间选择
    #include"stdio.h"
    
    int partition(int a[], int left, int right) {
    	int i=left, j=right;
    	int x=a[left];
    	while(i<=j) {
    		while(a[i]<=x && i<=j) i++;
    		while(a[j]>x && i<=j) j--;
    		if(i<=j) {
    			int t=a[i];
    			a[i]=a[j];
    			a[j]=t;
    			i++;
    			j--;
    		}
    	}
    	a[left]=a[j];
    	a[j]=x;
    	return j;
    }
    
    int select(int a[], int left, int right, int k) {
    	if(left==right) return a[left];
    	else {
    		int j = partition(a,left,right);
    		int length = j-left+1;
    		if(length==k){
    			return a[j];
    		} else if(k<length) {
    			return select(a,left,j-1,k);
    		} else {
    			return select(a,j+1,right,k-length);
    		}
    	}
    }
    
    int main() {
    	int a[100],i,n,k;
    	scanf("%d",&n);// 输入一个整数n,表示线性表的长度
    	for(i=0; i<n; i++) scanf("%d",&a[i]);// 输入n个整数,表示线性表中存储的具体数据
    	scanf("%d",&k);// 输入一个整数k,表示需要查找的第k个小元素
    	int result=select(a,0,n-1,k);
    	printf("%d\n",result);// 输出一个整数,表示第k个小元素的值
    	return 0;
    }
  8.  活动安排问题
    #include <stdio.h>
    
    struct action {
    	int s;// 存储活动开始时间
    	int f;// 存储活动结束时间
    	int id;// 存储活动的编号 
    	int x;// x=1表示选择了该活动,否则表示没有选择该活动 
    };
    
    int fun(struct action a[],int n) {
    	int i,j,sum;
    	j = 1;// j用于跟踪上一个选择的活动
    	a[j].x = 1;// 选择第一个活动
    	sum = 1;// 选择的活动数量
    	for(i=2;i<=n;i++) {
    		// 如果当前活动的开始时间大于等于上一个选择活动的结束时间,则选择该活动
    		if(a[i].s>=a[j].f) {
    			a[i].x = 1;// 选择当前活动
    			j = i;// 更新上一个选择的活动
    			sum++;// 增加选择的活动数量
    		} else {
    			a[i].x = 0;
    		}
    	}
    	return sum;
    }
    
    void sort(struct action a[],int n) {
    	int i,j;
    	for(i=1; i<=n-1; i++) { // 按照活动的结束时间进行升序排序 
    		for(j=1; j<=n-i; j++) {
    			if(a[j].f>a[j+1].f) {
    				struct action t=a[j];
    				a[j]=a[j+1];
    				a[j+1]=t;
    			}
    		}
    	}
    }
    
    int main() {
    	int i,n;
            struct action a[21]; // 0号单元不存储有效数据
    	scanf("%d", &n);// 输入一个整数,表示有n个活动
    	for(i=1; i<=n; i++) {
    		scanf("%d", &a[i].s);// 输入n个整数,分别表示每个活动的开始时间
    	}
    	for(i=1; i<=n; i++) {
    		scanf("%d", &a[i].f);// 输入n个整数,分别表示每个活动的结束时间
    	}
    	for(i=1; i<=n; i++) {
    		a[i].id=i;
    	}
    	sort(a,n);
    	int sum=fun(a,n);
    	printf("%d\n",sum);
    	for(i=1; i<=n; i++) {
    		printf("%d %d\n",a[i].id,a[i].x);
    	}
    	return 0;
    }
  9.  背包问题
    #include <stdio.h>
    
    struct good {
    	int w,v,id;// w,v,id分别表示物品的重量,价值和编号
    	double x;// x在0-1之间取值,表示该物品需要放多少到背包中
    	double ratio;// 单位重量的价值
    };
    
    void f(struct good goods[],int n,int c) {
    	for(int i=1; i<=n; i++) {
    		if(c==0) break;// 如果背包已满,结束循环
    		if(goods[i].w<=c) { // 如果物品可以完全放入背包
    			goods[i].x = 1;
    			c -= goods[i].w;
    		} else {
    			goods[i].x = (double)c / goods[i].w;
    			c = 0;
    		}
    	}
    }
    
    void sort(struct good goods[],int n) {
    	for(int i=1; i<=n-1; i++) { // 冒泡排序(降序)
    		for(int j=1; j<=n-i; j++) {
    			if(goods[j].ratio<goods[j+1].ratio) {
    				struct good temp;
    				temp=goods[j];
    				goods[j]=goods[j+1];
    				goods[j+1]=temp;
    			}
    		}
    	}
    }
    
    int main(void) {
    	int i,n,c;
    	struct good goods[21]; // 0号单元不存储有效数据
    	scanf("%d %d", &n,&c);// 输入物品的个数以及背包的容量n和c
    	for(i=1; i<=n; i++) {
    		scanf("%d", &goods[i].w);
    	}
    	for(i=1; i<=n; i++) {
    		scanf("%d", &goods[i].v);
    	}
    	for(i=1; i<=n; i++) {
    		goods[i].id=i;
    		goods[i].x=0;
    		goods[i].ratio=1.0*goods[i].v/goods[i].w;
    	}
    	sort(goods,n);// 按照单位价值排序
    	f(goods,n,c);
    	for(i=1; i<=n; i++) {
    		printf("%d %.2f\n",goods[i].id,goods[i].x);
    	}
    	return 0;
    }
  10.  0-1背包问题
    #include <stdio.h>
    // 为了方便编写限界函数,假设按照单位重量获利递减输入每个物品的重量和获利。
    
    int w[21]; // 存储物品重量,0号单元不存储有效数据
    int v[21]; // 存储物品价值,0号单元不存储有效数据
    int n;// 存储物品个数
    int c;// 存储背包容量
    int bestx[21]; // 最优解,0号单元不存储有效数据
    int x[21]; // 当前解,0号单元不存储有效数据
    int bestv;// 最优值
    int cv;// 当前已经放到背包中的物品价值
    int cw;// 当前已经放到背包中的物品重量
    
    double bound(int i) { // 计算剩余物品(i:n)的上界
    	int cleft=c-cw;  // 剩余容量
    	int b=0;   // b是一个临时变量
    	while(i<=n && w[i]<=cleft) {
    		cleft-=w[i];
    		b+=v[i];
    		i++;
    	}
    	if (i<=n) {
    		b+=1.0*v[i]/w[i]*cleft;  // 装满背包
    	}
    	return b;
    }
    
    void backtrack(int i) { // 搜索第i层结点
    	if(i>n) { // 到达叶结点考虑结束本次递归
    		if(cv>bestv) {
    			bestv = cv;// 更新最优值
    			for(int j=1;j<=n;j++) {
    				bestx[j] = x[j];
    			}
    		} 
    	} else {
    		if(cw+w[i]<=c) { // 搜索左子树:选择放入背包
    			x[i] = 1;// 选择第i个物品
    			cw += w[i];// 更新当前重量
    			cv += v[i];// 更新当前价值
    			backtrack(i+1);// 递归到下一个物品
    			cw -= w[i];// 撤销当前选择
    			cv -= v[i];// 撤销当前选择
    		}
    		x[i] = 0;
    		if(cv+bound(i+1)>bestv) { // 搜索右子树:不选择放入背包
    			backtrack(i+1); 
    		}
    	}
    }
    
    int main() {
    	scanf("%d %d",&n,&c);// 输入两个整数,分别表示n个物品和背包容量c 
    	for(int i=1; i<=n; i++) {
    		scanf("%d",&w[i]);// 输入n个整数,分别表示每个物品的重量
    	}
    	for(int i=1; i<=n; i++) {
    		scanf("%d",&v[i]);// 输入n个整数,分别表示每个物品的价值
    	}
    	cw=0;
    	cv=0;
    	backtrack(1);
    	printf("%d\n",bestv);// 输出最大价值
    	for(int i=1; i<=n; i++) {
    		printf("%d ",bestx[i]);// 输出最优解 
    	}
    	return 0;
    }
  11.  N皇后问题
    #include <stdio.h>
    #include <math.h>
    
    int x[11];// xi表示第i个皇后存放的列位置(假设第i个皇后放在棋盘中的第i行),0号不存储有效数据
    int sum=0;// 记录当前已找到的可行方案数量,初始化为0
    int n;// 存储皇后的个数
    
    int place(int i) { // 检查第i个皇后的列位置与前i-1个皇后的位列位置是否冲突
    	for(int j=1;j<i;j++) {
    		if(x[j]==x[i]||abs(x[j]-x[i])==abs(j-i)) {
    			return 0;
    		}
    	}
    	return 1;
    }
    
    void backtrack(int i) {
    	if(i>n) {
    		sum++;// 找到一个可行方案
    	} else {
    		for(int j=1;j<=n;j++) { // 尝试将第i个皇后放在第j列
    			x[i] = j;// 放置皇后
    			if(place(i)) {
    				backtrack(i+1);
    			}
    		}
    	}
    }
    
    int main() {
    	scanf("%d",&n);// 输入一个整数表示皇后的个数
    	backtrack(1);// 从第1个皇后开始放置
    	printf("%d\n",sum);// 输出满足条件的不同放法数量
    	return 0;
    }
  12.  着色问题
    #include<stdio.h>
    #include<string.h>
    
    int n;// 图中节点的个数
    int m;// 给定的颜色种类,编号从1到m
    int sum=0;// 保存可以着色的方案数
    int x[11];// xi记录第i个顶点着的颜色编号
    int a[11][11];// 表示图的邻接矩阵
    
    int OK(int i) { // 检验第i个顶点着的颜色是否与前i-1个顶点的着色有冲突
    	for(int j=1;j<i;j++) {
    		if(a[i][j]==1&&x[i]==x[j]) {
    			return 0;
    		}
    	}
    	return 1;
    }
    
    void backtrack(int i) {
    	if(i>n) {
    		sum++;// 找到一种可行的着色方案
    	} else {
    		for(int color=1;color<=m;color++) { // 尝试每种颜色
    			x[i] = color;// 给第i个顶点上色
    			if(OK(i)) {
    				backtrack(i+1);
    			}
    		}
    	}
    }
    
    int main() {
    	int i,j;
    	scanf("%d %d",&n,&m);// 输入两个整数,分别表示图中的顶点数n和给定的颜色数m
    	for(i=1;i<=n;i++){ // 每行输入n个0或1的整数序列(每两个整数之间用一个空格隔开),表示该图对应的邻接矩阵
    		for(j=1;j<=n;j++){
    			scanf("%d",&a[i][j]);
    		}
    	}
    	backtrack(1);
    	printf("%d\n",sum);
    	return 0;
    }
Algorithms   本次README修订为算法仓库Algorithms的第100次commit,首先我们庆祝自2016年8月4日本仓库建立以来Dev-XYS在算法学习方面取得的显著进步!   这里有各种算法的C++代码,任何人可以在自己的任何程序中使用,欢迎大家指出代码中的错误以及有待改进的地方。   本仓库内所有代码的授权方式为Unlicense,大家如果使用我的代码开发自己的软件挣了大钱,或是参考我的代码在NOI中得了金牌,我都会很高兴的。使用这里的代码之后,你可以自主选择是否公开源代码。总而言之,你可以把这里的代码当作你自己写的一样,无论怎样使用都是被允许的。但是,我不对本仓库内代码的正确性负责。大家要是使用我的代码开发软件而导致程序崩溃,或是参考我的代码在考试时出错,请不要向我抱怨。如果你愿意,遇到问题可以在Issues中提出来,我们共同解决。我们不赞成Pull Request,因为本仓库主要储存作者已经学习的算法,全部代码均由作者本人负责维护与更新。   以下索引提供了本仓库内算法的中文名,方便大家查找。更新可能有很长时间的延迟,不保证所有算法的名称都在列表中出现。 Index --------------------------Contents-------------------------- --------------------------FileName-------------------------- AC自动机 Aho-Corasick-Automation 单源最短路径(SPFA) Bellman-Ford(Queue-Optimised) 单源最短路径(Bellman-Ford) Bellman-Ford 使用Edmonds-Karp进行二分图匹配 Bigrpah-Matching(Edmonds-Karp) 普通的二叉搜索树 Binary-Search-Tree 广度优先搜索 Breadth-First-Search 冒泡排序 Bubble-Sort 桶排序 Bucket-Sort 组合数的递推求解 Combination(Recursion) 枚举组合 Combination 基本的复数类 Complex-Number 割点 Cut-Vertex 深度优先搜索 Depth-First-Search 堆优化的Dijkstra算法 Dijkstra(Heap-Optimised) 并查集 Disjoint-Set-Union 最大流Edmonds-Karp算法 Edmonds-Karp 欧拉函数 Euler's-Totient-Function 有向图的欧拉回路 Eulerian-Tour(Digraph) 拓展欧几里得算法 Extended-Euclid 简单的快速幂 Fast-Exponentiation 树状数组 Fenwick-Tree 所有结点对之间的最短路径(Floyd) Floyd-Warshall 凸包算法(Graham扫描法) Graham-Scan 辗转相除法求最大公约数 Greatest-Common-Divisor 堆排序 Heap-Sort ISAP算法 Improved-Shortest-Augmenting-Path(Naive) 插入排序 Insertion-Sort 字符串匹配(KMP) Knuth-Morris-Pratt 最小生成树(Kruskal) Kruskal 最近公共祖先(Tarjan) Least-Common-Ancestor(Tarjan) 使用后缀数组求解最长公共子串 Longest-Common-Substring 最长上升子序列(n·log(n)) Longest-Increasing-Subsequence(n·log(n)) 倍增法求最近公共祖先 Lowest-Common-Ancestor(Doubling) 朴素的矩阵乘法 Matrix-Multiplication(Naive) 归并排序 Merge-Sort 最小堆 Min-Heap 乘法逆元 Modular-Multiplicative-Inverse 仅支持单点修改的可持久化线段树(维护区间和值) Persistent-Segment-Tree(Sum) 试除法素数测试 Prime-Check(Naive) 线性的素数筛法 Prime-Sieve(Linear) 队列的基本操作 Queue 快速排序的优化版本 Quick-Sort(Extra-Optimised) 快速排序的随机化版本 Quick-Sort(Randomized) 快速排序 Quick-Sort 使用向量叉积判断两个有向线段的时针关系 Segment-Direction 线段树维护区间最大值 Segment-Tree(Maximum) 线段树维护区间最小值 Segment-Tree(Minimum) 线段树维护区间和值 Segment-Tree(Sum) 普通的选择算法 Selection Eratosthenes素数筛法 Sieve-of-Erotosthenes 指针版的单向链表 Singly-Linked-List(Pointer) 跳表 Skip-List ST表 Sparse-Table 伸展树 Splay 博弈论SG函数 Sprague-Grundy 栈的基本操作 Stack 递推法求解无符号第一类斯特林数 Stirling-Number(Cycle,Unsigned,Recursion) 递推法求解第二类斯特林数 Stirling-Number(Subset,Recursion) 倍增法求解后缀数组 Suffix-Array(Doubling) 倍增法求解后缀数组(附带Height数组) Suffix-Array-with-Height(Doubling) 使用Tarjan算法求解强连通分量 Tarjan(Strongly-Connected-Components) 数组版的字典树 Trie(Array) 指针版的字典树 Trie(Pointer)
目录 目录 1 Graph 图论 3 | DAG 的深度优先搜索标记 3 | 无向图找桥 3 | 无向图连通度(割) 3 | 最大团问题 DP + DFS 3 | 欧拉路径 O(E) 3 | DIJKSTRA 数组实现 O(N^2) 3 | DIJKSTRA O(E * LOG E) 4 | BELLMANFORD 单源最短路 O(VE) 4 | SPFA(SHORTEST PATH FASTER ALGORITHM) 4 | 第 K 短路(DIJKSTRA) 5 | 第 K 短路(A*) 5 | PRIM 求 MST 6 | 次小生成树 O(V^2) 6 | 最小生成森林问题(K 颗树)O(MLOGM). 6 | 有向图最小树形图 6 | MINIMAL STEINER TREE 6 | TARJAN 强连通分量 7 | 弦图判断 7 | 弦图的 PERFECT ELIMINATION 点排列 7 | 稳定婚姻问题 O(N^2) 7 | 拓扑排序 8 | 无向图连通分支(DFS/BFS 邻接阵) 8 | 有向图强连通分支(DFS/BFS 邻接阵)O(N^2) 8 | 有向图最小点基(邻接阵)O(N^2) 9 | FLOYD 求最小环 9 | 2-SAT 问题 9 Network 网络流 11 | 二分图匹配(匈牙利算法 DFS 实现) 11 | 二分图匹配(匈牙利算法 BFS 实现) 11 | 二分图匹配(HOPCROFT-CARP 的算法) 11 | 二分图最佳匹配(KUHN MUNKRAS 算法 O(M*M*N)) 11 | 无向图最小割 O(N^3) 12 | 有上下界的最小(最大)流 12 | DINIC 最大流 O(V^2 * E) 12 | HLPP 最大流 O(V^3) 13 | 最小费用流 O(V * E * F) 13 | 最小费用流 O(V^2 * F) 14 | 最佳边割集 15 | 最佳点割集 15 | 最小边割集 15 | 最小点割集(点连通度) 16 | 最小路径覆盖 O(N^3) 16 | 最小点集覆盖 16 Structure 数据结构 17 | 求某天是星期几 17 | 左偏树 合并复杂度 O(LOG N) 17 | 树状数组 17 | 二维树状数组 17 | TRIE 树(K 叉) 17 | TRIE 树(左儿子又兄弟) 18 | 后缀数组 O(N * LOG N) 18 | 后缀数组 O(N) 18 | RMQ 离线算法 O(N*LOGN)+O(1) 19 | RMQ(RANGE MINIMUM/MAXIMUM QUERY)-ST 算法 (O(NLOGN + Q)) 19 | RMQ 离线算法 O(N*LOGN)+O(1)求解 LCA 19 | LCA 离线算法 O(E)+O(1) 20 | 带权值的并查集 20 | 快速排序 20 | 2 台机器工作调度 20 | 比较高效的大数 20 | 普通的大数运算 21 | 最长公共递增子序列 O(N^2) 22 | 0-1 分数规划 22 | 最长有序子序列(递增/递减/非递增/非递减) 22 | 最长公共子序列 23 | 最少找硬币问题(贪心策略-深搜实现) 23 | 棋盘分割 23 | 汉诺塔 23 | STL 中的 PRIORITY_QUEUE 24 | 堆栈 24 | 区间最大频率 24 | 取第 K 个元素 25 | 归并排序求逆序数 25 | 逆序数推排列数 25 | 二分查找 25 | 二分查找(大于等于 V 的第一个值) 25 | 所有数位相加 25 Number 数论 26 1 |递推求欧拉函数 PHI(I) 26 |单独求欧拉函数 PHI(X) 26 | GCD 最大公约数 26 | 快速 GCD 26 | 扩展 GCD 26 | 模线性方程 A * X = B (% N) 26 | 模线性方程组 26 | 筛素数 [1..N] 26 | 高效求小范围素数 [1..N] 26 | 随机素数测试(伪素数原理) 26 | 组合数学相关 26 | POLYA 计数 27 | 组合数 C(N, R) 27 | 最大 1 矩阵 27 | 约瑟夫环问题(数学方法) 27 | 约瑟夫环问题(数组模拟) 27 | 取石子游戏 1 27 | 集合划分问题 27 | 大数平方根(字符串数组表示) 28 | 大数取模的二进制方法 28 | 线性方程组 A[][]X[]=B[] 28 | 追赶法解周期性方程 28 | 阶乘最后非零位,复杂度 O(NLOGN) 29 递归方法求解排列组合问题 30 | 类循环排列 30 | 全排列 30 | 不重复排列 30 | 全组合 31 | 不重复组合 31 | 应用 31 模式串匹配问题总结 32 | 字符串 HASH 32 | KMP 匹配算法 O(M+N) 32 | KARP-RABIN 字符串匹配 32 | 基于 KARP-RABIN 的字符块匹配 32 | 函数名: STRSTR 32 | BM 算法的改进的算法 SUNDAY ALGORITHM 32 | 最短公共祖先(两个长字符串) 33 | 最短公共祖先(多个短字符串) 33 Geometry 计算几何 34 | GRAHAM 求凸包 O(N * LOGN) 34 | 判断线段相交 34 | 求多边形重心 34 | 三角形几个重要的点 34 | 平面最近点对 O(N * LOGN) 34 | LIUCTIC 的计算几何库 35 | 求平面上两点之间的距离 35 | (P1-P0)*(P2-P0)的叉积 35 | 确定两条线段是否相交 35 | 判断点 P 是否在线段 L 上 35 | 判断两个点是否相等 35 | 线段相交判断函数 35 | 判断点 Q 是否在多边形内 35 | 计算多边形的面积 35 | 解二次方程 AX^2+BX+C=0 36 | 计算直线的一般式 AX+BY+C=0 36 | 点到直线距离 36 | 直线与圆的交点,已知直线与圆相交 36 | 点是否在射线的正向 36 | 射线与圆的第一个交点 36 | 求点 P1 关于直线 LN 的对称点 P2 36 | 两直线夹角(弧度) 36 ACM/ICPC 竞赛之 STL 37 ACM/ICPC 竞赛之 STL 简介 37 ACM/ICPC 竞赛之 STL--PAIR 37 ACM/ICPC 竞赛之 STL--VECTOR 37 ACM/ICPC 竞赛之 STL--ITERATOR 简介 38 ACM/ICPC 竞赛之 STL--STRING 38 ACM/ICPC 竞赛之 STL--STACK/QUEUE 38 ACM/ICPC 竞赛之 STL--MAP 40 ACM/ICPC 竞赛之 STL--ALGORITHM 40 STL IN ACM 41 头文件 42 线段树 43 求矩形并的面积(线段树+离散化+扫描线) 43 求矩形并的周长(线段树+离散化+扫描线) 44
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值