A - Add Odd or Subtract Even
诚心诚意的签到题。不过做的时候有点启发，也就是(a-b)%2的结果，可以是-1,0,+1。
B - WeirdSort
题意：给一个数组，以及指定其中一些位置是可以进行邻位交换的，可以交换任意多次。求是否能把数组变回有序。
题解：数据量太小，甚至可以检查每个可交换的位置是否需要交换。但是更明显的是一段连续的可邻位交换的位置可以直接sort。注意sort传入的下标的格式。
int a[1005];
int p[1005];
void test_case() {
int n, m;
scanf("%d%d", &n, &m);
for(int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
for(int i = 1; i <= m; ++i)
scanf("%d", &p[i]);
sort(p + 1, p + 1 + m);
for(int l = 1, r = 1; l <= m; l = r + 1, r = l) {
while(r + 1 <= m && p[r + 1] == p[r] + 1)
++r;
sort(a + p[l], a + p[r] + 1 + 1);
}
for(int i = 2; i <= n; ++i) {
if(a[i] < a[i - 1]) {
puts("NO");
return;
}
}
puts("YES");
return;
}
C - Perform the Combo
诚心诚意的签到题。比B还水。
*D - Three Integers
题意：给三个数a,b,c(1<=a,b,c<=1e4)，用最少的操作使得a<=b<=c且a是b的因数且b是c的因数，每次操作可以对一个数进行+1或者-1（需要保证结果仍然是正数）。
题解：发现b是对两边进行制约的，假如枚举b的取值，可以立刻算出c的取值，但是a的取值比较难算，要分解因数。但是假如反过来dp，枚举a的取值，然后把a的倍数全部更新，复杂度会显著降低。易知枚举的上限是2e4，因为把三个数变成完全相等，需要的代价最大也是1e4（max减去min的值就是1e4，min和max都往中间的数靠，总共至多移动1e4次，所以b最大变到2e4）。
int dis[20005];
int from[20005];
void test_case() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
memset(dis, INF, sizeof(dis));
for(int i = 1; i <= 20000; ++i) {
int d = abs(a - i);
for(int j = i; j <= 20000; j += i) {
if(d < dis[j]) {
dis[j] = d;
from[j] = i;
}
}
}
int ans = INF, ansa, ansb, ansc;
for(int i = 1; i <= 20000; ++i) {
int tmpans = dis[i];
tmpans += abs(b - i);
tmpans += (c <= i) ? (i - c) : min(c % i, i - c % i);
if(ans > tmpans) {
ans = tmpans;
ansa = from[i];
ansb = i;
if(c <= i)
ansc = i;
else if(c % i <= i - c % i)
ansc = c / i * i;
else
ansc = (c / i + 1) * i;
}
}
printf("%d
", ans);
printf("%d %d %d
", ansa, ansb, ansc);
}
*E - Construct the Binary Tree
又一条2400的题，是不是准备要起飞了？
题意：构造一棵以1为根的n个节点的二叉树，使得其所有节点的深度和恰好为d。
题解：易知最小深度和为完全二叉树，最大深度和为一条链，判断d不超过最大深度和之后，可以逐步调整。每次调整贪心把深度最大的节点往上调整，若有某个位置刚刚好，就调整到那个位置，否则调整到当前最小深度的空位上。易知这样会产生两个新的比当前最小深度+1的空位。假如已经形成完全二叉树（当前最小深度的空位的深度已经不小于（不是等于）最大深度的节点的深度了）。每个节点至多被调整1次，所以复杂度与n同阶（比官方题解更好）。
stack<int> dep[5005];
int pa[5005];
void test_case() {
int n, d;
scanf("%d%d", &n, &d);
if(d > n * (n - 1) / 2) {
puts("NO");
return;
}
for(int i = 1; i <= n; ++i) {
while(!dep[i].empty())
dep[i].pop();
}
int curd = n * (n - 1) / 2;
for(int i = 2; i <= n; ++i) {
pa[i] = i - 1;
dep[i - 1].push(i - 1);
}
int mind = 1, maxd = n - 1;
while(1) {
if(curd == d) {
puts("YES");
for(int i = 2; i <= n; ++i)
printf("%d%c", pa[i], "
"[i == n]);
return;
}
if(mind >= maxd) {
puts("NO");
return;
}
if(curd - d <= maxd - mind) {
pa[maxd + 1] = dep[maxd - (curd - d)].top();
puts("YES");
for(int i = 2; i <= n; ++i)
printf("%d%c", pa[i], "
"[i == n]);
return;
}
pa[maxd + 1] = dep[mind].top();
dep[mind].pop();
dep[mind + 1].push(maxd + 1);
dep[mind + 1].push(maxd + 1);
curd -= maxd - mind;
if(dep[mind].empty())
++mind;
--maxd;
}
}
F - Moving Points
看通过率觉得可能很水，结果还真的很水。
题意：有n个点，第i个点初始在xi，并且有恒定的速度vi，定义两个点之间的最小距离为从0时刻开始的两点的距离的最小值。求所有点对之间的最小距离的和。
题解：把所有点按xi排序，维护两棵平衡树，把xj小于当前的xi的全部放在左树，把xj大于当前的xi的全部放在右树，在左树中找速度<=vi的点的距离和，在右树中找速度>=vi的点的距离和，按xi的顺序扫描，逐个把右树的点搬到左树，即可。上面这个算法恰好把同一个距离算了两倍，其实只需要保留一棵右树，就可以算出来。
struct Treap {
#define ls ch[id][0]
#define rs ch[id][1]
static const int MAXN = 200000;
int ch[MAXN + 5][2], dat[MAXN + 5];
int val[MAXN + 5];
ll val2[MAXN + 5];
ll sumval2[MAXN + 5];
int cnt[MAXN + 5];
int sumcnt[MAXN + 5];
int tot, root;
inline void Init() {
tot = 0;
root = 0;
}
inline int NewNode(int v, ll x) {
int id = ++tot;
ls = rs = 0;
dat[id] = rand();
val[id] = v;
val2[id] = x;
sumval2[id] = x;
cnt[id] = 1;
sumcnt[id] = 1;
return id;
}
inline void PushUp(int id) {
sumval2[id] = sumval2[ls] + sumval2[rs] + val2[id];
sumcnt[id] = sumcnt[ls] + sumcnt[rs] + cnt[id];
}
inline void Rotate(int &id, int d) {
int temp = ch[id][d ^ 1];
ch[id][d ^ 1] = ch[temp][d];
ch[temp][d] = id;
id = temp;
PushUp(ch[id][d]);
PushUp(id);
}
inline void Insert(int &id, int v, ll x) {
if(!id)
id = NewNode(v, x);
else {
if(v == val[id]) {
val2[id] += x;
cnt[id] += 1;
} else {
int d = val[id] > v ? 0 : 1;
Insert(ch[id][d], v, x);
if(dat[id] < dat[ch[id][d]])
Rotate(id, d ^ 1);
}
PushUp(id);
}
}
void Remove(int &id, int v, ll x) {
if(!id)
return;
else {
if(v == val[id]) {
if(val2[id] > x) {
val2[id] -= x;
cnt[id] -= 1;
PushUp(id);
} else if(ls || rs) {
if(!rs || dat[ls] > dat[rs])
Rotate(id, 1), Remove(rs, v, x);
else
Rotate(id, 0), Remove(ls, v, x);
PushUp(id);
} else
id = 0;
} else {
val[id] > v ? Remove(ls, v, x) : Remove(rs, v, x);
PushUp(id);
}
}
}
//查询小于等于v的数的和
ll GetSumValue2LEQ(int id, int v) {
ll res = 0;
while(id) {
if(val[id] > v)
id = ls;
else if(val[id] == v) {
res += sumval2[ls] + val2[id];
break;
} else {
res += sumval2[ls] + val2[id];
id = rs;
}
}
return res;
}
//查询小于等于v的数的数量
int GetSumCntLEQ(int id, int v) {
int res = 0;
while(id) {
if(val[id] > v)
id = ls;
else if(val[id] == v) {
res += sumcnt[ls] + cnt[id];
break;
} else {
res += sumcnt[ls] + cnt[id];
id = rs;
}
}
return res;
}
//查询大于等于v的数的和
ll GetSumValue2GEQ(int id, int v) {
ll res = 0;
while(id) {
if(val[id] > v) {
res += sumval2[rs] + val2[id];
id = ls;
} else if(val[id] == v) {
res += sumval2[rs] + val2[id];
break;
} else
id = rs;
}
return res;
}
//查询大于等于v的数的数量
int GetSumCntGEQ(int id, int v) {
int res = 0;
while(id) {
if(val[id] > v) {
res += sumcnt[rs] + cnt[id];
id = ls;
} else if(val[id] == v) {
res += sumcnt[rs] + cnt[id];
break;
} else
id = rs;
}
return res;
}
#undef ls
#undef rs
}Right;
pii p[200005];
void test_case() {
int n;
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
scanf("%d", &p[i].first);
for(int i = 1; i <= n; ++i)
scanf("%d", &p[i].second);
sort(p + 1, p + 1 + n);
ll ans = 0;
Right.Init();
for(int i = 1; i <= n; ++i)
Right.Insert(Right.root, p[i].second, p[i].first);
for(int i = 1; i <= n; ++i) {
ans += Right.GetSumValue2GEQ(Right.root, p[i].second)
- 1ll * p[i].first * Right.GetSumCntGEQ(Right.root, p[i].second);
Right.Remove(Right.root, p[i].second, p[i].first);
}
printf("%lld
", ans);
}
看了别人的代码，发现其实可以用树状数组来做，因为只关心大于等于某个v值的所有还在树中的点的x值的和，可以反过来变成一个前缀和。
启示：可以离线排序关键字的算法，不需要使用平衡树，使用树状数组或者线段树即可，当询问的区间为>=x或者<=x这样的形式时，尤其适合树状数组。
struct SegmentTree {
#define ls (o<<1)
#define rs (o<<1|1)
static const int MAXN = 200000;
ll sumx[(MAXN << 2) + 5];
int cnt[(MAXN << 2) + 5];
void PushUp(int o) {
sumx[o] = sumx[ls] + sumx[rs];
cnt[o] = cnt[ls] + cnt[rs];
}
void Build(int o, int l, int r) {
if(l == r) {
sumx[o] = 0;
cnt[o] = 0;
} else {
int m = l + r >> 1;
Build(ls, l, m);
Build(rs, m + 1, r);
PushUp(o);
}
}
void Update1(int o, int l, int r, int p, ll v) {
if(l == r) {
sumx[o] += v;
cnt[o] += 1;
return;
} else {
int m = l + r >> 1;
if(p <= m)
Update1(ls, l, m, p, v);
if(p >= m + 1)
Update1(rs, m + 1, r, p, v);
PushUp(o);
}
}
void Update2(int o, int l, int r, int p, ll v) {
if(l == r) {
sumx[o] -= v;
cnt[o] -= 1;
return;
} else {
int m = l + r >> 1;
if(p <= m)
Update2(ls, l, m, p, v);
if(p >= m + 1)
Update2(rs, m + 1, r, p, v);
PushUp(o);
}
}
ll QuerySumx(int o, int l, int r, int ql, int qr) {
if(ql <= l && r <= qr) {
return sumx[o];
} else {
int m = l + r >> 1;
ll res = 0;
if(ql <= m)
res = res + QuerySumx(ls, l, m, ql, qr);
if(qr >= m + 1)
res = res + QuerySumx(rs, m + 1, r, ql, qr);
return res;
}
}
ll QueryCnt(int o, int l, int r, int ql, int qr) {
if(ql <= l && r <= qr) {
return cnt[o];
} else {
int m = l + r >> 1;
ll res = 0;
if(ql <= m)
res = res + QueryCnt(ls, l, m, ql, qr);
if(qr >= m + 1)
res = res + QueryCnt(rs, m + 1, r, ql, qr);
return res;
}
}
#undef ls
#undef rs
} Right;
pii p[200005];
int v[200005], vtop;
void test_case() {
int n;
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
scanf("%d", &p[i].first);
for(int i = 1; i <= n; ++i) {
scanf("%d", &p[i].second);
v[i] = p[i].second;
}
sort(p + 1, p + 1 + n);
sort(v + 1, v + 1 + n);
vtop = unique(v + 1, v + 1 + n) - (v + 1);
ll ans = 0;
Right.Build(1, 1, vtop);
for(int i = 1; i <= n; ++i) {
int pv = lower_bound(v + 1, v + 1 + vtop, p[i].second) - v;
Right.Update1(1, 1, vtop, pv, p[i].first);
}
for(int i = 1; i <= n; ++i) {
int pv = lower_bound(v + 1, v + 1 + vtop, p[i].second) - v;
ans += Right.QuerySumx(1, 1, vtop, pv, vtop)
- 1ll * p[i].first * Right.QueryCnt(1, 1, vtop, pv, vtop);
Right.Update2(1, 1, vtop, pv, p[i].first);
}
printf("%lld
", ans);
}
struct BinaryIndexTree {
static const int MAXN = 200000;
int n;
ll bit1[MAXN + 5];
int bit2[MAXN + 5];
void Init(int _n) {
n = _n;
memset(bit1, 0, sizeof(bit1[0]) * (n + 1));
memset(bit2, 0, sizeof(bit2[0]) * (n + 1));
}
void Add(int x, ll v1, int v2) {
for(; x <= n; x += x & -x) {
bit1[x] += v1;
bit2[x] += v2;
}
}
pair<ll, int> Sum(int x) {
ll res1 = 0;
int res2 = 0;
for(; x; x -= x & -x) {
res1 += bit1[x];
res2 += bit2[x];
}
return {res1, res2};
}
} bit;
pii p[200005];
int v[200005], vtop;
void test_case() {
int n;
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
scanf("%d", &p[i].first);
for(int i = 1; i <= n; ++i) {
scanf("%d", &p[i].second);
v[i] = p[i].second;
}
sort(p + 1, p + 1 + n);
sort(v + 1, v + 1 + n);
vtop = unique(v + 1, v + 1 + n) - (v + 1);
ll ans = 0;
bit.Init(vtop);
for(int i = 1; i <= n; ++i) {
int pv = lower_bound(v + 1, v + 1 + vtop, p[i].second) - v;
bit.Add(vtop - pv + 1, p[i].first, 1);
p[i].second = pv;
}
for(int i = 1; i <= n; ++i) {
int pv = p[i].second;
pair<ll, int> res = bit.Sum(vtop - pv + 1);
ans += res.first
- 1ll * p[i].first * res.second;
bit.Add(vtop - pv + 1, -p[i].first, -1);
}
printf("%lld
", ans);
}
启发：只要排序关键字可以离线，就立刻离散化然后换成树状数组来做。