煤球数目
有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
….
如果一共有100层，共有多少个煤球？
请填表示煤球总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
思路：
推出第i层有i*(i+1)/2个煤球，累加到100层即可，答案为171700
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0;
for (int i = 1; i <= 100; i++) {
ans += i * (i + 1) / 2;
}
cout << ans << endl;
return 0;
}
生日蜡烛
某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。
现在算起来，他一共吹熄了236根蜡烛。
请问，他从多少岁开始过生日party的？
请填写他开始过生日party的年龄数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
思路
根据题目意思，假设他从x岁开始过生日，现在是y岁，这么多年的岁数和是236，由于每一年年龄会加1，相当于是一个项数位(y-x+1)，公差为1的等差数列求和。于是只要枚举x和y，然后根据公式算一下（直接累加求和也是可以的）是不是等于236就行了。答案等于26。
#include <bits/stdc++.h>
using namespace std;
int main() {
for (int i = 1; i <= 100; i++) {
for (int j = i + 1; j <= 100; j++) {
if ((i + j) * (j - i + 1) / 2 == 236) cout << i << endl;
}
}
return 0;
}
凑算式
B DEF
A + - + --- = 10
C GHI这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。
比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。
这个算式一共有多少种解法？
注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。
思路
利用全排列生成所有A~I和1~9可能的对应情况，对每一种对应情况判断一下等式是否成立即可。答案是29。(当时比赛的时候逗比了，看见”/”就以为必须是整除，所以代码里多了个B%C==0&&DEF%GHI==0)
#include <bits/stdc++.h>
using namespace std;
int a[10], ans;
int main() {
for (int i = 1; i <= 9; i++) {
a[i] = i;
}
do {
double A = a[1];
double B = a[2];
double C = a[3];
double DEF = a[4] * 100 + a[5] * 10 + a[6];
double GHI = a[7] * 100 + a[8] * 10 + a[9];
if (fabs(A + B / C + DEF / GHI - 10) < 1e-12) ans++;
} while (next_permutation(a + 1, a + 10));
cout << ans << endl;
return 0;
}
快速排序
排序在各种场合经常被用到。
快速排序是十分常用的高效率的算法。
其思想是：先选一个“标尺”，
用它把整个队列过一遍筛子，
以保证：其左边的元素都不大于它，其右边的元素都不小于它。
这样，排序问题就被分割为两个子区间。
再分别对子区间排序就可以了。
下面的代码是一种实现，请分析并填写划线部分缺少的代码。
#include <stdio.h>
void swap(int a[], int i, int j) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
int partition(int a[], int p, int r) {
int i = p;
int j = r + 1;
int x = a[p];
while(1) {
while(i < r && a[++i] < x);
while(a[--j] > x);
if(i >= j) break;
swap(a, i, j);
}
______________________;
return j;
}
void quicksort(int a[], int p, int r) {
if(p < r) {
int q = partition(a, p, r);
quicksort(a, p, q - 1);
quicksort(a, q + 1, r);
}
}
int main() {
int i;
int a[] = {5, 13, 6, 24, 2, 8, 19, 27, 6, 12, 1, 17};
int N = 12;
quicksort(a, 0, N - 1);
for(i = 0; i < N; i++) printf("%d ", a[i]);
printf("\n");
return 0;
}
注意：只填写缺少的内容，不要书写任何题面已有代码或说明性文字。
思路
相信对每一位计算机相关的考研党和学霸来说这种题目都是小case吧。。。根据quicksort的参数和main函数的调用，以及partition里面的参数可以猜到partition的参数a[],p,r的含义是要排序的数组、开始位置、结束位置，那么partition的功能就是将a数组的p位置到r位置的序列划分成两半，让左一半全部小于等于右一半，同时返回那个临界值的位置。在partition里面，将a[p]选为了参考值(int x=a[p])，而后这个a[p]就再没变化，这显然是不行的，因为参考值放在了最前面，比它小的只能放后面。所以还缺了“将a[p]这个临界值换到后面去”这一步。换到哪里呢？由于后面return的是j，那么答案就出来了，swap(a, p, j)。填进代码里面测试，对或错就知道了，如果还不放心，用rand()给a数组赋值，排完序再打出来看看。
抽签
X星球要派出一个5人组成的观察团前往W星。
其中：
A国最多可以派出4人。
B国最多可以派出2人。
C国最多可以派出2人。
….
那么最终派往W星的观察团会有多少种国别的不同组合呢？
下面的程序解决了这个问题。
数组a[] 中既是每个国家可以派出的最多的名额。
程序执行结果为：
DEFFF
CEFFF
CDFFF
CDEFF
CCFFF
CCEFF
CCDFF
CCDEF
BEFFF
BDFFF
BDEFF
BCFFF
BCEFF
BCDFF
BCDEF
….
(以下省略，总共101行)
#include <stdio.h>
#define N 6
#define M 5
#define BUF 1024
void f(int a[], int k, int m, char b[]) {
int i, j;
if(k == N) {
b[M] = 0;
if(m == 0) printf("%s\n", b);
return;
}
for(i = 0; i <= a[k]; i++) {
for(j = 0; j < i; j++) b[M - m + j] = k + 'A';
______________________; //填空位置
}
}
int main() {
int a[N] = {4, 2, 2, 1, 1, 3};
char b[BUF];
f(a, 0, M, b);
return 0;
}
思路：
其实最喜欢这样的填空题了，因为很容易判断填的是对还是错=.=这个题其实当时都没怎么思考，直接就填了个f(a, k+1, m-i, b)试一试，打出来的结果跟题目中的一致，还自己加个统计变量，刚好是101行。。。大概就是要搞出几个变量的含义吧，f(a, k, m, b)里面，a限制了每一次往答案数组b填的相同字母个数，k是表示第几个字母，m表示剩余的字母个数，b是答案数组。f函数里面的i就是表示第k个字母选i个往b里放，而j就是放的过程，放完以后自然就要考虑下一个了。所以答案就是f(a, k+1, m-i, b)，表示放下一个字母，这一次放了i个，所以还剩下m-i个可以放。
方格填数
填入0~9的数字。要求：连续的两个数字不能相邻。
（左右、上下、对角都算相邻）
+--+--+--+
| | | |
+--+--+--+--+
| | | | |
+--+--+--+--+
| | | |
+--+--+--+
一共有多少种可能的填数方案？
请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
思路
用全排列生成所有情况，然后判断是否合法就行了。另外题目中给的条件：“连续的两个数字不能相邻” 等价于 “相邻的数字不连续”，这个是至关重要的。答案是1580。
#include <bits/stdc++.h>
using namespace std;
int ans;
int a[10];
bool chk(int i, int j) {
return abs(a[i] - a[j]) != 1;
}
bool chk() {
return chk(0, 1) && chk(1, 2) && chk(3, 4) && chk(4, 5) && chk(5, 6) && chk(7, 8) && chk(8, 9) &&
chk(0, 4) && chk(1, 5) && chk(2, 6) && chk(3, 7) && chk(4, 8) && chk(5, 9) &&
chk(0, 5) && chk(1, 6) && chk(3, 8) && chk(4, 9) &&
chk(0, 3) && chk(1, 4) && chk(2, 5) && chk(4, 7) && chk(5, 8) && chk(6, 9);
}
int main() {
for (int i = 0; i < 10; i++) a[i] = i;
do {
ans += chk();
} while (next_permutation(a, a + 10));
cout << ans << endl;
return 0;
}
剪邮票
+--+--+--+--+
| | | | |
+--+--+--+--+
| | | | |
+--+--+--+--+
| | | | |
+--+--+--+--+
有12张连在一起的12生肖的邮票。
现在你要从中剪下5张来，要求必须是连着的。
（仅仅连接一个角不算相连）
请你计算，一共有多少种不同的剪取方法。
请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
思路
先生成所有邮票的形状，然后看这个形状在一个连通块内，对每个格子编号，那么它的形状可以用5个数来表示，判断是否为联通块用dfs或bfs都行。答案是116。
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int a[5], ans;
bool flag[3][4], vis[3][4];
void dfs2(int x, int y) {
vis[x][y] = 1;
for (int i = 0; i < 4; i++) {
int xx = x + dx[i];
int yy = y + dy[i];
if (xx >= 0 && xx < 3 && yy >= 0 && yy < 4 && !flag[xx][yy] && !vis[xx][yy]) dfs2(xx, yy);
}
}
bool work() {
memset(flag, 1, sizeof(flag));
memset(vis, 0, sizeof(vis));
for (int i = 0; i < 5; i++) flag[a[i] / 4][a[i] % 4] = 0;
dfs2(a[0] / 4, a[0] % 4);
for (int i = 0; i < 5; i++) {
if (!vis[a[i] / 4][a[i] % 4]) return 0;
}
return 1;
}
void dfs(int k, int b) {
if (k == 5) {
ans += work();
return;
}
for (int i = b; i <= 7 + k; i++) {
a[k] = i;
dfs(k + 1, i + 1);
}
}
int main() {
dfs(0, 0);
cout << ans << endl;
return 0;
}
四平方和
四平方和定理，又称为拉格朗日定理：
每个正整数都可以表示为至多4个正整数的平方和。
如果把0包括进去，就正好可以表示为4个数的平方和。
比如：
5 = 0^2 + 0^2 + 1^2 + 2^2
7 = 1^2 + 1^2 + 1^2 + 2^2
（^符号表示乘方的意思）
对于一个给定的正整数，可能存在多种平方和的表示法。
要求你对4个数排序：
0 <= a <= b <= c <= d
并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法
程序输入为一个正整数N (N<5000000)
要求输出4个非负整数，按从小到大排序，中间用空格分开
例如，输入：
5
则程序应该输出：
0 0 1 2
再例如，输入：
12
则程序应该输出：
0 2 2 2
再例如，输入：
773535
则程序应该输出：
1 1 267 838
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 3000ms
思路
最简单的思路4重for循环，不知道这样能过多少组数据，毕竟这个复杂度不好确定，虽然最坏是 O(n2) 的。一个简单的优化办法是预处理所有两个数的平方和，放在一个表中，要求根据平方和要迅速得到它的所有解。所以可以用一个 map<int,vector<Node>> 来搞。具体见代码。
#include <bits/stdc++.h>
using namespace std;
#include "local.h"
struct Node {
int x, y;
Node() {}
Node(int x, int y) {
this->x = x;
this->y = y;
}
};
map<int, vector<Node> > mp;
int n;
void work() {
for (int i = 0; i * i <= n; i++) {
for (int j = i; i * i + j * j <= n; j++) {
vector<Node>::iterator it, st = mp[n - i * i - j * j].begin(), ed = mp[n - i * i - j * j].end();
for (it = st; it != ed; it++) {
if (j <= it->x) {
cout << i << " " << j << " " << it->x << " " << it->y << endl;
return;
}
}
}
}
}
int main() {
cin >> n;
for (int i = 0; i * i <= n; i++) {
for (int j = i; i * i + j * j <= n; j++) {
mp[i * i + j * j].push_back(Node(i, j));
}
}
work();
return 0;
}
交换瓶子
有N个瓶子，编号 1 ~ N，放在架子上。
比如有5个瓶子：
2 1 3 5 4
要求每次拿起2个瓶子，交换它们的位置。
经过若干次后，使得瓶子的序号为：
1 2 3 4 5
对于这么简单的情况，显然，至少需要交换2次就可以复位。
如果瓶子更多呢？你可以通过编程来解决。
输入格式为两行：
第一行: 一个正整数N（N<10000）, 表示瓶子的数目
第二行：N个正整数，用空格分开，表示瓶子目前的排列情况。
输出数据为一行一个正整数，表示至少交换多少次，才能完成排序。
例如，输入：
5
3 1 2 5 4
程序应该输出：
3
再例如，输入：
5
5 4 3 2 1
程序应该输出：
2
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms
思路
每一种该序列都可以看成一种置换，每一种置换都可以写成若干循环的乘积，比如
2 1 3 5 4
1 2 3 4 5
可以写成(1 2)(3)(4 5)，显然我们的目标使使得循环个数最多即(1)(2)(3)(4)(5)
在循环内部交换，除最后一次外，每次可以让一个到达目标位置，即循环个数增加1。在循环外部交换，会较少循环的个数，得不偿失。因此得到结论，先把序列写成若干循环的乘积，然后再循环内部交换，交换的次数为循环的大小-1，最后结果等于n-循环的个数
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 7;
int a[N], ans, n;
bool vis[N];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
ans++;
vis[i] = 1;
for (int j = a[i]; j != i; j = a[j]) vis[j] = 1;
}
}
cout << n - ans << endl;
return 0;
}
最大比例
X星球的某个大奖赛设了M级奖励。每个级别的奖金是一个正整数。
并且，相邻的两个级别间的比例是个固定值。
也就是说：所有级别的奖金数构成了一个等比数列。比如：
16,24,36,54
其等比值为：3/2
现在，我们随机调查了一些获奖者的奖金数。
请你据此推算可能的最大的等比值。
输入格式：
第一行为数字N，表示接下的一行包含N个正整数
第二行N个正整数Xi(Xi<1 000 000 000 000)，用空格分开。每个整数表示调查到的某人的奖金数额
要求输出：
一个形如A/B的分数，要求A、B互质。表示可能的最大比例系数
测试数据保证了输入格式正确，并且最大比例是存在的。
例如，输入：
3
1250 200 32
程序应该输出：
25/4
再例如，输入：
4
3125 32 32 200
程序应该输出：
5/2
再例如，输入：
3
549755813888 524288 2
程序应该输出：
4/1
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 3000ms
思路
首先将原序列从小到大排序去重，然后得到最大可能的比值a[1]/a[0]，因为如果比这个大，显然第1、2项就不能满足。而且其它的可能的比值只能是a[1]/a[0]的平方根、立方根等等（如果它们是有理数的话）。那么一个暴力的思路就出来了，枚举所有a[0]和a[1]之间”隐藏”的项数，比如为1，那么就应该把比例确定为 (a[1]/a[0])1/2 （如果为2，就是 (a[1]/a[0])1/3 ），然后依次判断后面的比例是否可以通过这个比例累乘得到。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a[100], A, B, g, x, y, s, t;
int n, m;
ll gcd(ll a, ll b) {
return b? gcd(b, a % b) : a;
}
ll power(ll a, int b) {
ll ans = 1;
for (int i = 0; i < b; i++) ans *= a;
return ans;
}
ll chk(ll A, int d) {
double r = pow(A, 1.0 / d);
ll ir = (ll)(r + 0.5);
if (power(ir, d) == A) return ir;
return 0;
}
ll calc(ll A, ll x) {
if (x == 1) return 0;
ll cnt = 0;
while (A >= x) {
A /= x;
cnt++;
}
if (A == 1) return cnt;
return 0;
}
bool work(ll x, ll y) {
ll A, B;
for (int i = 1; i < m - 1; i++) {
A = a[i + 1];
B = a[i];
g = gcd(A, B);
A /= g;
B /= g;
s = calc(A, x);
t = calc(B, y);
if (y == 1) t = s;
if (s != t || !s) return false;
}
cout << x << "/" << y << endl;
return true;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
m = unique(a, a + n) - a;
if (m == 1) {
puts("1/1");
return 0;
}
A = a[1];
B = a[0];
g = gcd(A, B);
A /= g;
B /= g;
for (int i = 1; power(2, i) <= A; i++) {
x = chk(A, i);
y = chk(B, i);
if (B == 1) y = 1;
if (x && y) {
if (work(x, y)) break;
}
}
return 0;
}
399
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
