ACM必做50题的解题-搜索
acm数学竞赛试题
acm数学竞赛试题
ACM数学竞赛试题通常涉及各种数学领域，包括但不限于代数、几何、概率统计和组合数学等。
以下是一些经典的ACM数学竞赛试题：
1. 平面上n个点的k距离和最小值问题：给定平面上n个点，对于每个点，计算它到其他所有点的距离，然后求出这些距离中的k个最小值。
问题是：如何有效地计算这k个最小值？
2.最长公共子序列问题：给定两个序列，找出它们的最长公共子序列。
例如，对于序列
A = [1, 2, 3, 4] 和
B = [2, 3, 4, 5]，最长公共子序列是[2, 3, 4]。
3. 凸包问题：给定平面上的一组点，找到一个最小的凸多边形，使得这个多边形能够包含这组点中的所有点。
4. 最短路问题：给定一个有向图，其中每条边都有一个非负的权重，找出图中任意两点之间的最短路径。
5. 子集和问题：给定一个正整数数组和一个目标值，判断数组中是否存在和为目标值的两个非空子集。
例如，给定数组[1, 2, 3, 4] 和目标值7，判断是否存在两个子集，它们的和分别为7。
以上只是ACM数学竞赛试题的一部分，实际上还有更多涉及数学各个领域的题目。
要提高解决这类问题的能力，需要不断练习和研究。
计算机acm试题及答案
计算机acm试题及答案一、选择题1. 在计算机科学中，ACM代表什么？A. 人工智能与机器学习B. 计算机辅助制造C. 计算机辅助设计D. 国际计算机学会答案：D2. 下列哪个不是计算机程序设计语言？A. PythonB. JavaC. C++D. HTML答案：D3. 在计算机系统中，CPU代表什么？A. 中央处理单元B. 计算机辅助设计C. 计算机辅助制造D. 计算机辅助教学答案：A二、填空题1. 计算机的内存分为__________和__________。
答案：RAM；ROM2. 在编程中，__________是一种用于存储和操作数据的数据结构。
答案：数组3. 计算机病毒是一种__________，它能够自我复制并传播到其他计算机系统。
答案：恶意软件三、简答题1. 请简述计算机操作系统的主要功能。
答案：计算机操作系统的主要功能包括管理计算机硬件资源，提供用户界面，运行应用程序，以及控制其他系统软件和应用软件的运行。
2. 什么是云计算，它与传统的本地计算有何不同？答案：云计算是一种通过互联网提供计算资源（如服务器、存储、数据库、网络、软件等）的服务模式。
与传统的本地计算相比，云计算允许用户按需获取资源，无需购买和维护物理硬件，具有更高的灵活性和可扩展性。
四、编程题1. 编写一个程序，计算并输出从1到100（包括1和100）之间所有偶数的和。
答案：```pythonsum = 0for i in range(1, 101):if i % 2 == 0:sum += iprint(sum)```2. 给定一个字符串，编写一个函数，将字符串中的所有字符按ASCII 码值排序并返回。
答案：```pythondef sort_string(s):return ''.join(sorted(s))```五、论述题1. 论述计算机硬件和软件之间的关系及其对计算机系统性能的影响。
答案：计算机硬件是计算机系统的物质基础，包括CPU、内存、硬盘等，而软件则是运行在硬件上的程序和数据。
(2020年编辑)ACM必做50题的解题-数论
poj 1061 青蛙的约会这题用的是解线性同余方程的方法，之前没接触到过，搜索资料后看到一个人的博客里面讲的很好就拷贝过来了。
内容如下：对于方程：ax≡b(mod m)，a，b，m都是整数，求解x 的值，这个就是线性同余方程。
符号说明：mod表示：取模运算ax≡b(mod m)表示：(ax - b) mod m = 0，即同余gcd(a,b)表示：a和b的最大公约数求解ax≡b(mod n)的原理：对于方程ax≡b(mod n)，存在ax + by = gcd(a,b)，x，y是整数。
而ax≡b(mod n)的解可以由x，y来堆砌。
具体做法如下：第一个问题：求解gcd(a,b)定理一：gcd(a,b) = gcd(b,a mod b)欧几里德算法int Euclid(int a,int b){if(b == 0)return a;elsereturn Euclid(b,mod(a,b));}附：取模运算int mod(int a,int b){if(a >= 0)return a % b;elsereturn a % b + b;}第二个问题：求解ax + by = gcd(a,b)定理二：ax + by = gcd(a,b)= gcd(b,a mod b) = b * x' + (a mod b) * y'= b * x' + (a - a / b * b) * y'= a * y' + b * (x' - a / b * y')= a * x + b * y则：x = y'y = x' - a / b * y'以上内容转自/redcastle/blog/item/934b232dbc40d336349bf7e4.html由这个可以得出扩展的欧几里德算法：int exGcd(int a, int b, int &x, int &y) {if(b == 0){x = 1;y = 0;return a;}int r = exGcd(b, a % b, x, y);int t = x;x = y;y = t - a / b * y;return r;}代码：#include<iostream>#include<cstdlib>#include<cstring>#include<cmath>using namespace std;__int64 mm,nn,xx,yy,l;__int64 c,d,x,y;__int64 modd(__int64 a, __int64 b){if(a>=0)return a%b;elsereturn a%b+b;}__int64 exGcd(__int64 a, __int64 b) {if(b==0){x=1;y=0;return a;}__int64 r=exGcd(b, a%b);__int64 t=x;x=y;y=t-a/b*y;return r;}int main(){scanf("%I64d %I64d %I64d %I64d %I64d",&xx,&yy,&mm,&nn,&l);if(mm>nn) //分情况{d=exGcd(mm-nn,l);c=yy-xx;}else{d=exGcd(nn-mm,l);c=xx-yy;}if(c%d != 0){printf("Impossible\n");return 0;}l=l/d;x=modd(x*c/d,l); ///取模函数要注意printf("%I64d\n",x);system("pause");return 0;}POJ 1142 SmithNumber题意：寻找最接近而且大于给定的数字的SmithNumber什么是SmithNumber？用sum(int)表示一个int的各位的和，那一个数i如果是SmithNumber,则sum（i） =sigma( sum(Pj )),Pj表示i的第j个质因数。
acm试题及答案2
acm试题及答案2ACM试题及答案21. 问题描述：编写一个程序，计算给定整数序列中的最大子段和。
2. 输入格式：第一行包含一个整数N，表示序列的长度。
第二行包含N个整数，表示序列中的整数。
3. 输出格式：输出一个整数，表示序列中的最大子段和。
4. 样例输入：```51 -2 -34 -1```5. 样例输出：```6```6. 问题分析：该问题可以通过动态规划的方法来解决。
定义一个数组dp，其中dp[i]表示以第i个元素结尾的最大子段和。
状态转移方程为dp[i] = max(dp[i-1] + nums[i], nums[i])。
7. 算法实现：```pythondef maxSubArray(nums):n = len(nums)dp = [0] * ndp[0] = nums[0]max_sum = nums[0]for i in range(1, n):dp[i] = max(dp[i-1] + nums[i], nums[i])max_sum = max(max_sum, dp[i])return max_sum```8. 复杂度分析：时间复杂度为O(n)，其中n为序列的长度。
空间复杂度为O(n)。
9. 测试用例：- 输入：`[3, -2, 4]`输出：`5`- 输入：`[-2, 1, -3, 4, -1, 2, 1, -5, 4]`输出：`6`10. 注意事项：- 确保输入的序列长度N大于等于1。
- 序列中的整数可以是负数或正数。
- 输出结果应该是一个整数。
11. 扩展思考：- 如何优化算法以减少空间复杂度？- 如果序列中的整数是浮点数，算法是否仍然有效？12. 参考答案：- 可以通过只使用一个变量来存储最大子段和，以及一个变量来存储当前子段和，从而将空间复杂度优化到O(1)。
- 如果序列中的整数是浮点数，算法仍然有效，但需要注意浮点数运算的精度问题。
ACM必做50题——动归
1 动态规划——POJ 2479 Maximum sum我觉得这个题目跟2593是一样的题目，就是数据量有些不同。
这个题目数据量是50000，但时间只有1000ms，而2593数据量有100000，但时间有3000ms，所以相对而言，这个题目对算法的要求还要高一些，也难怪好多人都在后面发贴说过了2593但这个却没过得了。
考查点：动态规划思路：在输入的同时，进行一次DP，计算出从左到右的最大值，并把它保存在数组dp的对应的下标元素中，这样之后，对于下标为i的元素，它其中保存的便是前面所有元素可能的最大连续和。
再从右到左进行一次DP，计算从右到左的最大连续和。
假设此时已经算到下标为i的元素，那么将sum+dp[i-1]与ans进行比较，将ans取较大者。
最后当i到2的时候ans中的值即为所求的最大值。
提交情况：记不清是多少Wrong Answer，但肯定是有一次Time Limit Error，因为我有用O(N^2)的DP做过，而且可以通过我想到的所有测试数据。
收获：对动态规划问题如何更好地减少时间有了一点点理解，也复习了一下基本的技能。
经验：做题之前做好充分地分析，包括时间效率、空间效率以及实现地难度。
TLE Code(O(N^2)):（自己想了好久才想出来的，给自己鼓励一下）#include <iostream>using namespace std;int array[50001], num[50001];const int MIN = -999999999;int main(){int tcase, n;cin>>tcase;int tmp, ans, i, sum;while(tcase--){scanf("%d", &n);tmp = MIN; sum = 0;for(i = 1; i <= n; i++){scanf("%d", &num[i]);sum += num[i];if(sum > tmp)tmp = sum;array[i] = tmp;if(sum < 0)sum = 0;}tmp = ans = MIN;sum = 0;for(i = n; i > 1; i--){sum += num[i];if(sum > tmp)tmp = sum;if(ans < (array[i-1]+tmp))ans = array[i-1]+tmp;if(sum < 0)sum = 0;}cout<<ans<<endl;}return 0;}2 POJ 2593 Max Sequence考察点：动态规划思路：虽然题目给出了3000ms的时间，但考虑到数据量可以达到100000，如果用O(N^2)的算法的话，还是极有可能会超时的，于是决定采用这种O(N)时间效率的动规。
北大 poj acm题目推荐50题
-北大poj acm题目推荐50题POJ == 北京大学ACM在线评测系统/JudgeOnline1. 标记难和稍难的题目大家可以看看，思考一下，不做要求，当然有能力的同学可以直接切掉。
2. 标记为A and B 的题目是比较相似的题目，建议大家两个一起做，可以对比总结，且二者算作一个题目。
3. 列表中大约有70个题目。
大家选做其中的50道，且每类题目有最低数量限制。
4. 这里不少题目在BUPT ACM FTP 上面都有代码，请大家合理利用资源。
5. 50个题目要求每个题目都要写总结，养成良好的习惯。
6. 这50道题的规定是我们的建议，如果大家有自己的想法请与我们Email 联系。
7. 建议使用C++ 的同学在POJ 上用G++ 提交。
8. 形成自己编写代码的风格，至少看上去美观，思路清晰(好的代码可以很清楚反映出解题思路)。
9. 这个列表的目的在于让大家对各个方面的算法有个了解，也许要求有些苛刻，教条，请大家谅解，这些是我们这些年的经验总结，所以也请大家尊重我们的劳动成果。
10. 提交要求：一个总文件夹名为bupt0xx (即你的比赛帐号), 这个文件夹内有各个题目类别的子目录(文件夹)，将相应的解题报告放入对应类别的文件夹。
在本学期期末，小学期开始前，将该文件夹的压缩包发至buptacm@。
对于每个题目只要求一个POJxxxx.cpp 或POJxxxx.java (xxxx表示POJ该题题号) 的文件，注意不要加入整个project 。
11. 如果有同学很早做完了要求的题目，请尽快和我们联系，我们将指导下一步的训练。
下面是一个解题报告的范例：例如：POJ1000.cpp//考查点：会不会编程序。
//思路：此题要求输入两个数，输出两个数的和，我用scanf 和printf。
//提交情况：Wrong Answer 1次，忘了写printf()。
Compile Error 2次，选错了语言，由于C++ 和G++ 在iostream.h 的不用引用方法；少一个大括号。
acm大学生程序设计试题
acm大学生程序设计试题题目一：最大公约数（GCD）题目描述：给定两个正整数，求它们的最大公约数（GCD）。
输入两个正整数a和b（1 <= a, b <= 10^9），求它们的最大公约数。
输入格式：两个正整数，以空格分隔。
输出格式：输出一个整数，表示输入两个正整数的最大公约数。
示例：输入：14 21输出：7思路和分析：最大公约数（GCD）可以使用欧几里得算法来求解，即辗转相除法。
具体的步骤如下：1. 用较大的数除以较小的数，将得到的余数作为新的较大数。
2. 再用新的较大数除以较小数，将得到的余数作为新的较大数。
3. 如此重复，直到两个数可以整除，此时较小的数就是最大公约数。
代码实现：```cpp#include <iostream>using namespace std;int gcd(int a, int b) {if (b == 0)return a;return gcd(b, a % b);}int main() {int a, b;cin >> a >> b;int result = gcd(a, b);cout << result << endl;return 0;}```题目二：字符串反转题目描述：给定一个字符串，要求将其反转并输出。
输入一个字符串s（1 <= |s| <= 1000)，输出该字符串的反转结果。
输入格式：一个字符串s，只包含大小写字母和数字。
输出格式：一个字符串，表示输入字符串的反转结果。
示例：输入：HelloWorld123输出：321dlroWolleH思路和分析：字符串反转可以使用双指针的方法来实现。
初始时，左指针指向字符串的开头，右指针指向字符串的末尾，然后交换左右指针所指向的字符，并向中间移动，直到左指针不小于右指针。
代码实现：```cpp#include <iostream>using namespace std;string reverseString(string s) {int left = 0, right = s.length() - 1; while (left < right) {swap(s[left], s[right]);left++;right--;}return s;}int main() {string s;cin >> s;string result = reverseString(s); cout << result << endl;return 0;}```题目三：字符串匹配题目描述：给定一个字符串s和一个模式串p，判断s中是否存在与p相匹配的子串。
acm基础试题及答案
acm基础试题及答案ACM基础试题及答案1. 以下哪个选项是C语言中正确的字符串声明方式？A. char str[] = "Hello World";B. char str[10] = "Hello World";C. string str = "Hello World";D. char str = "Hello World";答案：A2. 在C++中，以下哪个关键字用于定义类的私有成员？A. publicB. privateC. protectedD. static答案：B3. 以下哪个数据结构允许快速随机访问元素？A. 链表B. 队列C. 数组D. 栈答案：C4. 在Python中，以下哪个函数用于将列表中的元素连接成一个字符串？A. join()B. concat()C. append()D. merge()答案：A5. 在数据库管理系统中，SQL代表什么？A. Structured Query LanguageB. Standard Query LanguageC. Simple Query LanguageD. System Query Language答案：A6. 在HTML中，用于定义最重要的标题的标签是什么？A. <h1>B. <title>C. <header>D. <h6>答案：A7. 在JavaScript中，以下哪个方法用于将字符串转换为小写？A. toUpperCase()B. toLowerCase()C. toUpperCase()D. toCamelCase()答案：B8. 在Unix/Linux系统中，哪个命令用于查看当前目录下的文件和文件夹？A. lsB. pwdC. cdD. mkdir答案：A9. 在C语言中，以下哪个函数用于计算数组中元素的总和？A. sum()B. count()C. sizeof()D. memset()答案：A10. 在Java中，以下哪个关键字用于创建单例模式？A. staticB. finalC. synchronizedD. volatile答案：A。
acm数学竞赛试题及答案
acm数学竞赛试题及答案# 题目一：数列问题问题描述：给定一个数列 \( a_1, a_2, a_3, \ldots, a_n \)，数列中每个元素都是正整数，且满足 \( a_i = a_{i-1} + a_{i-2} \) 对于所有\( i \geq 3 \)。
如果 \( a_1 = 1 \) 且 \( a_2 = 1 \)，请找出数列的第 \( n \) 项。
解答：根据题意，这是一个斐波那契数列。
第 \( n \) 项的值可以通过递归关系计算得出。
对于 \( n \) 的值，可以使用以下递归公式：\[ a_n = a_{n-1} + a_{n-2} \]其中，\( a_1 = 1 \) 和 \( a_2 = 1 \)。
因此，数列的前几项为 1, 1, 2, 3, 5, 8, 13, 21, ...。
对于任意的 \( n \)，可以通过递归或动态规划方法计算出 \( a_n \)。
# 题目二：组合问题问题描述：从 \( n \) 个不同的元素中选择 \( k \) 个元素的所有可能组合的个数是多少？解答：这个问题可以通过组合数学中的二项式系数来解决。
从 \( n \) 个不同元素中选择 \( k \) 个元素的组合数 \( C(n, k) \) 可以用以下公式计算：\[ C(n, k) = \frac{n!}{k!(n-k)!} \]其中，\( n! \) 表示 \( n \) 的阶乘。
# 题目三：几何问题问题描述：在一个直角坐标系中，给定三个点 \( A(x_1, y_1) \)，\( B(x_2, y_2) \) 和 \( C(x_3, y_3) \)。
如果 \( \overrightarrow{AB} \) 和 \( \overrightarrow{AC} \) 是垂直的，求证 \( A \) 是直角三角形 \( ABC \) 的直角顶点。
解答：如果 \( \overrightarrow{AB} \) 和 \( \overrightarrow{AC} \) 垂直，那么它们的数量积（点积）应该为零。
ACM必做50题的解题-快速查找 (B-Search, Hash and so on)
if(r[x]>r[y])
p[y]=x;
else if(r[x]<r[y])
p[x]=y;
else
{
r[y]++;
char fn[11];
}dict;
dict a[100001];
/* 定义qsort比较函数 */
int q_cmp(const void * a,const void *b)
{
return strcmp(((dict*)a)->fn, ((dict*)b)->fn);
int i, sign;
dict *p;
i = 0;
/* 查询标记记为"未开始" */
sign = 1;
/* 读取字符串直到文件结束 */
while(gets(str))
/* 找到则输出结果 */
if (p)
{
puts(p->en);
}
int id2 = search(s2,root);
degree[id1]++;
degree[id2]++;
if(p[id1]==0)
make_set(id1);
p->next[s[i]-'a']=new TreeNode;
p=p->next[s[i]-'a'];
}
if(p->id==0)//first insert
#include <cstring>
using namespace std;
const int max_size=500001;
ACM必做50题的解题-搜索
POJ1011 Sticks 搜索+强剪枝这个题目是不是贪心的，我就是第一次用了贪心，一直W A，相当的悲剧，贪心错误的sample：7 15 11 8 8 8 4 3 2 1，所以大家还是全部搜索。
但是全部搜索必须剪枝，不然肯定是TLE的，而且本体属于强剪枝，少剪了也是TLE。
经典搜索题，果然是到处充斥着剪枝才能过啊，我的代码离剪到极限还差很多题目给出一大堆小棍子的长度，需要把他们拼成几根长度相等的大棍子，求大棍子的最短长度看自己剪枝方法的效果时候，可以添设一个变量来记录递归次数如剪枝4：没有这个剪枝的情况下对以下数据需要40万次递归，而加上这个剪枝后减少到了4万多次对数据：4515 3 2 4 11 1 8 8 8 15 3 2 4 11 1 8 8 8 15 3 2 4 11 1 8 8 8 15 3 2 4 11 1 8 8 8 15 3 2 4 11 1 8 8 8#include <iostream>#include <algorithm>using namespace std;int sticks[65];int used[65];int n,len;bool dfs(int i,int l,int t)//i为当前试取的棍子序号,l为要拼成一根完整的棍子还需要的长度,t初值为所有棍子总长度{if(l==0){t-=len;if(t==0)return true;for(i=0;used[i];++i); //剪枝1：搜索下一根大棍子的时候，找到第一个还没有使用的小棍子开始used[i]=1; //由于排序过，找到的第一根肯定最长，也肯定要使用，所以从下一根开始搜索if(dfs(i+1,len-sticks[i],t))return true;used[i]=0;t+=len;}{for(int j=i;j<n;++j){if(j>0&&(sticks[j]==sticks[j-1]&&!used[j-1])) //剪枝2：前后两根长度相等时，如果前面那根没被使用，也就是由前面那根continue; //开始搜索不到正确结果，那么再从这根开始也肯定搜索不出正确结果，此剪枝威力较大if(!used[j]&&l>=sticks[j]) //剪枝3：最简单的剪枝，要拼成一根大棍子还需要的长度L>=当前小棍子长度，才能选用{l-=sticks[j];used[j]=1;if(dfs(j,l,t))return true;l+=sticks[j];used[j]=0;if(sticks[j]==l) //剪枝4：威力巨大的剪枝，程序要运行到此处说明往下的搜索失败，若本次的小棍长度刚好填满剩下长度，但是后break; //面的搜索失败，则应该返回上一层}}}return false;}bool cmp(const int a, const int b){return a>b;}int main(){while(cin>>n&&n){int sum=0;for(int i=0;i<n;++i){cin>>sticks[i];sum+=sticks[i];used[i]=0;}sort(sticks,sticks+n,cmp); //剪枝5：从大到小排序后可大大减少递归次数bool flag=false;for(len=sticks[0];len<=sum/2;++len) //剪枝6：大棍长度一定是所有小棍长度之和的因数，且最小因数应该不小于小棍中最长的长度{if(sum%len==0){if(dfs(0,len,sum)){flag=true;cout<<len<<endl;break;}}}if(!flag)cout<<sum<<endl;}return 0;}poj 1033 Defragment题意：磁盘整理，按照从第一个文件到最后一个文件的顺序排放，而且每个文件的碎片按原来的顺序放在一起，要求转移的次数最少。
acm基础试题及答案
acm基础试题及答案1. 题目：给定一个整数数组，请找出数组中第二大的数。
答案：我们可以使用排序的方法，将数组从小到大排序，然后数组中的倒数第二个数就是第二大的数。
或者使用一次遍历的方法，首先初始化两个变量，一个用来存储最大值，一个用来存储第二大的值。
遍历数组，每次比较当前元素与最大值，如果当前元素大于最大值，则更新第二大的值为最大值，并将当前元素赋给最大值；如果当前元素小于最大值但大于第二大的值，则更新第二大的值。
2. 题目：实现一个函数，计算一个字符串中字符出现的次数。
答案：可以使用哈希表来实现，遍历字符串中的每个字符，将其作为键值对存储在哈希表中，键是字符，值是该字符出现的次数。
遍历结束后，哈希表中存储的就是每个字符出现的次数。
3. 题目：给定一个链表，删除链表的倒数第n个节点，并且返回新的链表头节点。
答案：可以使用双指针的方法，首先初始化两个指针，都指向链表的头节点。
然后移动第一个指针，移动n步，此时第一个指针指向倒数第n个节点的前一个节点。
接着同时移动两个指针，直到第一个指针到达链表的末尾，此时第二个指针指向的节点就是需要删除的节点的前一个节点。
然后更新第二个指针的next指针，使其指向第二个指针的next节点的next节点，最后返回链表的头节点。
4. 题目：编写一个函数，判断一个整数是否是回文数。
回文数是指正序和倒序读都一样的数。
答案：首先将整数转换为字符串，然后使用双指针的方法，一个指针从字符串的开始位置，一个指针从字符串的结束位置，向中间移动。
如果两个指针指向的字符不相等，则该整数不是回文数。
如果遍历结束后没有发现不相等的字符，则该整数是回文数。
5. 题目：给定一个字符串，找出其中不含有重复字符的最长子串的长度。
答案：可以使用滑动窗口的方法，维护一个哈希表记录窗口内字符的出现情况，以及一个变量记录不含有重复字符的最长子串的长度。
遍历字符串，每次移动窗口的右端点，如果当前字符不在窗口内，则更新最长子串的长度，并将字符添加到哈希表中。
bfs acm竞赛题解
BFS（广度优先搜索）是一种常用的算法，在ACM竞赛中经常出现。
以下是一个BFS的ACM竞赛题解的例子：
题目：农夫知道一头牛的位置，想要抓住它。
农夫和牛都于数轴上，农夫起始位于点N（0<=N<=100000），牛位于点K（0<=K<=100000）。
最少要花多少时间才能抓住牛？
思路：
建立结构体，将牛的位置now和时间time放在一起。
建立一个数组来记录农夫走过的位置。
将结构体放入队列中，用结构体建立next和now（农夫的现在和接下来的位置）。
在农夫每一次行动的最终结果与牛所在的位置做对比，如果now.x与m相等，就说明农夫找到了牛，根据BFS广搜的特性必定是最短路径。
ACM必做50题——动归题
ACM 必做50题——动归 1、POJ 2479 Maximum sumDescription:Given a set of n integers: A={a1, a2,..., an}, we define a function d(A) as below: D(A)=)(max112222111∑∑==<<<<<+t s i t s j nt s t s aj aiYour task is to calculate d(A). InputThe input consists of T(<=30) test cases. The number of test cases (T) is given in the first line of the input.Each test case contains two lines. The first line is an integer n(2<=n<=50000). The second line contains n integers: a1, a2, ..., an. (|ai| <= 10000).There is an empty line after each case. OutputPrint exactly one line for each test case. The line should contain the integer d(A). Sample Input 1 101 -12 23 -34 -45 -5 Sample Output 13 HintIn the sample, we choose {2,2,3,-3,4} and {5}, then we can get the answer. Huge input,scanf is recommended.题意：好题。
ACM竞赛试题集锦
取石子游戏Time Limit:1S Memory Limit:1000KTotal Submit:505 Accepted:90Description有两堆石子，数量任意，可以不同。
游戏开始由两个人轮流取石子。
游戏规定，每次有两种不同的取法，一是可以在任意的一堆中取走任意多的石子；二是可以在两堆中同时取走相同数量的石子。
最后把石子全部取完者为胜者。
现在给出初始的两堆石子的数目，如果轮到你先取，假设双方都采取最好的策略，问最后你是胜者还是败者。
Input输入包含若干行，表示若干种石子的初始情况，其中每一行包含两个非负整数a和b，表示两堆石子的数目，a和b都不大于1,000,000,000。
Output输出对应也有若干行，每行包含一个数字1或0，如果最后你是胜者，则为1，反之，则为0。
Sample Input2 18 44 7Sample Output1跳蚤Time Limit:1S Memory Limit:1000KTotal Submit:198 Accepted:44DescriptionZ城市居住着很多只跳蚤。
在Z城市周六生活频道有一个娱乐节目。
一只跳蚤将被请上一个高空钢丝的正中央。
钢丝很长，可以看作是无限长。
节目主持人会给该跳蚤发一张卡片。
卡片上写有N+1个自然数。
其中最后一个是M，而前N个数都不超过M，卡片上允许有相同的数字。
跳蚤每次可以从卡片上任意选择一个自然数S，然后向左，或向右跳S个单位长度。
而他最终的任务是跳到距离他左边一个单位长度的地方，并捡起位于那里的礼物。
比如当N=2，M=18时，持有卡片(10, 15, 18)的跳蚤，就可以完成任务：他可以先向左跳10个单位长度，然后再连向左跳3次，每次15个单位长度，最后再向右连跳3次，每次18个单位长度。
而持有卡片(12, 15, 18)的跳蚤，则怎么也不可能跳到距他左边一个单位长度的地方。
当确定N和M后，显然一共有M^N张不同的卡片。
ACM题库完整版
if(str[i]>='a'&&str[i]<='z') { str[i]=str[i]-32; } i++;
} puts(str); return 0; }
日历问题
1.题目描述 在我们现在使用的日历中, 闰年被定义为能被4整除的年份，但是能被100整除而不能被400整除的年 是例外，它们不是闰年。例如：1700, 1800, 1900 和 2100 不是闰年，而 1600, 2000 和 2400是闰年。 给定从公元2000年1月1日开始逝去的天数，你的任务是给出这一天是哪年哪月哪日星期几。 2.输入 输入包含若干行，每行包含一个正整数，表示从2000年1月1日开始逝去的天数。输入最后一行是?1, 不必处理。可以假设结果的年份不会超过9999。 3.输出 对每个测试样例，输出一行，该行包含对应的日期和星期几。格式为“YYYY-MM-DD DayOfWeek”, 其中 “DayOfWeek” 必须是下面中的一个： "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" 或 "Saturday“。 4.样例输入 1730 1740 1750 1751 -1 5.样例输出 2004-09-26 Sunday 2004-10-06 Wednesday 2004-10-16 Saturday 2004-10-17 Sunday 6.提示 2000.1.1. 是星期六
ACM必做50题——高精度
ACM必做50题——高精度1 POJ 1001 Exponentiation高精度数的计算，以前在网上看到过一个计算大数阶乘比如10000000！的算法，总体思想就是将结果用数组保存起来，然后将结果的每一位与乘数相乘，当然还有进位...有了这个算法的思想，这个题思路就可以是：先将输入的小数转换成一个整数，当然这个整数肯定能够用int类型的变量保存，比如1.2345, 通过函数removeDot（）将它转化成12345，然后利用大数阶乘的思想计算12345*12345.....*12345, 最后的就是输出了，这个要考虑的情况比较多，因为这个也W A了5次才AC(笨的要死), 情况虽多，但不难.这道题是高精度计算的，不算很难，但是很繁琐，尤其是对输入输出的要求。
被这道题搞了好久，耐心来，一点一点调试，总会成功的。
#include#include#includeusing namespace std;char ans[10];char res[2][205];__int64 ps;//有几位小数点int len;//长度，R的有效长度//计算c = b * avoid Multiply(char * b,int bt,char * a,int at,char * c){int i,j;int up=0;for(i=0;i<at;++i)< p="">{up=0;for(j=0;j<bt;j++)< p="">{int t;if(c[i+j]==0)c[i+j]='0';t=(a[i]-48)*(b[j]-48)+c[i+j]-48+up; if(t>=10){up=t/10;t=t%10;c[i+j]=t+48;if(j==(bt-1) )c[i+j+1]=(up+48);}else{c[i+j]=t+48;up=0;}}}}int main(){string str;int n;int i,j;int s,t;int pos;while(cin>>str>>n){i=5;pos=str.find('.',0);if(pos<0)//没有小数点{ps=0;//zs=zs*n;//后面为0的总数}else//有小数点{ps=(5-pos);ps=ps*n;//小数位总数}memset(ans,0,sizeof(ans)); memset(res[0],0,sizeof(res[0])); memset(res[1],0,sizeof(res[1])); t=5;s=0;while(str[s]=='0' || str[s]=='.') s++;j=0;for(i=t;i>=s;--i){if(str[i]=='.')continue;ans[j]=str[i];j++;}len=j;strcpy(res[0],ans);strcpy(res[1],ans);for(i=2;i<=n;++i){memset(res[(i+1)%2],0,sizeof(res[0]));Multiply(res[i%2],strlen(res[i%2]),ans,len,res[(i+1)%2]); } int L=strlen(res[(n+1)%2]);int d=(n+1)%2;if(ps>0){j=0;while(res[d][j]=='0')j++;if(ps>=L){printf(".");for(i=ps-1;i>=j ;--i){if(i>=L)printf("0");elseprintf("%c",res[(n+1)%2][i]);}}else{if(j>=ps){for(i=L-1;i>=ps;--i)printf("%c",res[(n+1)%2][i]);}else{for(i=L-1;i>=j ;--i){if(i==ps){printf("%c.",res[(n+1)%2][i]);}elseprintf("%c",res[(n+1)%2][i]);}}}}else{for(i=L-1;i>=0;--i)printf("%c",res[(n+1)%2][i]);}printf("\n");}return 0;}2 POJ 1047 Round and Round We Go题意:输入一个数,要求判该数是否为循环数.依次将该数分别于2到len(输入的数的位数)相乘,在乘的过程中,判断数发生了变化没有,如果发生了变化,则直接输出该数不是循环数,没有必要再继续乘下去,而如果是循环数,则一直需要乘下去.#include#include#include#includeusing namespace std;int num[70];int ans[70];char ss[70];bool match[70];int main(){int i,j,k,len;bool flag;while(scanf("%s",ss)!=EOF){len=strlen(ss);for(i=len-1,j=0;i>=0;i--,j++)num[j]=ss[i]-'0';for(i=2;i<=len;i++){memset(ans,0,sizeof(ans));for(j=0;j<len;j++)< p="">//依次将该数与2到len之间的数相乘ans[j]=num[j]*i;for(j=0;j<len;j++)< p="">//循环处理进位if(ans[j]>=10){ans[j+1]+=ans[j]/10;ans[j]%=10;}memset(match,0,sizeof(match)); //match数组用来标记数的匹配情况flag=true;for(j=0;j<len;j++)< p="">{k=0;while(k<len)< p="">{if(ans[k]==num[j]&&!match[k]) //两数字相等且没有进行标记{match[k]=true;break;}k++;}if(k==len)//此时说明相乘后的结果发生了改变{flag=false;break;}}if(!flag){printf("%s is not cyclic\n",ss);break;}}if(flag)printf("%s is cyclic\n",ss);}system("pause");return 0;}3 POJ 1131 Octal Fractions给定一个八进制的小数题目要求你把它转换为十进制小数，转换后小数的位数是转换前八进制小数位数的3倍且不输出末尾无意义的零(即后置零). 我采用的方法是乘10然后对8取整(现在假设将p进制的小数转换为n进制,同样采用乘n取整:),每转换一位,都必须从最低位s[len-1]开始至小数的最高位(即小数点后的一位),每次计算积g=a[j]*n+k(其中k为下一位积的进位),本位进位数k=g/p,积在本位存入s[j]=g%p;最后的整数k作为转换的一位存放于转换结果字符串中。
ACM必做50题的解题-计算几何
ACM必做50题的解题-计算几何.txt生活，是用来经营的，而不是用来计较的。
感情，是用来维系的，而不是用来考验的。
爱人，是用来疼爱的，而不是用来伤害的。
金钱，是用来享受的，而不是用来衡量的。
谎言，是用来击破的，而不是用来装饰的。
信任，是用来沉淀的，而不是用来挑战的。
POJ 1113 WALL计算几何，求凸包这题的结果等于这个多边形构成的凸包的周长加上以所给半径为半径的圆的周长步骤如下：1)算法首先寻找最最靠下方的点，如果遇到y坐标相同，则寻找x坐标最小的点firstP2)然后根据所有点相对于firstP的偏角的大小进行排序，遇到偏角相等的，只取距离firstP最远的点(排序利用自己手写的快排)3)然后利用Graham算法求凸包4)最后直接求职#include <iostream>#include <cmath>#define PI 3.1415926#define MAX_N 1000using namespace std;//存储原始输入的坐标值，rad是输入的半径double cord[MAX_N + 2][2], rad;int seq[MAX_N + 2];int stack[MAX_N + 2];int n, top;int firstP;int realN;void swap(int pos1, int pos2){int temp = seq[pos1];seq[pos1] = seq[pos2];seq[pos2] = temp;}int dir(int nodes, int node1, int node2){double x1 = cord[node1][0], y1 = cord[node1][1];double x2 = cord[node2][0], y2 = cord[node2][1];double sx = cord[nodes][0], sy = cord[nodes][1];return (x2 - sx) * (y1 - sy) - (x1 - sx) * (y2 - sy);}double getDist(int node1, int node2){double x1 = cord[node1][0], y1 = cord[node1][1];double x2 = cord[node2][0], y2 = cord[node2][1];double res = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));return res;}int compare(int node1, int node2){double x1 = cord[node1][0], y1 = cord[node1][1];double x2 = cord[node2][0], y2 = cord[node2][1];double sx = cord[firstP][0], sy = cord[firstP][1];double type = dir(firstP, node1, node2);if(type == 0){double dist1 = (x1 - sx) * (x1 - sx) + (y1 - sy) * (y1 - sy);double dist2 = (x2 - sx) * (x2 - sx) + (y2 - sy) * (y2 - sy);if(dist1 > dist2)return -2;else if(dist1 == dist2)return 0;elsereturn 2;}else if(type > 0)return 1;elsereturn -1;}void fastSort(int start, int end){if(start < end){int curPos = start;int posS = start, posE = end + 1;while(true){while(compare(seq[++posS], seq[curPos]) < 0 && posS < end); while(compare(seq[--posE], seq[curPos]) > 0 && posE > start); if(posS < posE)swap(posS, posE);elsebreak;}swap(curPos, posE);fastSort(start, posE - 1);fastSort(posE + 1, end);}}void sortSeq(){int i, s = 0;for(i = 1; i <= n; i++){//最低最左点不参加排序if(i == firstP)continue;seq[++s] = i;}realN = n - 1;fastSort(1, realN);//清理夹角相同但是距离不同的点，只取举例firstP最远的点i = 1;while(i < realN){s = i + 1;//equal angle but smaller distancewhile(s <= realN && compare(seq[i], seq[s]) == -2) {seq[s] = -1; //置为无效s++;}i = s;}}//寻找凸包void findQ(){int nodes, node1, node2, type;top = 0;stack[top++] = firstP;int s = 1;int c = 0;while(c < 2){if(seq[s] != -1){c++;stack[top++] = seq[s];}s++;}for(; s <= realN; s++){if(seq[s] == -1)continue;while(true){nodes = stack[top - 2];node1 = stack[top - 1];node2 = seq[s];type = dir(nodes, node1, node2);if(type >= 0)top--;elsebreak;}stack[top++] = seq[s];}}double getRes(){double totalDist = 0;int lastNode = firstP;int curNode;while(top > 0){curNode = stack[--top];totalDist += getDist(lastNode, curNode);lastNode = curNode;}//totalDist += getDist(lastNode, firstP);totalDist += 2 * PI * rad;return totalDist;}int main(){int i;cin>>n>>rad;int minX = INT_MAX, minY = INT_MAX;for(i = 1; i <= n; i++){cin>>cord[i][0]>>cord[i][1];if((cord[i][1] < minY) || (cord[i][1] == minY && cord[i][0] < minX)){firstP = i;minX = cord[i][0];minY = cord[i][1];}}sortSeq();findQ();double res = getRes();printf("%.0f\n", res);return 0;}POJ1292 Will Indiana Jones Get There?题目大意：英雄Jones现在在位置1，有人在位置2呼救，所以他要过去救他，但是有个条件，他必须在墙上走，其实就是说他只能在图示的线段上走，但是线段间有空隙，所以要用一个长板搭在线段间才能从一个线段到另外一个线段，问怎么找到一个路径使得要使用的长板最小。
acm初级试题及答案
acm初级试题及答案1. 题目：字符串反转- 描述：编写一个函数，实现对输入字符串的反转。
- 输入：一个字符串。
- 输出：反转后的字符串。
答案：```pythondef reverse_string(s):return s[::-1]```2. 题目：求最大公约数- 描述：编写一个函数，计算两个正整数的最大公约数。
- 输入：两个正整数。
- 输出：两个数的最大公约数。
答案：```pythondef gcd(a, b):while b:a, b = b, a % breturn a```3. 题目：计算阶乘- 描述：编写一个函数，计算一个非负整数的阶乘。
- 输入：一个非负整数。
- 输出：该整数的阶乘。
答案：```pythondef factorial(n):if n == 0:return 1else:return n * factorial(n-1)```4. 题目：判断素数- 描述：编写一个函数，判断一个正整数是否为素数。
- 输入：一个正整数。
- 输出：如果该数是素数，返回True；否则返回False。
答案：```pythondef is_prime(n):if n <= 1:return Falsefor i in range(2, int(n0.5) + 1):if n % i == 0:return Falsereturn True```5. 题目：寻找数组中第二大的数- 描述：编写一个函数，找出数组中第二大的数。
- 输入：一个整数数组。
- 输出：数组中第二大的数。
答案：```pythondef find_second_max(arr):first = second = float('-inf')for num in arr:if num > first:second = firstfirst = numelif num > second and num != first: second = numreturn second```。
acm试题及答案
acm试题及答案ACM试题及答案试题 1: 给定一个整数数组，请找出数组中第二大的数。
答案:1. 对数组进行排序。
2. 数组排序后，倒数第二个元素即为第二大的数。
试题 2: 编写一个函数，计算给定字符串中字符出现的次数。
答案:```pythondef count_characters(s):count_dict = {}for char in s:if char in count_dict:count_dict[char] += 1else:count_dict[char] = 1return count_dict```试题 3: 判断一个数是否为素数。
答案:1. 如果数小于2，则不是素数。
2. 从2开始到该数的平方根，检查是否有因数。
3. 如果没有因数，则该数是素数。
试题 4: 实现一个算法，将一个整数数组按照奇数在前，偶数在后的顺序重新排列。
答案:```pythondef rearrange_array(arr):odd = []even = []for num in arr:if num % 2 == 0:even.append(num)else:odd.append(num)return odd + even```试题 5: 给定一个链表，删除链表的倒数第n个节点。
答案:1. 遍历链表，找到链表的长度。
2. 再次遍历链表，找到倒数第n个节点的前一个节点。
3. 将前一个节点的next指针指向当前节点的下一个节点。
4. 如果当前节点是头节点，则更新头节点。
试题 6: 编写一个函数，实现字符串反转。
答案:```pythondef reverse_string(s):return s[::-1]```试题 7: 给定一个整数数组，找出数组中没有出现的最小正整数。
答案:1. 遍历数组，使用哈希表记录出现的数字。
2. 从1开始，检查每个数字是否在哈希表中。
3. 第一个不在哈希表中的数字即为答案。
试题 8: 实现一个算法，计算斐波那契数列的第n项。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
memset(q,-1,10000*sizeof(int));
memset(d,-1,10000*sizeof(int));
scanf("%d%d",&n,&k);
int counter=0;
for(int j=0;j<k;j++){
scanf("%d",&t);
for(int i=0;i<n;++i)
{
cin>>sticks[i];
sum+=sticks[i];
used[i]=0;
}
sort(sticks,sticks+n,cmp); //剪枝5：从大到小排序后可大大减少递归次数
for(int i=0;i<t;i++){
scanf("%d",&tmp);
tmp--;
q[tmp]=counter;
d[counter]=tmp;
counter++;
}
}
//put nodes whose correct place is empty and solve the chains.
#define N 27
int g[N][N], num, n;
int x[N];
int ok(int t)
{
int i;
for(i = 1; i<=n; i++)
{
if(i != t)
{
if(g[t][i] == 1 && x[i] == x[t])
经典搜索题，果然是到处充斥着剪枝才能过啊，我的代码离剪到极限还差很多
题目给出一大堆小棍子的长度，需要把他们拼成几根长度相等的大棍子，求大棍子的最短长度
看自己剪枝方法的效果时候，可以添设一个变量来记录递归次数
如剪枝4：没有这个剪枝的情况下对以下数据需要40万次递归，而加上这个剪枝后减少到了4万多次
{
t-=len;
if(t==0)return true;
for(i=0;used[i];++i); //剪枝1：搜索下一根大棍子的时候，找到第一个还没有使用的小棍子开始
对数据：
45
15 3 2 4 11 1 8 8 8 15 3 2 4 11 1 8 8 8 15 3 2 4 11 1 8 8 8 15 3 2 4 11 1 8 8 8 15 3 2 4 11 1 8 8 8
#include <iostream>
#include <algorithm>
if(!used[j]&&l>=sticks[j]) //剪枝3：最简单的剪枝，要拼成一根大棍子还需要的长度L>=当前小棍子长度，才能选用
{
l-=sticks[j];
if(sticks[j]==l) //剪枝4：威力巨大的剪枝，程序要运行到此处说明往下的搜索失败，若本次的小棍长度刚好填满剩下长度，但是后
break; //面的搜索失败，则应该返回上一层
}
POJ1011 Sticks 搜索+强剪枝（终于AC了，分享经验）
这个题目是不是贪心的，我就是第一次用了贪心，一直WA，相当的悲剧，贪心错误的sample：7 15 11 8 8 8 4 3 2 1，所以大家还是全部搜索。但是全部搜索必须剪枝，不然肯定是TLE的，而且本体属于强剪枝，少剪了也是TLE。
解决方法：
1。对于1，只需要从A0开始一个一个按顺序放到原来的位置上即可。
2。对于2，只需要从环中的任何一个节点开始，先将这个节点放到从尾部开始数起的空位，然后以链的方式处理，最后再将这个节点的数放回到最后一个节点的位置。
主要数据结构：
q[i]:放在第i个位上的数应该放在第q[i]个位上。
t+=len;
}
else
{
for(int j=i;j<n;++j)
{
if(j>0&&(sticks[j]==sticks[j-1]&&!used[j-1])) //剪枝2：前后两根长度相等时，如果前面那根没被使用，也就是由前面那根
思路：
根据给出的点构造邻接矩阵，顶点相邻的位置置1，不同的置0。因为图着色问题颜色最多是四种颜色。所以1种，2种，3种，4种，一个一个试，如果返回回来的着色方案总数不是0说明可行，为用的最少的颜色数。
#include <stdio.h>
#include <string.h>
#include <ctype.h>
{
if(dfs(0,len,sum))
{
flag=true;
cout<<len<<endl;
break;
q[index]=q[tmp];q[tmp]=-1;
}
}else printf("No optimization needed\n");
return 0;
}
本文来自CSDN博客，转载请标明出处：/liangxing0728/archive/2009/03/07/3964973.aspx
poj 1129 Channel Allocation(图着色)
题意：
用中继器（repeater）给每个接受者(receiver)发送信号，为了防止信号干扰，两个相邻的广播站之间的中继器要不相同。问至少需要多少个中继器。
这个问题相当于给定—个图，如果要求把所有顶点涂上颜色，使得相邻顶点具有不同的颜色，问最少需要几种不同的颜色。经典的图着色问题。
poj 1033 Defragment
题意：
磁盘整理，按照从第一个文件到最后一个文件的顺序排放，而且每个文件的碎片按原来的顺序放在一起，要求转移的次数最少。
解：
其实根本不用搜索，一开始想搜索想了很久，上网找解题报告也没找到（这么水的一题竟然没有解题报告），于是开始自已想。
其实碎片的排列只有二种情况：
}
}
}
if(!flag)
cout<<sum<<endl;
}
return 0;
}
本文来自CSDN博客，转载请标明出处：/lovelyloulou/archive/2010/01/31/5274966.aspx
using namespace std;
int sticks[65];
int used[65];
int n,len;
bool dfs(int i,int l,int t)//i为当前试取的棍子序号,l为要拼成一根完整的棍子还需要的长度,t初值为所有棍子总长度
{
if(l==0)
bool flag=false;
for(len=sticks[0];len<=sum/2;++len) //剪枝6：大棍长度一定是所有小棍长度之和的因数，且最小因数应该不小于小棍中最长的长度
{
if(sum%len==0)
}
}
return false;
}
bool cmp(const int a,n a>b;
}
int main()
{
while(cin>>n&&n)
{
int sum=0;
1. A0碎片没有放在原来的位置，而它原来的位置正好是空的。而A1碎片也刚好没有放在原来的位置，而b原来的位置之前一直被A0占领，同样还有A2碎片没有在原来位置，而其原来的位置之前一直被A1占领，以此递推直到Ai,没有碎片要放在Ai的位置为止。这种情况称为链。
2. 基本上同1一样，不过，一开始的时候A0的原来位置并不是空的，而是最后的那个Ai占领着，这种情况称为环。
continue; //开始搜索不到正确结果，那么再从这根开始也肯定搜索不出正确结果，此剪枝威力较大
while(d[index]!=-1){
printf("%d %d\n",d[index]+1,index+1);
q[d[index]]=-1;q[index]=index;
index=d[index];
}
continue;
}
}
if(optneed==true){
d[i]:应该放在第i个位上的数，现在放在了第d[i]个位上。
#include <iostream>
using namespace std;
int n,k,tmp,t,index,pi;
int q[10000];
int d[10000];
bool optneed;
int main(){
used[i]=1; //由于排序过，找到的第一根肯定最长，也肯定要使用，所以从下一根开始搜索
if(dfs(i+1,len-sticks[i],t))return true;
used[i]=0;
//solve the rings
for(int i=0;i<n;i++){
if(q[i]==i||q[i]==-1) continue;
index=i;
for(tmp=n-1;tmp>=0;tmp--) if(q[tmp]==-1) break;