2014年第五届蓝桥杯预赛 C/C++本科B组 快速解题思路及报告（完整版，4.9修订）
今天看了下成绩表，确定是一等了...唉~ 第二题错了，第8题就交了个错的代码上去，没调试的。 若是机器看题，算一下应该就是80-90分的样子。初赛还是水。 决赛再见！，到现在算是完成了去年帝都归来时，说的的那句，"明年再见"了。 期待今年决赛！
第一题：啤酒和饮料（4' ）（点击看题，含解答，下同）
快速解题思路：蓝桥杯的题，模拟暴力应该是主要考虑的方法，尤其是对于这种小题，大题，想不出能模拟则模拟，毕竟它是按测试数据分组拿分。此题，直接暴力，为避免精度，价格乘以10来算。
#include
using namespace std;
int main(){
for(int i = 0; i < 40; ++i){
for(int j = 1; j < 43; ++j){
if(i > j)continue;
if(i * 23 + j * 19 == 823){
cout< 答案：11 （4' 到手）
第二题：切面条（5' ）
在此基础上如果折一次，那么t3 = t3' + t2' ， t2 = t1' ，t1 = 2^(n-1),（n是当前是第几次折），t1的计算方法就是每次折都是讲横着的面条翻了一倍，然后切下来之
后，因为右边是连着的，所以值是2^(n-1)。 因此方法得证。
快速解题思路： 直接找规律。
#include
#include
using namespace std;
int main(){
int t1 = 1,t2 = 0,t3 = 1;
for(int i = 1; i <= 10; ++i){
t3 += t2;
t2 = t1;
t1 = pow(2,i-1);
}
cout< 答案：1025 （艹蛋啊，少算了一次，交了个513上去，5' 就这么没了。。。。）
第三题：李白打酒 （8' ）
快速解题思路：dfs
答案：14 （8' 到手了）
#include
#include
#include
#include
using namespace std;
#define eps 10e-10
#define N 15
int ans;
void dfs(int alco,int store,int flower, int pre){
if(store == 0 && flower == 0 ){
if(pre == 0 && alco == 0)ans++;
return ;
}
if(store > 0){
dfs(alco*2,store-1,flower,1);
}
if(alco > 0 && flower > 0){
dfs(alco-1,store,flower-1,0);
}
return ;
}
int main(){
ans = 0;
dfs(2,5,10,-1);
printf("%d\n",ans);
return 0;
}
第四题：史丰收速算（7' ）
快速解题思路：蒙吧，如果你能直接看懂题意，就直接写就行了。不过你要大概看懂点，不然蒙的概率不大。
答案： if(r>0)return i (7' 这里我没有写 分号 ; ，因为上面有一个分号，不过有没有都没什么关系，这里多一个分号不影响结果，所以分拿到了)
第五题：打印图形 （12' ）
快速解题思路：如果能看到，那么肯定就可以直接写出来，如果半懂不懂的，那么就一点一点分析，先少了那句运行一次，然后看结果，自己再加点东西，大概一两步就能想到用循环递归。然后一个参数一个参数的试试，结果就能很快出来了。
答案： f(a,rank-1,row, col + w/2) （12‘ 到手，蒙对的感觉，那是爽歪歪）
第六题：奇怪的分式（11'）
快速解题思路：蓝桥杯的主打解题算法-暴力， 就是在这个时候派上用场的，什么都不用想，直接码。 一个四重循环。（差判需要注意精度，相除记得乘以1.0）
#include
#include
#include
using namespace std;
#define eps 10e-10
int main(){
int ans = 0;
for(int i = 1; i < 10; ++i){
for(int j = 1; j < 10; ++j){
for(int r = 1; r < 10; ++r){
for(int k = 1; k < 10; k ++){
if(i == j || r == k)continue;
if(fabs( (i*10 + r)*1.0/(j*10+k) - (i*r*1.0)/(j*k)) < eps){
//printf("%d/%d : %d/%d\n", (i*10 + r),(j*10+k), i*r,(j*k));
ans++;
}
}
}
}
}
cout< 答案：14 （11' 到手，暴力果然爽）
第7题：六角填数（12'）
快速解题思路：dfs 从上到下，从左到右从1到12标记每一个点。初始化1,8,3. 要求的地方点的标记为6.碰到1,2，12，就直接dfs下一个。
#include
#include
#include
#include
using namespace std;
#define eps 10e-10
#define N 15
int a[N];
bool vis[N];
void dfs(int x){
if(x == 1 || x == 2 || x == 12){
dfs(x+1);
return ;
}
if(x > 12){
int t[6];
t[0] = a[1] + a[3] + a[6] + a[8];
t[1] = a[1] + a[4] + a[7] + a[11];
t[2] = a[2] + a[3] + a[4] + a[5];
t[3] = a[2] + a[6] + a[9] + a[12];
t[4] = a[8] + a[9] + a[10] + a[11];
t[5] = a[12] + a[10] + a[7] + a[5];
for(int i = 1; i < 6; ++i){
if(t[i] != t[i-1])return ;
}
cout< 答案：10 （12' 到手，做这题，在1,2,12这里卡了一下。 无线循环了都。）
第八题：蚂蚁感冒（10'）
快速解题思路：uva上有个ants,不过和这个不太一样。这里根据数据模拟比较爽一些，还是暴力。 我用dfs调的暴力。
具体思路：第一个输入时感冒的蚂蚁，它有两种方向，向左或向右。
如果它是向左的：
那么对一组输入数据，输入完之后我们可以知道，在0-100这根直杆上，分别分布着一些蚂蚁，每只蚂蚁都有一个朝向。
那么那只感冒的蚂蚁所在直杆的位置就将直杆以它为中心分成左右两部分，
因为感冒的那只是向左的，所以它左边的直杆上的蚂蚁，只要是向右的，那么到最后都会被感冒。此时，只要它的左边的直杆上有一只向右走的蚂蚁，那么它右边的直杆上向左走的蚂蚁，走到最后肯定也会被感冒。如果它左边没有一只向右走的蚂蚁，那么最后只会有它这一只感冒。
如果它是向右走的计算方法同理。
所以走到最后会被感冒的总数就是，对第一个感冒的蚂蚁，在直杆上，它要走的方向的那一边的所有蚂蚁中，向它相反的方向走的蚂蚁的总数，如果总数不为0，就再加上它在直杆的位置的右边的直杆上的蚂蚁中和它的行动方向相同的蚂蚁的总数。最后再加上它自己本身就是answer了
代码：（最后写的这题，烦躁，dfs出来了，还有7分钟，老师赶人了，就没再调试 直接提交了，艹！）
#include
#include
#include
using namespace std;
#define N 100010
#define MAX 1000100
int dir[MAX];
int T, a, b, ans;
int main() {
while(~scanf("%d",&T)) {
scanf("%d",&a);
memset(dir,0,sizeof(dir));
if(a < 0){
a= -a;
dir[a] = -1;
}
else dir[a] = 1;
for(int i = 1; i < T; ++i){
scanf("%d",&b);
if(b < 0){
dir[-b] = -1;
}
else {
dir[b] = 1;
}
}
ans = 0;
if(dir[a] == -1){
for(int i = 0; i < a; ++i){
if(dir[i]){
if(dir[i] == 1)ans++;
}
}
if(ans){
for(int i = a+1; i < 100; ++i){
if(dir[i] == -1)ans++;
}
}
}
else if(dir[a] == 1){
for(int i = a + 1; i < 100; ++i){
if(dir[i] == -1)ans ++;
}
if(ans){
for(int i = 0; i < a; ++i){
if(dir[i] == 1)ans++;
}
}
}
printf("%d\n",++ans);
}
return 0;
}
第九题：地宫取宝（12'）
快速解题思路：四维数组直接dfs记忆化啊，看到后面三个大题，就觉得这题最好下手，直接动手做，一个四维数组标记。
代码：（dfs记忆化 12’ 应该没问题）
#include
#include
#include
#include
using namespace std;
#define eps 10e-10
#define N 1000000007
int ans;
int d[51][51][13][14];
int p[51][51];
int n,m,k;
int dfs(int x,int y,int num,int maxvalue){
if(d[x][y][num][maxvalue + 1] != -1){
return d[x][y][num][maxvalue + 1];
}
int t = 0;
if(x == n-1 && y == m-1){
if(p[x][y] > maxvalue){
if(num == k || num == k-1)t++;
}
else if(num == k){
t ++;
}
return d[x][y][num][maxvalue + 1] = t;
}
if(x + 1 < n){
if(p[x][y] > maxvalue){
t += dfs(x+1,y,num+1,p[x][y]);
t %= N;
t += dfs(x+1,y,num,maxvalue);
t %= N;
}
else {
t += dfs(x+1,y,num,maxvalue);
t %= N;
}
}
if(y + 1 < m){
if(p[x][y] > maxvalue){
t += dfs(x,y+1,num+1,p[x][y]);
t %= N;
t += dfs(x,y+1,num,maxvalue);
t %= N;
}
else {
t += dfs(x,y+1,num,maxvalue);
t %= N;
}
}
d[x][y][num][maxvalue + 1] = t;
return d[x][y][num][maxvalue + 1];
}
int main(){
while(cin>>n>>m>>k){
for(int i = 0; i < n; ++i){
for(int j = 0; j < m; ++j)
cin>>p[i][j];
}
memset(d,-1,sizeof(d));
d[0][0][0][0] = dfs(0,0,0,-1);
cout< 第十题：小朋友排队（19'）
快速解题思路：逆序对啊，每点的左边大于它的，右边小于它的数的个数。就是当前点的逆序对数。而对于此题的数量级，最惨能接受O(nlogn)的时间复杂度。求一个序列的逆序对数，最直接最暴力的方法就是直接算，for循环直接求。 这样应该可以过30%的数据，能拿分。 但是求逆序对有O(nlogn)的归并排序算法。改造一番，可以达到效果。
代码：（归并写的 19' 问题应该不会很大，希望拿全）
（树状数组）
#include
#include
#include
using namespace std;
#define N 100010
#define MAX 1000100
int C[MAX], S[MAX], b[N];
long long num[N], sum[N];
int T;
int Lowbit(int x){
return x&(x^(x-1));
}
void add(int pos,int num,int *C) {
while(pos <= N) {
C[pos] += num;
pos += Lowbit(pos);
}
}
int Sum(int end,int *C) {
int sum = 0;
while(end > 0) {
sum += C[end];
end -= Lowbit(end);
}
return sum;
}
int main() {
int s, t, i, j, T, ans;
sum[0] = 0;
for(i = 1; i < N; ++i){
sum[i] = sum[i-1] + i;
}
while(~scanf("%d",&T)) {
memset(C,0,sizeof(C));
memset(S,0,sizeof(S));
memset(num,0,sizeof(num));
memset(b,0,sizeof(b));
ans = 0;
for(j = 0; j < T; j ++) {//因为第一个数前面比它小的数没有，所以j要从0开始
scanf("%I64d",&num[j]);
add(num[j]+1,1,C);
b[j] = j - Sum(num[j], C);//Sum(num[j],C)求的就是小于s的个数，j - Sum(num[j],C)就是前j个数中大于num[j]的个数
}
ans = 0;
for(j = T-1; j > -1; --j){//反过来求第j个数右边中小于它的数的个数。
add(num[j] + 1 ,1, S);
b[j] += Sum(num[j] ,S);//Sum(num[j],S)求的就是小于num[j]的个数
ans += sum[b[j]];
}
printf("%d\n",ans);
}
return 0;
}
#include
#include
#include
using namespace std;
#define N 100010
#define MAX 1000100
int C[MAX], S[MAX], b[N];
long long total[N], ans;
int num[N], T, s, t, i, j;
int Lowbit(int x){
return x&(x^(x-1));
}
void add(int pos,int num,int *P) {
while(pos <= MAX) {
P[pos] += num;
pos += Lowbit(pos);
}
}
int Sum(int end,int *P) {
int cnt = 0;
while(end > 0) {
cnt += P[end];
end -= Lowbit(end);
}
return cnt;
}
void init(){
total[0] = 0;
for(i = 1; i < N; ++i){
total[i] = total[i-1] + i;
}
}
int main() {
init();
while(~scanf("%d",&T)) {
memset(C,0,sizeof(C));
memset(S,0,sizeof(S));
//memset(num,0,sizeof(num));
//memset(b,0,sizeof(b));
//ans = 0;
for(j = 0; j < T; j ++) {//因为第一个数前面比它小的数没有，所以j要从0开始
scanf("%d",&num[j]);
add(num[j]+1,1,C);
b[j] = j - Sum(num[j], C);//Sum(num[j],C)求的就是小于s的个数，j - Sum(num[j],C)就是前j个数中大于num[j]的个数
b[j] -= Sum(num[j]+1,C) - Sum(num[j],C)-1;
//printf("%d ",b[j]);
}
//printf("\n");
ans = 0;
for(j = T-1; j > -1; --j){//反过来求第j个数右边中小于它的数的个数。
add(num[j]+1 ,1, S);
b[j] += Sum(num[j] ,S);//Sum(num[j],S)求的就是小于num[j]的个数
//b[j] -= Sum(num[j]+1,S) - Sum(num[j],S)-1;
//printf("%d ",b[j]);
ans += total[b[j]];
}
//printf("\n");
printf("%I64d\n",ans);
}
return 0;
}
唉，不晓得拿不拿的到一等奖，唉，第二题错的太不应该了。