Educational Codeforces Round 50 (Rated for Div. 2)
A. Function Height
在一个坐标轴上， 给一个n，在2n+1长度的轴上，允许调高任意一个奇数的点的高度，形成一个三角形，每个三角形会框出一个区域。所有跳高过的点的最高点，称为坐标最高点。求，给定n，要圈出k面积的区域，求怎么调整每个点的高度，使得最高点最小。
嗯。。。说实话题目挺绕的，但是其实非常简单。。。不管如何调整高度，框出来的三角形面积总是跟高度相同，因为：
S = 2 * h / 2 = h
然后要圈出k面积，只需要取 k/n 的高度就行了。这个是数学形式上的最小最高点。但是由于题目要求整数，那就向上取整一下，就ok了。
#include "bits/stdc++.h"
using namespace std;
int main(int argc, char *argv[])
{
long long n,k;
cin >> n >> k;
long long ret = k / n;
if(ret * n != k)
{
ret ++;
}
cout << ret;
return 0;
}
B. Diagonal Walking v.2
这个题目当时脑子抽了，没有想明白，一直WA，等做完了，看看别人的思路，才明白，这么简单。
总的来说，思路就是，结果只有三种情况，k, k -1, k-2。
为什么呢？
首先我们来看下行走策略。
1，直接斜着走。嗯，这个当然很好
2，如果同一个方向走超过两个单位，那么，实际上可以变成两个斜线走。比如，从(0,0)走到(0,2)，可以这样走。先走到(1,1)，然后再走到(0,2)。
3，如果同一个方向走一个单位。嗯，没法了，只能直线走。
4，还有一种，为了走够k步，不得不走直线，浪费步数，比如k为3，目标为(0,0)，那么必须拿出两部来走直线。即(1,1) (1,0) (0,0)的走法。
5，唯一一种不能到达的，就是k < m + n了。
所以总体策略很简单。我们这么做：
1，先走斜线，走min(n,m)步，此时跟n或者m里面一个持水平
2，走直线，走max(n,m) - min(n,m)步，用斜线走，此时应该到(m,n)附近或者差1一步。
3，如果m+n为奇数，可以猜测，要么min(n,m)是奇数，要么max(n,m) 是奇数。但是无论如何，max(m,n)-min(m,n)一定是奇数。所以走直线这里，必定需要有一步直线，回到(m,n)。所以如果m+n为奇数，最后的答案就是k-1
4，如果m+n为偶数，要么刚好走到(m,n)，剩余的步数为偶数。那就k步都可以走斜线。
5，要么走到(m,n)的时候还多出一步。那这个时候只能拿出两个直线，来消耗这个多出来的斜线了。这个时候就只有k-2步可以走斜线了。而这种情况的判定，可以看第二个步骤，走直线那里。如果max(m,n) - min(m,n)为奇数，此时说明直线不能通过走两步斜线刚好到达，需要多两步。
#include "bits/stdc++.h"
using namespace std;
void debug(std::string p)
{
cout << p;
}
int main(int argc, char *argv[])
{
int q = 0;
cin >> q;
long long n, m, k;
while(q--)
{
cin >> n >> m >> k;
long long ret;
if(n > k || m > k)
{
cout << -1 << endl;
continue;
}
if((m + n) % 2 == 0)
{
//
ret = k;
if((2 + std::llabs(m - k)) % 2 == 1)
{
ret -= 2;
}
}
else
{
ret = k - 1;
}
cout << ret << endl;
}
return 0;
}
C. Classy Numbers
求[l,r]范围内，有多少数字满足只有三个非零数字位的条件。如12000，10001都满足。但是1111不满足。
把问题分两部分看，分别求小于 l + 1和小于r的范围内，有多少个数字满足要求，然后相减即可。这就转换为如何求小于数字x的数字数量了。
这个计数方法大致就是：
1，从高位开始，先选第一个数字n，定下来，这个数字非零。
2，剩下的几位，选0，1，2位非零数字，在里面填数字。
3，最高位变动，其变动范围为1到n-1，每个为定好之后，按照2处理。
4，重复第1为，但是这次定下的是第一第二位。
#include "bits/stdc++.h"
#include
using namespace std;
long long C(long long n,long long m){
long long ret = 1l;
for(long long i = 0l; i < m; i ++)
{
ret *= (n - i);
}
for(long long i = 0l; i < m; i ++)
{
ret /= (i + 1);
}
return ret;
}
long long my_pow(long long a, long long b)
{
if(b == 1)
{
return a;
}
else if(b == 0)
{
return 1;
}
long long halRet = my_pow(a, b/2);
if(b % 2 == 1)
{
return halRet * halRet * a;
}
else
{
return halRet * halRet;
}
}
long long f(long long x)
{
stringstream ss;
ss << x;
string s;
ss >> s;
reverse(s.begin(),s.end());
long long ret = 0, nonzero = 0;
for(int i = s.length() - 1; i >= 0; i--)
{
int d = s[i] - '0';
if(d != 0)
{
for(int k = 0; k < (4 - nonzero); k ++)
{
ret += C(i,k) * my_pow(9, k);
}
nonzero++;
for(int k = 0; k < (4 - nonzero); k ++)
{
ret += (d - 1) * C(i,k) * my_pow(9, k);
}
}
if(nonzero > 3)
{
break;
}
}
return ret;
}
int main(int argc, char *argv[])
{
long long q = 0;
cin >> q;
while(q--)
{
long long l, r;
cin >> l >> r;
cout << f(r + 1) - f(l) << endl;
}
return 0;
}
D. Vasya and Arrays
给定两个数组，允许合并连续的数字。两个数字分别合并，合并完之后，让两个数组尽可能长。
由于所有输入的数字都是正整数，且合并的时候不能移动位置。所以可以用贪心算法，轮流合并即可。
#include "bits/stdc++.h"
using namespace std;
long long a[300005];
long long b[300005];
long long c[300005];
int main(int argc, char *argv[])
{
int na, nb;
long long sum = 0;
cin >> na;
for (int i = 0; i < na; ++i) {
scanf("%d", &a[i]);
sum += a[i];
}
cin >> nb;
for (int i = 0; i < nb; ++i) {
scanf("%d", &b[i]);
sum -= b[i];
}
if(sum != 0)
{
cout << -1;
return 0;
}
int ret = 0;
long long sa = a[0], sb =b[0];
int i,j;
for(i = 1, j = 1; i <= na && j <= nb;)
{
while(sa != sb && i <= na && j <= nb)
{
if(sa < sb)
{
sa += a[i];
i++;
}
else
{
sb += b[j];
j++;
}
}
if(sa == sb)
{
c[ret] = sa;
ret++;
sa = sb = 0;
if(i >= na || j >= nb)
{
break;
}
sa = a[i];
sb = b[j];
i++;
j++;
}
}
if(i == na && j == nb)
{
cout << ret << endl;
}
else
{
cout << -1 << endl;
}
return 0;
}
E. Covered Points
给定很多线段。求这些线段覆盖到的整数点。这些线段会有交错，但是肯定不在一条线上。
先说第一部分。求一根线覆盖了多少整数点。这个点数很简单，__gcd(abs(dx), abs(dy)) + 1就是了。为什么？
令gcd(abs(dx),abs(dy))为gcd，必然有gcd a = abs(dx), gcd b = abs(dy)，a，b都为整数。此时，x每前进a长度，y必定前b长度。一共可以前进gcd次。
然后，就是求交错的整数点的数量了。这个，就是求交线，然后确认是不是整数，然后看看是不是在线段内，就ok了。这个套个模版，就ok。
#include
using namespace std;
#define N 1005
typedef struct _point
{
long x;
long y;
}point;
struct seg{
int x1, y1, x2, y2;
seg(){};
};
struct line{
long long A, B, C;
line(){};
line(seg a){
A = a.y1 - a.y2;
B = a.x2 - a.x1;
C = -A * a.x1 - B * a.y1;
};
};
long long det(long long a, long long b, long long c, long long d){
return a * d - b * c;
}
//求两个线是否有交集
bool inter_for_line(seg a, seg b, int& x, int& y){
line l1(a), l2(b);
long long dx = det(l1.C, l1.B, l2.C, l2.B);
long long dy = det(l1.A, l1.C, l2.A, l2.C);
long long d = det(l1.A, l1.B, l2.A, l2.B);
if (d == 0)
return false;
if (dx % d != 0 || dy % d != 0)
return false;
x = -dx / d;
y = -dy / d;
return true;
}
bool in_seg(int x, int l, int r){
if (l > r) swap(l, r);
return (l <= x && x <= r);
}
//求两个线段是否有交集
bool inter_for_seg(seg a, seg b, int& x, int& y)
{
if(inter_for_line(a,b,x,y))
{
if (!in_seg(x, a.x1, a.x2) || !in_seg(y, a.y1, a.y2))
return false;
if (!in_seg(x, b.x1, b.x2) || !in_seg(y, b.y1, b.y2))
return false;
return true;
}
return false;
}
//求线段内的整数坐标数
int get_int_coordinate_num(seg a){
int dx = a.x1 - a.x2;
int dy = a.y1 - a.y2;
if(dx == 0)
{
return abs(dy) + 1;
}
else if(dy == 0)
{
return abs(dx) + 1;
}
return __gcd(abs(dx), abs(dy)) + 1;
}
int main(int argc, char *argv[])
{
int n = 0;
int x1,y1,x2,y2;
vector a;
seg tmp;
cin >> n;
for (int i = 0; i < n; ++i)
{
scanf("%d %d %d %d", &x1,&y1, &x2,&y2);
tmp.x1 = x1;
tmp.x2 = x2;
tmp.y1 = y1;
tmp.y2 = y2;
a.push_back(tmp);
}
long long cnt = 0;
for (int i = 0; i < n; ++i)
{
set > pts;
cnt += get_int_coordinate_num(a[i]);
for(int j = 0; j < i; j++)
{
if(inter_for_seg(a[i], a[j], x1,y1))
{
pts.insert(pair(x1,y1));
}
}
cnt -= pts.size();
}
cout << cnt << endl;
return 0;
}
G. Sources and Sinks
有n个点，m个有向线段构成有向图。然后他们最多只有20个source和sink，source就是入度为0，sink是出度为0。source和sink数量保证相同。求，以任意方式从sink添加一个线段到source，是不是可以构成强联通。
题目看起来点线很多，但是，由于是有向图，所以可以肯定，对于非source和sink的点，必定至少有一个source点能到达该点，并且该点一定有一个方法，能到达sink点。
所以题目缩减到了40个source和sink点的问题。
更进一步，什么时候会有非强联通图呢？那就是有一个子图，这个子图内，所有的sink，都连接到本子图source。此时，本土的source，必定会有某些source不能到达（当然，还有可能有其他点，但是source点肯定不能到达）。
所以，只要枚举了所有可能，没有这种自图，就能说yes了。
这里还TLE了几次，分别是因为用了map来组织g数组，以及用cin来读输入。事实证明O(logn)和O(1)还是有差异的。。。。同时也证明自己偷懒就得浪费运行时时间的真理。。。
#include "bits/stdc++.h"
using namespace std;
int input[1000005];
int output[1000005];
bool reachable[21][1000005];
vector tail;
// use an array will be much faster then map
std::vector g[1000005];
void dfs(int sourceNumber, int source)
{
reachable[sourceNumber][source] = true;
for(auto x:g[source])
{
if(reachable[sourceNumber][x] == false)
{
dfs(sourceNumber, x);
}
}
}
int main(int argc, char *argv[])
{
int n,m;
int from, to;
scanf("%d %d", &n, &m);
memset(input,0, sizeof(input));
memset(output,0, sizeof(output));
memset(reachable, 0 , sizeof(reachable));
tail.clear();
for (int i = 0; i < m; ++i) {
//scanf is faster than cin!
scanf("%d %d", &from, &to);
g[from].push_back(to);
input[to]++;
output[from]++;
}
int sourceNumber = 0;
for (int i = 1; i <= n; ++i) {
if(input[i] == 0)
{
dfs(sourceNumber, i);
sourceNumber++;
}
if(output[i] == 0)
{
tail.push_back(i);
}
}
set s;
for(int i = 1; i < (1 << sourceNumber) - 1; i ++)
{
s.clear();
int cnt = 0;
for (int j = 0; j < sourceNumber; ++j) {
if(i & ( 1<