2014年蓝桥杯(第5届)预赛本科B组C语言真题解析

2014年蓝桥杯（第5届）预赛本科B组真题解析

啤酒和饮料

啤酒每罐2.3元，饮料每罐1.9元。小明买了若干啤酒和饮料，一共花了82.3元。

我们还知道他买的啤酒比饮料的数量少，请你计算他买了几罐啤酒。

注意：答案是一个整数。请通过浏览器提交答案。

不要书写任何多余的内容（例如：写了饮料的数量，添加说明文字等）。

（1）答案。

11

（2）编程思路。

把啤酒、饮料的单价和总共花的钱都乘上10，转换为整数。然后用循环对啤酒的罐数b（1≤b<823/23）和饮料的罐数c（1≤c<823/19）进行穷举，找出满足要求的啤酒罐数b。

（3）源程序。

#include

int main()

{

int b,c;

for (b=1;b<35;b++)

for (c=1;c<45;c++)

{

if((823==b*23+c*19) &&(b

printf("%d\n",b);

}

return 0;

}

（4）用单重循环完成穷举。

实际上，也可以只对啤酒的罐数进行穷举。

#include

int main()

{

int b,cSum;

for (b=1;b<35;b++)

{

cSum=823-23*b;

if (cSum%19==0 && cSum/19>b)

printf("%d\n",b);

}

return 0;

}

切面条

一根高筋拉面，中间切一刀，可以得到2根面条。

如果先对折1次，中间切一刀，可以得到3根面条。

如果连续对折2次，中间切一刀，可以得到5根面条。

那么，连续对折10次，中间切一刀，会得到多少面条呢？

答案是个整数，请通过浏览器提交答案。不要填写任何多余的内容。

（1）答案。

1025

（2）编程思路。

由题目可知，对折0次切一刀得到2根，对折1次切一刀得到3根，对折2次切一刀得到5根。自己再尝试对折3次切一刀，发现可以得到9根。

设F[i]表示对折i次后中间切一刀得到的面条根数，则有

F[i]=2*F[i-1]-1 （i≥1）。

（3）源程序。

#include

int main()

{

int f[11]={2,3,5};

for (int i=3;i<=10;i++)

{

f[i]=2*f[i-1]-1;

}

printf("%d\n",f[10]);

return 0;

}

李白打酒

话说大诗人李白，一生好饮。幸好他从不开车。

一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱：

无事街上走，提壶去打酒。

逢店加一倍，遇花喝一斗。

这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。

请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的次序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。

注意：通过浏览器提交答案。答案是个整数。不要书写任何多余的内容。

（1）答案。

14

（2）编程思路。

采用递归的方法生成15位二进制数的排列，对每一种排列进行判断，看是否满足要求（遇到店5次、酒正好喝完、最后一次遇到的是花），满足条件输出对应字符串即可。

（3）源程序。

#include

int cnt=0;

void dfs(int *a,int k)

{

if (k==15)

{

int alcohol,drinkery,i;

alcohol=2; drinkery=0;

for (i=0;i<15;i++)

if (a[i]==0)

{

alcohol=2*alcohol;

drinkery++;

}

else

alcohol--;

if (alcohol==0 && drinkery==5 && a[14]==1)

{

for (i=0;i<15;i++)

if (a[i]==0) printf("a");

else printf("b");

printf("\n");

cnt++;

}

return;

}

a[k]=0;

dfs(a,k+1);

a[k]=1;

dfs(a,k+1);

}

int main()

{

int a[15];

dfs(a,0);

printf("Count=%d\n",cnt);

return 0;

}

（4）程序优化。

上面的程序中用二进制数0表示遇到店，1表示遇到花。实际上，可以直接定义一个字符数组char a[16]，该数组的元素a[0]~a[14]直接用字符’a’或’b’赋值，a[15]赋结束符’\0’。

另外，通过递归产生15位二进制数的排列，共215=32768种情况，也就是上面的程序搜索判断了32768种情况。实际上，由于满足问题的解是遇店5次，因此在某一搜索过程中遇店达到6次，肯定不是问题的解，无需继续进行，可以实施剪枝。

为了实施剪枝，需要在递归时记录酒的斗数和遇店的次数，可以改写函数为

void dfs(char *a,int k,int alcohol,int drinkery)，其中alcohol记录酒壶里酒的斗数，drinkery 记录遇店的次数。

剪枝优化后的源程序如下：

#include

int cnt=0;

void dfs(char *a,int k,int alcohol,int drinkery)

{

if (k==15)

{

if (alcohol==0 && drinkery==5 && a[14]=='b')

{

printf("%s\n",a);

cnt++;

}

return;

}

if (drinkery<=5 && alcohol!=0) // 剪枝

{

a[k]='a';

dfs(a,k+1,2*alcohol,drinkery+1);

a[k]='b';

dfs(a,k+1,alcohol-1,drinkery);

}

}

int main()

{

char a[16];

a[15]='\0';

dfs(a,0,2,0);

printf("Count=%d\n",cnt);

return 0;

}

史丰收速算

史丰收速算法的革命性贡献是：从高位算起，预测进位。不需要九九表，彻底颠覆了传

统手算!

速算的核心基础是：1位数乘以多位数的乘法。

其中，乘以7是最复杂的，就以它为例。

因为，1/7 是个循环小数：0.142857...，如果多位数超过142857...，就要进1同理，2/7, 3/7, ... 6/7 也都是类似的循环小数，多位数超过n/7，就要进n 下面的程序模拟了史丰收速算法中乘以7的运算过程。

乘以7 的个位规律是：偶数乘以2，奇数乘以2再加5，都只取个位。

乘以7 的进位规律是：

满142857 (1)

满285714 (2)

满428571 (3)

满571428 (4)

满714285 (5)

满857142... 进6

请分析程序流程，填写划线部分缺少的代码。

//计算个位

int ge_wei(int a)

{

if(a % 2 == 0)

return (a * 2) % 10;

else

return (a * 2 + 5) % 10;

}

//计算进位

int jin_wei(char* p)

{

char* level[] = {

"142857",

"285714",

"428571",

"571428",

"714285",

"857142"

};

char buf[7];

buf[6] = '\0';

strncpy(buf,p,6);

int i;

for(i=5; i>=0; i--){

int r = strcmp(level[i], buf);

if(r<0) return i+1;

while(r==0){

p += 6;

strncpy(buf,p,6);

r = strcmp(level[i], buf);

if(r<0) return i+1;

______________________________; //填空

}

}

return 0;

}

//多位数乘以7

void f(char* s)

{

int head = jin_wei(s);

if(head > 0) printf("%d", head);

char* p = s;

while(*p){

int a = (*p-'0');

int x = (ge_wei(a) + jin_wei(p+1)) % 10;

printf("%d",x);

p++;

}

printf("\n");

}

int main()

{

f("428571428571");

f("34553834937543");

return 0;

}

注意：通过浏览器提交答案。只填写缺少的内容，不要填写任何多余的内容（例如：说明性文字）

（1）参考答案。

if(r>0) return i

（2）解析。

leve[i]就相当于满leve[i]进i+1，因为填空所在的那段是判断条件为r==0的循环，所以是在当前buff段与某个leve相等的情况下，看下一个buff段进位多少，那么r<0就是进位i+1，r>0就是进位i，r==0就继续看下一段buff。

打印图形

小明在X星球的城堡中发现了如下图形和文字：

小明开动脑筋，编写了如下的程序，实现该图形的打印。

#define N 70

void f(char a[][N], int rank, int row, int col)

{

if(rank==1){

a[row][col] = '*';

return;

}

int w = 1;

int i;

for(i=0; i

____________________________________________;

f(a, rank-1, row+w/2, col);

f(a, rank-1, row+w/2, col+w);

}

int main()

{

char a[N][N];

int i,j;

for(i=0;i

for(j=0;j

f(a,6,0,0);

for(i=0; i

for(j=0; j

printf("\n");

}

return 0;

}

请仔细分析程序逻辑，填写缺失代码部分。

通过浏览器提交答案。注意不要填写题目中已有的代码。也不要写任何多余内容（比如说明性的文字）

（1）参考答案。

f(a, rank-1, row, col+w/2);

奇怪的分式

上小学的时候，小明经常自己发明新算法。一次，老师出的题目是：

1/4 乘以8/5

小明居然把分子拼接在一起，分母拼接在一起，答案是：18/45 （参见图1.png）

老师刚想批评他，转念一想，这个答案凑巧也对啊，真是见鬼！

对于分子、分母都是1~9 中的一位数的情况，还有哪些算式可以这样计算呢？

请写出所有不同算式的个数（包括题中举例的）。

显然，交换分子分母后，例如：4/1 乘以5/8 是满足要求的，这算做不同的算式。

但对于分子分母相同的情况，2/2 乘以3/3 这样的类型太多了，不在计数之列!

注意：答案是个整数（考虑对称性，肯定是偶数）。请通过浏览器提交。不要书写多余的内容。

（1）答案。

14

（2）编程思路。

将分式符号化为：a/b × c/d = (10a+c)/(10b+d)。对a、b、c、d在1~9之间取值穷举即可。穷举时，a!=b且c!=d。

（3）源程序。

#include

int main()

{

int cnt=0;

for(int a=1;a<=9;a++)

{

for(int b=1;b<=9;b++)

{

if(b==a) continue;

for(int c=1;c<=9;c++)

{

for(int d=1;d<=9;d++)

{

if(d==c) continue;

if(a*c*(b*10+d)==b*d*(a*10+c))

cnt++;

}

}

}

}

printf("%d\n",cnt);

return 0;

}

六角填数

如图【1.png】所示六角形中，填入1~12的数字。

使得每条直线上的数字之和都相同。

图中，已经替你填好了3个数字，请你计算星号位置所代表的数字是多少？

请通过浏览器提交答案，不要填写多余的内容。

（1）答案。

10

（2）编程思路。

定义一个数组int a[13]，其中a[1]~a[12]这12个元素分别从上到下，自左向右的12个圆圈。可采用递归的方法生成由1~12这12个数字组成的无重复数字的全排列。

生成1~12不同的12个数字存储到数组中后，检测6条直线上的四个数字之和是否全相等，如果全相等，是一组解，输出并计数。

（3）源程序。

#include

int a[13];

int vis[13];

int cnt=0;

void dfs(int x)

{

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 ;

}

cnt++;

printf("No %d\n",cnt);

printf("%12d\n",a[1]);

printf("%3d%6d%6d%6d\n",a[2],a[3],a[4],a[5]);

printf("%6d%12d\n",a[6],a[7]);

printf("%3d%6d%6d%6d\n",a[8],a[9],a[10],a[11]);

printf("%12d\n\n",a[12]);

return ;

}

for(int i = 1;i < 13; ++i)

{

if(!vis[i])

{

vis[i] = 1;

a[x] = i;

dfs(x+1);

vis[i] = 0;

}

}

}

int main()

{

for (int i=1;i<=12;i++)

vis[i]=0;

vis[1] = 1;

a[1] = 1;

vis[8] = 1;

a[2] = 8;

vis[3] = 1;

a[12] =3;

dfs(3);

printf("Count=%d\n",cnt);

return 0;

}

蚂蚁感冒

长100厘米的细长直杆子上有n只蚂蚁。它们的头有的朝左，有的朝右。

每只蚂蚁都只能沿着杆子向前爬，速度是1厘米/秒。

当两只蚂蚁碰面时，它们会同时掉头往相反的方向爬行。

这些蚂蚁中，有1只蚂蚁感冒了。并且在和其它蚂蚁碰面时，会把感冒传染给碰到的蚂蚁。

请你计算，当所有蚂蚁都爬离杆子时，有多少只蚂蚁患上了感冒。

【数据格式】

第一行输入一个整数n (1 < n < 50), 表示蚂蚁的总数。

接着的一行是n个用空格分开的整数Xi (-100 < Xi < 100), Xi的绝对值，表示蚂蚁离开杆子左边端点的距离。正值表示头朝右，负值表示头朝左，数据中不会出现0值，也不会出现两只蚂蚁占用同一位置。其中，第一个数据代表的蚂蚁感冒了。

要求输出1个整数，表示最后感冒蚂蚁的数目。

例如，输入：

3

5 -2 8

程序应输出：

1

再例如，输入：

5

-10 8 -20 12 25

程序应输出：

3

（1）编程思路。

首先，两只蚂蚁相遇各自反向可以看作是两只蚂蚁分别穿过对方继续前进。这样处理的话就简单多了。感冒蚂蚁不管初始方向朝哪一边，它右边的蚂蚁只要向左走就可能碰撞感染（特殊情况除外），同样，它左边的蚂蚁只要朝右边走也可能被感染。

假如感冒蚂蚁开始时向左行，则会感染它左边所有向右行的蚂蚁（因为相遇后它穿过对方继续向左行碰到向右行的蚂蚁感染它们）；相遇被感染的第1只蚂蚁也穿过继续向右行，感染所有它右边向左行的蚂蚁。

感冒蚂蚁开始时向右行情况类似。

这样，最后感冒的蚂蚁的数量为：

感冒蚂蚁左边蚂蚁向右走的数量+右边蚂蚁向左走的数量+感冒蚂蚁本身特殊情况是，当感冒蚂蚁向左爬的时候，如果感冒蚂蚁左边没有向右爬行的蚂蚁，那么不管感冒蚂蚁右边有多少向左爬行的，因爬行的速度相同感冒蚂蚁不会遇到向右爬的蚂蚁进

行感染，因此右边的蚂蚁也永远不可能被感染。

同样的，当感冒蚂蚁向右爬的时候，如果感冒蚂蚁右边没有向左爬行的蚂蚁，那么同样感冒蚂蚁左边的蚂蚁也永远不可能被感染。

（2）源程序。

#include

int abs(int x)

{

return x>=0?x:-x;

}

int main()

{

int ant[51];

int n,i;

scanf("%d",&n);

for (i=0;i

scanf("%d",&ant[i]);

int left=0,right=0;

for (i=1;i

{

if (ant[i]<0 && abs(ant[i])>abs(ant[0]))

left++; // 感冒蚂蚁右边且向左走的

if (ant[i]>0&&abs(ant[i])

right++; // 感冒蚂蚁左边且向右走的

}

if ((ant[0]<0 && right==0)|| (ant[0]>0 && left==0))

printf("1\n");

else

printf("%d\n",left+right+1);

return 0;

}

地宫取宝

X 国王有一个地宫宝库。是n x m 个格子的矩阵。每个格子放一件宝贝。每个宝贝贴着价值标签。

地宫的入口在左上角，出口在右下角。

小明被带到地宫的入口，国王要求他只能向右或向下行走。

走过某个格子时，如果那个格子中的宝贝价值比小明手中任意宝贝价值都大，小明就可以拿起它（当然，也可以不拿）。

当小明走到出口时，如果他手中的宝贝恰好是k件，则这些宝贝就可以送给小明。

请你帮小明算一算，在给定的局面下，他有多少种不同的行动方案能获得这k件宝贝。

【数据格式】

输入一行3个整数，用空格分开：n m k (1<=n,m<=50, 1<=k<=12)

接下来有n 行数据，每行有m 个整数Ci (0<=Ci<=12)代表这个格子上的宝物的价值要求输出一个整数，表示正好取k个宝贝的行动方案数。该数字可能很大，输出它对1000000007 取模的结果。

例如，输入：

2 2 2

1 2

2 1

程序应该输出：

2

再例如，输入：

2 3 2

1 2 3

2 1 5

程序应该输出：

14

（1）编程思路。

采用记忆化搜索完成。

定义4维数组dp[51][51][15][15]。设dp[x][y][num][val]表示在坐标(x,y)时拿了num件宝贝并且宝贝中价值最大的为val，其中1≤x≤n，1≤y≤m，num的初值为0，表示还没有拿到宝贝，val的初值本来应该为-1，表示此时手上还没有宝物（因为从题目数据说明中可以看出宝贝的价值可以为0），为了让val初始值为0，可以将输入的宝贝的价值统一加1，这样宝贝的最小价值为1（不是0）。

定义二维数组int map[51][51]保存地宫各格子的宝贝价值。

采用倒推法列出状态转移方程，即把后面的情况种数不断的往前更新。

当map[x][y]>val时，

dp[x][y][num][val]=dp[x+1][y][num+1][map[x][y]]+dp[x][y+1][num+1][map[x][y]]

+dp[x+1][y][num][val]+dp[x][y+1][num][val]；

当map[x][y]<=val时，

dp[x][y][num][val]=dp[x+1][y][num][val]+dp[x][y+1][num][val]。

在通过DFS搜索方式求数组dp的各元素值时，由于数组元素值dp[x][y][num][val]跟位置（x,y）、宝贝个数以及当前最大的宝贝价值有关，当重复遍历这个结点时，若dp[x][y][num][val]的值已经计算出来了，则直接应用无需重复递归计算。为此，定义数组dp 的全部元素的初始值为-1。若计算时需要用到dp[x][y][num][val]，此时dp[x][y][num][val]！=-1，则无需重复调用，直接应用计算好的dp[x][y][num][val]元素值。之所以初值定义为-1，是考虑到若路径不存在的情况（此时方案数应为0）。

（2）源程序。

#include

#include

#define MOD 1000000007

long long dp[51][51][15][15];

int map[51][51];

int n,m,k;

void dfs(int x, int y, int num, int val)

{

if (dp[x][y][num][val] != -1)

return;

dp[x][y][num][val] = 0;

if (x == n && y == m && num == k)

{

dp[x][y][num][val] = 1;

return;

}

if (map[x][y] > val && num < k)

{

dfs(x, y, num + 1, map[x][y]);

dp[x][y][num][val] += dp[x][y][num + 1][map[x][y]];

dp[x][y][num][val] %= MOD;

}

if (x < n) // 向下走

{

dfs(x + 1, y, num, val);

dp[x][y][num][val] += dp[x + 1][y][num][val];

dp[x][y][num][val] %= MOD;

}

if (y < m) // 向右走

{

dfs(x, y + 1, num, val);

dp[x][y][num][val] += dp[x][y + 1][num][val];

dp[x][y][num][val] %= MOD;

}

}

int main()

{

scanf("%d%d%d",&n,&m,&k);

for (int i = 1; i <=n ; i++)

{

for (int j = 1; j <= m; j++)

{

scanf("%d",&map[i][j]);

map[i][j]++;

}

}

memset(dp, -1, sizeof(dp));

dfs(1, 1, 0, 0);

printf("%d\n",dp[1][1][0][0]);

return 0;

}

小朋友排队

n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。

每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是0。

如果某个小朋友第一次被要求交换，则他的不高兴程度增加1，如果第二次要求他交换，则他的不高兴程度增加2（即不高兴程度为3），依次类推。当要求某个小朋友第k次交换时，他的不高兴程度增加k。

请问，要让所有小朋友按从低到高排队，他们的不高兴程度之和最小是多少。

如果有两个小朋友身高一样，则他们谁站在谁前面是没有关系的。

【数据格式】

输入的第一行包含一个整数n，表示小朋友的个数。

第二行包含n 个整数H1 H2 …Hn，分别表示每个小朋友的身高。

输出一行，包含一个整数，表示小朋友的不高兴程度和的最小值。

例如，输入：

3

3 2 1

程序应该输出：

9

【样例说明】

首先交换身高为3和2的小朋友，再交换身高为3和1的小朋友，再交换身高为2和1的小朋友，每个小朋友的不高兴程度都是3，总和为9。

【数据规模与约定】

对于10%的数据，1<=n<=10；

对于30%的数据，1<=n<=1000；

对于50%的数据，1<=n<=10000；

对于100%的数据，1<=n<=100000，0<=Hi<=1000000。

（1）编程思路。

本题的实质是求一组数据中逆序数对的个数。比如题目中的3，2，1，和3有关的逆序对为（3，2）和（3，1），和2有关的逆序对为（3，2）和（2，1），和1有关的逆序对为（3，1）和（2，1），为了完成排序，任何一个逆序对的两个元素都必须交换一次，于是可知，每个小朋友都完成了两次交换。

要求一个数组元素有关的逆序对个数，就是求它之前有几个大于它的元素（设为b1），之后有几个小于它的元素（设为b2），这样每个元素的交换次数为b1+b2。

根据数据规模与约定，若采用二重循环进行暴力搜索逆序对的个数，肯定会超时的。因此，采用树状数组来解决本题。

树状数组实际上是由两部分组成：数据数组（设为num）和统计数组（设为C）。

我们以数据数组num[3]={3,2,1}为例进行描述。树状数组的各元素初始值为0，但由于树状数组元素下标是从1开始的，因此将数据数组的每个元素值加1，然后作为树状数组的下标，将数值1存到相应的位置。

从左到右依次扫描数据数组。

1）读入3，此时读入的数据个数为1，树状数组C为：

C[1] C[2]C[3] C[4] C[5] C[6] C[7] C[8] ……

0 0 0 1 0 0 0 0

可以看到sum(C[1],C[4])=1，这是小于等于3的数字的个数，也就是说当输入第一个数3的时候没有比它小的数字存在。这时“输入数值个数-sum(C[1],C[4])=1-1=0”，也就是说大于3的数字的个数为0，保存起来，即b[0]=0。（在这里特别注意，根据树状数组sum(C[1],C[n])算出来的数值是某个数字n左边比它小的数字的个数。）

2）读入2，此时读入的数据个数为2，树状数组C为：

C[1] C[2]C[3] C[4] C[5] C[6] C[7] C[8] ……

0 0 1 1 0 0 0 0

可以看到sum(C[1],C[3])=1，仍然不存在比它小的数，而此时输入的数据个数为2，2-1=1，就是说，存在一个数在2之前并且大于2（这个数是第1个数3），保存b[1]=1。

3）读入1，此时读入的数据个数为3，树状数组C为：

C[1] C[2]C[3] C[4] C[5] C[6] C[7] C[8] ……

0 1 1 1 0 0 0 0

可以看到sum(C[1],C[2])=1，仍然不存在比它小的数，而此时输入的数据个数为3，3-1=2，就是说，存在两个数在1之前并且大于1（这两个数就是3和2），保存b[2]=2。

到此，求出了每个数据元素前面的较大的数的个数了。

类似地，从右到左依次扫描数据数组，求出每个数据元素后面的较小的数的个数。此时依次直接求sum(C[1],C[n])，得到每个元素后面的较小的数的个数，然后将得到的数值累加到相应的b[i]中。最终我们会得到b[0]=2，b[1]=2，b[2]=2，分别对应num[0]=3，num[1]=2，num[2]=1。

另外需要注意的是，如果输入数组中出现重复的数字怎么办？如果出现，可以简单地处理。具体方法是通过树状数组求得sum(1,a)和sum(1,a+1)，其中输入的数字为a，前者算出的小于a的数的个数，后者算出的是小于等于a（小于a+1）的数的个数，两个相减就是等于a的个数。

采用树状数组求得每个小朋友被移动的次数后，需要计算其不高兴程度。若小朋友被移动n次，则其不高兴程度为1+2+3+…+n。为避免重复计算，实现构造好total数组，数组元素total[n]的值就是1+2+3+…+n。这样在计算不高兴程度总和时直接引用元素值即可。

（2）源程序。

#include

#include

#define MAX 1000010

#define N 100010

int C[MAX],b[MAX];

int num[N];

long long total[N],ans;

int lowbit(int x) // 取出x的最低位1所在位号

{

return x&(-x);

}

void add(int pos,int num,int *C)

{

while(pos

{

C[pos]+=num;

pos+=lowbit(pos);

}

}

int Sum(int pos,int *C)

{

int sum=0;

while(pos>0)

{

sum+=C[pos];

pos-=lowbit(pos);

}

return sum;

}

int main()

{

int i;

total[0]=0;

for (i=1;i

{

total[i]=total[i-1]+i;

}

memset(C,0,sizeof(C));

int n;

scanf("%d",&n);

for (i=0;i

{

scanf("%d",&num[i]);

add(num[i]+1,1,C);

b[i]=i-Sum(num[i],C);

b[i]=b[i]-(Sum(num[i]+1,C)-Sum(num[i],C)-1);

}

memset(C,0,sizeof(C));

for(i=n-1;i>=0;i--)

{

add(num[i]+1,1,C);

b[i]=b[i]+Sum(num[i],C);

}

ans=0;

for(i=0;i

{

ans+=total[b[i]];

}

printf("%I64d\n",ans);

return 0;

}