ACM_计算几何_源码
美赛 c 常用代码
美赛c 常用代码全文共四篇示例,供读者参考第一篇示例:随着数学建模比赛的不断普及和发展,越来越多的参赛者开始关注美赛(MCM/ICM)比赛。
在进行比赛时,常用代码可以帮助参赛者更高效地完成模型建立和求解的工作。
本文将介绍一些常用的C 语言代码,帮助参赛者在美赛比赛中更加得心应手。
一、文件读写在数学建模比赛中,常常需要读取外部文件中的数据进行建模或者将模型的结果写入到文件中。
以下是常见的文件读写操作代码示例:```c// 文件读取FILE *file;char line[256];file = fopen("input.txt", "r");while (fgets(line, sizeof(line), file)) {// 处理读取的数据fclose(file);二、矩阵运算在数学建模比赛中,经常涉及到矩阵运算,比如矩阵相乘、矩阵转置等。
以下是一些常用的矩阵运算代码示例:```c// 矩阵相乘for (i = 0; i < n; i++) {for (j = 0; j < n; j++) {result[i][j] = 0;for (k = 0; k < n; k++) {result[i][j] += matrix1[i][k] * matrix2[k][j];}}}三、数值计算数学建模比赛中常常需要进行一些数值计算,比如求解方程、优化函数等。
以下是一些常用的数值计算代码示例:// 求解一元方程double a, b, c, x;x = (-b + sqrt(b * b - 4 * a * c)) / (2 * a);// 简单优化double x = 0.0;while (fabs(f(x)) > EPSILON) {x -= f(x) / f_prime(x);}```四、模拟算法在一些建模问题中,需要进行模拟来得出结果。
以下是一些常用的模拟算法代码示例:第二篇示例:美赛c 常用代码美赛(数学建模竞赛)是一个全球性的学科竞赛活动,旨在促进学生对实际问题的解决能力和数学建模能力的提高。
ACM必须掌握的算法
ACM必须的算法1.最短路(Floyd、Dijstra,BellmanFord)2.最小生成树(先写个prim,kruscal要用并查集,不好写)3.大数(高精度)加减乘除4.二分查找. (代码可在五行以内)5.叉乘、判线段相交、然后写个凸包.6.BFS、DFS,同时熟练hash表(要熟,要灵活,代码要简)7.数学上的有:辗转相除(两行内),线段交点、多角形面积公式.8. 调用系统的qsort, 技巧很多,慢慢掌握.9. 任意进制间的转换第二阶段:练习复杂一点,但也较常用的算法。
:1. 二分图匹配(匈牙利),最小路径覆盖2. 网络流,最小费用流。
3. 线段树.4. 并查集。
5. 熟悉动态规划的各个典型:LCS、最长递增子串、三角剖分、记忆化dp6.博弈类算法。
博弈树,二进制法等。
7.最大团,最大独立集。
8.判断点在多边形内。
9. 差分约束系统. 10. 双向广度搜索、A*算法,最小耗散优先.相关的知识图论:路径问题 0/1边权最短路径 BFS 非负边权最短路径(Dijkstra)可以用Dijkstra解决问题的特征负边权最短路径Bellman-Ford Bellman-Ford的Yen-氏优化差分约束系统 Floyd 广义路径问题传递闭包极小极大距离 / 极大极小距离 EulerPath / Tour 圈套圈算法混合图的 Euler Path / TourHamilton Path / Tour 特殊图的Hamilton Path / Tour 构造生成树问题最小生成树第k小生成树最优比率生成树 0/1分数规划度限制生成树连通性问题强大的DFS算法无向图连通性割点割边二连通分支有向图连通性强连通分支 2-SAT最小点基有向无环图拓扑排序有向无环图与动态规划的关系二分图匹配问题一般图问题与二分图问题的转换思路最大匹配有向图的最小路径覆盖0 / 1矩阵的最小覆盖完备匹配最优匹配稳定婚姻网络流问题网络流模型的简单特征和与线性规划的关系最大流最小割定理最大流问题有上下界的最大流问题循环流最小费用最大流 / 最大费用最大流弦图的性质和判定组合数学解决组合数学问题时常用的思想逼近递推 / 动态规划概率问题Polya定理计算几何 / 解析几何计算几何的核心:叉积 / 面积解析几何的主力:复数基本形点直线,线段多边形凸多边形 / 凸包凸包算法的引进,卷包裹法Graham扫描法水平序的引进,共线凸包的补丁完美凸包算法相关判定两直线相交两线段相交点在任意多边形内的判定点在凸多边形内的判定经典问题最小外接圆近似O(n)的最小外接圆算法点集直径旋转卡壳,对踵点多边形的三角剖分数学 / 数论最大公约数Euclid算法扩展的Euclid算法同余方程 / 二元一次不定方程同余方程组线性方程组高斯消元法解mod 2域上的线性方程组整系数方程组的精确解法矩阵行列式的计算利用矩阵乘法快速计算递推关系分数分数树连分数逼近数论计算求N的约数个数求phi(N)求约数和快速数论变换……素数问题概率判素算法概率因子分解数据结构组织结构二叉堆左偏树二项树胜者树跳跃表样式图标斜堆reap统计结构树状数组虚二叉树线段树矩形面积并圆形面积并关系结构Hash表并查集路径压缩思想的应用 STL中的数据结构vectordequeset / map动态规划 / 记忆化搜索动态规划和记忆化搜索在思考方式上的区别最长子序列系列问题最长不下降子序列最长公共子序列最长公共不下降子序列一类NP问题的动态规划解法树型动态规划背包问题动态规划的优化四边形不等式函数的凸凹性状态设计规划方向线性规划常用思想二分最小表示法串KMPTrie结构后缀树/后缀数组 LCA/RMQ有限状态自动机理论排序选择/冒泡快速排序堆排序归并排序基数排序拓扑排序排序网络中级:一.基本算法:(1)C++的标准模版库的应用. (poj3096,poj3007)(2)较为复杂的模拟题的训练(poj3393,poj1472,poj3371,poj1027,poj2706)二.图算法:(1)差分约束系统的建立和求解. (poj1201,poj2983)(2)最小费用最大流(poj2516,poj2516,poj2195)(3)双连通分量(poj2942)(4)强连通分支及其缩点.(poj2186)(5)图的割边和割点(poj3352)(6)最小割模型、网络流规约(poj3308, )三.数据结构.(1)线段树. (poj2528,poj2828,poj2777,poj2886,poj2750)(2)静态二叉检索树. (poj2482,poj2352)(3)树状树组(poj1195,poj3321)(4)RMQ. (poj3264,poj3368)(5)并查集的高级应用. (poj1703,2492)(6)KMP算法. (poj1961,poj2406)四.搜索(1)最优化剪枝和可行性剪枝(2)搜索的技巧和优化 (poj3411,poj1724)(3)记忆化搜索(poj3373,poj1691)五.动态规划(1)较为复杂的动态规划(如动态规划解特别的施行商问题等)(poj1191,poj1054,poj3280,poj2029,poj2948,poj1925,poj3034)(2)记录状态的动态规划. (POJ3254,poj2411,poj1185)(3)树型动态规划(poj2057,poj1947,poj2486,poj3140)六.数学(1)组合数学:1.容斥原理.2.抽屉原理.3.置换群与Polya定理(poj1286,poj2409,poj3270,poj1026).4.递推关系和母函数.(2)数学.1.高斯消元法(poj2947,poj1487,poj2065,poj1166,poj1222)2.概率问题. (poj3071,poj3440)3.GCD、扩展的欧几里德(中国剩余定理) (poj3101)(3)计算方法.1.0/1分数规划. (poj2976)2.三分法求解单峰(单谷)的极值.3.矩阵法(poj3150,poj3422,poj3070)4.迭代逼近(poj3301)(4)随机化算法(poj3318,poj2454)(5)杂题.(poj1870,poj3296,poj3286,poj1095)七.计算几何学.(1)坐标离散化.(2)扫描线算法(例如求矩形的面积和周长并,常和线段树或堆一起使用).(poj1765,poj1177,poj1151,poj3277,po j2280,poj3004)(3)多边形的内核(半平面交)(poj3130,poj3335)(4)几何工具的综合应用.(poj1819,poj1066,poj2043,poj3227,poj2165,poj3429)高级:一.基本算法要求:(1)代码快速写成,精简但不失风格(poj2525,poj1684,poj1421,poj1048,poj2050,poj3306)(2)保证正确性和高效性. poj3434二.图算法:(1)度限制最小生成树和第K最短路. (poj1639)(2)最短路,最小生成树,二分图,最大流问题的相关理论(主要是模型建立和求解)(poj3155,poj2112,poj1966,poj3281,poj1087,poj2289,poj3216,poj2446(3)最优比率生成树. (poj2728)(4)最小树形图(poj3164)(5)次小生成树.(6)无向图、有向图的最小环三.数据结构.(1)trie图的建立和应用. (poj2778)(2)LCA和RMQ问题(LCA(最近公共祖先问题) 有离线算法(并查集+dfs) 和在线算法(RMQ+dfs)).(poj1330)(3)双端队列和它的应用(维护一个单调的队列,常常在动态规划中起到优化状态转移的目的). (poj2823)(4)左偏树(可合并堆).(5)后缀树(非常有用的数据结构,也是赛区考题的热点).(poj3415,poj3294)四.搜索(1)较麻烦的搜索题目训练(poj1069,poj3322,poj1475,poj1924,poj2049,poj3426)(2)广搜的状态优化:利用M进制数存储状态、转化为串用hash表判重、按位压缩存储状态、双向广搜、A*算法.(poj1768,poj1184,poj1872,poj1324,poj2046,poj1482)(3)深搜的优化:尽量用位运算、一定要加剪枝、函数参数尽可能少、层数不易过大、可以考虑双向搜索或者是轮换搜索、IDA*算法. (poj3131,poj2870,poj2286)五.动态规划(1)需要用数据结构优化的动态规划.(poj2754,poj3378,poj3017)(2)四边形不等式理论.(3)较难的状态DP(poj3133)六.数学(1)组合数学.1.MoBius反演(poj2888,poj2154)2.偏序关系理论.(2)博奕论.1.极大极小过程(poj3317,poj1085)2.Nim问题.七.计算几何学.(1)半平面求交(poj3384,poj2540)(2)可视图的建立(poj2966)(3)点集最小圆覆盖.(4)对踵点(poj2079)八.综合题.(poj3109,poj1478,poj1462,poj2729,poj2048,poj333 6,poj3315,poj2148,poj1263)初期:一.基本算法:(1)枚举. (poj1753,poj2965) (2)贪心(poj1328,poj2109,poj2586)(3)递归和分治法. (4)递推.(5)构造法.(poj3295) (6)模拟法.(poj1068,poj2632,poj1573,poj2993,poj2996)二.图算法:(1)图的深度优先遍历和广度优先遍历.(2)最短路径算法(dijkstra,bellman-ford,floyd,heap+dijkstra)(poj1860,poj3259,poj1062,poj2253,poj1125,po j2240)(3)最小生成树算法(prim,kruskal)(poj1789,poj2485,poj1258,poj3026)(4)拓扑排序 (poj1094)(5)二分图的最大匹配 (匈牙利算法) (poj3041,poj3020)(6)最大流的增广路算法(KM算法). (poj1459,poj3436)三.数据结构.(1)串 (poj1035,poj3080,poj1936)(2)排序(快排、归并排(与逆序数有关)、堆排)(poj2388,poj2299)(3)简单并查集的应用.(4)哈希表和二分查找等高效查找法(数的Hash,串的Hash)(poj3349,poj3274,POJ2151,poj1840,poj2002,po j2503)(5)哈夫曼树(poj3253)(6)堆(7)trie树(静态建树、动态建树) (poj2513)四.简单搜索(1)深度优先搜索(poj2488,poj3083,poj3009,poj1321,poj2251)(2)广度优先搜索(poj3278,poj1426,poj3126,poj3087.poj3414)(3)简单搜索技巧和剪枝(poj2531,poj1416,poj2676,1129)五.动态规划(1)背包问题. (poj1837,poj1276)(2)型如下表的简单DP(可参考lrj的书 page149):1.E[j]=opt{D+w(i,j)}(poj3267,poj1836,poj1260,poj2533)2.E[i,j]=opt{D[i-1,j]+xi,D[i,j-1]+yj,D[i-1][j-1 ]+zij} (最长公共子序列)(poj3176,poj1080,poj1159)3.C[i,j]=w[i,j]+opt{C[i,k-1]+C[k,j]}.(最优二分检索树问题)六.数学(1)组合数学:1.加法原理和乘法原理.2.排列组合.3.递推关系.(POJ3252,poj1850,poj1019,poj1942)(2)数论.1.素数与整除问题2.进制位.3.同余模运算.(poj2635, poj3292,poj1845,poj2115)(3)计算方法.1.二分法求解单调函数相关知识.(poj3273,poj3258,poj1905,poj3122)七.计算几何学.(1)几何公式.(2)叉积和点积的运用(如线段相交的判定,点到线段的距离等). (poj2031,poj1039)(3)多边型的简单算法(求面积)和相关判定(点在多边型内,多边型是否相交)(poj1408,poj1584)(4)凸包. (poj2187,poj1113)。
二分法程序实现平面区域计算几何
二分法程序实现平面区域计算几何计算几何是一门研究不同形状的几何图形之间的关系和属性的学科。
而平面区域计算几何则是研究平面上的区域和图形之间的关系和属性的领域。
在平面区域计算几何中,二分法是一种常见且有效的算法,能够在相当快的时间内对平面上的区域和图形进行分析和计算。
下面将介绍如何使用编程语言实现二分法程序,在计算几何问题中应用。
一、二分法算法二分法是一种基于分治思想的高效算法,其核心思想是通过将一个问题拆分为多个子问题,逐步缩小问题规模,最终得到问题的解。
在平面区域计算几何中,二分法通常被用来确定一个区域中特定位置的坐标或特定图形的性质。
下面是二分法的伪代码:```// 求解特定区域中位置的坐标或图形的性质low = 区域左下角坐标high = 区域右上角坐标while low < high:mid = (low + high) / 2if 满足条件1:high = midelse:low = mid + 1// 返回满足条件的坐标或性质return low```在二分法算法中,我们需要定义满足条件1的规则,以便在分治过程中快速定位目标区域。
对于不同问题,这个规则有很大的差异。
二、应用二分法算法解决平面区域计算几何问题使用二分法实现平面区域计算几何,需要先定义问题,然后才能确定条件1和算法规则。
这里我们的例子是一个简单的问题:给定一个二维平面上的矩形区域和一个内部点P,求该点到矩形的距离。
这个问题在计算机图形学和计算几何中是一个经典问题,可以应用于线段和多边形的求解。
二分法的核心是分治,所以我们首先要将问题分解为多个子问题,然后使用递归算法来解决它。
在这个问题中,我们可以使用水平线和垂直线将矩形划分成9个小矩形(包括本身)。
然后对每个小矩形重复这个过程,直到我们找到包含点P的最小矩形。
这个过程可以看做是一个模板,我们可以在这个过程中填充我们自己定义的条件1和算法规则。
代码实现如下:```// 定义一个二维点类class Point {double x;double y;}// 定义一个矩形类class Rect {Point topLeft;Point bottomRight;}// 定义一个函数来计算点到矩形的距离double distanceFromPointToRect(Point p, Rect rect) {// 判断点是否在矩形内if (p.x >= rect.topLeft.x && p.x <= rect.bottomRight.x &&p.y >= rect.topLeft.y && p.y <= rect.bottomRight.y) {return 0;}// 判断点在矩形的上下左右哪个区域double dx = 0.0, dy = 0.0;if (p.x < rect.topLeft.x) {dx = p.x - rect.topLeft.x;} else if (p.x > rect.bottomRight.x) {dx = p.x - rect.bottomRight.x;}if (p.y < rect.topLeft.y) {dy = p.y - rect.topLeft.y;} else if (p.y > rect.bottomRight.y) {dy = p.y - rect.bottomRight.y;}// 如果点在矩形的左上角、右上角、右下角或者左下角,直接返回距离if (dx == 0.0 || dy == 0.0) {return sqrt(dx*dx + dy*dy);}// 查找包含点P的最小子矩形Rect subRect = null;while (true) {// 将当前矩形平分为4个子矩形double midX = (rect.topLeft.x + rect.bottomRight.x) / 2.0;double midY = (rect.topLeft.y + rect.bottomRight.y) / 2.0;Rect[] subRects = {new Rect(rect.topLeft, new Point(midX, midY)),new Rect(new Point(midX, rect.topLeft.y), newPoint(rect.bottomRight.x, midY)),new Rect(new Point(midX, midY), rect.bottomRight),new Rect(new Point(rect.topLeft.x, midY), new Point(midX, rect.bottomRight.y))};// 判断点所在的子矩形if (p.x < midX) {if (p.y < midY) {subRect = subRects[0];} else {subRect = subRects[1];}} else {if (p.y < midY) {subRect = subRects[3];} else {subRect = subRects[2];}}// 如果包含点,则递归实现求解if (p.x >= subRect.topLeft.x && p.x <= subRect.bottomRight.x &&p.y >= subRect.topLeft.y && p.y <= subRect.bottomRight.y) {return distanceFromPointToRect(p, subRect);}// 否则将包含点的子矩形作为下一个矩形继续递归分治rect = subRect;}}```这个算法基于二分法思想,分治过程中计算出点P到矩形最小矩形的距离,最终得出点P到矩形的距离。
ACM必备内容(几乎全)
2 数论........................................................................................................................................... 21
2.1 最大公约数 gcd............................................................................................................21 2.2 最小公倍数 lcm............................................................................................................22
3.1 堆(最小堆)...............................................................................................................31
3.1.1 3.1.2
删除最小值元素:.......................................................................................... 31 插入元素和向上调整:.................................................................................. 32
1.5 拓扑排序.........................................................................................................................7
acm算法源代码
| SPFA(SHORTEST PATH FASTER ALGORITHM) .............. 4 | 第K短路(DIJKSTRA)................................................... 5 | 第K短路(A*) .............................................................. 5 | PRIM求MST ..................................................................... 6 | 次小生成树O(V^2)....................................................... 6 | 最小生成森林问题(K颗树)O(MLOGM). ....................... 6 | 有向图最小树形图 ......................................................... 6
(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
ACM常用算法模板
专用模板目录:一、图论1.最大团2.拓扑排序3.最短路和次短路4.SAP模板5.已知各点度,问能否组成一个简单图6.KRUSKAL7. Prim算法求最小生成树8. Dijkstra9 . Bellman-ford10. SPFA11. Kosaraju 模板12. tarjan 模板二、数学1. 剩余定理2. N!中质因子P的个数3.拓展欧几里得4.三角形的各中心到顶点的距离和5.三角形外接圆半径周长6.归并排序求逆序数7. 求N!的位数8.欧拉函数9. Miller-Rabin,大整数分解,求欧拉函数10. 第一类斯特林数11.计算表达式12.约瑟夫问题13.高斯消元法14. Baby-step,giant-step n是素数.n任意15. a^b%c=a ^(b%eular(c)+eular(c)) % c16.判断第二类斯特林数的奇偶性17.求组合数C(n,r)18.进制转换19.Ronberg算法计算积分20.行列式计算21. 返回x 的二进制表示中从低到高的第i位22.高精度运算 +-*/23.超级素数筛选三、数据结构1.树状数组2.线段树求区间的最大、小值3.线段树求区间和4.单调队列5.KMP模板6. 划分树,求区间第k小数7.最大堆,最小堆模板8. RMQ模板求区间最大、最小值9.快速排序,归并排序求逆序数.10.拓展KMP四、计算几何1.凸包面积2.Pick公式求三角形内部有多少点3.多边形边上内部各多少点以及面积pick4.平面最远点对5.判断矩形是否在矩形内6.判断点是否在多边形内7.判断4个点(三维)是否共面8.凸包周长9.等周定理变形一直两端点和周长求最大面积10.平面最近点对11.单位圆最多覆盖多少点(包括边上)12.多边形费马点求点到多边形各个点的最短距离13.矩形并周长14.zoj 2500 求两球体积并一、图论1.最大团#include<iostream>#include<algorithm>using namespace std;int n,m;int cn;//当前顶点数int best;//当前最大顶点数int vis[50];//当前解int bestn[50];//最优解int map[50][50];//临界表void dfs(int i){if(i>n){for(int j=1;j<=n;j++) bestn[j]=vis[j];best=cn;return ;}int ok=1;for(int j=1;j<i;j++){if(vis[j]==1&&map[i][j]==0){ok=0;break;}}if(ok){//进入左子树vis[i]=1;cn++;dfs(i+1);cn--;}if(cn+n-i>best){//进入右子树vis[i]=0;dfs(i+1);}}int main(){while(scanf("%d%d",&n,&m)==2){memset(vis,0,sizeof(vis));memset(map,0,sizeof(map));while(m--){int p,q;scanf("%d%d",&p,&q);map[p][q]=map[q][p]=1;//无向图}cn=0;best=0;dfs(1);printf("%d\n",best);}return 0;}2.拓扑排序#include<iostream>#include<cstring>using namespace std;int map[105][105],in[105],vis[105],ans[105],n;int flag;void dfs(int step){if(flag) return ;if(step==n+1) {flag=1; printf("%d",ans[1]);for(int i=2;i<=n;i++) printf(" %d",ans[i]);printf("\n");return ;}for(int i=1;i<=n;i++){if(vis[i]==0&&in[i]==0){vis[i]=1;for(int j=1;j<=n;j++){if(map[i][j]>0){map[i][j]=-map[i][j];in[j]--;}}ans[step]=i;dfs(step+1);vis[i]=0;for(int j=1;j<=n;j++){if(map[i][j]<0){map[i][j]=-map[i][j];in[j]++;}}}}}int main(){while(scanf("%d",&n)==1){flag=0;memset(map,0,sizeof(map));memset(vis,0,sizeof(vis));memset(in,0,sizeof(in));for(int i=1;i<=n;i++){int t;while(scanf("%d",&t),t){map[i][t]=1;in[t]++;}}dfs(1);}return 0;}3.最短路和次短路#include<iostream>#include<cstdio>#include<vector>#include<cstring>using namespace std;class Node{public:int e,w;//表示终点和边权};const int inf=(1<<25);int main(){int ci;cin>>ci;while(ci--){vector<Node> G[1005];//用邻接表存边int n,m;cin>>n>>m;for(int i=1;i<=m;i++){Node q;int u;cin>>u>>q.e>>q.w;G[u].push_back(q);}int s,f;//起点和终点cin>>s>>f;//dijkstra 求最短路和次短路int flag[1005][2];int dis[1005][2],cnt[1005][2];//0表示最短路,1表示次短路memset(flag,0,sizeof(flag));for(int i=1;i<=n;i++) dis[i][0]=dis[i][1]=inf;dis[s][0]=0;cnt[s][0]=1;//初始化for(int c=0;c<2*n;c++) //找最短路和次短路,故要进行2*n次循环也可以改成while(1){int temp=inf,u=-1,k;//找s-S'集合中的最短路径,u记录点的序号,k记录是最短路或者是次短路for(int j=1;j<=n;j++){if(flag[j][0]==0&&temp>dis[j][0]) temp=dis[j][0],u=j,k=0;else if(flag[j][1]==0&&temp>dis[j][1]) temp=dis[j][1],u=j,k=1;}if(temp==inf) break;//S'集合为空或者不联通,算法结束//更新路径flag[u][k]=1;for(int l=0;l<G[u].size();l++){int d=dis[u][k]+G[u][l].w,j=G[u][l].e;//important//4种情况if(d<dis[j][0]){dis[j][1]=dis[j][0];cnt[j][1]=cnt[j][0];dis[j][0]=d;cnt[j][0]=cnt[u][k];}else if(d==dis[j][0]){cnt[j][0]+=cnt[u][k];}else if(d<dis[j][1]){dis[j][1]=d;cnt[j][1]=cnt[u][k];}else if(d==dis[j][1]){cnt[j][1]+=cnt[u][k];}}}int num=cnt[f][0];//最短路int cc=cnt[f][1];//次短路}return 0;}4.SAP模板#include<iostream>#include<cstdio>#include<cstring>using namespace std;const int inf=(1<<31)-1;const int point_num=300;int cap[point_num][point_num],dist[point_num],gap[point_num];//初始化见main里面int s0,t0,n;//源,汇和点数int find_path(int p,int limit=0x3f3f3f3f){if(p==t0) return limit;for(int i=0;i<n;i++)if(dist[p]==dist[i]+1 && cap[p][i]>0){int t=find_path(i,min(cap[p][i],limit));if(t<0) return t;if(t>0){cap[p][i]-=t;cap[i][p]+=t;return t;}}int label=n;for(int i=0;i<n;i++) if(cap[p][i]>0) label=min(label,dist[i]+1);if(--gap[dist[p]]==0 || dist[s0]>=n ) return -1;++gap[dist[p]=label];return 0;}int sap(){//初始化s,ts0=0,t0=n-1;int t=0,maxflow=0;gap[0]=n;while((t=find_path(s0))>=0) maxflow+=t;return maxflow;}int main(){int ci;while(cin>>ci>>n){//初始化memset(cap,0,sizeof(cap));memset(dist,0,sizeof(dist));memset(gap,0,sizeof(gap));//初始化capwhile(ci--){int x,y,c;cin>>x>>y>>c;x--;y--;cap[x][y]+=c;//因题而异}int ans=sap();cout<<ans<<endl;}return 0;}5.已知各点度,问能否组成一个简单图#include<iostream>#include<cstdio>#include<algorithm>using namespace std;const int inf=(1<<30);int d[1100];bool cmp(int x,int y){return x>y;}int main(){int ci;scanf("%d",&ci);while(ci--){int n,flag=1,cnt=0;scanf("%d",&n); for(int i=0;i<n;i++){scanf("%d",&d[i]);if(d[i]>n-1||d[i]<=0) flag=0; cnt+=d[i];}if(flag==0||cnt%2){printf("no\n");continue;}sort(d,d+n,cmp);for(int l=n;l>0;l--){for(int i=1;i<l&&d[0];i++){d[0]--,d[i]--;if(d[i]<0){flag=0;break;}}if(d[0]) flag=0;if(flag==0) break;d[0]=-inf;sort(d,d+l,cmp);}if(flag) printf("yes\n");else printf("no\n");}return 0;}6.KRUSKAL#include<iostream>#include<algorithm>using namespace std;int u[15005],v[15005],w[15005],fath[15005],r[15005];int ans1[15005],ans2[15005];bool cmp(int i,int j){return w[i]<w[j];}int find(int x){return fath[x]==x?x:fath[x]=find(fath[x]);}int main(){int n,m;cin>>n>>m;for(int i=1;i<=n;i++) fath[i]=i;for(int i=1;i<=m;i++) r[i]=i;for(int i=1;i<=m;i++){cin>>u[i]>>v[i]>>w[i];}sort(r+1,r+m+1,cmp);int maxn=0,ans=0,k=0;for(int i=1;i<=m;i++){int e=r[i];int x=find(u[e]),y=find(v[e]);if(x!=y){ans+=w[e];fath[x]=y;if(w[e]>maxn) maxn=w[e];ans1[k]=u[e];ans2[k++]=v[e];}}return 0;}7.prime求最小生成树语法:prim(Graph G,int vcount,int father[]);参数:G:图,用邻接矩阵表示vcount:表示图的顶点个数father[]:用来记录每个节点的父节点返回值:null注意:常数max_vertexes 为图最大节点数常数infinity为无穷大源程序:#define infinity 1000000#define max_vertexes 5typedef int Graph[max_vertexes][max_vertexes];void prim(Graph G,int vcount,int father[]){int i,j,k;intlowcost[max_vertexes],closeset[max_vertexes],used[max_vertexes]; for (i=0;i<vcount;i++){lowcost[i]=G[0][i];closeset[i]=0;used[i]=0;father[i]=-1;}used[0]=1;for (i=1;i<vcount;i++){j=0;while (used[j]) j++;for (k=0;k<vcount;k++)if ((!used[k])&&(lowcost[k]<lowcost[j])) j=k;father[j]=closeset[j];used[j]=1;for (k=0;k<vcount;k++)if (!used[k]&&(G[j][k]<lowcost[k])){ lowcost[k]=G[j][k];closeset[k]=j; }}}8.Dijkstra语法:result=Dijkstra(Graph G,int n,int s,int t, int path[]); 参数:G:图,用邻接矩阵表示n:图的顶点个数s:开始节点t:目标节点path[]:用于返回由开始节点到目标节点的路径返回值:最短路径长度注意:输入的图的权必须非负顶点标号从0 开始用如下方法打印路径:i=t;while (i!=s){printf("%d<--",i+1);i=path[i];}printf("%d\n",s+1);源程序:int Dijkstra(Graph G,int n,int s,int t, int path[]){int i,j,w,minc,d[max_vertexes],mark[max_vertexes];for (i=0;i<n;i++) mark[i]=0;for (i=0;i<n;i++){ d[i]=G[s][i];path[i]=s; }mark[s]=1;path[s]=0;d[s]=0;for (i=1;i<n;i++){minc=infinity;w=0;for (j=0;j<n;j++)if ((mark[j]==0)&&(minc>=d[j])) {minc=d[j];w=j;}mark[w]=1;for (j=0;j<n;j++)if((mark[j]==0)&&(G[w][j]!=infinity)&&(d[j]>d[w]+G[w][j])){ d[j]=d[w]+G[w][j];path[j]=w; }}return d[t];}9.Bellman-ford语法:result=Bellman_ford(Graph G,int n,int s,int t,int path[],int success);参数:G:图,用邻接矩阵表示n:图的顶点个数s:开始节点t:目标节点path[]:用于返回由开始节点到目标节点的路径success:函数是否执行成功返回值:最短路径长度注意:输入的图的权可以为负,如果存在一个从源点可达的权为负的回路则success=0顶点标号从0 开始用如下方法打印路径:i=t;while (i!=s){printf("%d<--",i+1);i=path[i];}printf("%d\n",s+1);源程序:int Bellman_ford(Graph G,int n,int s,int t,int path[],int success){int i,j,k,d[max_vertexes];for (i=0;i<n;i++) {d[i]=infinity;path[i]=0;}d[s]=0;for (k=1;k<n;k++)for (i=0;i<n;i++)for (j=0;j<n;j++)if (d[j]>d[i]+G[i][j]){d[j]=d[i]+G[i][j];path[j]=i;}success=0;for (i=0;i<n;i++)for (j=0;j<n;j++)if (d[j]>d[i]+G[i][j]) return 0;success=1;return d[t];}10. SPFA#include<iostream>#include<cstdio>#include<cstring>#include<vector>using namespace std;const __int64 maxn=1001000;const __int64 inf=1000100000;struct edge//邻接表{__int64 t,w;//s->t=w;__int64 next;//数组模拟指针};__int64 p[maxn],pf[maxn];//邻接表头节点edge G[maxn],Gf[maxn];//邻接表__int64 V,E;//点数[1-n] 边数__int64 dis[maxn];__int64 que[maxn],fro,rear;//模拟队列__int64 vis[maxn];__int64 inque[maxn];//入队次数bool spfa(__int64 s0){fro=rear=0;for(__int64 i=1;i<=V;i++) dis[i]=inf;dis[s0]=0;memset(vis,0,sizeof(vis));memset(inque,0,sizeof(inque));que[rear++]=s0;vis[s0]=1;inque[s0]++;while(fro!=rear){__int64 u=que[fro];fro++;if(fro==maxn) fro=0;vis[u]=0;for(__int64 i=p[u];i!=-1;i=G[i].next){__int64 s=u,t=G[i].t,w=G[i].w;if(dis[t]>dis[s]+w){dis[t]=dis[s]+w;if(vis[t]==0){que[rear++]=t,vis[t]=1;inque[t]++;if(inque[t]>V) return false;if(rear==maxn) rear=0;}}}}return true;}int main(){__int64 ci;scanf("%I64d",&ci);while(ci--){scanf("%I64d%I64d",&V,&E);memset(p,-1,sizeof(p));memset(pf,-1,sizeof(pf)); for(__int64 i=0;i<E;i++){__int64 u,v,w;scanf("%I64d%I64d%I64d",&u,&v,&w);G[i].t=v;G[i].w=w;G[i].next=p[u];p[u]=i;Gf[i].t=u;Gf[i].w=w;Gf[i].next=pf[v];pf[v]=i;}__int64 ans=0;spfa(1);//求第一个点到其他点的最短距离和for(__int64 i=1;i<=V;i++) ans+=dis[i];//反方向再来一次spfa 求其他点到第一个点的最短距离和 for(__int64 i=1;i<=V;i++) p[i]=pf[i];for(__int64 i=0;i<E;i++) G[i]=Gf[i];spfa(1);for(__int64 i=1;i<=V;i++) ans+=dis[i];printf("%I64d\n",ans);}return 0;}11.Kosaraju模板#include<iostream>#include<cstdio>#include<cstring>#include<algorithm>using namespace std;const int maxn=100000;struct edge{int t,w;//u->t=w;int next;};int V,E;//点数(从1开始),边数int p[maxn],pf[maxn];//邻接表原图,逆图edge G[maxn],Gf[maxn];//邻接表原图,逆图int l,lf;void init(){memset(p,-1,sizeof(p));memset(pf,-1,sizeof(pf));l=lf=0;}void addedge(int u,int t,int w,int l){G[l].w=w;G[l].t=t;G[l].next=p[u];p[u]=l;}void addedgef(int u,int t,int w,int lf){Gf[l].w=w;Gf[l].t=t;Gf[l].next=pf[u];pf[u]=l;}///Kosaraju算法,返回为强连通分量个数bool flag[maxn]; //访问标志数组int belg[maxn]; //存储强连通分量,其中belg[i]表示顶点i属于第belg[i]个强连通分量int numb[maxn]; //结束时间(出栈顺序)标记,其中numb[i]表示离开时间为i的顶点//用于第一次深搜,求得numb[1..n]的值void VisitOne(int cur, int &sig){flag[cur] = true;for (int i=p[cur];i!=-1;i=G[i].next){if (!flag[G[i].t]){VisitOne(G[i].t,sig);}}numb[++sig] = cur;}//用于第二次深搜,求得belg[1..n]的值void VisitTwo(int cur, int sig){flag[cur] = true;belg[cur] = sig;for (int i=pf[cur];i!=-1;i=Gf[i].next){if (!flag[Gf[i].t]){VisitTwo(Gf[i].t,sig);}}//Kosaraju算法,返回为强连通分量个数int Kosaraju_StronglyConnectedComponent(){int i, sig;//第一次深搜memset(flag,0,sizeof(flag));for ( sig=0,i=1; i<=V; ++i ){if ( false==flag[i] ){VisitOne(i,sig);}}//第二次深搜memset(flag,0,sizeof(flag));for ( sig=0,i=V; i>0; --i ){if ( false==flag[numb[i]] ){VisitTwo(numb[i],++sig);}}return sig;}int main(){while(scanf("%d",&V)==1){init();for(int i=1;i<=V;i++){int u=i,t,w=1;while(scanf("%d",&t)==1&&t){E++;addedge(u,t,w,l++);addedgef(t,u,w,lf++);}}int ans=Kosaraju_StronglyConnectedComponent(); printf("%d\n",ans);}return 0;12.tarjan模板//自己模板#include<iostream>#include<cstdio>#include<cstring>#include<algorithm>using namespace std;const int maxn=100000;int V,E;//点数(1) 边数struct edge//邻接表{int t,w;//u->t=w;int next;};int p[maxn];//表头节点edge G[maxn];int l;void init(){memset(p,-1,sizeof(p));l=0;}//添加边void addedge(int u,int t,int w,int l)//u->t=w;{G[l].w=w;G[l].t=t;G[l].next=p[u];p[u]=l;}//tarjan算法求有向图强联通分量int dfn[maxn],lowc[maxn];//dfn[u]节点u搜索的次序编号,lowc[u]u或者u的子树能够追溯到的栈中的最早的节点int belg[maxn];//第i个节点属于belg[i]个强连通分量int stck[maxn],stop;//stck栈int instck[maxn];//第i个节点是否在栈中int scnt;//强联通分量int index;void dfs(int i){dfn[i]=lowc[i]=++index;instck[i]=1;//节点i入栈stck[++stop]=i;for(int j=p[i];j!=-1;j=G[j].next){int t=G[j].t;//更新lowc数组if(!dfn[t])//t没有遍历过{dfs(t);if(lowc[i]>lowc[t]) lowc[i]=lowc[t];}//t是i的祖先节点else if(instck[t]&&lowc[i]>dfn[t]) lowc[i]=dfn[t];}//是强连通分量的根节点if(dfn[i]==lowc[i]){scnt++;int t;do{t=stck[stop--];instck[t]=0;belg[t]=scnt;}while(t!=i);}}int tarjan(){stop=scnt=index=0;memset(dfn,0,sizeof(dfn));memset(instck,0,sizeof(instck));for(int i=1;i<=V;i++){if(!dfn[i]) dfs(i);}return scnt;}int main(){while(scanf("%d",&V)==1){init();for(int i=1;i<=V;i++){int x;while(scanf("%d",&x)==1&&x){E++;addedge(i,x,1,l++);}}int ans=tarjan();printf("%d\n",ans);}return 0;}//吉大模板邻接表版#include<iostream>#include<cstdio>#include<cstring>#include<algorithm>using namespace std;const int maxn=100000;int V,E;//点数(1) 边数struct edge//邻接表{int t,w;//u->t=w;int next;};int p[maxn];//表头节点edge G[maxn];int l;void init(){memset(p,-1,sizeof(p));l=0;}//添加边void addedge(int u,int t,int w,int l)//u->t=w;{G[l].w=w;G[l].t=t;G[l].next=p[u];p[u]=l;}//tarjan算法求有向图强联通分量int dfn[maxn],lowc[maxn];//dfn[u]节点u搜索的次序编号,lowc[u]u或者u的子树能够追溯到的栈中的最早的节点int stck[maxn],stop;//stck栈int pre[maxn];//int scnt;//强联通分量int cnt;//void dfs(int v)//1-V{int t,minc=lowc[v]=pre[v]=cnt++;stck[stop++]=v;for(int i=p[v];i!=-1;i=G[i].next){int pv=G[i].t;if(pre[pv]==-1) dfs(pv);if(lowc[pv]<minc) minc=lowc[pv]; }if(minc<lowc[v]){lowc[v]=minc;return ;}do{dfn[t=stck[--stop]]=scnt;lowc[t]=V;}while(t!=v);++scnt;}int tarjan(){stop=cnt=scnt=0;memset(pre,-1,sizeof(pre));for(int i=1;i<=V;i++){if(pre[i]==-1) dfs(i);}return scnt;}int main(){while(scanf("%d",&V)==1){init();for(int i=1;i<=V;i++){int x;while(scanf("%d",&x)==1&&x){E++;addedge(i,x,1,l++);}}int ans=tarjan();printf("%d\n",ans);}return 0;}二、数学1.剩余定理int mod(int c[],int b[],int n){int all_multy=1,sum=0;int i,j,x[5];for(i=0;i<n;i++)all_multy*=c[i];for(i=0;i<n;i++)x[i]=all_multy/c[i];for(i=0;i<n;i++){j=1;while((x[i]*j)%c[i]!=1)j++;x[i]*=j;}for(i=0;i<n;i++)sum+=(b[i]*x[i]);return sum%all_multy;}2.N!中质因子P的个数//对于任意质数p,n!中有(n/p+n/p^2+n/p^3+...)个质因子p。
ACM 计算几何 最小圆覆盖算法
平面上有n个点,给定n个点的坐标,试找一个半径最小的圆,将n 个点全部包围,点可以在圆上。
1. 在点集中任取3点A,B,C。
2. 作一个包含A,B,C三点的最小圆,圆周可能通过这3点,也可能只通过其中两点,但包含第3点.后一种情况圆周上的两点一定是位于圆的一条直径的两端。
3. 在点集中找出距离第2步所建圆圆心最远的D点,若D点已在圆内或圆周上,则该圆即为所求的圆,算法结束.则,执行第4步。
4. 在A,B,C,D中选3个点,使由它们生成的一个包含这4个点的圆为最小,这3 点成为新的A,B,C,返回执行第2步。
若在第4步生成的圆的圆周只通过A,B,C,D 中的两点,则圆周上的两点取成新的A 和B,从另两点中任取一点作为新的C。
程序设计题解上的解题报告:对于一个给定的点集A,记MinCircle(A)为点集A的最小外接圆,显然,对于所有的点集情况A,MinCircle(A)都是存在且惟一的。
需要特别说明的是,当A为空集时,MinCircle(A)为空集,当A={a}时,MinCircle(A)圆心坐标为a,半径为0;显然,MinCircle(A)可以有A 边界上最多三个点确定(当点集A中点的个数大于1时,有可能两个点确定了MinCircle(A)),也就是说存在着一个点集B,|B|<=3 且B 包含与A,有MinCircle(B)=MinCircle(A).所以,如果a不属于B,则MinCircle(A-{a})=MinCircle(A);如果MinCircle(A-{a})不等于MinCircle(A),则a属于B。
所以我们可以从一个空集R开始,不断的把题目中给定的点集中的点加入R,同时维护R的外接圆最小,这样就可以得到解决该题的算法。
不断添加圆,维护最小圆。
如果添加的点i在圆内,不动,否则:问题转化为求1~I的最小圆:求出1与I的最小圆,并且扫描j=2~I-1,维护(1)+(i)+(2~j)的最小圆,如果找到J不在最小圆内,问题转化为:求(1~J)+(i)的最小圆。
ACM学习经验
入门篇1、acm入门经验对于还没有方向处于盲目阶段的acmer新手会有所帮助。
1、先大概浏览《算法导论》,。
2. 注册OJ账号,找AC人数最多的做,或者找自己会做的做,不会的一概不管。
遇到不会做的题目,尽量自己想,想不出找同学讨论discuss, 也可以搜索解决报告。
3、多做题,一定要多做题,每天至少(是至少)过个几题(1题也行,但一定要做,天天做,有空就做)4、有空多看看别人的代码,不管这题你是过了还是没过,最好都仔细读读,吸取其中写的好的地方,尤其是新手,多看看别人的代码很有好处。
5、有问题不懂可以在acm群、acm百科网问问题,因为主要是自学,交流很重要,在(且只有在)想不出来看不懂书网上又搜不到自己实在无法解决时,一定要多问,死缠烂打地问。
6、有一定水平后,各个OJ,topcoder,所有的比赛都要关注,能做的比赛尽量做,不管刚开始你有多菜,一题都做不出来也要去参加。
并在赛后总结,尽量把能做的题目干掉。
7、所有的大牛都是从只会简单题开始的,不管你现在多菜,只要你坚持,总有一天你会变成大牛。
8、原来以为只有ACM会辛苦,后来和别人交流了,其实所有的专业比赛(计算机方面)都很辛苦,不仅辛苦,而且都需要很长时间,没有任何比赛是你说随便搞搞短时间就能出成绩的,拼的都是内功,成功没有捷径。
如果选择ACM,就一定要坚持,而且必须放弃很多其他东西,不要什么都做什么都没成绩,有所得必有所失。
2、对ACM新人的建议一、语言是最重要的基本功无论侧重于什么方面,只要是通过计算机程序去最终实现的竞赛,语言都是大家要过的第一道关。
亚洲赛区的比赛支持的语言包括C/C++与JA V A。
首先说说JA V A,众所周知,作为面向对象的王牌语言,JA V A在大型工程的组织与安全性方面有着自己独特的优势,但是对于信息学比赛的具体场合,JA V A则显得不那么合适,它对于输入输出流的操作相比于C++要繁杂很多,更为重要的是JA V A程序的运行速度要比C++慢10倍以上,而竞赛中对于JA V A程序的运行时限却往往得不到同等比例的放宽,这无疑对算法设计提出了更高的要求,是相当不利的。
计算机图形学习题参考答案(完整版)
计算机图形学习题参考答案第1章绪论1、第一届ACM SIGGRAPH会议是哪一年在哪里召开的?解:1974年,在Colorado大学召开了第一届SIGGRAPH年会。
2、计算机图形学之父是谁?解:Sutherland3、列举一些计算机图形学的应用领域(至少5个)。
解:计算机辅助设计、图示图形学、计算机艺术、娱乐、教学与培训、可视化、图像处理、图形用户界面等。
4、简要介绍计算机图形学的研究内容。
解:(1)图形的输入。
如何开发和利用图形输入设备及相关软件把图形输入到计算机中,以便进行各种处理。
(2)图形的处理。
包括对图形进行变换(如几何变换、投影变换)和运算(如图形的并、交、差运算)等处理。
(3)图形的生成和输出。
如何将图形的特定表示形式转换成图形输出系统便于接受的表示形式,并将图形在显示器或打印机等输出设备上输出。
5、简要说明计算机图形学与相关学科的关系。
解:与计算机图形学密切相关的学科主要有图像处理、计算几何、计算机视觉和模式识别等。
计算机图形学着重讨论怎样将数据模型变成数字图像。
图像处理着重研究图像的压缩存储和去除噪音等问题。
模式识别重点讨论如何从图像中提取数据和模型。
计算几何着重研究数据模型的建立、存储和管理。
随着技术的发展和应用的深入,这些学科的界限变得模糊起来,各学科相互渗透、融合。
一个较完善的应用系统通常综合利用了各个学科的技术。
6、简要介绍几种计算机图形学的相关开发技术。
解:(1)OpenGL。
OpenGL是一套三维图形处理库,也是该领域事实上的工业标准。
OpenGL独立于硬件、操作系统和窗口系统,能运行于不同操作系统的各种计算机,并能在网络环境下以客户/服务器模式工作,是专业图形处理、科学计算等高端应用领域的标准图形库。
以OpenGL为基础开发的应用程序可以十分方便地在各种平台间移植;OpenGL与C/C++紧密接合,便于实现图形的相关算法,并可保证算法的正确性和可靠性;OpenGL使用简便,效率高。
ACM在线训练方法09
poj3273,poj3258,poj1905,poj3122 poj2976
poj3150,poj3422,poj3070 poj3301
poj2031,poj1039
poj1408,poj1584 poj2187,poj1113 poj1151 poj1765,poj1177,poj1151,poj3277,poj228 0,poj3004 poj3130,poj3335 poj1819,poj1066,poj2043,poj3227,poj216 5,poj3429 poj3384,poj2540 poj2966 poj2079 poj3318,poj2454 poj1870,poj3296,poj3286,poj1095 poj3317,poj1085 poj3109,poj1478,poj1462,poj2729,poj204 8,poj3336,poj3315,poj2148,poj1263
(1)串
poj1753,poj2965 poj1328,poj2109,poj2586 很多,不专门列题 很多,不专门列题 poj3295 poj1068,poj2632,poj1573,poj2993,poj299 6 poj3096,poj3007 poj3393,poj1472,poj3371,poj1027,poj270 6 poj2525,poj1684,poj1421,poj1048,poj205 0,poj3306 poj3434
1.加法原理和乘法原理. 2.排列组合. 3.递推关系.
1.容斥原理. 2.抽屉原理. 3.置换群与 Polya 定理 4.递推关系和母函数. 1.MoBius 反演 2.偏序关系理论
1.素数与整除问题 2.进制位. 3.同余模运算.
ACM资料
作者:威士忌
价钱:0 hdoj币
所在位置:Hangzhou Dianzi University Online Judge Forum ? 资料下载 new!!
这一楼是ACM的资料等的简介以及连接,搜罗了好半天,各位看看啊!
这里主要分成免费的和收费的,为了自己方便,同时也是服务大家。
=============近日更新项目=============
1、添加新的题目代码:1237、2059、2060、2569、2568、2567。
2、居然发现HDU有人玩过仙剑4~~意外。
ACM课件(8)_搜索入门:/forum/read.php?tid=3669
ACM课件(9)_二分匹配入门:/forum/read.php?tid=3744
ACM课件(10)_母函数及其应用:/forum/read.php?tid=3853
简介:还记得lcy可见上的ACM Programming的比赛吗?可能已经过了,你还可以从Passed中找到,但是,这些题目的答案还是找不到的,除非你很有毅力,一道一道搜索。感谢menjitian,他把几次竞赛的题目整理出来了,大家可以看看!
下载地址:2008《ACM Programming》Exercise(1)_A+B 参考代码:
名称:HDOJ 题目 离线版 下载 最最最新版 2008-07-16 更新强烈推荐
作者:Linle
价钱:0 hdoj币
所在位置:Hangzhou Dianzi University Online Judge Forum ? 灌水专区
acm编程例题 参考答案
acm编程例题参考答案ACM编程例题参考答案ACM(Advanced Computer Mathematics)是一种面向计算机科学与技术的竞赛形式,旨在提高参与者的编程技能和解决问题的能力。
ACM编程例题是指在ACM竞赛中出现的一系列编程题目,这些题目涵盖了各种算法和数据结构的应用。
本文将给出一些ACM编程例题的参考答案,希望能够帮助读者更好地理解和掌握这些题目的解法。
一、题目一:最大公约数题目描述:给定两个正整数a和b,求它们的最大公约数。
解题思路:最大公约数可以通过欧几里得算法来求解。
该算法的基本思想是,两个正整数的最大公约数等于其中较小的数和两数之差的最大公约数。
具体的实现可以使用递归或循环的方式。
代码示例:```c++int gcd(int a, int b) {if (b == 0) {return a;}return gcd(b, a % b);}```二、题目二:素数判断题目描述:给定一个正整数n,判断它是否为素数。
解题思路:素数是只能被1和自身整除的正整数。
判断一个数是否为素数可以使用试除法,即从2开始,依次判断n是否能被2到sqrt(n)之间的数整除。
如果存在能整除n的数,则n不是素数;否则,n是素数。
代码示例:```c++bool isPrime(int n) {if (n <= 1) {return false;}for (int i = 2; i * i <= n; i++) {if (n % i == 0) {return false;}}return true;}```三、题目三:字符串反转题目描述:给定一个字符串s,将其反转后输出。
解题思路:字符串反转可以通过将字符串的首尾字符依次交换来实现。
可以使用双指针的方式,一个指针指向字符串的首字符,另一个指针指向字符串的尾字符,然后交换两个指针所指向的字符,并向中间移动,直到两个指针相遇。
代码示例:```c++void reverseString(string& s) {int left = 0;int right = s.length() - 1;while (left < right) {swap(s[left], s[right]);left++;right--;}}```四、题目四:二分查找题目描述:给定一个有序数组和一个目标值,使用二分查找算法在数组中找到目标值的索引,如果目标值不存在,则返回-1。
ACM信息汇总
ACM信息汇总⼀、ACM算法总结及刷题参考(摘⾃:)初期:⼀.基本算法:(1)枚举. (poj1753,poj2965)(2)贪⼼(poj1328,poj2109,poj2586)(3)递归和分治法.(4)递推.(5)构造法.(poj3295)(6)模拟法.(poj1068,poj2632,poj1573,poj2993,poj2996)⼆.图算法:(1)图的深度优先遍历和⼴度优先遍历.(2)最短路径算法(dijkstra,bellman-ford,floyd,heap+dijkstra)(poj1860,poj3259,poj1062,poj2253,poj1125,poj2240)(3)最⼩⽣成树算法(prim,kruskal)(poj1789,poj2485,poj1258,poj3026)(4)拓扑排序 (poj1094)(5)⼆分图的最⼤匹配 (匈⽛利算法) (poj3041,poj3020)(6)最⼤流的增⼴路算法(KM算法). (poj1459,poj3436)三.数据结构.(1)串 (poj1035,poj3080,poj1936)(2)排序(快排、归并排(与逆序数有关)、堆排) (poj2388,poj2299)(3)简单并查集的应⽤.(4)哈希表和⼆分查找等⾼效查找法(数的Hash,串的Hash)(poj3349,poj3274,POJ2151,poj1840,poj2002,poj2503)(5)哈夫曼树(poj3253)(6)堆(7)trie树(静态建树、动态建树) (poj2513)四.简单搜索(1)深度优先搜索 (poj2488,poj3083,poj3009,poj1321,poj2251)(2)⼴度优先搜索(poj3278,poj1426,poj3126,poj3087.poj3414)(3)简单搜索技巧和剪枝(poj2531,poj1416,poj2676,1129)五.动态规划(1)背包问题. (poj1837,poj1276)(2)型如下表的简单DP(可参考lrj的书 page149):1.E[j]=opt{D[i]+w(i,j)} (poj3267,poj1836,poj1260,poj2533)2.E[i,j]=opt{D[i-1,j]+xi,D[i,j-1]+yj,D[i-1][j-1]+zij} (最长公共⼦序列)(poj3176,poj1080,poj1159)3.C[i,j]=w[i,j]+opt{C[i,k-1]+C[k,j]}.(最优⼆分检索树问题)六.数学(1)组合数学:1.加法原理和乘法原理.2.排列组合.3.递推关系.(POJ3252,poj1850,poj1019,poj1942)(2)数论.1.素数与整除问题2.进制位.3.同余模运算.(poj2635, poj3292,poj1845,poj2115)(3)计算⽅法.1.⼆分法求解单调函数相关知识.(poj3273,poj3258,poj1905,poj3122)七.计算⼏何学.(1)⼏何公式.(2)叉积和点积的运⽤(如线段相交的判定,点到线段的距离等). (poj2031,poj1039)(3)多边型的简单算法(求⾯积)和相关判定(点在多边型内,多边型是否相交)(poj1408,poj1584)(4)凸包. (poj2187,poj1113)中级:⼀.基本算法:(1)C++的标准模版库的应⽤. (poj3096,poj3007)(2)较为复杂的模拟题的训练(poj3393,poj1472,poj3371,poj1027,poj2706)⼆.图算法:(1)差分约束系统的建⽴和求解. (poj1201,poj2983)(2)最⼩费⽤最⼤流(poj2516,poj2516,poj2195)(3)双连通分量(poj2942)(4)强连通分⽀及其缩点.(poj2186)(5)图的割边和割点(poj3352)(6)最⼩割模型、⽹络流规约(poj3308, )三.数据结构:(1)线段树. (poj2528,poj2828,poj2777,poj2886,poj2750)(2)静态⼆叉检索树. (poj2482,poj2352)(3)树状树组(poj1195,poj3321)(4)RMQ. (poj3264,poj3368)(5)并查集的⾼级应⽤. (poj1703,2492)(6)KMP算法. (poj1961,poj2406)四.搜索(1)最优化剪枝和可⾏性剪枝(2)搜索的技巧和优化 (poj3411,poj1724)(3)记忆化搜索(poj3373,poj1691)五.动态规划(1)较为复杂的动态规划(如动态规划解特别的施⾏商问题等)(poj1191,poj1054,poj3280,poj2029,poj2948,poj1925,poj3034)(2)记录状态的动态规划. (POJ3254,poj2411,poj1185)(3)树型动态规划(poj2057,poj1947,poj2486,poj3140)六.数学(1)组合数学:1.容斥原理.2.抽屉原理.3.置换群与Polya定理(poj1286,poj2409,poj3270,poj1026).4.递推关系和母函数.(2)数学.1.⾼斯消元法(poj2947,poj1487, poj2065,poj1166,poj1222)2.概率问题. (poj3071,poj3440)3.GCD、扩展的欧⼏⾥德(中国剩余定理) (poj3101)(3)计算⽅法.1.0/1分数规划. (poj2976)2.三分法求解单峰(单⾕)的极值.3.矩阵法(poj3150,poj3422,poj3070)4.迭代逼近(poj3301)(4)随机化算法(poj3318,poj2454)(5)杂题.(poj1870,poj3296,poj3286,poj1095)七.计算⼏何学:(1)坐标离散化.(2)扫描线算法(例如求矩形的⾯积和周长并,常和线段树或堆⼀起使⽤).(poj1765,poj1177,poj1151,poj3277,poj2280,poj3004)(3)多边形的内核(半平⾯交)(poj3130,poj3335)(4)⼏何⼯具的综合应⽤.(poj1819,poj1066,poj2043,poj3227,poj2165,poj3429)⾼级:⼀.基本算法要求:(1)代码快速写成,精简但不失风格(poj2525,poj1684,poj1421,poj1048,poj2050,poj3306)(2)保证正确性和⾼效性. poj3434⼆.图算法:(1)度限制最⼩⽣成树和第K最短路. (poj1639)(2)最短路,最⼩⽣成树,⼆分图,最⼤流问题的相关理论(主要是模型建⽴和求解)(poj3155, poj2112,poj1966,poj3281,poj1087,poj2289,poj3216,poj2446(3)最优⽐率⽣成树. (poj2728)(4)最⼩树形图(poj3164)(5)次⼩⽣成树.(6)⽆向图、有向图的最⼩环三.数据结构.(1)trie图的建⽴和应⽤. (poj2778)(2)LCA和RMQ问题(LCA(最近公共祖先问题) 有离线算法(并查集+dfs) 和在线算法(RMQ+dfs)).(poj1330)(3)双端队列和它的应⽤(维护⼀个单调的队列,常常在动态规划中起到优化状态转移的⽬的). (poj2823)(4)左偏树(可合并堆).(5)后缀树(⾮常有⽤的数据结构,也是赛区考题的热点).(poj3415,poj3294)四.搜索(1)较⿇烦的搜索题⽬训练(poj1069,poj3322,poj1475,poj1924,poj2049,poj3426)(2)⼴搜的状态优化:利⽤M进制数存储状态、转化为串⽤hash表判重、按位压缩存储状态、双向⼴搜、A*算法.(poj1768,poj1184,poj1872,poj1324,poj2046,poj1482)(3)深搜的优化:尽量⽤位运算、⼀定要加剪枝、函数参数尽可能少、层数不易过⼤、可以考虑双向搜索或者是轮换搜索、IDA*算法. (poj3131,poj2870,poj2286)五.动态规划(1)需要⽤数据结构优化的动态规划.(poj2754,poj3378,poj3017)(2)四边形不等式理论.(3)较难的状态DP(poj3133)六.数学(1)组合数学.1.MoBius反演(poj2888,poj2154)2.偏序关系理论.(2)博奕论.1.极⼤极⼩过程(poj3317,poj1085)2.Nim问题.七.计算⼏何学.(1)半平⾯求交(poj3384,poj2540)(2)可视图的建⽴(poj2966)(3)点集最⼩圆覆盖.(4)对踵点(poj2079)⼋.综合题.(poj3109,poj1478,poj1462,poj2729,poj2048,poj3336,poj3315,poj2148,poj1263)补充:Dp状态设计与⽅程总结1.不完全状态记录<1>青蛙过河问题<2>利⽤区间dp2.背包类问题<1> 0-1背包,经典问题<2>⽆限背包,经典问题<3>判定性背包问题<4>带附属关系的背包问题<5> + -1背包问题<6>双背包求最优值<7>构造三⾓形问题<8>带上下界限制的背包问题(012背包)3.线性的动态规划问题<1>积⽊游戏问题<2>决⽃(判定性问题)<3>圆的最⼤多边形问题<4>统计单词个数问题<5>棋盘分割<6>⽇程安排问题<7>最⼩逼近问题(求出两数之⽐最接近某数/两数之和等于某数等等)<8>⽅块消除游戏(某区间可以连续消去求最⼤效益)<9>资源分配问题<10>数字三⾓形问题<11>漂亮的打印<12>邮局问题与构造答案<13>最⾼积⽊问题<14>两段连续和最⼤<15>2次幂和问题<16>N个数的最⼤M段⼦段和<17>交叉最⼤数问题4.判定性问题的dp(如判定整除、判定可达性等)<1>模K问题的dp<2>特殊的模K问题,求最⼤(最⼩)模K的数<3>变换数问题5.单调性优化的动态规划<1>1-SUM问题<2>2-SUM问题<3>序列划分问题(单调队列优化)6.剖分问题(多边形剖分/⽯⼦合并/圆的剖分/乘积最⼤)<1>凸多边形的三⾓剖分问题<2>乘积最⼤问题<3>多边形游戏(多边形边上是操作符,顶点有权值)<4>⽯⼦合并(N^3/N^2/NLogN各种优化)7.贪⼼的动态规划<1>最优装载问题<2>部分背包问题<3>乘船问题<4>贪⼼策略<5>双机调度问题Johnson算法8.状态dp<1>⽜仔射击问题(博弈类)<2>哈密顿路径的状态dp<3>两⽀点天平平衡问题<4>⼀个有向图的最接近⼆部图9.树型dp<1>完美服务器问题(每个节点有3种状态)<2>⼩胖守皇宫问题<3>⽹络收费问题<4>树中漫游问题<5>树上的博弈<6>树的最⼤独⽴集问题<7>树的最⼤平衡值问题<8>构造树的最⼩环⼆、ACM⼤赛准备(经验1)(摘⾃:)ACM常⽤算法及练习第⼀阶段:练经典常⽤算法,下⾯的每个算法给我打上⼗到⼆⼗遍,同时⾃⼰精简代码,因为太常⽤,所以要练到写时不⽤想,10-15分钟内打完,甚⾄关掉显⽰器都可以把程序打出来.1.最短路(Floyd、Dijstra,BellmanFord)2.(先写个prim,kruscal要⽤并查集,不好写)3.⼤数(⾼精度)加减乘除4.⼆分查找. (代码可在五⾏以内)5.叉乘、判线段相交、然后写个凸包.6.BFS、DFS,同时熟练(要熟,要灵活,代码要简)7.数学上的有:辗转相除(两⾏内),线段交点、多⾓形⾯积公式.8. 调⽤系统的qsort, 技巧很多,慢慢掌握.9. 任意进制间的转换第⼆阶段:练习复杂⼀点,但也较常⽤的算法。
ACM资料
最优比率生成树
0/1分数规划
度限制生成树
连通性问题
强大的DFS算法
无向图连通性
割点
割边
二连通分支
有向图连通性
强连通分支
2-SAT
最小点基
有向无环图
拓扑排序
有向无环图与动态规划的关系
二分图匹配问题
一般图问题与二分图问题的转换思路
组合数学
解决组合数学问题时常用的思想
逼近
递推 / 动态规划
概率问题
Polya定理
计算几何 / 解析几何
计算几何的核心:叉积 / 面积
解析几何的主力:复数
基本形
点
直线,线段
多边形
凸多边形 / 凸包
凸包算法的引进,卷包裹法
数论计算
求N的约数个数
求phi(N)
求约数和
快速数论变换
……
素数问题
概率判素算法
概率因子分解
数据结构
组织结构
二叉堆
左偏树
二项树
胜者树
跳跃表
样式图标
斜堆
reap
统计结构
树状数组
虚二叉树
线段树
8. 调用系统的qsort, 技巧很多,慢慢掌握.
9. 任意进制间的转换
第二阶段:
练习复杂一点,但也较常用的算法。
如:
1. 二分图匹配(匈牙利),最小路径覆盖
2. 网络流,最小费用流。
3. 线段树.
4. 并查集。
5. 熟悉动态规划的各个典型:LCS、最长递增子串、三角剖分、记忆化dp
ACM常用代码
一、数学问题1.精度计算——大数阶乘语法:int result=factorial(int n);参数:n: n 的阶乘返回值:阶乘结果的位数注意:本程序直接输出n!的结果,需要返回结果请保留long a[]需要 math.h源程序:int factorial(int n){long a[10000];int i,j,l,c,m=0,w;a[0]=1;for(i=1;i<=n;i++){c=0;for(j=0;j<=m;j++){a[j]=a[j]*i+c;c=a[j]/10000;a[j]=a[j]%10000;}if(c>0) {m++;a[m]=c;}}w=m*4+log10(a[m])+1;printf("\n%ld",a[m]);for(i=m-1;i>=0;i--) printf("%4.4ld",a[i]);return w;}2.精度计算——乘法(大数乘小数)语法:mult(char c[],char t[],int m);参数:c[]:被乘数,用字符串表示,位数不限t[]:结果,用字符串表示m:乘数,限定10以内返回值: null注意:需要 string.h源程序:void mult(char c[],char t[],int m){int i,l,k,flag,add=0;char s[100];l=strlen(c);for (i=0;i<l;i++)s[l-i-1]=c[i]-'0';for (i=0;i<l;i++){k=s[i]*m+add;if (k>=10){s[i]=k%10;add=k/10;flag=1;} else {s[i]=k;flag=0;add=0;}}if (flag) {l=i+1;s[i]=add;} else l=i;for (i=0;i<l;i++)t[l-1-i]=s[i]+'0';t[l]='\0';}3.精度计算——乘法(大数乘大数)语法:mult(char a[],char b[],char s[]);参数:a[]:被乘数,用字符串表示,位数不限b[]:乘数,用字符串表示,位数不限t[]:结果,用字符串表示返回值: null注意:空间复杂度为 o(n^2)需要 string.h源程序:void mult(char a[],char b[],char s[]){inti,j,k=0,alen,blen,sum=0,res[65][65]={0},flag=0;char result[65];alen=strlen(a);blen=strlen(b);for (i=0;i<alen;i++)for (j=0;j<blen;j++)res[i][j]=(a[i]-'0')*(b[j]-'0');for (i=alen-1;i>=0;i--){for (j=blen-1;j>=0;j--)sum=sum+res[i+blen-j-1][j];result[k]=sum%10;k=k+1;sum=sum/10;}for (i=blen-2;i>=0;i--){for (j=0;j<=i;j++)sum=sum+res[i-j][j];result[k]=sum%10;k=k+1;sum=sum/10;}if (sum!=0) {result[k]=sum;k=k+1;}for (i=0;i<k;i++) result[i]+='0';for (i=k-1;i>=0;i--) s[i]=result[k-1-i];s[k]='\0';while(1){if (strlen(s)!=strlen(a)&&s[0]=='0')strcpy(s,s+1);elsebreak;}}4.精度计算——加法语法:add(char a[],char b[],char s[]);参数:a[]:被乘数,用字符串表示,位数不限b[]:乘数,用字符串表示,位数不限t[]:结果,用字符串表示返回值: null注意:空间复杂度为 o(n^2)需要 string.h源程序:void add(char a[],char b[],char back[]){int i,j,k,up,x,y,z,l;char *c;if (strlen(a)>strlen(b)) l=strlen(a)+2; elsel=strlen(b)+2;c=(char *) malloc(l*sizeof(char));i=strlen(a)-1;j=strlen(b)-1;k=0;up=0;while(i>=0||j>=0){if(i<0) x='0'; else x=a[i];if(j<0) y='0'; else y=b[j];z=x-'0'+y-'0';if(up) z+=1;if(z>9) {up=1;z%=10;} else up=0;c[k++]=z+'0';i--;j--;}if(up) c[k++]='1';i=0;c[k]='\0';for(k-=1;k>=0;k--)back[i++]=c[k];back[i]='\0';}5.精度计算——减法语法:sub(char s1[],char s2[],char t[]);参数:s1[]:被减数,用字符串表示,位数不限s2[]:减数,用字符串表示,位数不限t[]:结果,用字符串表示返回值: null注意:默认s1>=s2,程序未处理负数情况需要 string.h源程序:void sub(char s1[],char s2[],char t[]){int i,l2,l1,k;l2=strlen(s2);l1=strlen(s1);t[l1]='\0';l1--;for (i=l2-1;i>=0;i--,l1--){if (s1[l1]-s2[i]>=0)t[l1]=s1[l1]-s2[i]+'0';else{t[l1]=10+s1[l1]-s2[i]+'0';s1[l1-1]=s1[l1-1]-1;}}k=l1;while(s1[k]<0) {s1[k]+=10;s1[k-1]-=1;k--;}while(l1>=0) {t[l1]=s1[l1];l1--;}loop:if (t[0]=='0'){l1=strlen(s1);for (i=0;i<l1-1;i++) t[i]=t[i+1];t[l1-1]='\0';goto loop;}if (strlen(t)==0) {t[0]='0';t[1]='\0';}}6.任意进制转换语法:conversion(char s1[],char s2[],long d1,long d2);参数:s[]:原进制数字,用字符串表示s2[]:转换结果,用字符串表示d1:原进制数d2:需要转换到的进制数返回值: null注意:高于9的位数用大写'A'~'Z'表示,2~16位进制通过验证源程序:void conversion(char s[],char s2[],long d1,long d2){long i,j,t,num;char c;num=0;for (i=0;s[i]!='\0';i++){if (s[i]<='9'&&s[i]>='0') t=s[i]-'0';else t=s[i]-'A'+10;num=num*d1+t;}i=0;while(1){t=num%d2;if (t<=9) s2[i]=t+'0'; elses2[i]=t+'A'-10;num/=d2;if (num==0) break;i++;}for (j=0;j<i/2;j++){c=s2[j];s2[j]=s[i-j];s2[i-j]=c;}s2[i+1]='\0';}7.最大公约数、最小公倍数语法:resulet=hcf(int a,int b)、result=lcd(int a,int b)参数:a: int a,求最大公约数或最小公倍数b: int b,求最大公约数或最小公倍数返回值:返回最大公约数(hcf)或最小公倍数(lcd)注意:lcd 需要连同 hcf 使用源程序:int hcf(int a,int b){int r=0;while(b!=0){r=a%b;a=b;b=r;}return(a);}lcd(int u,int v,int h){return(u*v/h);}8.组合序列语法:m_of_n(int m, int n1, int m1, int* a, int head)参数:m:组合数C的上参数n1:组合数C的下参数m1:组合数C的上参数,递归之用*a: 1~n的整数序列数组head:头指针返回值: null注意:*a需要自行产生初始调用时,m=m1、head=0调用例子:求C(m,n)序列:m_of_n(m,n,m,a,0);源程序:void m_of_n(int m, int n1, int m1, int* a, int head){int i,t;if(m1<0 || m1>n1) return;if(m1==n1){for(i=0;i<m;i++) cout<<a[i]<<' '; // 输出序列cout<<'\n';return;}m_of_n(m,n1-1,m1,a,head); // 递归调用t=a[head];a[head]=a[n1-1+head];a[n1-1+head]=t;m_of_n(m,n1-1,m1-1,a,head+1); // 再次递归调用t=a[head];a[head]=a[n1-1+head];a[n1-1+head]=t;}9.快速傅立叶变换(FFT)语法:kkfft(double pr[],double pi[],int n,int k,double fr[],doublefi[],int l,int il);参数:pr[n]输入的实部:pi[n]数入的虚部:n,k:满足n=2^kfr[n]输出的实部:fi[n]输出的虚部:l:逻辑开关,0 FFT,1 ifFTil:逻辑开关,0 输出按实部/虚部;1 输出按模/幅角返回null值:注意:需要 math.h源程序:void kkfft(pr,pi,n,k,fr,fi,l,il)int n,k,l,il;double pr[],pi[],fr[],fi[];{int it,m,is,i,j,nv,l0;double p,q,s,vr,vi,poddr,poddi;for (it=0; it<=n-1; it++){m=it; is=0;for (i=0; i<=k-1; i++){j=m/2; is=2*is+(m-2*j); m=j;}fr[it]=pr[is]; fi[it]=pi[is];}pr[0]=1.0; pi[0]=0.0;p=6.283185306/(1.0*n);pr[1]=cos(p); pi[1]=-sin(p);if (l!=0) pi[1]=-pi[1];for (i=2; i<=n-1; i++){p=pr[i-1]*pr[1];q=pi[i-1]*pi[1];s=(pr[i-1]+pi[i-1])*(pr[1]+pi[1]);pr[i]=p-q; pi[i]=s-p-q;}for (it=0; it<=n-2; it=it+2){vr=fr[it]; vi=fi[it];fr[it]=vr+fr[it+1]; fi[it]=vi+fi[it+1];fr[it+1]=vr-fr[it+1];fi[it+1]=vi-fi[it+1];}m=n/2; nv=2;for (l0=k-2; l0>=0; l0--){m=m/2; nv=2*nv;for (it=0; it<=(m-1)*nv; it=it+nv)for (j=0; j<=(nv/2)-1; j++){p=pr[m*j]*fr[it+j+nv/2];q=pi[m*j]*fi[it+j+nv/2];s=pr[m*j]+pi[m*j];s=s*(fr[it+j+nv/2]+fi[it+j +nv/2]);poddr=p-q; poddi=s-p-q;fr[it+j+nv/2]=fr[it+j]-pod dr;fi[it+j+nv/2]=fi[it+j]-pod di;fr[it+j]=fr[it+j]+poddr;fi[it+j]=fi[it+j]+poddi;}}if (l!=0)for (i=0; i<=n-1; i++){fr[i]=fr[i]/(1.0*n);fi[i]=fi[i]/(1.0*n);}if (il!=0)for (i=0; i<=n-1; i++){pr[i]=sqrt(fr[i]*fr[i]+fi[i]*fi[i]);if(fabs(fr[i])<0.000001*fabs(fi[i])){if ((fi[i]*fr[i])>0)pi[i]=90.0;else pi[i]=-90.0;}elsepi[i]=atan(fi[i]/fr[i])*360.0/6.283185306;}return;}10.Ronberg算法计算积分语法:result=integral(double a,double b);参数:a:积分上限b:积分下限function积分函数f:返回值: f在(a,b)之间的积分值注意:function f(x)需要自行修改,程序中用的是sina(x)/x需要 math.h默认精度要求是1e-5源程序:double f(double x){return sin(x)/x; //在这里插入被积函数}double integral(double a,double b){double h=b-a;double t1=(1+f(b))*h/2.0;int k=1;double r1,r2,s1,s2,c1,c2,t2;loop:double s=0.0;double x=a+h/2.0;while(x<b){s+=f(x);x+=h;}t2=(t1+h*s)/2.0;s2=t2+(t2-t1)/3.0;if(k==1){k++;h/=2.0;t1=t2;s1=s2;goto loop;}c2=s2+(s2-s1)/15.0;if(k==2){c1=c2;k++;h/=2.0;t1=t2;s1=s2;goto loop;}r2=c2+(c2-c1)/63.0;if(k==3){r1=r2; c1=c2;k++;h/=2.0;t1=t2;s1=s2;goto loop;}while(fabs(1-r1/r2)>1e-5){r1=r2;c1=c2;k++;h/=2.0;t1=t2;s1=s2;goto loop;}return r2;}11.行列式计算语法:result=js(int s[][],int n)参数:s[][]:行列式存储数组n:行列式维数,递归用返回值:行列式值注意:函数中常数N为行列式维度,需自行定义源程序:int js(s,n)int s[][N],n;{int z,j,k,r,total=0;int b[N][N];/*b[N][N]用于存放,在矩阵s[N][N]中元素s[0]的余子式*/if(n>2){for(z=0;z<n;z++){for(j=0;j<n-1;j++)for(k=0;k<n-1;k++)if(k>=z) b[j][k]=s[j+1][k+1]; else b[j][k]=s[j+1][k];if(z%2==0) r=s[0][z]*js(b,n-1);/*递归调用*/else r=(-1)*s[0][z]*js(b,n-1);total=total+r;}}else if(n==2)total=s[0][0]*s[1][1]-s[0][1]*s[1][0];return total;}12.求排列组合数语法:result=P(long n,long m); / result=long C(long n,long m);参数:m:排列组合的上系数n:排列组合的下系数返回值:排列组合数注意:符合数学规则:m<=n源程序:long P(long n,long m){long p=1;while(m!=0){p*=n;n--;m--;}return p;}long C(long n,long m){long i,c=1;i=m;while(i!=0){c*=n;n--;i--;}while(m!=0){c/=m;m--;}return c;}二、字符串处理1.字符串替换语法:replace(char str[],char key[],char swap[]);参数:str[]:在此源字符串进行替换操作key[]:被替换的字符串,不能为空串swap[]:替换的字符串,可以为空串,为空串表示在源字符中删除key[]返回值: null注意:默认str[]长度小于1000,如否,重新设定设定tmp大小需要 string.h源程序:void replace(char str[],char key[],char swap[]){int l1,l2,l3,i,j,flag;char tmp[1000];l1=strlen(str);l2=strlen(key);l3=strlen(swap);for (i=0;i<=l1-l2;i++){flag=1;for (j=0;j<l2;j++)if (str[i+j]!=key[j]){flag=0;break;}if (flag){strcpy(tmp,str);strcpy(&tmp[i],swap);strcpy(&tmp[i+l3],&str[i+l2]);strcpy(str,tmp);i+=l3-1;l1=strlen(str);}}}2.字符串查找语法:result=strfind(char str[],char key[]);参数:str[]:在此源字符串进行查找操作key[]:被查找的字符串,不能为空串返回值:如果查找成功,返回key在str中第一次出现的位置,否则返回-1注意:需要 string.h源程序:int strfind(char str[],char key[]){int l1,l2,i,j,flag;l1=strlen(str);l2=strlen(key);for (i=0;i<=l1-l2;i++){flag=1;for (j=0;j<l2;j++)if (str[i+j]!=key[j]){flag=0;break;}if (flag) return i;}return -1;}3.字符串截取语法:mid(char str[],int start,int len,char strback[])参数:str[]:操作的目标字符串start:从第start个字符串开始,截取长度为len的字符len:从第start个字符串开始,截取长度为len的字符strback[]截取的到的字符:返回值: 0:超出字符串长度,截取失败;1:截取成功注意:需要 string.h源程序:int mid(char str[],int start,int len,char strback[]){int l,i,k=0;l=strlen(str);if (start+len>l) return 0;for (i=start;i<start+len;i++)strback[k++]=str[i];strback[k]='\0';return 1;}三、计算几何1.叉乘法求任意多边形面积语法:result=polygonarea(Point *polygon,int N);参数:*polygon多变形顶点数组:N:多边形顶点数目返回值:多边形面积注意:支持任意多边形,凹、凸皆可多边形顶点输入时按顺时针顺序排列源程序:typedef struct {double x,y;} Point;double polygonarea(Point *polygon,int N){int i,j;double area = 0;for (i=0;i<N;i++) {j = (i + 1) % N;area += polygon[i].x * polygon[j].y;area -= polygon[i].y * polygon[j].x;}area /= 2;return(area < 0 ? -area : area);}2.求三角形面积语法:result=area3(float x1,float y1,float x2,float y2,floatx3,float y3);参数:x1~3:三角形3个顶点x坐标y1~3:三角形3个顶点y坐标返回值:三角形面积注意:需要 math.h源程序:float area3(float x1,float y1,float x2,float y2,floatx3,float y3){float a,b,c,p,s;a=sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));b=sqrt((x1-x3)*(x1-x3)+(y1-y3)*(y1-y3));c=sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2));p=(a+b+c)/2;s=sqrt(p*(p-a)*(p-b)*(p-c));return s;}3.两矢量间角度语法:result=angle(double x1, double y1, double x2, double y2);参数:x/y1~2两矢量的坐标:返回值:两的角度矢量注意:返回角度为弧度制,并且以逆时针方向为正方向需要 math.h源程序:#define PI 3.1415926double angle(double x1, double y1, double x2, double y2){double dtheta,theta1,theta2;theta1 = atan2(y1,x1);theta2 = atan2(y2,x2);dtheta = theta2 - theta1;while (dtheta > PI)dtheta -= PI*2;while (dtheta < -PI)dtheta += PI*2;return(dtheta);}4.两点距离(2D、3D)语法:result=distance_2d(float x1,float x2,float y1,float y2);参数:x/y/z1各点的x、y、z坐标~2:返回值两点之间的距离:注意:需要 math.h源程序:float distance_2d(float x1,float x2,float y1,float y2){return(sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)));}float distance_3d(float x1,float x2,float y1,float y2,float z1,floatz2){return(sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)+(z1-z2)*(z1-z2 )));}5.射向法判断点是否在多边形内部语法:result=insidepolygon(Point *polygon,int N,Point p);参数:*polygon多边形顶点数组:N:多边形顶点个数p:被判断点返回值: 0:点在多边形内部;1:点在多边形外部注意:若p点在多边形顶点或者边上,返回值不确定,需另行判断需要 math.h源程序:#define MIN(x,y) (x < y ? x : y)#define MAX(x,y) (x > y ? x : y)typedef struct {double x,y;} Point;int insidepolygon(Point *polygon,int N,Point p){int counter = 0;int i;double xinters;Point p1,p2;p1 = polygon[0];for (i=1;i<=N;i++) {p2 = polygon[i % N];if (p.y > MIN(p1.y,p2.y)) {if (p.y <= MAX(p1.y,p2.y)) {if (p.x <=MAX(p1.x,p2.x)) {if (p1.y != p2.y) {xinters = (p.y-p1.y)*(p2.x-p1.x)/(p2.y-p1.y)+p1.x;if (p1.x == p2.x || p.x <= xinters)counter++;}}}}p1 = p2;}if (counter % 2 == 0)return(OUTSIDE);elsereturn(INSIDE);}6.判断点是否在线段上语法:result=Pointonline(Point p1,Point p2,Point p);参数:p1、p2:线段的两个端点p:被判断点返回值: 0:点在不在线段上;1:点在线段上注意:若p线段端点上返回1需要 math.h源程序:#define MIN(x,y) (x < y ? x : y)#define MAX(x,y) (x > y ? x : y)typedef struct {double x,y;} Point;int FC(double x1,double x2){if (x1-x2<0.000002&&x1-x2>-0.000002) return 1;else return 0;}int Pointonline(Point p1,Point p2,Point p){double x1,y1,x2,y2;x1=p.x-p1.x;x2=p2.x-p1.x;y1=p.y-p1.y;y2=p2.y-p1.y;if (FC(x1*y2-x2*y1,0)==0) return 0;if ((MIN(p1.x,p2.x)<=p.x&&p.x<=MAX(p1.x,p2.x))&&(MIN(p1.y,p2.y)<=p.y&&p.y<=MAX(p1.y,p2.y)))return 1; else return 0;}7.判断两线段是否相交语法:result=sectintersect(Point p1,Point p2,Point p3,Point p4);参数:p1两条线段的四个端点~4:返回0:两线段不相交;1:两线段相交;2两线段首尾相接值:注意:p1!=p2;p3!=p4;源程序:#define MIN(x,y) (x < y ? x : y)#define MAX(x,y) (x > y ? x : y)typedef struct {double x,y;} Point;int lineintersect(Point p1,Point p2,Point p3,Point p4){Point tp1,tp2,tp3;if((p1.x==p3.x&&p1.y==p3.y)||(p1.x==p4.x&&p1.y==p4.y)||(p2.x==p3.x&&p2.y==p3.y)| |(p2.x==p4.x&&p2.y==p4.y))return 2;//快速排斥试验if((MIN(p1.x,p2.x)<p3.x&&p3.x<MAX(p1.x,p2.x)&&MIN(p1.y,p2.y)<p3.y<MAX(p1.y,p2.y) )||(MIN(p1.x,p2.x)<p4.x&&p3.x<MAX(p1.x,p2.x)&&MIN(p1.y,p2 .y)<p3.y<MAX(p1.y,p2.y)));else return 0;//跨立试验tp1.x=p1.x-p3.x;tp1.y=p1.y-p3.y;tp2.x=p4.x-p3.x;tp2.y=p4.y-p3.y;tp3.x=p2.x-p3.x;tp3.y=p2.y-p3.y;if ((tp1.x*tp2.y-tp1.y*tp2.x)*(tp2.x*tp3.y-tp2.y*tp3.x)>=0) return 1;else return 0;}8.判断线段与直线是否相交语法:result=lineintersect(Point p1,Point p2,Point p3,Point p4);参数:p1、p2:线段的两个端点p3、p4:直线上的两个点返回值: 0:线段直线不相交;1:线段和直线相交注意:如线段在直线上,返回 1源程序:typedef struct {double x,y;} Point;int lineintersect(Point p1,Point p2,Point p3,Point p4){Point tp1,tp2,tp3;tp1.x=p1.x-p3.x;tp1.y=p1.y-p3.y;tp2.x=p4.x-p3.x;tp2.y=p4.y-p3.y;tp3.x=p2.x-p3.x;tp3.y=p2.y-p3.y;if((tp1.x*tp2.y-tp1.y*tp2.x)*(tp2.x*tp3.y-tp2.y*tp3.x)>=0)return 1; else return 0;}9.点到线段最短距离语法:result=mindistance(Point p1,Point p2,Point q);参数:p1、线段的两个端点p2:q判断点:回点q到线段p1p2的距离值:注意:需要 math.h源程序:#define MIN(x,y) (x < y ? x : y)#define MAX(x,y) (x > y ? x : y)typedef struct {double x,y;} Point;double mindistance(Point p1,Point p2,Point q){int flag=1;double k;Point s;if (p1.x==p2.x) {s.x=p1.x;s.y=q.y;flag=0;}if (p1.y==p2.y) {s.x=q.x;s.y=p1.y;flag=0;}if (flag){k=(p2.y-p1.y)/(p2.x-p1.x);s.x=(k*k*p1.x+k*(q.y-p1.y)+q.x)/(k*k+1);s.y=k*(s.x-p1.x)+p1.y;}if (MIN(p1.x,p2.x)<=s.x&&s.x<=MAX(p1.x,p2.x))return sqrt((q.x-s.x)*(q.x-s.x)+(q.y-s.y)*(q.y-s.y));elsereturnMIN(sqrt((q.x-p1.x)*(q.x-p1.x)+(q.y-p1.y)*(q.y-p1.y)),sqrt((q.x-p2.x)*(q.x-p2.x)+(q.y-p2.y)*(q.y-p2.y)));}10.求两直线的交点语法:result=mindistance(Point p1,Point p2,Point q);参数:p1~直线上不相同的两点p4:*通过指针返回结果p返回1:两直线相交;2:两直线平行值:注意:如需要判断两线段交点,检验k和对应k1(注释中)的值是否在0~1之间,用在0~1之间的那个求交点源程序:typedef struct {double x,y;} Point;int linecorss(Point p1,Point p2,Point p3,Point p4,Point *p){double k;//同一直线if ((p4.x-p3.x)*(p1.y-p3.y)-(p4.y-p3.y)*(p1.x-p3.x)==0&&(p2.x-p1.x)*(p1.y-p3.y)-(p2.y-p1.y)*(p1.x-p3.x)==0) return 2;//平行,不同一直线if ((p4.y-p3.y)*(p2.x-p1.x)-(p4.x-p3.x)*(p2.y-p1.y)==0) return 0;k=((p4.x-p3.x)*(p1.y-p3.y)-(p4.y-p3.y)*(p1.x-p3.x))/((p4.y-p3.y)*(p2.x-p1.x)-( p4.x-p3.x)*(p2.y-p1.y));//k1=((p2.x-p1.x)*(p1.y-p3.y)-(p2.y-p1.y)*(p1.x-p3.x))/((p4.y-p3.y)*(p2.x-p1.x )-(p4.x-p3.x)*(p2.y-p1.y));(*p).x=p1.x+k*(p2.x-p1.x);(*p).y=p1.y+k*(p2.y-p1.y);return 1;//有交点}11.判断一个封闭图形是凹集还是凸集语法:result=convex(Point *p,int n);参数:*p:封闭曲线顶点数组n:封闭曲线顶点个数返回值: 1:凸集;-1:凹集;0:曲线不符合要求无法计算注意:默认曲线为简单曲线:无交叉、无圈源程序:typedef struct {double x,y;} Point;int convex(Point *p,int n){int i,j,k;int flag = 0;double z;if (n < 3)return(0);for (i=0;i<n;i++) {j = (i + 1) % n;k = (i + 2) % n;z = (p[j].x - p[i].x) * (p[k].y - p[j].y);z -= (p[j].y - p[i].y) * (p[k].x - p[j].x);if (z < 0)flag |= 1;else if (z > 0)flag |= 2;if (flag == 3)return -1; //CONCAVE}if (flag != 0)return 1; //CONVEXelsereturn 0;}12.Graham扫描法寻找凸包语法:Graham_scan(Point PointSet[],Point ch[],int n,int &len);参数:PointSe输入的点集t[]:ch[]:输出的凸包上的点集,按照逆时针方向排列n: PointSet中的点的数目len:输出的凸包上的点的个数返回值: null源程序:struct Point{float x,y;};float multiply(Point p1,Point p2,Point p0){return((p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y));}float distance(Point p1,Point p2){return(sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y)));}void Graham_scan(Point PointSet[],Point ch[],int n,int &len){int i,j,k=0,top=2;Point tmp;for(i=1;i<n;i++)if((PointSet[i].y<PointSet[k].y)||((PointSet[i].y==PointSet[k].y)&&(PointSet[i].x<PointSet[k].x)))k=i;tmp=PointSet[0];PointSet[0]=PointSet[k];PointSet[k]=tmp;for (i=1;i<n-1;i++){k=i;for (j=i+1;j<n;j++)if ((multiply(PointSet[j],PointSet[k],PointSet[0])>0) ||((multiply(PointSet[j],PointSet[ k],PointSet[0])==0)&&(distance(PointSet[0] ,PointSet[j])<distance(PointSet[0],PointSet[k]))) )k=j;tmp=PointSet[i];PointSet[i]=PointSet[k];PointSet[k]=tmp;}ch[0]=PointSet[0];ch[1]=PointSet[1];ch[2]=PointSet[2];for (i=3;i<n;i++){while (multiply(PointSet[i],ch[top],ch[top-1])>=0) top--;ch[++top]=PointSet[i];}len=top+1;}四、数论1.x的二进制长度语法:result=BitLength(int x);参数:x:测长的x返回值: x的二进制长度源程序:int BitLength(int x){int d = 0;while (x > 0) {x >>= 1;d++;}return d;}2.返回x的二进制表示中从低到高的第i位语法:result=BitAt(int x, int i);参数:x:十进制 xi:要求二进制的第i位返回值:返回x的二进制表示中从低到高的第i位注意:最低位为第一位源程序:int BitAt(int x, int i){return ( x & (1 << (i-1)) );}3.模取幂运算语法:result=Modular_Expoent(int a,int b,int n);参数:a、b、na^b mod n 的对应参数:返回值: a^b mod n 的值注意:需要BitLength和BitAt源程序:int Modular_Expoent(int a,int b,int n){int i, y=1;for (i = BitLength(b); i > 0; i--){y = (y*y)%n;if (BitAt(b,i) > 0)y = (y*a)%n;}return y;}4.求解模线性方程语法:result=modular_equation(int a,int b,int n);参数:a、b、nax=b (mod n) 的对应参数:返回值:方程的解源程序:int ext_euclid(int a,int b,int &x,int &y) //求gcd(a,b)=ax+by{int t,d;if (b==0) {x=1;y=0;return a;}d=ext_euclid(b,a %b,x,y);t=x;x=y;y=t-a/b*y;return d;}void modular_equation(int a,int b,int n){int e,i,d;int x,y;d=ext_euclid(a,n,x,y);if (b%d>0)printf("No answer!\n");else{e=(x*(b/d))%n;for (i=0;i<d;i++)printf("The %dth answer is : %ld\n",i+1,(e+i*(n/d))%n);}}5.求解模线性方程组(中国余数定理)语法:result=Modular_Expoent(int a,int b,int n);参数:B[]、W[]a=B[] (mod W[]) 的对应参数:返回值: a 的值注意:其中W[],B[]已知,W[i]>0且W[i]与W[j]互质, 求a 源程序:int ext_euclid(int a,int b,int &x,int &y) //求gcd(a,b)=ax+by{int t,d;if (b==0) {x=1;y=0;return a;}d=ext_euclid(b,a %b,x,y);t=x;x=y;y=t-a/b*y;return d;}int China(int B[],int W[],int k){int i;int d,x,y,a=0,m,n=1;for (i=0;i<k;i++)n*=W[i];for (i=0;i<k;i++){m=n/W[i];d=ext_euclid(W[i],m,x,y);a=(a+y*m*B[i])%n;}if (a>0) return a;else return(a+n);}6.筛法素数产生器语法:result=prime(int a[],int n);参数:a[]:用于返回素数的数组n:产生n以内的素数,按升序放入a[]中返回值: n以内素数的个数注意:其中W[],B[]已知,W[i]>0且W[i]与W[j]互质, 求a 源程序:int prime(int a[],int n){int i,j,k,x,num,*b;n++;n/=2;b=(int *)malloc(sizeof(int)*(n+1)*2);a[0]=2;a[1]=3;num=2;for(i=1;i<=2*n;i++)b[i]=0;for(i=3;i<=n;i+=3)for(j=0;j<2;j++){x=2*(i+j)-1;while(b[x]==0){a[num++]=x;for(k=x;k<=2*n;k+=x)b[k]=1;}}return num;}7.判断一个数是否素数语法:result=comp(int n);参数:n:判断n是否素数返回值:素数返回1,否则返回0源程序:int comp(int n){int i,flag=1;for (i=2;i<=sqrt(n);i++)if (n%i==0) {flag=0;break;}if (flag==1) return 1; else return 0;}五、图论1.Prim算法求最小生成树语法:prim(Graph G,int vcount,int father[]);参数:G:图,用邻接矩阵表示vcount:表示图的顶点个数father[]用来记录每个节点的父节点:返回值: null注意:常数max_vertexes为图最大节点数常数infinity为无穷大源程序:#define infinity 1000000#define max_vertexes 5typedef int Graph[max_vertexes][max_vertexes];void prim(Graph G,int vcount,int father[]){int i,j,k;intlowcost[max_vertexes],closeset[max_vertexes],used[max_vertexes];for (i=0;i<vcount;i++){lowcost[i]=G[0][i];closeset[i]=0;used[i]=0;father[i]=-1;}used[0]=1;for (i=1;i<vcount;i++){j=0;while (used[j]) j++;for (k=0;k<vcount;k++)if ((!used[k])&&(lowcost[k]<lowcost[j])) j=k;father[j]=closeset[j];used[j]=1;for (k=0;k<vcount;k++)if (!used[k]&&(G[j][k]<lowcost[k])){ lowcost[k]=G[j][k];closeset[k]=j; }}}2.Dijkstra算法求单源最短路径语法:result=Dijkstra(Graph G,int n,int s,int t, int path[]);参数:G:图,用邻接矩阵表示n:图的顶点个数s:开始节点t:目标节点path[]:用于返回由开始节点到目标节点的路径返回值:最短路径长度注意:输入的图的权必须非负顶点标号从0开始用如下方法打印路径:i=t;while (i!=s){printf("%d<--",i+1);i=path[i];}printf("%d\n",s+1);源程序:int Dijkstra(Graph G,int n,int s,int t, int path[]){inti,j,w,minc,d[max_vertexes],mark[max_vertexes];for (i=0;i<n;i++) mark[i]=0;for (i=0;i<n;i++){ d[i]=G[s][i];path[i]=s; }mark[s]=1;path[s]=0;d[s]=0;for (i=1;i<n;i++){minc=infinity;w=0;for (j=0;j<n;j++)if ((mark[j]==0)&&(minc>=d[j])) {minc=d[j];w=j;}mark[w]=1;for (j=0;j<n;j++)if((mark[j]==0)&&(G[w][j]!=infinity)&&(d[j]>d[w]+G[w][j])){ d[j]=d[w]+G[w][j];path[j]=w; }}return d[t];}3.Bellman-ford算法求单源最短路径语法:result=Bellman_ford(Graph G,int n,int s,int t,int path[],intsuccess);参数:G:图,用邻接矩阵表示n:图的顶点个数s:开始节点t:目标节点path[]:用于返回由开始节点到目标节点的路径success函数是否执行成功:返回值:最短路径长度注意:输入的图的权可以为负,如果存在一个从源点可达的权为负的回路则success=0顶点标号从0开始用如下方法打印路径:i=t;while (i!=s){printf("%d<--",i+1);i=path[i];}printf("%d\n",s+1);源程序:int Bellman_ford(Graph G,int n,int s,int t,int path[],intsuccess){int i,j,k,d[max_vertexes];for (i=0;i<n;i++) {d[i]=infinity;path[i]=0;}d[s]=0;for (k=1;k<n;k++)for (i=0;i<n;i++)for (j=0;j<n;j++)if (d[j]>d[i]+G[i][j]){d[j]=d[i]+G[i][j];path[j]=i;}success=0;for (i=0;i<n;i++)for (j=0;j<n;j++)if (d[j]>d[i]+G[i][j]) return 0;success=1;return d[t];}4.Floyd-Warshall算法求每对节点间最短路径语法:Floyd_Washall(Graph G,int n,Graph D,Graph P);参数:G:图,用邻接矩阵表示n:图的顶点个数D: D[i,j]表示从i到j的最短距离P: P[i,j]表示从i到j的最短路径上j 的父节点返回值: null源程序:void Floyd_Washall(Graph G,int n,Graph D,Graph P){int i,j,k;for (i=0;i<n;i++)for (j=0;j<n;j++){ D[i][j]=G[i][j];P[i][j]=i; }for (i=0;i<n;i++) { D[i][i]=0;P[i][i]=0; }for (k=0;k<n;k++)for (i=0;i<n;i++)for (j=0;j<n;j++)if(D[i][j]>D[i][k]+D[k][j]){D[i][j]=D[i][k]+D[k][j];P[i][j]= P[k][j]; }}六、排序/查找1.快速排序语法:quicksort(int l,int r,int b[]);参数:l:排序上界,开始时l=0r:排序下界,开始时r=数组元素个数b[]:被排序的元素返回值: null注意:输出升序序列源程序:void quicksort(int l,int r,int b[]){int i,j,x;if(l>=r) return;i=l;j=r;x=b[i];while(i!=j){while(b[j]>x&&j>i) j--;if(i<j){b[i]=b[j];i++;}while(b[i]<x&&j>i)i++;if(i<j){b[j]=b[i];j--;}}b[i]=x;quicksort(l,j-1,b);quicksort(i+1,r,b);}2.希尔排序语法:shellsort(int a[],int n);参数:n:数组元素个数a[]:待排序数组返回值: null注意:输出升序序列源程序:void shellsort(int a[],int n){int i,j,g;int temp,k;g=n/2;while(g!=0){for(i=g+1;i<=n;i++){temp=a[i];j=i-g;while(j>0){k=j+g;if(a[j]<=a[k])j=0;else{temp=a[j];a[j]=a [k];a[k]=temp;}j=j-g;}}g=g/2;}}3.选择法排序语法:sort(int t[],int n);参数:t[]:待排序数组n:数组t[]元素的个数返回值: null注意:输出升序序列小规模排序用源程序:void sort(int t[],int n){int i,j,k,temp;for (i=0;i<n;i++){k=i;for (j=i;j<n;j++) if (t[j]<t[k]) k=j;temp=t[i];t[i]=t[k];t[k]=temp;}}4.二分查找语法:result=search_bin(int *t,int k);参数:t[]:待查找数组k:查找关键字返回值:如果k在t[]中存在,输出i:t[i]=k,否则输出-1注意:要求查找数组是有序升序序列源程序:int search_bin(int *t,int k){int low=1,high=10,mid;while (low<=high){mid=(low+high)/2;if (k==t[mid]) return mid;else if (k<t[mid]) high=mid-1;else low=mid+1;}return -1;}七、数据结构1.顺序队列源程序:#define maxsize 100typedef struct{int data[maxsize];int front;int rear;} sqqueue;int sqinit(sqqueue *p) //队列初始化{p->front=0;p->rear=0;return 1;}int enqueue(sqqueue *q, int e) //入队{if((q->rear+1)%maxsize==q->front)return 0;elseq->data[q->rear]=e;q->rear=(q->rear+1)%maxsize;return 1;}int dequeue(sqqueue *q) //出队{int e;if (q->front==q->rear)return 0;e=q->data[q->front];q->front=(q->front+1)%maxsize;return e;}int empty(sqqueue *q) //判空{int v;if (q->front==q->rear)v=1;elsev=0;return v;}int gethead(sqqueue *q) //取得头元素{int e;if (q->front==q->rear)e=-1;elsee=q->data[q->front];return e;}void display(sqqueue *q) //显示所有元素{int s;s=q->front;printf("the sequeue is display:\n");if (q->front==q->rear)printf("the sequeue is empty!");else{while(s<q->rear){printf("->%d", q->data[s]);s=(s+1)%maxsize;}printf("\n");}}main(sqqueue *head) //函数使用样例{。
简便算法的题型 ACM 题型算法分类
ACM 题型算法分类题目均来自主流算法搜索//回溯DP(动态规划)贪心图论//Dijkstra、最小生成树、网络流数论//解模线性方程计算几何//凸壳、同等安置矩形的并的面积与周长组合数学//Polya定理模拟数据结构//并查集、堆10.博弈论1、排序1423, 1694, 1723, 1727, 1763, 1788, 1828, 1838, 1840, 2201, 2376, 2377, 2380,1318, 1877, 1928, 1971, 1974, 1990, 2001, 2002, 2092, 2379,1002(需要字符处理,排序用快排即可)1007(稳定的排序)2159(题意较难懂)2231 2371(简单排序)2388(顺序统计算法)2418(二叉排序树)2、搜索、回溯、遍历1022 1111d 1118 1129 1190 1562 1564 1573 1655 2184 2225 2243 2312 2362 2378 2386 1010,1011,1018,1020,1054,1062,1256,1321,1363,1501,1650,1659,1664,1753,2078,2083,2303,2310,2329简单1128, 1166, 1176, 1231, 1256, 1270, 1321, 1543, 1606, 1664, 1731, 1742,1745, 1847, 1915, 1950, 2038, 2157, 2182, 2183, 2381, 2386, 2426,不易1024, 1054, 1117, 1167, 1708, 1746, 1775, 1878, 1903, 1966, 2046, 2197,2349,推荐1011, 1190, 1191, 1416, 1579, 1632, 1639, 1659, 1680, 1683, 1691, 1709,1714, 1753, 1771, 1826, 1855, 1856, 1890, 1924, 1935, 1948, 1979, 1980, 2170,2288, 2331, 2339, 2340,1979(和迷宫类似)1980(对剪枝要求较高)3、历法1008 2080 (这种题要小心)4、枚举1012,1046,1387,1411,2245,2326,2363,2381,1054(剪枝要求较高),1650 (小数的精度问题)5、数据结构的典型算法容易1182, 1656, 2021, 2023, 2051, 2153, 2227, 2236, 2247, 2352, 2395,不易1145, 1177, 1195, 1227, 1661, 1834,推荐1330, 1338, 1451, 1470, 1634, 1689, 1693, 1703, 1724, 1988, 2004, 2010,2119, 2274, 1125(弗洛伊德算法) ,2421(图的最小生成树)6、动态规划1037 A decorative fence、1050 To the Max、1088 滑雪、1125 Stockpoker Grapevine、1141 Brackets Sequence、1159 Palindrome、1160 Post Office、1163 The Triangle、1458 Common Subsequence、1579 Function Run Fun、1887 Testing the CATCHER、1953 World Cup Noise、2386 Lake Counting7、贪心1042, 1065, 1230, 1323, 1477, 1716, 1784,1328 1755(或用单纯形方法),2054,1017,1328,1862,1922 ,2054,2209,2313,2325,2370。
计算几何C#源码
/*计算几何目录㈠点的基本运算1. 平面上两点之间距离 12. 判断两点是否重合 13. 矢量叉乘 14. 矢量点乘 25. 判断点是否在线段上 26. 求一点饶某点旋转后的坐标 27. 求矢量夹角 2㈡线段及直线的基本运算1. 点与线段的关系 32. 求点到线段所在直线垂线的垂足 43. 点到线段的最近点 44. 点到线段所在直线的距离 45. 点到折线集的最近距离 46. 判断圆是否在多边形内 57. 求矢量夹角余弦 58. 求线段之间的夹角 59. 判断线段是否相交 610.判断线段是否相交但不交在端点处 611.求线段所在直线的方程 612.求直线的斜率 713.求直线的倾斜角 714.求点关于某直线的对称点 715.判断两条直线是否相交及求直线交点 716.判断线段是否相交,如果相交返回交点 7㈢多边形常用算法模块1. 判断多边形是否简单多边形 82. 检查多边形顶点的凸凹性 93. 判断多边形是否凸多边形 94. 求多边形面积 95. 判断多边形顶点的排列方向,方法一 106. 判断多边形顶点的排列方向,方法二 107. 射线法判断点是否在多边形内 108. 判断点是否在凸多边形内 119. 寻找点集的graham算法 1210.寻找点集凸包的卷包裹法 1311.判断线段是否在多边形内 1412.求简单多边形的重心 1513.求凸多边形的重心 1714.求肯定在给定多边形内的一个点 1715.求从多边形外一点出发到该多边形的切线 1816.判断多边形的核是否存在 19㈣圆的基本运算1 .点是否在圆内 202 .求不共线的三点所确定的圆 21㈤矩形的基本运算1.已知矩形三点坐标,求第4点坐标 22㈥常用算法的描述 22㈦补充1.两圆关系: 242.判断圆是否在矩形内: 243.点到平面的距离: 254.点是否在直线同侧: 255.镜面反射线: 256.矩形包含: 267.两圆交点: 278.两圆公共面积: 289. 圆和直线关系: 2910. 内切圆: 3011. 求切点: 3112. 线段的左右旋: 3113.公式: 32*//* 需要包含的头文件 */#include <cmath >/* 常用的常量定义 */const double INF = 1E200const double EP = 1E-10const int MAXV = 300const double PI = 3.14159265/* 基本几何结构 */struct POINT{double x;double y;POINT(double a=0, double b=0) { x=a; y=b;} //constructor};struct LINESEG{POINT s;POINT e;LINESEG(POINT a, POINT b) { s=a; e=b;}LINESEG() { }};struct LINE // 直线的解析方程 a*x+b*y+c=0 为统一表示,约定 a >= 0{double a;double b;double c;LINE(double d1=1, double d2=-1, double d3=0) {a=d1; b=d2; c=d3;} };/*********************** ** 点的基本运算 ** ***********************/double dist(POINT p1,POINT p2) // 返回两点之间欧氏距离{return( sqrt( (p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y) ) ); }bool equal_point(POINT p1,POINT p2) // 判断两个点是否重合{return ( (abs(p1.x-p2.x)<EP)&&(abs(p1.y-p2.y)<EP) );}/******************************************************************** **********r=multiply(sp,ep,op),得到(sp-op)和(ep-op)的叉积r>0:ep在矢量opsp的逆时针方向;r=0:opspep三点共线;r<0:ep在矢量opsp的顺时针方向********************************************************************* **********/double multiply(POINT sp,POINT ep,POINT op){return((sp.x-op.x)*(ep.y-op.y)-(ep.x-op.x)*(sp.y-op.y));}/*r=dotmultiply(p1,p2,op),得到矢量(p1-op)和(p2-op)的点积,如果两个矢量都非零矢量r<0:两矢量夹角为钝角;r=0:两矢量夹角为直角;r>0:两矢量夹角为锐角********************************************************************* **********/double dotmultiply(POINT p1,POINT p2,POINT p0){return ((p1.x-p0.x)*(p2.x-p0.x)+(p1.y-p0.y)*(p2.y-p0.y));}/******************************************************************** **********判断点p是否在线段l上条件:(p在线段l所在的直线上) && (点p在以线段l为对角线的矩形内)********************************************************************* **********/bool online(LINESEG l,POINT p){return( (multiply(l.e,p,l.s)==0) &&( ( (p.x-l.s.x)*(p.x-l.e.x)<=0 )& &( (p.y-l.s.y)*(p.y-l.e.y)<=0 ) ) );}// 返回点p以点o为圆心逆时针旋转alpha(单位:弧度)后所在的位置POINT rotate(POINT o,double alpha,POINT p){POINT tp;p.x-=o.x;p.y-=o.y;tp.x=p.x*cos(alpha)-p.y*sin(alpha)+o.x;tp.y=p.y*cos(alpha)+p.x*sin(alpha)+o.y;return tp;}/* 返回顶角在o点,起始边为os,终止边为oe的夹角(单位:弧度)角度小于pi,返回正值角度大于pi,返回负值可以用于求线段之间的夹角原理:r = dotmultiply(s,e,o) / (dist(o,s)*dist(o,e))r'= multiply(s,e,o)r >= 1 angle = 0;r <= -1 angle = -PI-1<r<1 && r'>0 angle = arccos(r)-1<r<1 && r'<=0 angle = -arccos(r)double angle(POINT o,POINT s,POINT e){double cosfi,fi,norm;double dsx = s.x - o.x;double dsy = s.y - o.y;double dex = e.x - o.x;double dey = e.y - o.y;cosfi=dsx*dex+dsy*dey;norm=(dsx*dsx+dsy*dsy)*(dex*dex+dey*dey);cosfi /= sqrt( norm );if (cosfi >= 1.0 ) return0;if (cosfi <= -1.0 ) return -3.1415926;fi=acos(cosfi);if (dsx*dey-dsy*dex>0) return fi; // 说明矢量os 在矢量 oe的顺时针方向return -fi;}/*****************************\* ** 线段及直线的基本运算 ** *\*****************************//* 判断点与线段的关系,用途很广泛本函数是根据下面的公式写的,P是点C到线段AB所在直线的垂足AC dot ABr = ---------||AB||^2(Cx-Ax)(Bx-Ax) + (Cy-Ay)(By-Ay)= -------------------------------L^2r has the following meaning:r=0 P = Ar=1 P = Br<0 P is on the backward extension of ABr>1 P is on the forward extension of AB0<r<1 P is interior to ABdouble relation(POINT p,LINESEG l){LINESEG tl;tl.s=l.s;tl.e=p;return dotmultiply(tl.e,l.e,l.s)/(dist(l.s,l.e)*dist(l.s,l.e)); }// 求点C到线段AB所在直线的垂足 PPOINT perpendicular(POINT p,LINESEG l){double r=relation(p,l);POINT tp;tp.x=l.s.x+r*(l.e.x-l.s.x);tp.y=l.s.y+r*(l.e.y-l.s.y);return tp;}/* 求点p到线段l的最短距离,并返回线段上距该点最近的点np注意:np是线段l上到点p最近的点,不一定是垂足 */double ptolinesegdist(POINT p,LINESEG l,POINT &np){double r=relation(p,l);if(r<0){np=l.s;return dist(p,l.s);}if(r>1){np=l.e;return dist(p,l.e);}np=perpendicular(p,l);return dist(p,np);}// 求点p到线段l所在直线的距离,请注意本函数与上个函数的区别double ptoldist(POINT p,LINESEG l){return abs(multiply(p,l.e,l.s))/dist(l.s,l.e);}/* 计算点到折线集的最近距离,并返回最近点.注意:调用的是ptolineseg()函数 */double ptopointset(int vcount,POINT pointset[],POINT p,POINT &q) {int i;double cd=double(INF),td;LINESEG l;POINT tq,cq;for(i=0;i<vcount-1;i++){l.s=pointset[i];l.e=pointset[i+1];td=ptolinesegdist(p,l,tq);if(td<cd){cd=td;cq=tq;}}q=cq;return cd;}/* 判断圆是否在多边形内.ptolineseg()函数的应用2 */bool CircleInsidePolygon(int vcount,POINT center,double radius,POINT polygon[]){POINT q;double d;q.x=0;q.y=0;d=ptopointset(vcount,polygon,center,q);if(d<radius||fabs(d-radius)<EP)return true;elsereturn false;}/* 返回两个矢量l1和l2的夹角的余弦(-1 --- 1)注意:如果想从余弦求夹角的话,注意反余弦函数的定义域是从 0到pi */double cosine(LINESEG l1,LINESEG l2){return (((l1.e.x-l1.s.x)*(l2.e.x-l2.s.x) +(l1.e.y-l1.s.y)*(l2.e.y-l2.s.y))/(dist(l1.e,l1.s)*dist(l2.e,l2.s))) );}// 返回线段l1与l2之间的夹角单位:弧度范围(-pi,pi)double lsangle(LINESEG l1,LINESEG l2){POINT o,s,e;o.x=o.y=0;s.x=l1.e.x-l1.s.x;s.y=l1.e.y-l1.s.y;e.x=l2.e.x-l2.s.x;e.y=l2.e.y-l2.s.y;return angle(o,s,e);}// 如果线段u和v相交(包括相交在端点处)时,返回true////判断P1P2跨立Q1Q2的依据是:( P1 - Q1 ) × ( Q2 - Q1 ) * ( Q2 - Q1 ) × ( P2 - Q1 ) >= 0。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
------------------------------------------------------------------------------------------------------------------------------------------ (1)凸包/*凸包cug_1038*/#include <stdio.h>#include <stdlib.h>struct point{int x, y;}pp;point p[100005];int stack[100005], top;int dis(point a, point b){return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));}int multi(point b, point c, point a){return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);}void swap(point p[], int s, int t){point tmp;tmp = p[s];p[s] = p[t];p[t] = tmp;}int cmp(const void *a, const void *b){point *c = (point *)a;point *d = (point *)b;double k = multi(*c, *d, pp);if(k < 0) return 1;else if(k == 0 && dis(*c, pp) >= dis(*d, pp)) return 1;else return -1;}void Graham(point p[], int n, int stack[], int &top){int i, u;u = 0;for(i = 1;i < n;i++){if(p[i].y == p[u].y && p[i].x < p[u].x) u = i;else if(p[i].y < p[u].y) u = i;}swap(p, 0, u);pp = p[0];qsort(p + 1, n - 1, sizeof(p[0]), cmp);stack[0] = 0;stack[1] = 1;top = 1;for(i = 2;i < n;i++){while(multi(p[i], p[stack[top]], p[stack[top - 1]]) >= 0){if(top == 0) break;top--;}top++;stack[top] = i;}}int main(){int ca, i, j, n;int area;scanf("%d", &ca);for(i = 1;i <= ca;i++){scanf("%d", &n);for(j = 0;j < n;j++){scanf("%d%d", &p[j].x, &p[j].y);}Graham(p, n, stack, top);area = 0;for(j = 1;j <= top - 1;j++){area += abs(multi(p[stack[0]], p[stack[j]], p[stack[j + 1]])); }printf("%.1lf\n", (double)area / 2);}return 0;}--------------------------------------------------------------------------------------------------------------------- (2)判断两条线段是否相交(平行,不平行)bool isIntersected(TPoint s1, TPoint e1, TPoint s2, TPoint e2){//判断线段是否相交//1.快速排斥试验判断以两条线段为对角线的两个矩形是否相交//2.跨立试验if((max(s1.x, e1.x) >= min(s2.x, e2.x)) &&(max(s2.x, e2.x) >= min(s1.x, e1.x)) &&(max(s1.y, e1.y) >= min(s2.y, e2.y)) &&(max(s2.y, e2.y) >= min(s1.y, e1.y)) &&(multi(s2, e1, s1) * multi(e1, e2, s1) >= 0) &&(multi(s1, e2, s2) * multi(e2, e1, s2) >= 0)) return true;return false;}(3)三角形的外接圆(已知不在同一直线上的三点求经过三点的圆)/*三角形的外接圆pku_1329*/#include <stdio.h>#include <math.h>const double eps = 1e-6;typedef struct TPoint{double x;double y;}TPoint;typedef struct TTriangle{TPoint t[3];}TTriangle;typedef struct TCircle{TPoint centre;double r;}TCircle;double distance(TPoint p1, TPoint p2){//计算平面上两个点之间的距离return sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y)); }double triangleArea(TTriangle t){//已知三角形三个顶点的坐标,求三角形的面积return fabs(t.t[0].x * t.t[1].y + t.t[1].x * t.t[2].y + t.t[2].x * t.t[0].y - t.t[1].x * t.t[0].y - t.t[2].x * t.t[1].y - t.t[0].x * t.t[2].y) / 2; }TCircle circumcircleOfTriangle(TTriangle t){//三角形的外接圆TCircle tmp;double a, b, c, c1, c2;double xA, yA, xB, yB, xC, yC;a = distance(t.t[0], t.t[1]);b = distance(t.t[1], t.t[2]);c = distance(t.t[2], t.t[0]);//根据S = a * b * c / R / 4;求半径Rtmp.r = a * b * c / triangleArea(t) / 4;xA = t.t[0].x; yA = t.t[0].y;xB = t.t[1].x; yB = t.t[1].y;xC = t.t[2].x; yC = t.t[2].y;c1 = (xA * xA + yA * yA - xB * xB - yB * yB) / 2;c2 = (xA * xA + yA * yA - xC * xC - yC * yC) / 2;tmp.centre.x = -(c1 * (yA - yC) - c2 * (yA - yB)) /((xA - xB) * (yA - yC) - (xA - xC) * (yA - yB));tmp.centre.y = -(c1 * (xA - xC) - c2 * (xA - xB)) /((yA - yB) * (xA - xC) - (yA - yC) * (xA - xB));return tmp;}int main(){TTriangle t;TCircle circle;double c, d, e;while(scanf("%lf%lf%lf%lf%lf%lf", &t.t[0].x, &t.t[0].y,&t.t[1].x, &t.t[1].y, &t.t[2].x, &t.t[2].y) != EOF){circle = circumcircleOfTriangle(t);// printf("%lf %lf %lf\n", circle.centre.x, circle.centre.y, circle.r);if(fabs(circle.centre.x) < eps) printf("x^2");else if(circle.centre.x < 0) printf("(x - %.3lf)^2 + ", -circle.centre.x);else printf("(x + %.3lf)^2 + ", circle.centre.x);if(fabs(circle.centre.y) < eps) printf("y^2 = ");else if(circle.centre.y < 0) printf("(y - %.3lf)^2 = ", -circle.centre.y);else printf("(y + %.3lf)^2 = ", circle.centre.y);printf("%.3lf^2\n", circle.r);c = 2 * circle.centre.x;d = 2 * circle.centre.y;e = circle.centre.x * circle.centre.x +circle.centre.y * circle.centre.y - circle.r * circle.r;printf("x^2 + y^2 ");//if(fabs(c) < eps)if(c < 0) printf("- %.3lfx ", -c);else printf("+ %.3lfx ", c);if(d < 0) printf("- %.3lfy ", -d);else printf("+ %.3lfy ", d);if(e < 0) printf("- %.3lf = 0\n", -e);else printf("+ %.3lf = 0\n", e);printf("\n");}return 0;}(4)三角形的垂心内心重心中垂线/*cug_1011_垂心内心重心中垂线.cpp*/#include <iostream>#include <cmath>using namespace std;const double eps = 1e-6;struct point{double x, y;};void K(){//到三边距离和最短}void L(double a, double b, double c, double A, double B, double C){ //垂线的交点double t1, t2, t3;t1 = c * cos(A) / cos(M_PI / 2 - C);t2 = c * cos(B) / cos(M_PI / 2 - C);t3 = a * cos(C) / cos(M_PI / 2 - A);t1 += t2 + t3;printf("%.3lf\n", t1);}struct TLine{double a, b, c;};TLine lineFromSegment(point p1, point p2){//线段所在直线,返回直线方程的三个系统TLine tmp;tmp.a = p2.y - p1.y;tmp.b = p1.x - p2.x;tmp.c = p2.x * p1.y - p1.x * p2.y;return tmp;}point LineInter(TLine l1, TLine l2){//求两直线得交点坐标point tmp;if(fabs(l1.b) < eps){tmp.x = -l1.c / l1.a;tmp.y = (-l2.c - l2.a * tmp.x) / l2.b;}else{tmp.x = (l1.c * l2.b - l1.b * l2.c) / (l1.b * l2.a - l2.b * l1.a); tmp.y = (-l1.c - l1.a * tmp.x) / l1.b;}return tmp;}double dis(point a, point b){return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));}void F(double a, double b, double c, double A, double B, double C) {//到三顶点的距离和最短, 费马点/*当三角形最大的顶角小于120度的时候,三角形内一点到三顶点之间的距离最小是与三顶点夹角都成120度的点P当最到顶点大于等于120度,该顶点取最小值补充一下,当三角形的最大角小于120度时,费尔码点在三角形内,作法有多种,可以从任二办向外作等边三角形,联接正三角形的顶点和原三角形的对角,两者的联线即所求。