摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=1042思路：大数阶乘代码如下： 1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 #define N 40000 5 int s[N]; 6 int main() 7 { 8 int i,j,k,t,n; 9 while(scanf("%d",&n)!=EOF)10 {11 memset(s,0,sizeof(s));//每次使用前都要清零 12 s[0]=1;
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=451思路：组合数+全错位全错排列问题,最早是由欧拉给出的答案.我们不妨设N个人的拿法为f(N),则f(N)=(N-1)[f(N-1)+f(N-2)].f(0)=0,f(1)=1.这个递推公式是很容易证明的.证明如下:设N个人为a,b,c,d...,N张卡为A,B,C,D...若a拿b的卡B,b也拿a的卡A,则显然只剩下N-2个人拿卡,自然是f(N-2)种了.若a拿b的卡B,b没拿a的卡A(与"b没拿b的卡B"相同),则显然与N-1个人拿卡一样,自然是f(N-1)种了.而
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=469思路：动态规划dp题目分析：由于第一个只能是1，则第二个数只能是2,3当第二个数是2时，则相当于是对2-n的排列，相当于对1-(n-1)的排列,即s[n-1];当第二个数是3时，第三个数只能是2,4,5此时，当第三个数为2时，则是对3-n的排列，相当于对1-(n-3)的排列，即s[n-3] 当第三个数为4时，此时，第四个数只能是2，除了n等于4时，对于n大于4的排列，都不符合要求， 而n为4时，与第三个数为5时的排列相同，所以， 可认为第三个数为4时不符合要求， 当第三个数...
阅读全文
摘要：ACM队不是为了一场比赛而存在的，为的是队员的整体提高。大学期间，ACM队队员必须要学好的课程有：lC/C++两种语言l高等数学l线性代数l数据结构l离散数学l数据库原理l操作系统原理l计算机组成原理l人工智能l编译原理l算法设计与分析除此之外，我希望你们能掌握一些其它的知识，因为知识都是相互联系，触类旁通的。以下学习计划每学期中的内容不分先后顺序，虽说是为立志于学习ACM的同学列的知识清单，但内容不限于ACM的知识。英语之类与专业相距较远的课程请自行分配时间，这里不再列举。大一上学期：必学：1.C语言基础语法必须全部学会a)推荐“语言入门”分类20道题以上b)提前完成C语言课程设计2.简单数
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=91思路：贪心，最大到最小依次加~~代码如下： 1 #include<stdio.h> 2 #include<string.h> 3 int main() 4 { 5 int m,n,i,aim; 6 int a[11]; 7 memset(a,0,sizeof(a)); 8 a[1]=1; 9 for(i=2;i<=10;i++) //计算阶乘 10 a[i]=a[i-1]*i;11 scanf("%d",&m);12 ...
阅读全文
摘要：一．贪心算法的基本概念当一个问题具有最优子结构性质时，我们会想到用动态规划法去解它。但有时会有更简单有效的算法。我们来看一个找硬币的例子。假设有四种硬币，它们的面值分别为二角五分、一角、五分和一分。现在要找给某顾客六角三分钱。这时，我们会不假思索地拿出2个二角五分的硬币，1个一角的硬币和3个一分的硬币交给顾客。这种找硬币方法与其他的找法相比，所拿出的硬币个数是最少的。这里，我们下意识地使用了这样的找硬币算法：首先选出一个面值不超过六角三分的最大硬币，即二角五分；然后从六角三分中减去二角五分，剩下三角八分；再选出一个面值不超过三角八分的最大硬币，即又一个二角五分，如此一直做下去。这个找硬币的方法
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=79思路：同NYOJ 17 单调递增最长子序列（经典dp）而本题区别是求最长递减子序列的长度，只需要改动a[i]与a[j]大小方向即可 动态规划法:O(n^2) 设f(i)表示L中以ai为末元素的最长递增子序列的长度。则有如下的递推方程： f(i)=max(f(i+1),f(i+2),...,f(L-1),f(L))+1；用一个int dp[i]数组保存当前的f(i)值，可想而知最后 *max_element(dp,dp+L) 便得到了答案 这个递推方程的意思是，在求以ai为末元素的...
阅读全文
摘要：题目：键盘输入一个高精度的正整数ｎ（<=240位），去掉任意ｓ个数字后剩下的数字按原左右次序将组成一个新的正整数。编程对给定的ｎ和ｓ，寻找一种方案，使得剩下的数最小。Simple Input1785434Simple Output13思路：每一步总是选择一个使剩下的数最小的数字删除，即按高位到低位的顺序搜索，若各位数字递增，则删除最后一个数字；否则删除第一个递减区间的首字符，这样删一位便形成了一个新的数字串。然后回到串首，按上述规则再删除下一个数字参考借鉴代码1如下： 1 #include<iostream> 2 #include<string> 3 using
阅读全文
摘要：地址：http://poj.org/problem?id=1017翻译：http://poj.grids.cn/practice/1017/思路：贪心算法 ， 其实这道题的关键就是要解决2*2规格的。处理的时候要注意向上调整题目分析：有6*6规格的箱子和一大堆木块 用多少箱子可以把木块都装下先放大的6*6 5*5 4*4 都需要新开箱子 每4个3*3需要开个新箱子 算下剩多少2*2和1*1的 如果不够再开箱子如果一个箱子中放置了一个6*6的产品，则此箱子中无法放置其它产品；若放置一个5*5的产品，则此箱子中还可放置11个1*1的产品；若放4*4的产品，还可放5个2*2的产品。若放置3*3的产品
阅读全文
摘要：大家应该都听说过这个老题目：有 1000 个一模一样的瓶子，其中有 999 瓶是普通的水，有一瓶是毒药。任何喝下毒药的生物都会在一星期之后死亡。现在，你只有 10 只小白鼠和一星期的时间，如何检验出哪个瓶子里有毒药？这个问题的答案也堪称经典：把瓶子从 0 到 999 依次编号，然后全部转换为 10 位二进制数。让第一只老鼠喝掉所有二进制数右起第一位是 1 的瓶子，让第二只老鼠喝掉所有二进制数右起第二位是 1 的瓶子，等等。一星期后，如果第一只老鼠死了，就知道毒药瓶子的二进制编号中，右起第一位是 1 ；如果第二只老鼠没死，就知道毒药瓶子的二进制编号中，右起第二位是 0 ⋯⋯每只老鼠的死活都能确定
阅读全文
摘要：你是否很小就注意到了下面这两个有趣的算术现象？这两个简单的算术谜题是否一直都困扰着你？今天，大家终于有机会解开谜团了。问题一： 2 加 2 等于 4 ， 2 乘 2 也等于 4 。还有其它的整数对，它们的和与积也相等吗？我们要求的就是 mn = m+n 的整数解。方程可以变为mn - m - n + 1 = 1也就是(m - 1)(n - 1) = 1由于 m 、 n 都是整数，因此 m - 1 和 n - 1 也都是整数。两个整数之积为 1 ，只有两种情况——这两个数都是 1，或者这两个数都是 -1 。前者对应了 m = 2, n = 2 ，后者解出来则是 m = 0, n = 0 。如果把
阅读全文
摘要：介绍一：LIS（Longest Increasing Subsequence）最长上升（不下降）子序列，有两种算法复杂度为O(n*logn)和O(n^2)。在上述算法中，若使用朴素的顺序查找在D1..Dlen查找，由于共有O(n)个元素需要计算，每次计算时的复杂度是O(n)，则整个算法的时间复杂度为O(n^2)，与原来算法相比没有任何进步。但是由于D的特点(2)，在D中查找时，可以使用二分查找高效地完成，则整个算法时间复杂度下降为O(nlogn)，有了非常显著的提高。需要注意的是，D在算法结束后记录的并不是一个符合题意的最长上升子序列！算法还可以扩展到整个最长子序列系列问题。 有两种算法复杂度
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=17题目分析：同NYOJ 79拦截导弹先解释下什么叫子序列。若a序列删去其中若干个元素后与b序列完全相同，则称b是a的子序列。我们假定存在一个单调序列{An}（以递增序列为例)，现在在其后面添加一个元素a(n+1)，有两种情况：1.a(n+1)>a(n) 。此时，a(n+1)可以添加到An序列的尾部，形成一个新的单调序列，并且此序列长度大于之前An的长度；2.a(n+1)<=a(n)。此时，a(n+1）当然不可以添加到An序列的尾部。经过分析，我们可以得出这样的结论：一个单调序列
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=2159思路：动态规划dp之二维完全背包问题状态方程是关键。。。。。/*dp[j][l] = Max(dp[j][l],dp[j-1][l-b[i]]+a[i])它表示 用掉了l点的忍耐度，并且杀了j个怪后，所获得的最大经验数。*/ 题目分析：二维费用的背包问题是指：对于每件物品，具有两种不同的费用；选择这件物品必须同时付出这两种代价；对于每种代价都有 一个可付出的最大值（背包容量）。问怎样选择物品可以得到最大的价值。设这两种代价分别为代价1和代价2，第i件物品所需的两种代价分别为a[i]和 b[i]。两
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=1114思路：动态规划之完全背包问题题目分析：给出了钱罐开始的重量ｅ和装满后的重量ｆ，然后给你ｎ种硬币，每个价值为ｐ，重量为ｗ，求出最小的价值使钱罐的重量恰好为ｗ如果不存在 输出This is impossible.状态转移方程：f[v]=min{f[v],f[v-w[i]]+p[i]}注意：一道简单的完全背包题（于0-1背包就是第二个for循环倒过来就行了），要求做的仅仅是求最小值，而不是最大值，那么只要对初始化进行一些改变就可以了。把f[0]赋值为0，其他赋值为无穷大。这个题目的意思是有一只存钱的小猪
阅读全文
摘要：一般步骤确定决策序列(Decision sequences)明确问题状态(Problem states)验证优化原理(Principle of optimal)构造、求解优化值递归方程(Recurrence equation)回溯(traceback)构造优化解(Optimal solution)算法复杂性动态规划递归方程往往不能直接用递归实现, 会引发大量重复计算,算法的计算量将非常可观。最好是用迭代法求解动态规划法列出的递归方程迭代实现需要存贮所有子问题的优化解的值，因此动态规划法设计的算法往往需要较大的存储空间算法的复杂性来自子问题的数目,通常子问题的数目往往很大
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=18思路：dp问题代码如下： 1 #include<iostream> 2 using namespace std; 3 int a[105][105]; 4 int main() 5 { 6 int n,m,i,j; 7 while(cin>>n) 8 { 9 for(i=0;i<n;i++)10 for(j=0;j<=i;j++)11 cin>>a[i][j];12 for(i=n-2;i>=0;i-...
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=484代码如下： 1 #include<iostream> 2 #include<cstdio> 3 #include<cstring> 4 using namespace std; 5 int main() 6 { 7 int n=0,k; 8 string a; 9 while(cin>>a)10 {11 printf("Case %d: ",++n);12 if(a=="I")cout<<
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=171思路：dp问题，不过要注意开始的时候下表要考虑好，我是让d[][] 的四周空出一行，这样就不会出错了代码如下： 1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<string.h> 4 int i,j,N,M; 5 int map[25][25],d[25][25]; 6 int dp(int N,int M) 7 { 8 memset(d,0,sizeof(d)); 9 for(i=0;i<
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=2066思路：求有多个起点和多个终点，找出从其中任意一个起点到任意一个终点的距离最短，用floyd算法，但是要注意很多细节的优化，要不会超时借鉴代码如下： 1 #include<cstdio> 2 #include<cstring> 3 #include<cstdlib> 4 #define inf 0x3fffffff 5 int map[1001][1001],max; 6 bool start[1001],end[1001]; 7 int floyd() 8 {
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=2602思路：dp问题之01背包代码如下：一维的，我习惯的作风。。。 1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<string.h> 4 #define N 1001 5 int dp[N]; 6 int c[N],w[N]; 7 int max(int x,int y) 8 { 9 return x>y?x:y;10 }11 int main()12 {13 int t,n,v,i,j;14 scanf
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=1421思路：动态规划dp借鉴代码如下： 1 #include<cstring> 2 #include<iostream> 3 #include<algorithm> 4 #define P(x,y) ((x-y)*(x-y)) 5 using namespace std; 6 int a[2010],d[2010][2010]; 7 int main() 8 { 9 int i,j,n,k;10 while(cin>>n>>k){11 for(
阅读全文
摘要：地址：http://poj.org/problem?id=3767题目分析：由于战争，一个商人想从城市1，回到自己的家城市2，其中城市1始终是由领导1，城市2始终由领导2，其中，商人回家的路中只能有一条路上连接由两个领导领导的城市，还有就是给出的路上双向的，也就是如果城市1能到城市2，那么城市2也同样能到城市1，这是关键。由于这个题中从1类城市走到2类城市后就不能再回去，只能穿过一次，所以先存为双向路，后面再根据不同类型的城市，把双向路变为单向路N个城市，城市编号为1,2,3，……NM条路,路为双向路。 提供每条路的长度及端点城市编号,每两个城市之间直接连通的路最多一条。这N个城市分为两个集合
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=2544思路：（dijkstra算法）代码如下： 1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 #define Max 0xfffffff 5 int m[10010][10010],p[10010]; 6 bool vis[10010]; 7 int vexnum,arcnum; 8 void dijstra() 9 {10 int i,j,k,t,min;11 memset(vis,0
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=1142思路1：题目大意是给你一个图。起点为1，终点为2然后点a到点b是合法的判断（Notice 1:)是当b存在一个到终点的距离小于a到终点的最小距离，求从起点到终点的路径数。Notice 1:不合法并非是断路，合法指回家的时候只按dis[b] < dis[a]的路线走、dis[]表示到终点2的最短路径， 满足dis[b] < dis[a]， 表示这样a->b的是可选择的。 就是说每次回家时选择从距起点（最短距离)近的点 向 距起点（最短距离）远的点走， 求这样的路线条数。dp[i]
阅读全文
摘要：地址：http://acm.hunnu.edu.cn/online/?action=problem&id=10432&type=show题目在线：棋盘覆盖问题Time Limit: 1000ms, Special Time Limit:2500ms, Memory Limit:32768KBTotal submit users: 62, Accepted users: 26Problem 10432 : No special judgementProblem description在一个2k x 2k ( 即：2^k x 2^k )个方格组成的棋盘中，恰有一个方格与其他方格不同
阅读全文
摘要：地址：http://acm.nankai.edu.cn/p1437.html思路：http://wenku.baidu.com/view/a081ee49e45c3b3567ec8bf4.html 不太懂。。。题目： 1437: 校长杯Time Limit: 1500 ms Memory Limit: 32000 kB Judge type: Multi-cases Special JudgeTotal Submit : 108(51 users)Accepted Submit : 65(45 users)Page View : 3964Font Style: Aa Aa Aa 在南开大学..
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=1372思路：求“马”从一点到另一点的最短距离，马走日，BFS即可分析：广度优先搜索题题意如图所示：一个棋子（骑士）可以有八个方向走，广搜确定最小的走的步数。代码如下： 1 #include <iostream> 2 #include <stdio.h> 3 #include <string.h> 4 #include <queue> 5 using namespace std; 6 int c[9][9]; 7 int dir[8][2] = {{-2,-
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=283题目分析：意思是你已经写好了一个程序，可惜你的程序输出方式老板不喜欢！However, your boss does not like the way the output looks, and instead wants the output to appear more symmetric, with the shorter strings at the top and bottom and the longer strings in the middle.老板希望你能“symme
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=514思路1：有篇博文写的是统计二进制中1的个数和，这篇是统计区间内十进制的1的个数和。先讨论下1到n间的1的个数和。给你一个数如:384，求1~384的1的个数之和。那么我只需求出1~300中1的个数和+1~80中1的个数和+1~4中1的个数和。1~4的1的个数为1，1~80中1的个数为101(十位数)+8*100(个位数)----十位数有10，11,12,13....19(共10个数--其中11后面的1作为个位数看待)，个位数为1,11,21,31...71，共有8个1，同理可得1~30
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=105思路：大数求余，同NYOJ 205 求余数 1 #include<stdio.h> 2 #include<string.h> 3 char num[1000100]; 4 int main() 5 { 6 long int i; 7 int n,temp,t; 8 scanf("%d",&n); 9 while(n--)10 {11 scanf("%s",num);12 t=strlen(num);13 ...
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=1274不太懂，，先发表别人的。。。慢慢研究。。。。算法：用了最直接，最暴力的方法。一层层展开。从右到左，遇到(或是数字就展开。一开始想了很多，想得很复杂，但都没办法想下去。于是，就用最简单的方法，直接AC了。原以为是超时的。幸好数据不是很大。用了两个字符数组，一个用于存重复内容。一个存后辍具体做法。统一性。1。没括号的，数字+字母，字母这两种类型。当成数字+(字母)，(字母)类型。重复内容，直接是单个字母。2。没数字的，字母，(字符串)，当成1+字母，1+(字符串)类型。重复次数是1次。这样就把上面的所
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=187思路：一般的方法会超时，打表。。。算法分析：打素数表； 1 #include<stdio.h> 2 int a[2000001]; 3 int main() 4 { 5 int i,j,n; 6 for(i=2;i<=2000000;i++) 7 { 8 if(!a[i]) //未被标记 9 for(j=i+i;j<=2000000;j+=i) //素数的倍数不是素数10 a[j]=1; //标记11 ...
阅读全文
摘要：1 #include<stdio.h> 2 int main() 3 { 4 int n,i,m,sum; 5 scanf("%d",&n); 6 while(n--) 7 { 8 scanf("%d",&m); 9 sum=3;10 for(i=1;i<=m;i++)11 sum=(sum-1)<<1;12 printf("%d\n",sum);13 }14 return 0;15 }16
阅读全文
摘要：1 #include<stdio.h> 2 int main() 3 { 4 int n,i,m; 5 int f[50]; 6 scanf("%d",&n); 7 while(n--) 8 { 9 scanf("%d",&m);10 f[1]=0;f[2]=1;f[3]=2;11 for(i=4;i<=m;i++)12 f[i]=f[i-1]+f[i-2];13 printf("%d\n",f[m]);14 }15 return 0;16 }
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=2045一开始就把式子弄出来了，可惜还是WA一次，忘记验算了n=3了，这个式子的范围是n>3才行。思路如下：f(n) = 1, ... , n-2 , n-1, n前n-2个已涂好后，涂第n-1个即有2种情况： 1. n-1的色与n-2和1的色都不相同，那么n就是剩下的那个色，米选择。 即就是f(n-1)2. n-1的色与n-2不相同但与1个色一样，那么n的色就有2个色选择. 即就是f(n-2)*2 综上得：f(n) = f(n-1) + 2*f(n-2); 别忘了验算得出n的范围。正确代码：...
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=2044正确： 1 #include<iostream> 2 using namespace std; 3 int main() 4 { 5 long long f1,f2,temp; 6 int n,a,b; 7 cin>>n; 8 while(n--) 9 {10 cin>>a>>b;11 f1=1;f2=1;12 for(int i=1;i<b-a;i++)13 {14 t...
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=2013思路：没啥说的。。。 1 #include<stdio.h> 2 int main() 3 { 4 int m,x; 5 while(scanf("%d",&m)!=EOF) 6 { 7 x=1; 8 while(--m) 9 x=(x+1)<<1;10 printf("%d\n",x);11 }12 return 0;13 }
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=311思路：dp问题，同NYOJ 289 苹果问题，在此基础上改动即可AC，至于除dp[0]为0外全部初始化为负无穷,不太明白为啥要初始化负无穷。。。在思考。。。代码如下： 1 #include <stdio.h> 2 #include <string.h> 3 #define N 100001 4 int dp[50001]; 5 int c[N],w[N]; 6 int max(int x,int y) 7 { 8 return x>y?x:y; 9 }10
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=37思路1：dp动态规划分析：d[i][j]表示从第 i 到第 j 的最优解；if(a[i]==a[j]) d[i][j]=d[i+1][j-1];d[i][j]=max{d[i][j] , d[i+1][j]+1 , d[i][j-1]+1};代码如下： 1 #include<stdio.h> 2 #include<string.h> 3 #define N 1010 4 int d[N][N]; 5 char a[N]; 6 int min(int x,int y
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=289思路：同NYOJ 49 开心的小明 动态规划问题dp代码如下： 1 #include <stdio.h> 2 #include <string.h> 3 #define N 1001 4 int dp[N]; 5 int c[N],w[N]; 6 int max(int x,int y) 7 { 8 return x>y?x:y; 9 }10 int main()11 {12 int n,v,i,j;13 while (scanf("%d%d&q
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=36思路：dp[i][j]表示 s1 以 i结尾和 s2 以 j 结尾的最长公共子序列长度；if(i==0||j==0) dp[i][j]=0;if(s1[i]==s2[j])dp[i][j]=dp[i-1][j-1]+1else dp[i][j]=max(dp[i][j-1],dp[i-1][j]);代码如下： 1 2 #include<stdio.h> 3 #include<string.h> 4 #include<stdlib.h> 5 int dp
阅读全文
摘要：01背包问题总结一 问题描述：有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。 所谓01背包，表示每一个物品只有一个，要么装入，要么不装入。二 解决方案： 考虑使用dp问题 求解，定义一个递归式 opt[i][v] 表示前i个物品，在背包容量大小为v的情况下，最大的装载量。 opt[i][v] =max(opt[i-1][v] , opt[i-1][v-c[i]] + w[i])解释如下： opt[i-1][v] 表示第i件物品不装入背包中，而opt[i-1][v-c[i]] + w[i] 表示第i件物品装入背包中。 花费如下
阅读全文
摘要：1.什么是动态规划：动态规划，和分治法一样，是通过组合子问题的解而解决整个问题的。但不同的是，分治算法是指将问题划分成一些独立的子问题，递归求解各子问题，然后合并子问题的解而得到原问题的解。而动态规划适用于子问题不是独立的情况，也就是各子问题包含公共的子子问题。动态规划对每个子子问题只求解一次，将其结果保存在一张表中，从而避免每次遇到各个子问题时重新计算答案。2.动态规划中的几个重要性质：2.1最优子结构：用动态规划求最优化问题的第一步是描述最优解的结构。如果问题的一个最优解中包含子问题的最优解，则该问题具有最优子结构。当一个问题具有最优子结构时，提示我们动态规划可能会适用（注意，在这种情况下
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=558 1 #include<stdio.h> 2 #include<string.h> 3 int main() 4 { 5 int n,m; 6 char a[6]; 7 scanf("%d",&n); 8 while(n--) 9 {10 scanf("%s",a); 11 m=strlen(a);12 if(m==3)13 {14 if((a[0]=='o'...
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=117思路：归并排序，表示不太懂。。。。算法分析：这个题的算法是利用归并排序的 merge() 函数，在处理在处理两段时，恰好要比较大小，顺便把逆数也求出来 故时间复杂度o（nlogn）； 1 #include<stdio.h> 2 #include<stdlib.h> 3 #define N 1000010 4 long long ans; 5 int a[N]; 6 void merge(int s1,int e1,int s2,int e2) 7 { 8 int
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=32思路：递归 1 #include<stdio.h> 2 #include<stdlib.h> 3 int a[100]; //存储大数 4 void f(int m, int k) 5 { 6 int i,j; 7 for(i=m;i>=k;i--) 8 { 9 a[k]=i;10 if(k>1)11 f(i-1,k-1);12 else13 {14 fo...
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=95算法分析：hash映射 1 #include<stdio.h> 2 #include<string.h> 3 #define N 100010 4 int a[N]; //存放数字t出现的次数 5 int main() 6 { 7 int m,n,i,t,p,ans; 8 scanf("%d",&m); 9 while(m--)10 {11 ans=0;12 memset(a,0,sizeof(a));13 ...
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=53 1 #include<stdio.h> 2 int main() 3 { 4 int n,x,t,s,i,j,max; 5 scanf("%d",&n); 6 while(n--) 7 { 8 j=0;s=0,max=0; 9 for(i=1;i<=7;i++)10 {11 scanf("%d%d",&x,&t);12 s=x+t;13 ...
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=76 1 #include<stdio.h> 2 int main() 3 { 4 int n,i,m; 5 int f[50]; 6 scanf("%d",&n); 7 while(n--) 8 { 9 scanf("%d",&m);10 f[1]=0;f[2]=1;f[3]=2;11 for(i=4;i<=m;i++)12 f[i]=f[i-1]+f[i-2];13 p...
阅读全文
摘要：地址：思路：其实这个题联系的应该是对递归的理解，但是如果提交递归，会超时，所以应用公式递推的方法递归方法：会TimeLimitExceeded 1 #include<stdio.h> 2 #include<stdlib.h> 3 int f(int n) 4 { 5 if(n>=1&&n<=4) return n; 6 else 7 return f(n-1)+f(n-3); 8 } 9 int main()10 {11 int n;12 while(~scanf("%d",&n),n)13 {14 printf(
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=26思路：筛法求孪生素数 1 //筛法求孪生素数 2 #include<stdio.h> 3 #include<math.h> 4 #include<string.h> //memset函数 5 bool visit[1000001]; //判断是否拜访过 6 int main() 7 { 8 int i,j,n,count; 9 long int m; 10 scanf("%d",&n);11 while(n--)12 {13
阅读全文
摘要：基本思想： 用筛法求素数的基本思想是：把从1开始的、某一范围内的正整数从小到大顺序排列， 1不是素数，首先把它筛掉。剩下的数中选择最小的数是素数，然后去掉它的倍数。依次类推，直到筛子 为空时结束。如有： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 1不是素数，去掉。剩下的数中2最小，是素数，去掉2的倍数，余下的数是： 3 5 7 9 11 13 15 17 19 21 23 25 27 29 剩下的数中3最小，是素数，去掉3的倍数，如此下去直到所有的数都被筛完，求...
阅读全文
摘要：地址：http://poj.org/problem?id=1979思路：递归题目分析：输入：包括多个数据集合。每个数据集合的第一行是两个整数W和H，分别表示x方向和y方向瓷砖的数量。W和H都不超过20。在接下来的H行中，每行包括W个字符。每个字符表示一块瓷砖的颜色，规则如下‘.’：黑色的瓷砖‘#’：白色的瓷砖‘@’：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每个数据集合中唯一出现一次当在一行中读入的是两个零时，表示输入结束。输出：对每个数据集合，分别输出一行，显示你从初始位置出发能到达的瓷砖数(记数时包括初始位置的瓷砖)算法分析：设f(x,y)为从点(x,y)出发能够走过的黑瓷砖总数，则 f(
阅读全文
摘要：地址：http://poj.org/problem?id=1664题目分析：输入：m个苹果，n个盘子，问多少种不同放法．算法分析：设f(m,n) 为m个苹果，n个盘子的放法数目，则先对n作讨论，当n>m：必定有n-m个盘子永远空着，去掉它们对摆放苹果方法数目不产生影响。即 if(n>m) f(m,n) = f(m,m) 当n<=m：不同的放法可以分成两类：1、有至少一个盘子空着，即相当于f(m,n) = f(m,n-1); 或2、所有盘子都有苹果，相当于可以从每个盘子中拿掉一个苹果，不影响不同放法的数目，即 f(m,n) = f(m-n,n). 而总的放苹果的放法数目等于两者
阅读全文
摘要：地址：http://nenu.openjudge.cn/09jiaoji/803/思路：递归，分治 1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<math.h> 4 double exp() 5 { 6 char a[10]; 7 scanf("%s",a); 8 switch(a[0]) 9 {10 case '+': return exp()+exp();11 case '-': return exp()-exp();12 case '*
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=308题意大概就是找字符串s和它的逆序字符串的最长连续公共子序列 1 #include<stdio.h> 2 #include<string.h> 3 int main() 4 { 5 int n,l,i,j,k; 6 char a[55],b[55],c[55][55]; 7 scanf("%d",&n); 8 while(n--) 9 {10 memset(c,0,sizeof(c));11 getchar();12...
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=236思路：还是属于贪心系列，按照长度排序，如果长度相同则按重量排序。总是找长度和重量都大于等于前一个木棒，就能计算出最短时间。 1 #include<stdio.h> 2 #include<string.h> 3 #include<algorithm> 4 using namespace std; 5 struct mb 6 { 7 int len; //长 8 int weight;//重量 9 }w[10001]; //定义一个结构体数组 10 bo
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=14思路：贪心算法主要问题是时间的问题，这就需要用到ACM中常用的algorithm库函数 1 #include<stdio.h> 2 #include<algorithm> 3 using namespace std; 4 struct node 5 { 6 int first;//开始时间 7 int last; //结束时间 8 }w[10001]; 9 bool cmp(node x,node y)10 {11 if(x.last<y.last) ret
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=456思路：以价值的总和的一半为背包容量，构建0-1背包，只要保证一半的背包容量装的价值最大就行。。因为最大也就是总价值的一半。。 1 //0-1 背包 2 #include<stdio.h> 3 #include<string.h> 4 int val[500001]; //存放当前的最大容量 5 int main() 6 { 7 int n,m,i,j,sum; 8 int a[1001]; 9 scanf("%d",&m);10 wh
阅读全文
摘要：地址：http://poj.org/problem?id=1164问题描述：图1是一个城堡的地形图。请你编写一个程序，计算城堡一共有多少房间最大的房间有多大城堡被分割成m´n(m≤50，n≤50)个方块，每个方块可以有0~4面墙输入：程序从标准输入设备读入数据。第一行是两个整数，分别是南北向、东西向的方块数。在接下来的输入行里，每个方块用一个数字(0≤p≤50)描述。用一个数字表示方块周围的墙，1表示西墙，2表示北墙，4表示东墙，8表示南墙。每个方块用代表其周围墙的数字之和表示。城堡的内墙被计算两次，方块(1,1)的南墙同时也是方块(2,1)的北墙。输入的数据保证城堡至少有两个房间输
阅读全文
摘要：地址：http://poj.org/problem?id=1011问题描述：乔治拿来一组等长的木棒，将它们随机地裁断，使得每一节木棒的长度都不超过50个长度单位。然后他又想把这些木棒恢复到为裁截前的状态，但忘记了木棒的初始长度。请你设计一个程序，帮助乔治计算木棒的可能最小长度。每一节木棒的长度都用大于零的整数表示输入：由多个案例组成，每个案例包括两行。第一行是一个不超过64的整数，表示裁截之后共有多少节木棒。第二行是经过裁截后，所得到的各节木棒的长度。在最后一个案例之后，是零。输出：为每个案例，分别输出木棒的可能最小长度。每个案例占一行。思路1：题意： 给你n 木棍碎片，要求还原原木棍，且原木
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=88思路1：对于汉诺塔求移动次数公式为f(n+1)=f(n)*2+1;此题如果用要求十进制最后六位，f(n+1)=(f(n)*2+1)%100000;每次输入层数，求出移动次数，但如果输入数据很大，利用此公式必定超时，经过多次测试，发现若输入数据大于100005，有如下规律，如：f(123456)=f(23456); f(123456789)=f(23456789)---=f(56789)即略去最高位，但 if(m%100000<6)则需进行此操作 m=100000+m%10;这样就不
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=312思路：同hdu 18岁的生日，不过在这里需要在if(m==2&&d==29&&(!rn(y+20))) {cout<<"-1"<<endl;} 添加!rn(y+20)，而18岁的生日不需要添加是由于闰年+18=非闰年这道题不知道咋了，用C++就一直TimeLimitExceeded，换用C语言scanf，printf就AC了。。。。表示不太懂。。。。。。 1 #include<stdio.h> 2
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=1272思路：并查集的运用当用find函数去查找祖先时，如果合并过程中查找到的祖先相同，那么说明有两条路可以连通，就不符合要求 1 #include<string.h> 2 #include<stdio.h> 3 int f[100010];//存放一个节点的父节点的编号 4 bool is[100010];//标志编号为I的房间是否存在 5 void exist(int x,int y)//判断x,y点是否已经存在 6 { 7 if(!is[x]){ 8 is...
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=2574思路1：素数有关 ，不太懂。。。思路2：因为 大于 1 << 16 的和数都能用 1 -- 1<<16 之间的素数表示, 不能表示的肯定是 素数了, 所以处理 1-- 1<<16之间的素数就可以了.不过貌似这题的数据很弱没有大于 1 << 16 的素数. 1 #include<stdio.h> 2 #include<string.h> 3 #include<math.h> 4 int prime[1000000]
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=1999思路1：标准的筛选法。求出每个数的因子和，然后看因子和是否在1000以内，是的话就证明等于因子和的这个数不是不可摸数。 1 #include<stdio.h> 2 #include<string.h> 3 #include<math.h> 4 int sum[1000001],sign[1001]; //sum是因子数和，开的空间大些 5 int main() 6 { 7 int n,num,i,j; 8 scanf("%d",&n)
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=189思路：经过推算，如果m和n的最大公约数是1时，狼就会把所有的洞进过一边，这样兔子在劫难逃，如果最大公约数不是1，则狼进的洞口编号就是m的倍数，那么兔子就有可能存活，此题关键是看狼是否按着每隔m-1个洞把所有的洞转完。 1 #include<stdio.h> 2 int gcd(int a,int b) 3 { 4 if(b==0) 5 return a; // 如果b为0则a就是a和b的最大公约数 6 else 7 return gcd(...
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=49思路：01背包问题 考虑使用dp问题 求解，定义一个递归式 opt[i][v] 表示前i个物品，在背包容量大小为v的情况下，最大的装载量。 opt[i][v] =max(opt[i-1][v] , opt[i-1][v-c[i]] + w[i]) //w[i]是容量为c[i]时的装载量解释如下： opt[i-1][v] 表示第i件物品不装入背包中，而opt[i-1][v-c[i]] + w[i] 表示第i件物品装入背包中。 1 #include<iostream> 2 #in
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=254 1 #include<stdio.h> 2 #include<stdlib.h> 3 #define N 200010 4 int a[N]; 5 int cmp(void const *a,void const *b) 6 { 7 return *(int *)a-*(int *)b; 8 } 9 int main()10 {11 int T,max,count,maxnum,n,i;12 scanf("%d",&T);13 wh
阅读全文
摘要：续上一篇文章：“智力题研究（一）”。【IT思想类】1、 有1000瓶水，其中有一瓶有毒，小白鼠只要尝一点带毒的水24小时后就会死亡，至少要多少只小白鼠才能在24小时时鉴别出那瓶水有毒？（中级）2、 共有三类药，分别重1g,2g,3g，放到若干个瓶子中，现在能确定每个瓶子中只有其中一种药，且每瓶中的药片足够多，能只称一次就知道各个瓶子中都是盛的哪类药吗？如果有4类药呢？5类呢？N类呢(N可数)？（高级）如果是共有m个瓶子盛着n类药呢(m，n为正整数，药的质量各不相同但各种药的质量已知)？你能只称一次就知道每瓶的药是什么吗？(分析) 这类题目比较适合IT人做，因为要使用计算机中的概念或者思想。对于
阅读全文
摘要：不管是找工作还是考公务员，常见的一种面试或者笔试题目就是智力题，这种题目有的比较简单，有的难度很大，有的是一种技巧，有的需要数学知识推导，不管怎样，绝对对于一个人锻炼自己的思维能力非常有益。本文整理了当前比较常见的智力题目，供大家一块研究与学习。【绳子类】1、 一条绳子（粗细不均，长短不一），从一头点燃，全部烧完要耗时1个小时，问如何用这条绳子测出半个小时？（初级）2、 有一些绳子（粗细不均，长短不一），但是每根绳子点燃后都烧一个小时，问用什么方法可以用这些绳子计算45分钟的时间，计算1小时15分钟时间呢？（中级）（分析）这类题目比较简单。由于绳子是双向的，只需同时点燃绳子的两端，便可得到1/
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=1232思路：并查集的运用，最小生成树并查集的精髓（即它的三种操作，结合实现代码模板进行理解）：1、Make_Set(x) 把每一个元素初始化为一个集合n初始化后每一个元素的父亲节点是它本身，每一个元素的祖先节点也是它本身（也可以根据情况而变）。2、Find_Set(x) 查找一个元素所在的集合n查找一个元素所在的集合，其精髓是找到这个元素所在集合的祖先！这个才是并查集判断和合并的最终依据。判断两个元素是否属于同一集合，只要看他们所在集合的祖先是否相同即可。合并两个集合，也是使一个集合的祖先成为另一个集合
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=44思路：这道题也是动态规划的问题，开始的时候受导弹拦截的干扰，以为也要从数据的最后面开始处理呢，结果自己觉得思路不对，感觉别扭，后来写出来之后果然是错误的。然后从最开始进行处理，WA了三次，发现很多小的细节没有做好。最后一次提交，AC。解题思路就是从前往后处理数据，判断前面的数据是否大于0，不断的累加，最后输出最大的和。一些小的细节和思想都可以在代码和注释中有所体现。 1 #include<stdio.h> 2 int a[1000001];//防止函数内部数组过大，出现错误
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=274 1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int n; 6 double m,pi=3.1415926; 7 scanf("%d",&n); 8 while(n--) 9 {10 scanf("%lf",&m);11 printf("%.2lf\n",(pi*m*m)/3.0);12 }13 //system
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=273 1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<string.h> 4 int main() 5 { 6 char a[205]; 7 int n,m,i,count; 8 scanf("%d",&n); 9 while(n--)10 {11 count=0;12 scanf("%s",a);13 m=strlen(a);14 ...
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=32 1 #include<stdio.h> 2 #include<string.h> 3 int n,m; 4 int ok[15];// 5 int num[15];//存放 6 int ac[15];//标记 7 void f(int l) 8 { 9 int a,b;10 if(l==m)11 {12 for(a=0;a<m;a++)13 printf("%d",num[a]);14 printf("\n...
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=366方法；用next_permutation（pɝmjʊ'teʃə）来求解，递归调用代码 1 #include<stdio.h> 2 #include<algorithm> 3 using namespace std; 4 int main() 5 { 6 int a[]={1,2,3,4,5,6,7,8,9}; 7 int k,n,i; 8 scanf("%d",&k); 9 while(k--)10 {11 scanf(&qu
阅读全文
摘要：概念全排列的生成算法有很多种，有递归遍例，也有循环移位法等等。但C++/STL中定义的next_permutation和prev_permutation函数则是非常灵活且高效的一种方法，它被广泛的应用于为指定序列生成不同的排列。本文将详细的介绍prev_permutation函数的内部算法。按照STL文档的描述，next_permutation函数将按字母表顺序生成给定序列的下一个较大的排列，直到整个序列为降序为止。prev_permutation函数与之相反，是生成给定序列的上一个较小的排列。二者原理相同，仅遍例顺序相反，这里仅以next_permutation为例介绍算法。先对序列大小的比
阅读全文
摘要：标准库全排列next_permutation()在标准库算法中,next_permutation应用在数列操作上比较广泛.这个函数可以计算一组数据的全排列.但是怎么用,原理如何,我做了简单的剖析.首先查看stl中相关信息.函数原型:template<class BidirectionalIterator> bool next_permutation( BidirectionalIterator _First, BidirectionalIterator _Last );template<class BidirectionalIterator, class BinaryPred
阅读全文
摘要：下午研究了一下全排列算法，然后发现C++的STL有一个函数可以方便地生成全排列，这就是next_permutation在C++ Reference中查看了一下next_permutation的函数声明：#include <algorithm>bool next_permutation( iterator start, iterator end );Thenext_permutation() function attempts to transform the given range of elements [start,end) into the next lexicographi
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=469题目大意:给你一个正整数n，序列1,2,3,4,5......n满足以下情况的排列：1、第一个数必须是12、相邻两个数之差不大于2你的任务是给出排列的种数。题目分析：由于第一个只能是1，则第二个数只能是2,3当第二个数是2时，则相当于是对2-n的排列，相当于对1-(n-1)的排列,即s[n-1];当第二个数是3时，第三个数只能是2,4,5此时，当第三个数为2时，则是对3-n的排列，相当于对1-(n-3)的排列，即s[n-3] 当第三个数为4时，此时，第四个数只能是2，除了n等于4时..
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=19算法分析：暴力排列，递归，不太懂 1 #include<stdio.h> 2 int n,a[10]; 3 bool vis[10];//标示数字是否被用过 4 void f(int k,int m)//k用来给a中第k个元素赋值，m表示还需要寻找的数字个数 5 { 6 for(int i=1;i<=n;++i) 7 { 8 if(!vis[i]) a[k]=i; //未被标记赋值 9 else continue;...
阅读全文
摘要：同余定理(a+b)mod m=((a mod m)+(b mod m))mod m;a*b mod m=(a mod m)*(b mod m) mod m;a^b mod m=(a mod m)^b mod m; 1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 char num[1000010]; 5 int main() 6 { 7 long int i; 8 int n,temp,t; 9 scanf("%d",&n);10 while(n--)1
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=267 1 //本题是nyoj35与nyoj257的综合 2 #include<stdio.h> 3 #include<stdlib.h> 4 #define N 1010 5 char s[N]; 6 int i; 7 //字符栈的操作 8 typedef struct 9 { 10 char *base; 11 char *top; 12 }SqStack1; 13 int InitStack1(SqStack1 &S) 14 { 15 S.base=(c
阅读全文
摘要：同中缀式转化到后缀式地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=257 1 #include<stdio.h> 2 #include<stdlib.h> 3 #define N 1010 4 //字符栈的操作 5 typedef struct 6 { 7 char *base; 8 char *top; 9 }SqStack; 10 int InitStack(SqStack &S) 11 { 12 S.base=(char *)malloc(N*sizeof(char)); 13 if(!S.bas.
阅读全文
摘要：1 #include <iostream> 2 3 using namespace std; 4 5 #define MAX_VERTEXT 250 6 const int MAX_WEIGHT= 0x7f7f7f7f; 7 8 int map[MAX_VERTEXT][MAX_VERTEXT]; 9 int path[MAX_VERTEXT];10 11 void Init()12 {13 memset(map,MAX_WEIGHT,sizeof(map));14 memset(path,MAX_WEIGHT,sizeof(path));15 }16 17 void ...
阅读全文
摘要：Dijkstra算法又称为单源最短路径，所谓单源是在一个有向图中，从一个顶点出发，求该顶点至所有可到达顶点的最短路径问题。设G=（V，E）是一个有向图，V表示顶点，E表示边。它的每一条边（i，j）属于E，都有一个非负权W（I,j），在G中指定一个结点v0，要求把从v0到G的每一个接vj（vj属于V）的最短有向路径找出来（或者指出不存在）。Dijstra算法是运用贪心的策略，从源点开始，不断地通过相联通的点找出到其他点的最短距离基本思想是：设置一个顶点的集合s，并不断地扩充这个集合，一个顶点属于集合s当且仅当从源点到该点的路径已求出。开始时s中仅有源点，并且调整非s中点的最短路径长度，找当前最短
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=1106解题思路：这道题就是一个字符串处理啦，这道题我们要考虑几种情况 1.多个5连在一起2.第一个字符为53.最后一个字符为5 1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 int cmp(const void*a,const void*b) 5 { 6 return *(int *)a-*(int *)b; //升序 7 } 8 int main() 9 {10 int i,flag,
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=2085此题找出关系即可设n微秒时a( n ) 为高能粒子个数，b ( n )为低能粒子个数;经分析可得 a ( n ) = 3 * a( n - 1 ) + 2 * b ( n - 1 ), b ( n ) = a ( n - 1 ) + b ( n - 1 );然后直接打表即可，还有要注意要用long long 型存储 1 #include<stdio.h> 2 #include<stdlib.h> 3 long long sum[35][2]={1,0}; 4 int mai
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=2094思路一：产生冠军的条件：（1）获胜的人没输过一次（2）最终获胜的人只有一个思路二：观察一下，可以看到其实只要总元素数-失败者==1就可以输出YES了。。思路三：左边的为胜利者，右边的为失败者，如果左边的胜利者只有一个没在右边出现过，那么这个就是产生的冠军，否则产生不了 1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<string.h> 4 int main() 5 { 6 int n,i,j,k; 7 in
阅读全文
摘要：考虑到1-100的最小公倍数肯定超出__int64.所以需要转化成字符串问题来解仔细观察会发现，【1-n】的最小公倍数，是【1-n-1】的最小公倍数乘以n的所有素因子中没有被【1-n-1】包含的素因子。例如：【1-7】的最小公倍数是2*3*2*5*7，8=2*2*2,(8中2出现3次，【1-7】的素因子中只出现2次)那么【1-8】就是2*3*2*5*7*2 1 //我的代码: 2 #include<stdio.h> 3 #include<string.h> 4 #define N 50 5 int len,a[N]={1}; 6 char tab[100][45]={0
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=325题意：有n个西瓜(n<=20)，每个西瓜有一定的重量(w<=10000)，将它们分成两堆，问如何使两堆重量之差最小。解题思路：还是看成容量为 sum/2 的背包问题，用搜索枚举所有情况，使背包中的重量尽量大。如此可得到最优解。搜索的效率取决于剪枝。而剪枝一般有两种，可行性剪枝与最优性剪枝。可行性：如果将物品装入背包后，费用超过容量，则不将它放入背包。最优性：1、如果背包已经装满，则不再考虑其他情况。2、如果背包中已有物品加上现有可选物品的总重量都不大于已知的最优解，则剪枝。
阅读全文
摘要：树状数组是一种非常优雅的数据结构. 当要频繁的对数组元素进行修改,同时又要频繁的查询数组内任一区间元素之和的时候,可以考虑使用树状数组. 最直接的算法可以在O(1)时间内完成一次修改,但是需要O(n)时间来进行一次查询.而树状数组的修改和查询均可在O(log(n))的时间内完成. 设a[1...N]为原数组,定义c[1...N]为对应的树状数组: c[i] = a[i - 2^k + 1] + a[i - 2^k + 2] + ... + a[i] 其中k为i的二进制表示末尾0的个数,所以2^k即为i的二进制表示的最后一个1的权值. 所以2^k可以表示为n&(n^(n-1))或更简单的
阅读全文
摘要：题目链接：http://acm.nyist.net/JudgeOnline/problem.php?pid=322如果按冒泡排序这些O(n^2)肯定会超时，所以需要找一种更快的方法 --------归并排序。归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。这题还可以用树状数组来做 1 法一：用归并排序做 2 #include<stdio.h> 3 int a[1000001],b[1000001]; /*合并排序
阅读全文
摘要：1 #include<stdio.h> 2 int a[1010]; 3 int main() 4 { 5 int i,j,n,t,tmp; 6 while(scanf("%d",&n)!=EOF) 7 { 8 for(i=0;i<n;i++) 9 scanf("%d",a+i);10 for(i=0,t=0;i<=n-1;i++)11 for(j=i+1;j<=n-1;j++)12 if(a[i]>a[j])13 {14 ...
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=163字典树的应用。。。如果字符串Xn=X1X2....Xn是字符串Ym=Y1Y2....Ym的前缀，有在插入的时候有两种情况:Xn在Yn之前插入，Xn在Yn之后插入。(1)如果Xn在Yn之前插入，那么在插入Yn的时候必然经过Xn的路径，此时可以根据判断在这条路径上是否已经有结点被标记已经构成完成的字符串序列来判断是否存在Yn的前缀；(2)如果Xn在Yn之后插入，那么插入完成之后当前指针指向的结点的next数组中的元素必定不全为NULL。 1 #include<cstdio> 2
阅读全文
摘要：经典的线段上色问题，略有不同的地方时从0开始，还有要输出每种颜色的个数 。题目：线段染色问题，求最后最上面的颜色段数思路：对每一次染色执行update操作，当颜色未完全覆盖当前段时，当前根的颜色块需要下移！然后执行一次query操作记录所有线段的颜色法一： 1 #include<stdio.h> 2 #include<string.h> 3 #define N 8001 4 int color[N],cnt[N];//这个cnt是用来记录颜色i出现的段数 ，注意cnt里的这个N真的需要好大，我以为就几百种呢，结果WA好多次 5 int main() 6 { 7 int
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=1251字典树的应用。。。。。 1 #include<cstdio> 2 #include<cstring> //memset函数的头文件 3 #include<iostream> 4 using namespace std; 5 struct node{ 6 int count; 7 node *next[26]; 8 node(){ //初始化数据 9 memset(next,NULL,sizeof(next));10 co...
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<string.h> 4 int main() 5 { 6 int n,m,i,t ,s,w;; 7 char str[10]; 8 scanf("%d",&n); 9 while(n--)10 {11 scanf("%d",&m);12 s = 0; w = 1; i= 0;13 while(m--)14 {15 scanf("%s",&str);16 ...
阅读全文
摘要：题目链接：http://acm.nyist.net/JudgeOnline/problem.php?pid=290经典的字典树的问题，代码几乎可以来当模版来用了，就留下来了~~~，不过貌似用运算符重载排序（不知道是不是）也能过。。。。。。。。需要注意的是开辟一个新的内存时下一个指针一定要指向NULL; 1 #include<cstring> 2 #include<cstdio> 3 #include<iostream> 4 using namespace std; 5 struct node{ 6 node *next[26]; 7 int count; 8
阅读全文
摘要：字典树，又称单词查找树，Trie树，是一种树形结构，典型应用是用于统计，排序和保存大量的字符串，所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来节约存储空间，最大限度的减少无谓的字符串比较，查询效率比哈希表高。它有三个基本性质，根节点不包含字符，除根节点外每一个节点都只包含一个字符，从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串，每个节点的所有子节点包含的字符都不相同。字典树的插入，删除和查找都非常简单，用一个一重循环即可。1. 从根节点开始一次搜索2. 取得要查找关键词的第一个字母，并根据该字母选择对应的子树并转到该子树继续进行检索3. 在相应的
阅读全文
摘要：1、概述线段树，也叫区间树，是一个完全二叉树，它在各个节点保存一条线段（即“子数组”），因而常用于解决数列维护问题，它基本能保证每个操作的复杂度为O(lgN)。2、线段树基本操作线段树的基本操作主要包括构造线段树，区间查询和区间修改。（1） 线段树构造首先介绍构造线段树的方法：让根节点表示区间[0,N-1]，即所有N个数所组成的一个区间，然后，把区间分成两半，分别由左右子树表示。不难证明，这样的线段树的节点数只有2N-1个，是O(N)级别的，如图：显然，构造线段树是一个递归的过程，伪代码如下：//构造求解区间最小值的线段树function 构造以v为根的子树 if v所表示的区间内只有一个元.
阅读全文
摘要：1、概述树状数组(binary indexed tree)，是一种设计新颖的数组结构，它能够高效地获取数组中连续n个数的和。概括说，树状数组通常用于解决以下问题：数组{a}中的元素可能不断地被修改，怎样才能快速地获取连续几个数的和？2、树状数组基本操作传统数组(共n个元素)的元素修改和连续元素求和的复杂度分别为O(1)和O(n)。树状数组通过将线性结构转换成伪树状结构（线性结构只能逐个扫描元素，而树状结构可以实现跳跃式扫描），使得修改和求和复杂度均为O(lgn)，大大提高了整体效率。给定序列（数列）A，我们设一个数组C满足C[i] = A[i–2^k+ 1] + … + A[i]其中，k为i在
阅读全文
摘要：1、 概述二叉查找树（Binary Search Tree，也叫二叉排序树，即Binary Sort Tree）能够支持多种动态集合操作，它可以用来表示有序集合、建立索引等，因而在实际应用中，二叉排序树是一种非常重要的数据结构。从算法复杂度角度考虑，我们知道，作用于二叉查找树上的基本操作（如查找，插入等）的时间复杂度与树的高度成正比。对一个含n个节点的完全二叉树，这些操作的最坏情况运行时间为O(log n)。但如果因为频繁的删除和插入操作，导致树退化成一个n个节点的线性链（此时即为一个单链表），则这些操作的最坏情况运行时间为O(n)。为了克服以上缺点，很多二叉查找树的变形出现了，如红黑树、AV
阅读全文
摘要：1. 概述后缀数组是一种解决字符串问题的有力工具。相比于后缀树，它更易于实现且占用内存更少。在实际应用中，后缀数组经常用于解决字符串有关的复杂问题。本文大部分内容摘自参考资料[1][2]。2. 后缀数组2.1 几个概念（1）后缀数组SA 是一个一维数组，它保存1..n 的某个排列SA[1]，SA[2]，……，SA[n]，并且保证Suffix(SA[i]) < Suffix(SA[i+1])，1≤i<n。也就是将S 的n 个后缀从小到大进行排序之后把排好序的后缀的开头位置顺次放入SA 中。其中，suffix(i)表示字符串s[i,i+1…n-1]，即字符串s起始于第i个字符的后缀。（
阅读全文
摘要：这个方法超时了TimeLimitExceeded，看来只能用二分查找了，即折半查找法，因为数据太大了，要输出太多的数。。。。你懂的。。。。地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=86 1 #include<stdio.h> 2 #include<stdlib.h> 3 #define max 1000010 4 int a[max],b; 5 int cmp(const void *x,const void *y) 6 { 7 return *(int*)x-*(int*)y; 8 } 9 int main
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=106这道题典型的应用贪心算法。不过有些不同的是这个题目已经告诉你单位价值了，所以我们不需要考虑计算单位价值最高的，从高到低的选择了。我们现在所需要做的就是对单位价值进行排序，然后从高到底取物品，直到重量达到题目中告诉的背包的W。想明白之后，思路也就很清晰了。sort排序，结构体或者二维数组进行储存数据。最后执行计算价值和·······不过这个题目中值得留意就是那个对结构体数据的交换，没有单独定义一个变量，而是用结构体中最
阅读全文
摘要：考查点：简单计算题思路：一直加撒，直到大于等于那个数即可，注意控制下循环变量即可.>提交情况:没的说的，肯定直接AC.> 1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int i; 6 double a,sum; 7 while(scanf("%lf",&a),a) 8 { 9 i=1;10 sum=0;11 while(i++)12 {13 sum+=1.0/i;14 i...
阅读全文
摘要：在一堂无聊的信息检索课程上旁边的同学提出了一道java面试题——100的阶乖末尾有多少个零？我结合网上的思路对此探讨一下：题目：1*2*3*……*100 求结果末尾有多少个零分析：一般类似的题目都会蕴含某种规律或简便方法的阶乘末尾一个零表示一个进位，则相当于乘以10而10 是由2*5所得，在1~100当中，可以产生10的有：0 2 4 5 6 8 结尾的数字，显然2是足够的，因为4、6、8当中都含有因子2，所以都可看当是2，那么关键在于5的数量了那么该问题的实质是要求出1~100含有多少个5由特殊推广到一般的论证过程可得：1、每隔5个，会产生一个0，比如5，10，15，20.。。2 、每隔5&
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int t,n,i; 6 scanf("%d",&t); 7 while(t--) 8 { 9 i=0;10 scanf("%d",&n);11 while(n)12 {13 n/=5; //看有多少个5的因子，就有多少个0，具体看知识补充14 i+=n; 15 }16 printf("%d\...
阅读全文
摘要：阶乘指从1乘以2乘以3乘以4一直乘到所要求的数。C++中的阶乘亦是如此。有关阶乘的算法，不外乎两个方面：一是高精度计算；二是与数论相关。 一、高精度计算阶乘 这实际上是最没有技术含量的问题，但是又会经常用到，所以还是得编写，优化它的计算。 首先看小于等于12的阶乘计算（计算结果不会超出32位范围）：int factorial(int n) {if (n == 1 || n == 0)return 1;return factorial(n-1)*n;} 这个递归程序简单明了，非常直观，然而一旦n > 12，则超过32位int型的范围出现错误结果，所以上面这个递归程序仅适合n <= 1
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<math.h> 4 int main() 5 { 6 int x0,x1,x2,y0,y1,y2; 7 double s; 8 while(scanf("%d%d%d%d%d%d",&x0,&y0,&x1,&y1,&x2,&y2)) 9 {10 if(x0==0&&y0==0&&x1==0&&y1==0&&x2==0&
阅读全文
摘要：存在整数x和y使得二元一次方程 a*x+b*y=n有解,则n为a,b的最大公约数的整数倍即可，至于为啥，正在研究，应该是数论里的知识。。。。。 1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 long int a,b,n,a1,b1,t,m,r; 6 scanf("%ld",&m); 7 while(m--) 8 { 9 scanf("%ld%ld%ld",&a,&b,&n);10 a1=a;b1=b;11 if(a1<b
阅读全文
摘要：1 //三角形面积用到海伦公式：p=(a+b+c)/2; 2 //s=sqrt(p*(p-a)(p-b)(p-c)) 3 #include<stdio.h> 4 #include<math.h> 5 #include<stdlib.h> 6 int main() 7 { 8 double x1,x2,y1,y2,x3,y3; 9 double a,b,c,p,s;10 while(~scanf("%lf%lf%lf%lf%lf%lf",&x1,&y1,&x2,&y2,&x3,&y3))11
阅读全文
摘要：思路：将其看成一个一个正方形块，边长为k 。n=l/k。当l/k>(int)(l/k)时即属于长多出一点，这时为了全部覆盖，就还需要一个路由器，你懂的 1 #include<stdio.h> 2 #include<math.h> 3 int main() 4 { 5 int N,l,d,r,n; 6 double k; 7 scanf("%d",&N); 8 while(N--) 9 {10 scanf("%d%d%d",&l,&d,&r);11 k=sqrt((double)r*r-(dou
阅读全文
摘要：题目链接：http://acm.nyist.net/JudgeOnline/problem.php?pid=286简单的字符串统计，不多说，直接水过。 1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 char a[10010][11],b[10010];//数组a用以存贮字符串，数组b用以计次数 5 int main() 6 { 7 int n,i,j; 8 scanf("%d",&n); 9 for(i=0;i<n;i++)10 {11 sca
阅读全文
摘要：约瑟夫环问题： 1 #include <stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int m,x,i,s,n; 6 scanf("%d",&n); 7 while(n--) 8 { 9 while(~scanf("%d%d",&m,&x))10 { s=0;11 for (i=2;i<=m;i++) s=(s+x)%i;12 printf ("%d\n", s+1);13 }14 }15 system...
阅读全文
摘要：总结：这道题刚才是错了，我用了一维数组，不能编译，后来发现自己好傻，str[1010],只是存贮的有m个车牌号，即编号。而没有存字符串，所以要用一个二维数组，即str[1010][6];来存贮，当最后if(strcmp(str[i],str[0])<0)，strcpy(str[0],str[i]);比较完后输出的是str编号后的字符串 1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 int main() 5 { 6 int n,m,i; 7 char str[1010][6
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int i,j; 6 long long n; 7 int a[100]; 8 while(scanf("%lld",&n)!=EOF) 9 {10 i=0;11 if(n==0) puts("0");12 else{13 while(n)14 {15 a[i++]=n%2;16 n/=2;17 ...
阅读全文
摘要：总结：怎么又是这种情况，定义的数组太大？放到函数里出错？不会吧，没有那么大吧？ 1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 char ch[110];//定义在函数内就出错了，难道又越栈了？ 5 int main() 6 { 7 int n,R,W,B,i,len; 8 scanf("%d%*c",&n);//由于要输入字符串，所以要考虑到enter 9 while(n--)10 {11 gets(ch);12 len=strlen(ch)...
阅读全文
摘要：学C++的时候，这几个输入函数弄的有点迷糊；这里做个小结，为了自己复习，也希望对后来者能有所帮助，如果有差错的地方还请各位多多指教（本文所有程序均通过VC 6.0运行）转载请保留作者信息；1、cin1、cin.get()2、cin.getline()3、getline()4、gets()5、getchar()1、cin>>用法1：最基本，也是最常用的用法，输入一个数字：#includeusing namespace std;main (){int a,b;cin>>a>>b;cout<<a+b<<endl;}输入：2[回车]3[回车]
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int N,i,j; 6 int a[3][3]; 7 scanf("%d",&N); 8 while(N--) 9 {10 for(i=0;i<3;i++)11 for(j=0;j<3;j++)12 scanf("%d",&a[i][j]);13 for(i=0;i<3;i++)14 {15 for(j=0;j<3;j++)16 ...
阅读全文
摘要：遇到分数时不要定义为int型，因为1/2,1/3=0，要定义为float型或者double型 1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int n,k,i; 6 double s,t; 7 scanf("%d",&n); 8 while(n--) 9 {10 s=0;11 scanf("%d",&k);12 for(i=1;;i++)13 {14 t=1.0/i;15 ...
阅读全文
摘要：总结：遇到“去重”与“排序”的问题，记住要先排序，然后再去重，因为排完序之后，重复的肯定在一起，只需a[i]!=a[i-1]，把a[1]输出即可。排序可以用qsort，也可用冒泡排序，两个for循环。刚开始一直wa，后来终于发现自己犯了一个低级错误，我把count=0；定义在了while(t--)上面，这样的话导致我进行下一组测试时count不能从0开始，受伤一次的影响，太傻了，谨记，当遇到要进行多组测试数据时，计数的变量在每次进行新数据时要清零，方法就是把它放到while或者for循环里 1 #include<stdio.h> 2 #include<stdlib.h>
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int n,i,j,t,count=0; 6 int a[1010]; 7 scanf("%d",&n); 8 for(i=0;i<n;i++) 9 scanf("%d",a+i);10 for(i=0;i<=n-1;i++)11 {12 for(j=i+1;j<=n-1;j++)13 if(a[i]>a[j])14 {t=a[i];a[i]=a[j];a[j]=t;}1...
阅读全文
摘要：题目1：写一个函数，输入n，其斐波那契数列的第n项。斐波那契数列的定义如下：方法1：使用递归解，时间复杂度是n的指数级别斐波那契数列的定义就是递归的，我们根据定义可以很简单的写出代码。代码如下： 2 3 #include<iostream> 4 #include<stdlib.h> 5 using namespace std; 6 7 //f(n)={0,1,1,2,3...} n>=0 8 9 int Fibonacci(int n)10 {11 if(n<=0)12 return 0;13 if(n==1)14 return 1;15 ...
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=252总结：与斐波那契差不多，动态规划主要玩的就是递归。 1 //与斐波那契差不多，动态规划主要玩的就是递归 2 #include<stdio.h> 3 #include<stdlib.h> 4 int main() 5 { 6 int n,m,i,a[42]; 7 scanf("%d",&n); 8 a[2]=3;a[3]=5; 9 for(i=4;i<42;i++)10 a[i]=a[i-1]+a[i-2];//利用 斐波那契公式
阅读全文
摘要：斐波那契数列算法分析背景：假定你有一雄一雌一对刚出生的兔子，它们在长到一个月大小时开始交配，在第二月结束时，雌兔子产下另一对兔子，过了一个月后它们也开始繁殖，如此这般持续下去。每只雌兔在开始繁殖时每月都产下一对兔子，假定没有兔子死亡，在一年后总共会有多少对兔子？在一月底，最初的一对兔子交配，但是还只有1对兔子；在二月底，雌兔产下一对兔子，共有2对兔子；在三月底，最老的雌兔产下第二对兔子，共有3对兔子；在四月底，最老的雌兔产下第三对兔子，两个月前生的雌兔产下一对兔子，共有5对兔子；……如此这般计算下去，兔子对数分别是：1, 1, 2, 3, 5, 8, 13, 21, 34, 55,89, 14
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=240 1 #include<stdio.h> 2 #include<iostream> 3 #include<algorithm> 4 #include<string> 5 using namespace std; 6 struct chenji 7 { 8 int bj;//班级编号 9 int xh;//学号10 int cj;//数学成绩11 int mc;//名次12 } c[100001];13 bool comp(chenji x
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 int cmp(const void *a,const void *b) 4 { 5 return *(int *)a-*(int *)b; //升序 6 } 7 int main() 8 { 9 int t,n,i;10 int a[110];11 scanf("%d",&t);12 while(t--)13 {14 scanf("%d",&n);15 for(i=0;i<n;i++)16 scanf("%d..
阅读全文
摘要：1 #include<stdio.h> 2 #include<math.h> 3 #include<stdlib.h> 4 int is_prime(int x) 5 { 6 int i; 7 if(x==1) return 0; 8 for(i=2;i<=sqrt(x);i++) 9 if(x%i==0) return 0;10 return 1;11 }12 int main()13 {14 int t,n,i,sum;15 scanf("%d",&t);16 while(t--)17 {18 s...
阅读全文
摘要：刚开始一直不能编译，后来才知道，当数组所占空间比较大时，就不能放进函数里，因为在函数里定义的变量，是在栈上创建的，数组太大，会造成栈溢出，使程序出错。而全局变量是在数据段创建的，可非常大1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 int light[1000010];//不能放到函数里是由于在函数中定义的变量，在栈上创建，全局定义的变量，在数据段上创建。由于你的数组太大，会造成栈溢出，使得程序错误 5 int main() 6 { 7 int n,t,m,sum=0; 8 c
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int n; 6 scanf("%d%*c",&n); 7 while(n--) 8 { 9 int i,j,t=0;10 int a[11];11 char ch;12 for(i=0;i<=11;i++) //刚开始i<11，不知咋的出错了wa。我想应该要进行12次循环，虽然有11位号码，最后循环是enter吧13 {14 ch=ge...
阅读全文
摘要：法一：地址：http://acm.hdu.edu.cn/showproblem.php?pid=1863 1 #include<iostream> 2 #include<cstdlib> 3 #include<cstring> 4 #include<algorithm> 5 using namespace std; 6 int parent[105]; 7 struct Edge{ 8 int from,to,price; 9 }edge[5100];10 bool compare(Edge a,Edge b){11 return a.price
阅读全文
摘要：1、 概述并查集（Disjoint set或者Union-find set）是一种树型的数据结构，常用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。2、 基本操作并查集是一种非常简单的数据结构，它主要涉及两个基本操作，分别为：A． 合并两个不相交集合B． 判断两个元素是否属于同一个集合（1） 合并两个不相交集合（Union(x,y)）合并操作很简单：先设置一个数组Father[x]，表示x的“父亲”的编号。那么，合并两个不相交集合的方法就是，找到其中一个集合最父亲的父亲（也就是最久远的祖先），将另外一个集合的最久远的祖先的父亲指向它。上图为两个不相交集合，b图为合并后Fa
阅读全文
摘要：1. 概述堆（也叫优先队列），是一棵完全二叉树，它的特点是父节点的值大于（小于）两个子节点的值（分别称为大顶堆和小顶堆）。它常用于管理算法执行过程中的信息，应用场景包括堆排序，优先队列等。2. 堆的基本操作堆是一棵完全二叉树，高度为O（lg n），其基本操作至多与树的高度成正比。在介绍堆的基本操作之前，先介绍几个基本术语：A：用于表示堆的数组，下标从1开始，一直到nPARENT(t)：节点t的父节点，即floor(t/2)RIGHT(t)：节点t的左孩子节点，即:2*tLEFT(t)：节点t的右孩子节点，即:2*t+1HEAP_SIZE(A)：堆A当前的元素数目下面给出其主要的四个操作（以大顶
阅读全文
摘要：1. 概述同splay tree一样，treap也是一个平衡二叉树，不过Treap会记录一个额外的数据，即优先级。Treap在以关键码构成二叉搜索树的同时，还按优先级来满足堆的性质。因而，Treap=tree+heap。这里需要注意的是，Treap并不是二叉堆，二叉堆必须是完全二叉树，而Treap可以并不一定是。2. Treap基本操作为了使Treap 中的节点同时满足BST性质和最小堆性质，不可避免地要对其结构进行调整，调整方式被称为旋转。在维护Treap 的过程中，只有两种旋转，分别是左旋转(简称左旋)和右旋转(简称右旋)。左旋一个子树，会把它的根节点旋转到根的左子树位置，同时根节点的右子
阅读全文
摘要：1. 概述AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下都是O（log n），增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。本文介绍了AVL树的设计思想和基本操作。2. 基本术语有四种种情况可能导致二叉查找树不平衡，分别为：（1）LL：插入一个新节点到根节点的左子树（Left）的左子树（Left），导致根节点的平衡因子由1变为2（2）RR：插入一个新节点到根节点的右子树（Right）的右子树
阅读全文
摘要：1. 概述排序算法是计算机技术中最基本的算法，许多复杂算法都会用到排序。尽管各种排序算法都已被封装成库函数供程序员使用，但了解排序算法的思想和原理，对于编写高质量的软件，显得非常重要。本文介绍了常见的排序算法，从算法思想，复杂度和使用场景等方面做了总结。2. 几个概念（1）排序稳定：如果两个数相同，对他们进行的排序结果为他们的相对顺序不变。例如A={1,2,1,2,1}这里排序之后是A = {1,1,1,2,2} 稳定就是排序后第一个1就是排序前的第一个1，第二个1就是排序前第二个1，第三个1就是排序前的第三个1。同理2也是一样。不稳定就是他们的顺序与开始顺序不一致。（2）原地排序：指不申请多
阅读全文
摘要：1. 概述位图（bitmap）是一种非常常用的结构，在索引，数据压缩等方面有广泛应用。本文介绍了位图的实现方法及其应用场景。2. 位图实现（1）自己实现在位图中，每个元素为“0”或“1”，表示其对应的元素不存在或者存在。#define INT_BITS sizeof(int)#define SHIFT 5 // 2^5=32#define MASK 0x1f // 2^5=32#define MAX 1024*1024*1024 //max numberint bitmap[MAX / INT_BITS];/** 设置第i位* i >> SHIFT 相当于 i / (2 ^ SHI
阅读全文
摘要：1. 前言本文介绍了常用的排列组合算法，包括全排列算法，全组合算法，m个数选n个组合算法等。2. 排列算法常见的排列算法有：(A)字典序法(B)递增进位制数法(C)递减进位制数法(D)邻位对换法(E)递归法介绍常用的两种：(1) 字典序法对给定的字符集中的字符规定了一个先后关系，在此基础上按照顺序依次产生每个排列。[例]字符集{1,2,3},较小的数字较先,这样按字典序生成的全排列是:123,132,213,231,312,321。生成给定全排列的下一个排列 所谓一个的下一个就是这一个与下一个之间没有字典顺序中相邻的字符串。这就要求这一个与下一个有尽可能长的共同前缀，也即变化限制在尽可能短的后
阅读全文
摘要：1. 介绍本文介绍了比较初级的图搜索算法，包括深度优先遍历，广度优先遍历和双向广度优先遍历。2. 深度优先遍历DFS2.1 算法思想从图中某个顶点v开始，访问此节点，然后依次从v中未被访问的邻接点出发深度优先遍历图，直到图中上所有和v有路径相通的顶点都被访问；若此时图中尚有顶点未被访问，则另选图中一个未被访问顶点做起点，重复以上过程，直到图中所有顶点都被访问为止。深度优先搜索遍历类似于树的先序遍历。假定给定图G的初态是所有顶点均未被访问过，在G中任选一个顶点i作为遍历的初始点，则深度优先搜索遍历可定义如下：(1) 首先访问顶点i，并将其访问标记置为访问过，即visited[i]=1；(2) 然
阅读全文
摘要：1. 素数判定问题素数判定问题是一个非常常见的问题，本文介绍了常用的几种判定方法。2. 原始算法素数的定义是，除了能被1和它本身整除而不能被其他任何数整除的数。根据素数定义 只需要用2到n-1去除n，如果都除不尽，则n是素数，否则，只要其中有一个数能整除则n不是素数。bool is_primer1(int num) { int i; for(i = 2; i < num; i++) { if(num % i == 0) { return true; } } return false;}3. 改进算法n不是素数，则n可表示为a*b，其中2<=a<=b<=n-1,则a...
阅读全文
摘要：1. 简介红黑树是一种自平衡二叉查找树。它的统计性能要好于平衡二叉树（AVL树），因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的: 它可以在O(log n)时间内做查找，插入和删除等操作。本文介绍了红黑树的基本性质和基本操作。2. 红黑树的性质红黑树，顾名思义，通过红黑两种颜色域保证树的高度近似平衡。它的每个节点是一个五元组：color（
阅读全文
摘要：1. 背包问题介绍背包问题不单单是一个简单的算法问题，它本质上代表了一大类问题，这类问题实际上是01线性规划问题，其约束条件和目标函数如下：自从dd_engi在2007年推出《背包问题九讲》之后，背包问题的主要精髓基本已道尽。本文没有尝试对背包问题的本质进行扩展或深入挖掘，而只是从有限的理解（这里指对《背包问题九讲》的理解）出发，帮助读者更快地学习《背包问题九讲》中的提到的各种背包问题的主要算法思想，并通过实例解释了相应的算法，同时给出了几个背包问题的经典应用。2. 背包问题及应用dd_engi在《背包问题九讲》中主要提到四种背包问题，分别为：01背包问题，完全背包问题，多重背包问题，二维费用
阅读全文
摘要：题目分析：本题就是要利用M*N%R=((M%R)*(N%R))%R 来计算。即K先%1000，然后接下来有1001个K%1000相乘，之所以这样是由于当K或者Power比较大的时候它们相乘可能导致数据溢出，这就需要参考我的另一篇文章里的对大数进行求模运算的相关算法了 1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<string.h> //包含memset函数 4 5 int Record[1000];//用以记录的一维数组 6 7 int KTail(int K) 8 { 9 memset(Record
阅读全文
摘要：桌上有十个苹果，要把这十个苹果放到九个抽屉里，无论怎样放，我们会发现 至少会有一个抽屉里面放两个苹果。这一现象就是我们所说的“抽屉原理”。 抽屉原理的一般含义为：“如果每个抽屉代表一个集合，每一个苹果就可以代 表一个元素，假如有n＋1或多于n＋1个元素放到n个集合中去，其中必定至少有 一个集合里有两个元素。” 抽屉原理有时也被称为鸽巢原理（“如果有五个鸽 子笼，养鸽人养了6只鸽子，那么当鸽子飞回笼中后，至少有一个笼子中装有2 只鸽子”）。它是组合数学中一个重要的原理。 第一抽屉原理 原理1 把多于n个的物体放到n个抽屉里，则至少有一个抽屉里的东西不少 于两件； 抽屉原理[证明]（反证法）：如.
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<math.h> 4 int is_prime(int x) 5 { 6 int i; 7 if(x==1) return 1;//是素数返回0，不是素数返回1 8 for(i=2;i<=sqrt(x);i++) 9 if(x%i==0) return 1;10 return 0;11 }12 int main()13 {14 int n,m,a,b;15 scanf("%d",&n);16 while(n--)17 ...
阅读全文
摘要：在论坛里看到了一个人的提问，关于如何截断浮点数小数部分的问题。我的第一感觉是使用字符串处理（呵呵，估计知道floor函数的人都会笑话我了）。的确，用C++也算挺久了，竟然不知道C++库中的floor函数，可以轻易实现这个功能，唉，感慨~~~~就不多说别的了，下面说一下关于floor函数:1、函数原型：1 double floor ( double x );2 float floor ( float x );3 long double floor ( long double x );2、功能：返回一个小于传入参数的最大整数3、参数：x为将来被处理的数4、返回值：返回不大于x...
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=204 1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<math.h> 4 int main() 5 { 6 int i,N,k,t,m,n,a,b; 7 char s[65536]; 8 scanf("%d",&N); 9 getchar();10 gets(s);11 for(a=b=i=0;i<N;i++)12 {13 if(s[i]=='U')
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int T,i,j,t,sum; 6 char s1[11],s2[11];//用字符数组表示，最大11位，使用方便 7 scanf("%d",&T); 8 while(T--) 9 {10 scanf("%s %s",s1,s2);11 for(sum=i=0;s1[i]!='\0';i++)12 {13 for(t=j=0;s2[j]!='\0';j++)14...
阅读全文
摘要：由于是pow函数返回的是浮点型，此处不行，考虑到long long int 1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int x,n,i; 6 long long int s; 7 while(scanf("%d%d",&x,&n)!=EOF) 8 { 9 s=1;10 for(i=0;i<n;i++)11 {12 s=s*x;13 }14 printf("%lld\n",s);15...
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=85法一： 1 #include<stdio.h> 2 int main() 3 { 4 int i,k,m,n; 5 scanf("%d",&m); 6 while(m--) 7 { 8 scanf("%d",&n); 9 for(i=1;i*(i+1)>>1<n;i++);10 k=n-(i*(i-1)>>1);11 if(i&1)12 printf("%d/%d\n&qu
阅读全文
摘要：地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=102 1 //a^b mod c=(a mod c)^b mod c很容易设计出一个基于二分的递归算法。 2 #include<stdio.h> 3 #include<stdlib.h> 4 //快速幂算法，数论二分 5 long long powermod(int a,int b, int c) //不用longlong就报错，题目中那个取值范围不就在2的31次方内 6 { 7 long long t; 8 if(b==0) return 1%c; 9 if(..
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int m,n,s; 6 scanf("%d",&m); 7 while(m--) 8 { 9 scanf("%d",&n);10 s=0;11 while(n!=1)12 {13 s++;14 if(n&1) s++;15 n/=2;16 }17 printf("%d\n"...
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int n,i,j; 6 int a[3][3]; 7 scanf("%d",&n); 8 while(n--) 9 {10 for(i=0;i<3;i++)11 for(j=0;j<3;j++)12 scanf("%d",&a[i][j]);13 for(i=0;i<3;i++)14 {15 for(j=0;j<3;j++)16 ...
阅读全文
摘要：1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 int cmp(const void *a,const void *b) 5 { 6 return *(int *)a-*(int *)b; 7 } 8 int main() 9 {10 int t,m,n,i;11 int a[11000];12 scanf("%d",&t);13 while(t--)14 {15 scanf("%d",&m);16 memset(a,0,s
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #define Stack_Size 100 4 #define StackIncrement 10 5 #define Ok 1 6 #define Error 0 7 #define True 1 8 #define False 0 9 #define Overflow -2 10 typedef int status; 11 //字符栈的操作 12 typedef struct 13 { 14 char *base; 15 char *top; 16 int stacks...
阅读全文
摘要：1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 #define N 1100 5 char s[N]; 6 //数字栈的操作 7 typedef struct 8 { 9 float *base; 10 float *top; 11 }SqStack2; 12 int InitStack2(SqStack2 &S) 13 { 14 S.base=(float *)malloc(505*sizeof(float)); 15 S.top=S.base; 16 return 1
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=2108解题思路：叉乘的运用原理是在平面上取(0,0)来分割多边形为多个三角形，然后用叉乘来求三角形的面积（有向）再求和。这样的话可以把凸N多边形转化为N个三角形，然后求解N个三角形即可，输入顶点的顺序 无论是顺时针还是逆时针均可。* 题目要求：计算多边形面积* 方法：把n多边形分割成n-2个三角形，分别求和，然后相加* 注意：分割的所有三角形有一个公共的顶点，这里选择0点位公共点* 注：题中给出的点的顺序为逆时* 叉乘的性质：设两向量P和Q* 1.P ×Q > 0 则Q在P的逆时针方向*
阅读全文
摘要：地址：http://acm.hdu.edu.cn/showproblem.php?pid=2036解题思路：叉乘的运用原理是在平面上取(0,0)来分割多边形为多个三角形，然后用叉乘来求三角形的面积（有向）再求和。这样的话可以把凸N多边形转化为N个三角形，然后求解N个三角形即可，输入顶点的顺序 无论是顺时针还是逆时针均可。* 题目要求：计算多边形面积* 方法：把n多边形分割成n-2个三角形，分别求和，然后相加* 注意：分割的所有三角形有一个公共的顶点，这里选择0点位公共点* 注：题中给出的点的顺序为逆时* 叉乘的性质：设两向量P和Q* 1.P ×Q > 0 则Q在P的逆时针方向*
阅读全文
摘要：题目连接：http://acm.hdu.edu.cn/showproblem.php?pid=2035法一：每次取余数 1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int n,m,mul; 6 while(~scanf("%d%d",&n,&m)&&(n||m)) 7 { 8 mul=1; 9 while(m--)10 mul=(mul*n)%1000;11 printf("%d\n",mul);12 }13...
阅读全文
摘要：1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 #define N 501 5 char a[N]; 6 double fun() 7 { 8 int len; 9 char ch[10];10 sscanf(a,"%s",ch);//以字符串读入到ch11 len=strlen(ch);12 strcpy(a,a+len);13 switch(ch[0])14 {15 case '+': return fun()+fun();16 ...
阅读全文
摘要：法一： 1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int d,i,k; 6 while(~scanf("%d%d",&d,&i)&&(d||i)) 7 { 8 k=1; 9 while(--d)10 {11 if(i&1)12 {k*=2; i=(i+1)/2;}13 else14 {k=2*k+1; i/=2;}15 }16...
阅读全文
摘要：1 #include<stdio.h> 2 #include <string.h> 3 #define MAX_LEN 60 4 5 unsigned aNum[MAX_LEN+10];//存放倒过来的大数，从低位开始相乘 6 unsigned aRes[MAX_LEN+10];//存放相乘后的大数 7 unsigned aFlag[MAX_LEN+10];// 看是否匹配 8 9 int main()10 {11 char sNum[MAX_LEN+10];12 int nLen;13 int i,j,k;14 while (~scanf("%s"
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 int cmp(const void *a,const void *b) 4 { 5 return *(int *)a-*(int *)b;//升序 6 } 7 int main() 8 { 9 int a[110],b[110];10 int n,m,i,flag;11 while(~scanf("%d%d",&n,&m)&&(n||m))12 {13 for(i=0;i<n;i++)14 scanf("%d&quo
阅读全文
摘要：1 #include<stdio.h> 2 #include<math.h> 3 int main() 4 { 5 int i,n; 6 double x,s; 7 while(scanf("%lf%d",&x,&n)!=EOF) 8 { 9 for(s=0.0;n--;x=sqrt(x))10 s+=x;11 printf("%.2lf\n",s);12 }13 return 0;14 }
阅读全文
摘要：1 #include<stdio.h> 2 int n; 3 double rev(int c) 4 { 5 return c<=n?(((c&1)?1.0:-1.0)/c+rev(c+1)):0 ; 6 } 7 int main() 8 { 9 int t;10 scanf("%d",&t);11 while(t--&&scanf("%d",&n))12 printf("%.2lf\n",rev(1));13 return 0;14 }
阅读全文
摘要：1 #include<stdio.h> 2 int main() 3 { 4 int a,b,c,i,n; 5 double x; 6 while(scanf("%d",&n),n) 7 { 8 a=b=c=0; 9 for(i=0;i<n;i++)10 {11 scanf("%lf",&x);12 if(x<0) a++;13 else if(x>0) c++;14 else b++;15 }...
阅读全文
摘要：1 #include<stdio.h> 2 int main() 3 { 4 unsigned m,n,i,x,y; 5 while(scanf("%u%u",&m,&n)!=EOF) 6 { 7 if(m>n) 8 { 9 i=m;10 m=n;11 n=i;12 }13 x=y=0;14 for(i=m;i<=n;i++) 15 (i&1)?(y+=i*i*i):(x+=i*i);16 ...
阅读全文
摘要：1 #include<stdio.h> 2 int main() 3 { 4 int year,month,day,i; 5 while(scanf("%d/%d/%d",&year,&month,&day)!=EOF) 6 { 7 i=0; 8 switch(month-1) 9 {10 case 11: i+=30;11 case 10: i+=31;12 case 9: i+=30;13 case 8...
阅读全文
摘要：1 #include<stdio.h> 2 int main() 3 { 4 int r; 5 while(scanf("%d",&r)!=EOF) 6 { 7 if(r<0) 8 puts("Score is error!"); 9 else if(r<60)10 puts("E");11 else if(r<70)12 puts("D");13 else if(r<80)14 puts("C");15 else i...
阅读全文
摘要：1 #include <stdio.h> 2 #include<math.h> 3 int main() 4 { 5 double r; 6 while(scanf("%lf",&r)!=EOF) 7 printf("%.2lf\n",fabs(r)); 8 return 0; 9 }10
阅读全文
摘要：1 #include<stdio.h>2 #define PI 3.14159273 int main()4 {5 double r;6 while(scanf("%lf",&r)!=EOF)7 printf("%.3lf\n",r/3*4*r*r*PI);8 return 0;9 }
阅读全文
摘要：1 #include<stdio.h> 2 #include<math.h> 3 int main() 4 { 5 double x1,y1,x2,y2,r; 6 while(scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2)!=EOF) 7 { 8 r=sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)); 9 printf("%.2lf\n",r);10 }11 return 0;12 }
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 int main() 4 { 5 int T; 6 int h,m,s,hh,mm,ss; 7 scanf("%d",&T); 8 while(T--) 9 {10 scanf("%d%d%d%d%d%d",&h,&m,&s,&hh,&mm,&ss);11 s+=ss;12 if(s>60)13 m++;s%=60;//减去一个数不如对它取余14 m+=mm;15 if(m...
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<string.h> 4 int main() 5 { 6 int ret[50][50],i,j,n; 7 ret[1][1]=ret[2][1]=ret[2][2]=1; 8 for(i=3;i<=30;i++) 9 {10 for(j=2;j<=i-1;j++)11 {12 ret[i][j]=ret[i-1][j-1]+ret[i-1][j];13 }14 ret[...
阅读全文
摘要：法一： 1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 //这个表达式求值，要先算最小单元的数值，可以采用递归方式 5 char str[350];//使用全局数据保存字符串 6 int first;//字符当前位置 7 int min(int x,int y) 8 { 9 return x>y ? y:x;//返回比较小的数10 }11 int max(int x,int y)12 {13 return x>y ? x:y;//返回比较大的数14 }15 int f
阅读全文
摘要：函数原型: Int sscanf( const char * src, const char * format, ...);int scanf( const char * format, ...);这两个函数很相似，只是第一个函数以src作为输入，而第二个函数以标准输入STDIN读取输入；format 是格式控制字符串，它包含控制字符（如：%d,%i,%s等），空白字符（如：空格、制表符\t、回车换行符\n 或其连续组合）以及非空白字符；...是一组指针变量，是上述函数用来保存结果值的；返回值为被成功赋值的指针变量的个数，如果该函数发生错误，则返回EOF（-1）。 格式控制format: fo
阅读全文
摘要：1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 int main() 5 { 6 char s1[110]; 7 char s2[15]; 8 int i,n; 9 while(1)10 {11 gets(s2);12 if(strcmp(s2,"ENDOFINPUT")==0)13 break;14 else if(strcmp(s2,"START")==0)15 {16 ...
阅读全文
摘要：1 #include <iostream> 2 #include<cstdio> 3 #include <string> 4 using namespace std; 5 struct Node{ 6 char data; 7 Node* lchild; 8 Node* rchild; 9 };10 Node* CreateTree(string pre,string in)11 {12 Node* root = NULL;13 if(pre.length()>0)14 {15 root = new Node;16 ...
阅读全文
摘要：已知二叉树的前序遍历序列和中序遍历序列，求后序遍历序列。先递归构造二叉树，再递归后序遍历。思路：前序序列的第一个结点为要构造的二叉树的根节点，在中序序列中查找此节点，则其左为要构造的二叉树的左子树的中序序列，其右为要构造的二叉树的右子树的中序序列。而前序序列根节点后面分别跟着它的左子树和右子树的前序序列。有了根节点在中序序列中的位置，就知道了左子树和右子树的前序序列分别占据了前序序列中的那些位置，这样，就分别知道了两棵子树所代表的子序列。然后在构造了根结点后，就可以递归调用函数自身来分别构造根节点的左子树和右子树。以上为二叉树的构造即恢复。后序遍历二叉树也用递归。 1 #include <
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #define OK 1 4 #define FALSE 0 5 #define MAX_NUM 100 6 typedef int Status; 7 typedef int ElemType; 8 typedef struct SqList 9 {10 ElemType r[MAX_NUM];11 int length;12 }SqList;13 void Merge(ElemType SR[],ElemType TR[],int i,int m,int n)14 {15 int.
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #define OK 1 4 #define FALSE 0 5 #define MAX_NUM 100 6 typedef int Status; 7 typedef int ElemType; 8 typedef struct SqList 9 {10 ElemType r[MAX_NUM];11 int length;12 }SqList;13 typedef SqList HeapType;14 Status Exchange(ElemType &a,ElemType
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #define OK 1 4 #define TRUE 1 5 #define FALSE 0 6 #define ERROR -1 7 #define OVERFLOW -2 8 #define INFINITY 65535 9 #define MAX_VERTEX_NUM 2010 typedef int Status;11 typedef char TreeType;12 //定义邻接矩阵数据结构 13 typedef struct14 {15 TreeType vexs[MAX
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #define OK 1 4 #define TRUE 1 5 #define FALSE 0 6 #define ERROR -1 7 #define OVERFLOW -2 8 #define MAX_VERTEX_NUM 20 9 bool visited[MAX_VERTEX_NUM]; 10 typedef int QElemint; 11 typedef int Status; 12 //定义队列数据结构 13 typedef struct QNode 14 { 15 ..
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #define OK 1 4 #define TRUE 1 5 #define FALSE 0 6 #define ERROR -1 7 #define OVERFLOW -2 8 #define INFINITY 65535 9 #define MAX_VERTEX_NUM 10 10 typedef int Status; 11 typedef char TreeType; 12 int P[MAX_VERTEX_NUM];//用于存放最短路径，P[i]存放i的前驱结点序号 13
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #define Stack_Size 100 4 #define Stackincrement 10 5 #define ok 1 6 #define error -1 7 #define overflow 2 8 #define TRUE 1 9 #define FALSE 010 typedef int status;11 typedef struct12 {13 int *base;14 int *top;15 int stacksize;16 }SqStack;17 statu
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #define Stack_Size 100 4 #define StackIncrement 10 5 #define OK 1 6 #define TRUE 1 7 #define FALSE 0 8 #define ERROR -1 9 #define OVERFLOW -210 typedef int Status;11 typedef struct12 {13 int *base;14 int *top;15 int stacksize;16 }SqStack;17 Sta.
阅读全文
摘要：1 #include<stdio.h> 2 #include<string.h> 3 int next[12],la,lb; 4 void GetNext(char T[]) 5 { 6 int j=1,k=0; 7 next[1]=0; 8 while(j<=la) 9 { 10 if(k==0||T[j]==T[k])11 { 12 ++j;13 ++k;14 if(T[k]==T[j])15 next[j]=next[k...
阅读全文
摘要：1 #include<> 2 typedef struct 3 { 4 char *ch; 5 int length; 6 }HString; 7 Status StrAssign(Hstring &T,char *chars) 8 { 9 if(T.ch) free(T.ch);10 for(i=0,c=chars;c;i++,c++)11 if(!i)12 {13 T.ch=NULL;14 T.length=0;15 }16 else{17 if(!(T.ch=(char *)...
阅读全文
摘要：1 #include<cstdio> 2 #include<iostream> 3 #include<cstring> 4 #include<algorithm> 5 using namespace std; 6 struct Node 7 { 8 char data; 9 Node *lchild;10 Node *rchild;11 };12 Node *CreatTree(string pre,string in)13 {14 Node *root=NULL;15 if(pre.length()>0)16 {17 root...
阅读全文
摘要：1 #include<stdio.h> 2 #include<math.h> 3 #include<iostream.h> 4 #include<stdlib.h> 5 #define OK 1 6 #define FALSE 0 7 #define MAX_NUM 100 8 typedef int Status; 9 typedef int ElemType; 10 typedef struct SqList 11 { 12 ElemType r[MAX_NUM]; 13 int length; 14 }SqList; 15 typedef
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<iostream.h> 4 #define OK 1 5 #define TRUE 1 6 #define FALSE 0 7 #define ERROR -1 8 #define OVERFLOW -2 9 #define MAX_VEX_NUM 20 10 using namespace std; 11 typedef int Status; 12 //定义邻接表存储类型 13 typedef char VexType; 14 typedef stru
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #define OK 1 4 #define TRUE 1 5 #define FALSE 0 6 #define ERROR -1 7 #define OVERFLOW -2 8 typedef int Status; 9 typedef int KeyType; 10 typedef int TElemType; 11 typedef struct BiTNode{ 12 TElemType data; 13 BiTNode *lchild,*rchild; 14 }...
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #define ok 1 4 #define error 0 5 typedef int status; 6 typedef char TElemType; 7 typedef struct BiTNode 8 { 9 TElemType data; 10 struct BiTNode *lchild,*rchild; 11 }BiTNode,*BiTree; 12 13 void InitBiTree(BiTree &T) 14 { 15 T=NULL; 16 } ...
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #define Stack_Size 100 4 #define StackIncrement 10 5 #define OK 1 6 #define TRUE 1 7 #define FALSE 0 8 #define ERROR 0 9 #define OVERFLOW -2 10 typedef int Status; 11 typedef char TElemType; 12 typedef struct BiTNode 13 { 14 TElemType data; 15..
阅读全文
摘要：1 #include <stdio.h> 2 #include <malloc.h> 3 typedef int ElemType;// 稀疏矩阵的十字链表存储表示 4 typedef struct OLNode 5 { 6 int i,j; // 该非零元的行和列下标 7 ElemType e; // 非零元素值 8 struct OLNode *right,*down; // 该非零元所在行表和列表的后继链域 9 }OLNode, *OLink; 10 typedef struct// 行和列链表头指针向量基址,由CreatS...
阅读全文
摘要：1 #include<stdio.h> 2 #include<stdlib.h> 3 #define TRUE 1 4 #define FALSE -1 5 #define ERROR 0 6 #define OK 1 7 #define OVERFLOW -2 8 #define LEN1 sizeof(OLink) 9 #define LEN2 sizeof(OLNode) 10 typedef int Status; 11 typedef int ElemType; 12 typedef struct OLNode{ 13 int i,j; 14 El...
阅读全文
浙公网安备 33010602011771号