2017蓝桥杯题解
网上只有题目，没有集中的解析，自己试着写点..
虽说蓝桥杯相对简单，然而即使对于acm选手，蓝桥杯也不都是水题..(记得当年没有满分的，但有北大acm金牌选手参赛..)
一半以上的题目需要数据结构与算法基础..2个题比较难..(但做对一半至少二等奖，只错2道应该前几名)
代码风格偏竞赛，填空题答案对了就行..填代码题同义代码都行，大题是按通过的数据量给分。
搜索（bfs，dfs）是考察最多的，二分，枚举，递归也会考察。
1.迷宫
X星球的一处迷宫游乐场建在某个小山坡上。它是由10x10相互连通的小房间组成的。
房间的地板上写着一个很大的字母。我们假设玩家是面朝上坡的方向站立，则：
L表示走到左边的房间，R表示走到右边的房间，U表示走到上坡方向的房间，D表示走到下坡方向的房间。
X星球的居民有点懒，不愿意费力思考。他们更喜欢玩运气类的游戏。这个游戏也是如此！
开始的时候，直升机把100名玩家放入一个个小房间内。
玩家一定要按照地上的字母移动。
迷宫地图如下：
------------
UDDLUULRUL
UURLLLRRRU
RRUURLDLRD
RUDDDDUUUU
URUDLLRRUU
DURLRLDLRL
ULLURLLRDU
RDLULLRDDD
UUDDUDUDLL
ULRDLUURRR
------------
请你计算一下，最后，有多少玩家会走出迷宫? 而不是在里边兜圈子。
请提交该整数，表示走出迷宫的玩家数目，不要填写任何多余的内容。
如果你还没明白游戏规则，可以参看一个简化的4x4迷宫的解说图：
4
ULDL
RRUL
LRDL
ULLR
这组的答案是10。
题解：
很基础的模拟题，怎么写都行，甚至手算都行..答案是31。
附一个复杂度下限O(n^2)的记忆化搜索代码：
#include<cstdio>
#include<cstring>
char mp[15][15], pp[] = { 'U','R','D','L' };
int vis[15][15], to[][2] = {-1,0,0,1,1,0,0,-1}, n;
//vis[x][y]为-1表示未搜索到(x,y)，为0表示不能出去，为1表示可以出去
int dfs(int x, int y)
{
if (vis[x][y] != -1)
return vis[x][y];
if (mp[x][y] == 0)
return vis[x][y] = 1;
vis[x][y] = 0;
for (int i = 0; i < 4; i++)
if (mp[x][y] == pp[i])
return vis[x][y] = dfs(x + to[i][0], y + to[i][1]);
}
int main()
{
int i, j, ans;
while (~scanf("%d", &n))
{
memset(mp, 0, sizeof(mp));
memset(vis, -1, sizeof(vis));
ans = 0;
for (i = 1; i <= n; i++)
scanf("%s", mp[i] + 1);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
ans += dfs(i, j);
printf("%d\n", ans);
}
return 0;
}
2. 跳蚱蜢
有9只盘子，排成1个圆圈。其中8只盘子内装着8只蚱蜢，有一个是空盘。
我们把这些蚱蜢顺时针编号为 1~8
每只蚱蜢都可以跳到相邻的空盘中，也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，
并且保持空盘的位置不变（也就是1-8换位，2-7换位,...），至少要经过多少次跳跃？
注意：要求提交的是一个整数，请不要填写任何多余内容或说明文字。
题解：
显然是搜索题，需要搜索算法基础。
状态是跳的数字（初始是012345678终点是087654321），每个节点的子节点是0和左右各2格内的数交换后的数字。
追求快速的话可以发现最多9！种状态，用康拓展开来优化（因为存一个876543210b大小的数组有点大.. win系统下很难编译），可以秒出答案。
但为了更快编程，不如用map+string存状态（几十秒+100M内存）。
答案是20。
附个简短易懂的代码，但需要运行几十秒。
#include<string>
#include<queue>
#include<map>
#include<algorithm>
using namespace std;
queue<string>que;
map<string, int>mp;
string x = "012345678", te;
int to[] = { 1,2,8,7 };
//利用加法取模代替交换数位
int main()
{
int i, j;
que.push(x);
while (mp["087654321"] == 0)
{
x = que.front(), que.pop();
for (i = 0; i < 9; i++)
if (x[i] == '0')
break;
for (j = 0; j < 4; j++)
{
te = x;
swap(te[i], te[(i + to[j]) % 9]);
if (mp[te] == 0)
mp[te] = mp[x] + 1, que.push(te);
}
}
printf("%d\n",mp["087654321"]);
return 0;
}
3. 魔方状态
二阶魔方就是只有2层的魔方，只由8个小块组成。
小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：
前面：橙色
右面：绿色
上面：黄色
左面：绿色
下面：橙色
后面：黄色
请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。
如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。
请提交表示状态数的整数，不要填写任何多余内容或说明文字。
题解：
6面颜色不同的魔方有( 8! * 3^7 ) / 24 = 3,674,160种状态（8个角块都不同，8个角块都不同随意排列，固定1块剩下7块任意转3个角度，整体旋转共24种，除以24）
这个是只有3种颜色，兴许可以用数学方法算出答案？...
编程bfs搜索的话，不仅需要算法基础，还需代码功底...
可以如下图存状态：
估算一下复杂度，24*3.6m（6色魔方状态数）*log(3.6m),还有一个巨大的常数（复制状态之类），几十亿级，应该要跑一阵但不会太久。
用map或set标记访问，用一个方向数组模拟旋转操作。只用模拟3个平面的旋转(保证有一个角块固定不动，这样正好就是整体旋转不同的状态数)
很麻烦的模拟题目了...答案是459270（不是太确定..但把初始魔方改成6种颜色的答案确实是3674160，大概运行10分钟）
很变态的题，估计场上没几人写对...主要是麻烦，非实力acm/oi选手比赛时不推荐写..
附一个毫无剪枝的搜索+map标记的代码（别看代码不长，思考整理了很久很久..搞不好就写好几百行且难以调试）：
#include <cstdio>
#include <cstring>
#include <algorithm>
#include<map>
#include<queue>
using namespace std;
int ans;
struct node { int a[25]; };
int dir[7][25] = {
{ 0,1,8,14,4,3,7,13,17,9,10,2,6,12,16,15,5,11,18,19,20,21,22,23 },//前左 或 后右
{ 0,1,11,5,4,16,12,6,2,9,10,17,13,7,3,15,14,8,18,19,20,21,22,23 },//前右 或 后左
{ 1,3,0,2,23,22,4,5,6,7,10,11,12,13,14,15,16,17,18,19,20,21,9,8 },//上右 或 下左
{ 2,0,3,1,6,7,8,9,23,22,10,11,12,13,14,15,16,17,18,19,20,21,5,4 },//上左 或 下右
{ 6,1,12,3,5,11,16,7,8,9,4,10,18,13,14,15,20,17,22,19,0,21,2,23 },//左上 或 右下
{ 20,1,22,3,10,4,0,7,8,9,11,5,2,13,14,15,6,17,12,19,16,21,18,23 },//左下 或 右上
};
map<node, bool>mp;
queue<node>que;
bool operator<(node a, node b)
{//重载<号后才可以用map映射
for (int i = 0; i < 24; i++)
if (a.a[i] != b.a[i])
return a.a[i] < b.a[i];
return a.a[0] < b.a[0];
}
void bfs(node x)
{
node y;
que.push(x);
mp[x] = 1;
int i, j;
while (!que.empty())
{
x = que.front(), que.pop();
for (i = 0; i < 6; i++)
{
for (j = 0; j < 24; j++)
y.a[j] = x.a[dir[i][j]];
if (mp[y] == 0)
mp[y] = 1, que.push(y);
}
}
}
int main()
{
node a;
int ans = 0;
a.a[6] = a.a[7] = a.a[12] = a.a[13] = a.a[16] = a.a[17] = a.a[18] = a.a[19] = 1;
a.a[4] = a.a[5] = a.a[10] = a.a[11] = a.a[8] = a.a[9] = a.a[14] = a.a[15] = 2;
a.a[0] = a.a[1] = a.a[2] = a.a[3] = a.a[20] = a.a[21] = a.a[22] = a.a[23] = 3;
bfs(a);
for (auto i : mp)
ans++;
printf("%d\n", ans);
return 0;
}
4. 方格分割
6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。
如图4-1,4-2,4-3：就是可行的分割法。
试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法。
请提交该整数，不要填写任何多余的内容或说明文字。
题解：
看起来有点麻烦...可以不用算法基础，乱搞一下也能对，主要是题意。
翻译一下，有多少种情况使得图形中心对称，并连续。
既然是中心对称，只要枚举上一半图形，即可推出下一半图形，上一半图形共有2^18种排列，不太多。
至于连续，只要dfs判断一下就好（暴力判断什么的都行）。
大概需要计算2^18*6*6次，千万级，秒出答案。
网上一些代码是dfs切割线，感觉好麻烦...
答案是509（注意旋转对称，搜索出的答案要除以4）
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
char mp[8][8];
int to[][2] = { 1,0,-1,0,0,1,0,-1 };
void dfs(int i, int j)
{
mp[i][j] = '0';
for (int k = 0; k < 4; k++)
{
int ti = i + to[k][0], tj = j + to[k][1];
if (ti >= 0 && tj >= 0 && ti < 6 && tj < 6)
if (mp[ti][tj] == '1')
dfs(ti, tj);
}
}
int main()
{
int i, j, k, s, ans = 0, flag;
for (i = 0; i < (1 << 18); i++)
{//位运算枚举上一半的所有情况
memset(mp, 0, sizeof(mp));
s = i;
for (j = 0; j < 3; j++)
for (k = 0; k < 6; k++)
mp[j][k] = '0' + (s & 1), s >>= 1;
//中心对称推出下一半的数字
for (j = 3; j < 6; j++)
for (k = 0; k < 6; k++)
if (mp[5 - j][5 - k] == '1')
mp[j][k] = '0';
else if (mp[5 - j][5 - k] == '0')
mp[j][k] = '1';
//dfs判断是否连续
flag = 1;
for (j = 0; j < 6; j++)
for (k = 0; k < 6; k++)
if (mp[j][k] == '1'&&flag == 1)
flag = 0, dfs(j, k);
flag = 1;
for (j = 0; j < 6; j++)
for (k = 0; k < 6; k++)
if (mp[j][k] == '1')
flag = 0;
ans += flag;
}
printf("%d\n", ans/4);
//旋转对称属于同一种方法，即除以4
return 0;
}
5.字母组串
由 A,B,C 这3个字母就可以组成许多串。
比如："A","AB","ABC","ABA","AACBB" ....
现在，小明正在思考一个问题：
如果每个字母的个数有限定，能组成多少个已知长度的串呢？
他请好朋友来帮忙，很快得到了代码，
解决方案超级简单，然而最重要的部分却语焉不详。
请仔细分析源码，填写划线部分缺少的内容。
#include <stdio.h>
// a个A，b个B，c个C 字母，能组成多少个不同的长度为n的串。
int f(int a, int b, int c, int n)
{
if(a<0 || b<0 || c<0) return 0;
if(n==0) return 1;
return ______________________________________ ; // 填空
}
int main()
{
printf("%d\n", f(1,1,1,2));
printf("%d\n", f(1,2,3,3));
return 0;
}
对于上面的测试数据，小明口算的结果应该是：
6
19
题解：
应该填：f(a - 1, b, c, n - 1) + f(a, b - 1, c, n - 1) + f(a, b, c - 1, n - 1)
直接给出问题还不太好想，但既然让填return的部分，上2行还都是边界条件，必然是递归分解子问题，很容易想到答案，代码比自然语言有逻辑就不解释了。
6.最大公共子串
最大公共子串长度问题就是：
求两个串的所有子串中能够匹配上的最大长度是多少。
比如："abcdkkk" 和 "baabcdadabc"，
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。
请分析该解法的思路，并补全划线部分缺失的代码。
#include <stdio.h>
#include <string.h>
#define N 256
int f(const char* s1, const char* s2)
{
int a[N][N];
int len1 = strlen(s1);
int len2 = strlen(s2);
int i,j;
memset(a,0,sizeof(int)*N*N);
int max = 0;
for(i=1; i<=len1; i++){
for(j=1; j<=len2; j++){
if(s1[i-1]==s2[j-1]) {
a[i][j] = __________________________; //填空
if(a[i][j] > max) max = a[i][j];
}
}
}
return max;
}
int main()
{
printf("%d\n", f("abcdkkk", "baabcdadabc"));
return 0;
}
题解：
最简单的动态规划，答案是: a[i - 1][j - 1] + 1
a[i][j]表示以串1的第i个结尾，串2的第j个结尾的最大公共子串。所以显然如果s1[i-1]==s2[j-1]成立，就要更新a[i][j]，更新的值就是在原基础上+1。
这2个代码填空过于简单了..
（下面都是oi赛制题目，适合高中打过信息学竞赛的，注意不是通过了给的一两组数据就满分..）
7.正则问题
考虑一种简单的正则表达式：
只由 x ( ) | 组成的正则表达式。
小明想求出这个正则表达式能接受的最长字符串的长度。
例如 ((xx|xxx)x|(x|xx))xx 能接受的最长字符串是： xxxxxx，长度是6。
输入
一个由x()|组成的正则表达式。输入长度不超过100，保证合法。
输出
这个正则表达式能接受的最长字符串的长度。
例如，
输入：
((xx|xxx)x|(x|xx))xx
程序应该输出：
6
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
（下面题目就不复制资源要求了，都差不多）
题解：
难点是不知道正则表达式...
具体见百度，这题的意思就是|两边的只能取1个（这题就是取最长的），括号里没有|就可以去掉括号。相当于实现一个只有+和max（）的表达式计算。
比如：((xx|xxx)x|(x|xx))xx->((xxx)x|(xx))xx->(xxxx|xx)xx-> (xxxx)xx->xxxxxx->6
涉及中缀表达式的计算，用栈（递归）实现。
#include<cstdio>
#include<algorithm>
using namespace std;
char s[105], pos;//pos为当前位
int dfs()
{
int num = 0, res = 0;
//num表示当前x的连续个数，res表示当前|之前的num,为0则表示之前没有数
while (s[pos])
{
if (s[pos] == '(')//（则需要返回数并加到num里
pos++, num += dfs();
if (s[pos] == 'x')
pos++, num++;
if (s[pos] == ')')
{
pos++;
break;
}
if (s[pos] == '|')
{
pos++;
res = max(num, res);
num = 0;
}
}
res = max(num, res);
return res;
}
int main()
{
while (~scanf("%s", s))
{
pos = 0;
printf("%d\n", dfs());
}
return 0;
}
8.包子凑数
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有N种蒸笼，其中第i种蒸笼恰好能放Ai个包子。每种蒸笼都有非常多笼，可以认为是无限笼。
每当有顾客想买X个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有X个包子。比如一共有3种蒸笼，分别能放3、4和5个包子。当顾客想买11个包子时，大叔就会选2笼3个的再加1笼5个的（也可能选出1笼3个的再加2笼4个的）。
当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼，分别能放4、5和6个包子。而顾客想买7个包子时，大叔就凑不出来了。
小明想知道一共有多少种数目是包子大叔凑不出来的。
输入
第一行包含一个整数N。(1 <= N <= 100)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100)
输出
一个整数代表答案。如果凑不出的数目有无限多个，输出INF。
例如，
输入：
2
4
5
程序应该输出：6
再例如，
输入：
2
4
6
程序应该输出：
INF
样例解释：
对于样例1，凑不出的数目包括：1, 2, 3, 6, 7, 11。
对于样例2，所有奇数都凑不出来，所以有无限多个。
题解：
有无数多个凑不出来的充要条件是这些数的最大公因数不为1。（数论）
其他时候用背包动态规划，再统计总数（具体背包开100*100大小应该就足够，不太确定..保险起见尽量开大吧，小于1M都不会超时）。
#include<cstdio>
#include<algorithm>
using namespace std;
int a[105], n;
bool dp[500005];
int gcd(int x, int y)
{//最大公因数
return y ? gcd(y, x%y) : x;
}
int main()
{
int i, j;
while (~scanf("%d", &n))
{
for (i = 0; i < n; i++)
scanf("%d", a + i);
if (n == 1)
{
puts(a[0] == 1 ? "0" : "INF");
continue;
}
int gg = gcd(a[0], a[1]);
for (i = 2; i < n; i++)
gg = gcd(gg, a[i]);
if (gg != 1)
{
puts("INF");
continue;
}
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (i = 0; i < n; i++)
for (j = 0; j < 500000; j++)
if (dp[j] == 1 && j + a[i] <= 500000)
dp[j + a[i]] = 1;
int ans = 0;
for (i = 0; i < 500000; i++)
if (dp[i] == 0)
ans++;
printf("%d\n", ans);
}
return 0;
}
9.分巧克力
儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。
为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：
1. 形状是正方形，边长是整数
2. 大小相同
例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。
当然小朋友们都希望得到的巧克力尽可能大，你能帮小Hi计算出最大的边长是多少么？
输入
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000)
输入保证每位小朋友至少能获得一块1x1的巧克力。
输出
输出切出的正方形巧克力最大可能的边长。
样例输入：
2 10
6 5
5 6
样例输出：
2
题解：
注意到如果边长为x时可行，那么小于x时都可行，如果x时不可行，那么大于x时都不行。
这是单调的，考虑用二分找到边界，复杂度O（nlogn），刚刚好。（其实挺明显的..数据大时遍历每种可能明显会超时）
需要二分的算法基础..
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n, k, s[100005][2];
bool ok(int x)
{//判断分割为x*x大小的巧克力是否够分
int i, co = 0;
for (i = 0; i < n; i++)
co += (s[i][0] / x)*(s[i][1] / x);
return co >= k;
}
int main()
{
int i, j, ma, ni, mid;
while (scanf("%d%d", &n, &k))
{
for (i = 0; i < n; i++)
scanf("%d%d", s[i], s[i] + 1);
ni = 1, ma = 100005;
for (i = 0; i < n; i++)
ma = min(ma, s[i][0]), ma = min(ma, s[i][1]);
while (ma - ni > 1)
{//二分
mid = (ma + ni) / 2;
if (ok(mid) == 1)
ni = mid;
else ma = mid;
}
printf("%d\n", ni);
}
return 0;
}
10. 标题：油漆面积
X星球的一批考古机器人正在一片废墟上考古。该区域的地面坚硬如石、平整如镜。管理人员为方便，建立了标准的直角坐标系。每个机器人都各有特长、身怀绝技。它们感兴趣的内容也不相同。经过各种测量，每个机器人都会报告一个或多个矩形区域，作为优先考古的区域。
矩形的表示格式为(x1,y1,x2,y2)，代表矩形的两个对角点坐标。为了醒目，总部要求对所有机器人选中的矩形区域涂黄色油漆。小明并不需要当油漆工，只是他需要计算一下，一共要耗费多少油漆。其实这也不难，只要算出所有矩形覆盖的区域一共有多大面积就可以了。
注意，各个矩形间可能重叠。
本题的输入为若干矩形，要求输出其覆盖的总面积。
输入格式：
第一行，一个整数n，表示有多少个矩形(1<=n<10000)
接下来的n行，每行有4个整数x1 y1 x2 y2，空格分开，表示矩形的两个对角顶点坐标。
(0<= x1,y1,x2,y2 <=10000)
输出格式：
一行一个整数，表示矩形覆盖的总面积。
例如，
输入：
3
1 5 10 10
3 1 20 20
2 7 15 17
程序应该输出：
340
再例如，
输入：
3
5 2 10 6
2 7 12 10
8 1 15 15
程序应该输出：
128
题解：
题意就是求矩形的面积交，很直白，但怎么暴力写或用hash思想都不会满分（复杂度不会低于O(n^2)，满分要求复杂度O(nlogn)）。
没有算法竞赛经验的不可能满分，原题是90年代的国际信息学奥赛题目（求矩形周长交），国家队还有相关的论文..
正解是线段树优化扫描线，复杂度O(nlogn)。就不解释了..acm实验室的同学等到线段树专题会训练这个的..
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct
{
int l, r, co;
int n1, n2;
}t[40004 << 2];
struct lin
{
int x, y1, y2;
int f;
}sc[40004];
int y[40004];
int cmp(lin a, lin b)
{
return a.x < b.x;
}
void build(int l, int r, int i)
{
t[i].l = l, t[i].r = r, t[i].co = 0, t[i].n1 = t[i].n2 = 0;
if (r - l == 1)
return;
int mid = (l + r) >> 1;
build(l, mid, i << 1), build(mid, r, i << 1 | 1);
}
void up(int i)
{
if (t[i].co > 1)
t[i].n2 = y[t[i].r] - y[t[i].l], t[i].n1 = 0;
else if (t[i].co == 1)
if (t[i].r - t[i].l != 1)
{
t[i].n2 = t[i << 1].n1 + t[i << 1].n2 + t[i << 1 | 1].n1 + t[i << 1 | 1].n2;
t[i].n1 = y[t[i].r] - y[t[i].l] - t[i].n2;
}
else t[i].n2 = 0, t[i].n1 = y[t[i].r] - y[t[i].l];
else if (t[i].r - t[i].l == 1)
t[i].n1 = t[i].n2 = 0;
else {
t[i].n1 = t[i << 1].n1 + t[i << 1 | 1].n1;
t[i].n2 = t[i << 1].n2 + t[i << 1 | 1].n2;
}
}
void update(int l, int r, int k, int i)
{
int mid = (t[i].l + t[i].r) >> 1;
if (l <= y[t[i].l] && r >= y[t[i].r])
t[i].co += k;
else if (r <= y[mid])
update(l, r, k, i << 1);
else if (l >= y[mid])
update(l, r, k, i << 1 | 1);
else update(l, y[mid], k, i << 1), update(y[mid], r, k, i << 1 | 1);
up(i);
}
int main()
{
int n, i, z;
int x1, x2, y1, y2, li, sum;
while (~scanf("%d", &n) && n)
{
z = 0;
while (n--&&scanf("%d%d%d%d", &x1, &y1, &x2, &y2))
{
sc[z].x = x1, sc[z].y1 = y1, sc[z].y2 = y2, sc[z].f = 1, y[z] = y1, z++;
sc[z].x = x2, sc[z].y1 = y1, sc[z].y2 = y2, sc[z].f = -1, y[z] = y2, z++;
}
sort(y, y + z), sort(sc, sc + z, cmp);
build(0, unique(y, y + z) - y - 1, 1);
sum = li = 0;
for (i = 0; i < z; i++)
{
update(sc[i].y1, sc[i].y2, sc[i].f, 1);
if (i) sum += li * (sc[i].x - sc[i - 1].x);
li = t[1].n1 + t[1].n2;
}
printf("%d\n", sum);
}
return 0;
}