Codeforces Round #359 (Div. 2)

5/5

这场CF因为java课设没打，于是去VJ开了一场模拟补了下，结果打了1个小时就累了，于是滚去睡中午觉2333，补完题写个题解。这个博客基本就是记录我ACM做过什么题（不完全）以及对一些算法的理解~~算法专题以后有时间就补补。我发现CF的题目还是不是很难的（div2），看着题解慢慢理解还是能够跟得上的，打了一年多终于发现自己有点用了(/▽╲)！

 

题A Free Ice Cream

题意：给你n个操作，一开始有x个物品，然后+代表入货，-代表卖出，如果不够卖出则不卖给他，最后问你剩下的物品和没卖给的人数。

题解：直接模拟。

 

/*zhen hao*/
#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

int main() {
//  freopen("case.in", "r", stdin);
  int n, res = 0;
  ll d, t;
  cin >> n >> d;
  for (int i = 0; i < n; i++) {
    char c;
    cin >> c >> t;
    if (c == '+') d += t;
    else {
      if (d >= t) d -= t;
      else res++;
    }
  }
  cout << d << ' ' << res << endl;
}

 

题B Little Robber Girl's Zoo

题意：给你一个序列，然后你可以制定一个偶数长度的区间让其两两交换，也就是i和i+1，i+2和i+3……，最后得到一个递增的序列，然你输出操作，要求操作不超过2e4次。

题解：注意到序列的个数是100，那么我们利用冒泡排序，如果要交换那就push进答案去，最后输出来的都是长度为2的区间即可，这样的区间最多是n * （n - 1） / 2个，所以不用担心出错。

 

/*zhen hao*/
#include <bits/stdc++.h>
using namespace std;

#define lson l, m, rt*2
#define rson m + 1, r, rt*2+1
#define xx first
#define yy second

typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;

const int maxn = 1e2 + 10;
int a[maxn], n;
vector<pii> v;

int main() {
//  freopen("case.in", "r", stdin);
  cin >> n;
  for (int i = 0; i < n; i++) cin >> a[i];
  for (int i = 0; i < n - 1; i++) {
    bool flag = false;
    for (int j = 0; j < n - 1 - i; j++) {
      if (a[j] > a[j + 1]) {
        swap(a[j], a[j + 1]);
        v.push_back(make_pair(j + 1, j + 2));
        flag = true;
      }
    }
    if (!flag) break;
  }
  for (int i = 0; i < (int)v.size(); i++)
    cout << v[i].xx << ' ' << v[i].yy << endl;
  return 0;
}

 

题C Robbers' watch

题意：给你n和m表示x：y，其中0<=x<n，0<=y<m，然后问你表示为7进制要均有不同的数字，如果一个数不够这个位数的话要加前导零，问你有多少种可能？

题解：显然如果n + m的位数大于8的话是不可能的，所以这样可以暴力处理，对于那些满足的进行暴力枚举即可。

 

/*zhen hao*/
#include <bits/stdc++.h>
using namespace std;

#define lson l, m, rt*2
#define rson m + 1, r, rt*2+1
#define xx first
#define yy second

typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;

const int maxn = 300;
int dp1[maxn], dp2[maxn];

bool check(int x, int& l) {
  if (x == 0) return l = 1;
  l = 0;
  while (x) {
    l++;
    x /= 7;
  }
  return l <= 7;
}

void pre(int n, int l, int* dp) {
  for (int i = 0; i < n; i++) {
    int s = 0, t = i, ok = 1;
    for (int j = 0; j < l; j++) {
      if (s & 1 << (t % 7)) { ok = 0; break; }
      s ^= (1 << (t % 7));
      t /= 7;
    }
    if (ok) dp[s]++;
//    if (ok) cout << s << endl;
  }
}

int main() {
//  freopen("case.in", "r", stdin);
  int n, m, l1, l2;
  cin >> n >> m;
  if (!check(n - 1, l1) || !check(m - 1, l2)) ;
  if (l1 + l2 > 7) {
     puts("0"); return 0;
  }
  pre(n, l1, dp1);
  pre(m, l2, dp2);
  ll res = 0;
  for (int i = 1; i < 1 << 7; i++)
    for (int j = 1; j < 1 << 7; j++)
      if (!(i & j)) res += 1ll * dp1[i] * dp2[j];
  cout << res << endl;
}

 

题D Kay and Snowflake

题意：给你一颗以1为根的树，然后有q个询问，问你以这个顶点为根的子树的重心是什么？

题解：这道题根本不会做，主要考虑的是树的重心的一些性质。

先丢出一个博文：戳这里

这里讲到树的重心的三个性质，以后再慢慢研究，这里用到的是第二条性质：

当合并两颗树的时候新的树的重心就是原来两棵树的重心的路径上的一个点。

应用到这道题中，首先要知道对于一个点u的重心一定是在他的重儿子上（重儿子就是子树上最多结点的一个儿子节点）。

为什么呢？

先给出树的重心的其中一个定义：重心是所有点中那个点的所有子树的最大结点最小的一个点。现在我们证明的是一个点的重心一定是它本身或者是它的重儿子所在子树上的一个点，假设这个是不对的，也就是可能在别的非重儿子的子树上，现在假设重儿子结点数是x，这个非重儿子的结点数是y，那么有x > y，然后如果是非重儿子子树上的一个点，那么他必有的一个连通块的个数是x + 1（根节点），然后如果选的是本身，那么最大的结点数是x（重儿子子树的个数），所以不可能在轻儿子子树上。

接着回到这道题，已知是本身或者在重儿子上，那么对于一棵树的所有子树中，只需要考虑重儿子的子树，假设这个子树的重心是v，那么v到根节点的路径上的所有点都可能是重心（根据性质二可知），所以我们只要dfs一次即可，复杂度O（n + q）。

/*zhen hao*/
#include <bits/stdc++.h>
using namespace std;

const int maxn = 3e5 + 10;
int e, head[maxn], res[maxn], sz[maxn], fa[maxn];

struct Edge {
  int v, nx;
} edges[maxn * 2];

void init() {
  e = 0;
  memset(head, -1, sizeof head);
}

void add_edge(int u, int v) {
  edges[e] = (Edge){v, head[u]};
  head[u] = e++;
}

void dfs(int u) {
  res[u] = u;
  sz[u] = 1;
  int w_son = -1;
  for (int i = head[u]; ~i; i = edges[i].nx) {
    int v = edges[i].v;
    dfs(v);
    sz[u] += sz[v];
    if (w_son == -1 || sz[v] > sz[w_son])
      w_son = v;
  }
  if (w_son != -1 && sz[w_son] > sz[u] / 2) {
    int v = res[w_son];
    while (sz[u] - sz[v] > sz[u] / 2) v = fa[v];
    res[u] = v;
  }
}

int main() {
//  freopen("case.in", "r", stdin);
  int n, q;
  cin >> n >> q;
  init();
  for (int i = 1; i < n; i++) {
    scanf("%d", &fa[i]);
    fa[i]--;
    add_edge(fa[i], i);
  }
  dfs(0);
  for (int i = 0; i < q; i++) {
    int x;
    scanf("%d", &x);
    --x;
    printf("%d
", res[x] + 1);
  }
}

 

题E Optimal Point

题意：给你n个点（xi，yi，zi），让你找一个点（X，Y，Z）使得max{|x1 - X| + |y1 - Y| + |z1 - Z|}最小，让你输出任意一个满足的点，还有就是这个X、Y、Z必须是整数。

题解：最大最小问题显然要二分，怎么二分呢？在下实在渣渣，参考了叉姐的题解，还要研究上半天才写得出代码，果然是渣渣┑(￣Д ￣)┍，先丢出叉姐的解题报告：戳这里

接下来我将重复阐述一样的解法，当然会加上一点点我的理解:

首先是二分答案l，

然后对于所有点i均有

|xi - X| + |yi - Y| + |zi - Z| <= l

然后绝对值可以拆掉写成：

|xi - X| = max{ xi - X, X - xi }

（同理还有两个）

然后上述的式子就变成：

|xi - X| + |yi - Y| + |zi - Z| = max{ xi + yi + zi - (X + Y + Z), -xi + yi + zi - (-X + Y + Z)（同理还有六个） } <= l

于是单独写出来就有：

max{xi + yi + zi} - (X + Y + Z) <= l

X + Y + Z - min{xi + yi + zi} <= l

=>  max{xi + yi + zi} -l <= X + Y + Z <= min{xi + yi + zi} + l

同理有如下四个：

2) max{-xi + yi + zi} -l <= -X + Y + Z <= min{-xi + yi + zi} + l

3）max{xi + yi - zi} -l <= X + Y - Z <= min{xi + yi - zi} + l

4）max{-xi + yi - zi} -l <= -X + Y - Z <= min{-xi + yi - zi} + l

然后就是变形的时间了，另S = Y + Z，D = Y - Z，然后我们把前两个表示为（引用一下）：

接下来讲述一下怎么解出这个X的范围？

假设有两个区间[a,b]和[c,d]，然后他们相交，问你满足什么条件？

考虑其对立问题：不相交。

如果[a,b]在左，那么要满足b < c；否则要满足d < a，也就是b < c || d < a

取反得c <= d && a <= d，所以这样就得到了两个X的范围（四个不等式），然后取并集之后得到[x3,y3]，然后就是枚举X存不存在满足条件的Y和Z。怎样得到Y和Z呢？已知S和D的范围，然后因为

S = Y + Z； D = Y - Z；

因此Y = （S + D） / 2； Z = （S - D） / 2；

但是因为Y和Z都是整数，因此需要S和D同奇偶，所以判定一下就好，有的话就返回yes表示二分的结果是对的，可以继续缩小枚举的len。至此，这道题就解完了。。。。

/*zhen hao*/
#include <bits/stdc++.h>
using namespace std;

#define lson l, m, rt*2
#define rson m + 1, r, rt*2+1
#define xx first
#define yy second

typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;

const ll inf = 3 * 1e18;
ll mi[5], ma[5], low[5], high[5];
ll resx, resy, resz;

ll div2(ll x, ll y) {
  if (x > 0 && y > 0 || x < 0 && y < 0) {
    ll f = 0;
    if (x % 2 && y % 2) f = 1;
    if (x > 0 && y > 0) return x / 2 + y / 2 + f;
    else return x / 2 + y / 2 - f;
  }
  else
    return (x + y) / 2;
}

void update(ll s, ll d) {
  resy = div2(s, d);
  resz = div2(s, -d);
}

bool check(ll x) {
  for (int i = 1; i <= 4; i++) {
    low[i] = ma[i] - x;
    high[i] = mi[i] + x;
    if (low[i] > high[i]) return false;
  }
  ll x1 = div2(low[1], -high[2]);
  ll y1 = div2(high[1], -low[2]);
  ll x2 = div2(low[3], -high[4]);
  ll y2 = div2(high[3], -low[4]);
  ll x3 = max(x1, x2);
  ll y3 = min(y1, y2);
  if (x3 > y3) return false;
  for (ll i = x3; i <= y3; i++) {
    resx = i;
    ll s1 = max(low[1] - i, low[2] + i);
    ll s2 = min(high[1] - i, high[2] + i);
    ll d1 = max(low[3] - i, low[4] + i);
    ll d2 = min(high[3] - i, high[4] + i);
    if (s1 > s2 || d1 > d2) continue;
    if (s1 < s2) {
      if ((s1 & 1) == (d1 & 1)) update(s1, d1);
      else update(s1 + 1, d1);
      return true;
    }
    else if (d1 < d2) {
      if ((s1 & 1) == (d1 & 1)) update(s1, d1);
      else update(s1, d1 + 1);
      return true;
    } else {
      if ((s1 & 1) == (d1 & 1)) { update(s1, d1); return true; }
    }
  }
  return false;
}

int main() {
//  freopen("case.in", "r", stdin);
  int T;
  cin >> T;
  while (T--) {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= 4; i++) {
      mi[i] = inf; ma[i] = -inf;
    }
    for (int i = 0; i < n; i++) {
      ll x, y, z;
      scanf("%I64d%I64d%I64d", &x, &y, &z);
      mi[1] = min(mi[1], x + y + z);  ma[1] = max(ma[1], x + y + z);
      mi[2] = min(mi[2], -x + y + z); ma[2] = max(ma[2], -x + y + z);
      mi[3] = min(mi[3], x + y - z);  ma[3] = max(ma[3], x + y - z);
      mi[4] = min(mi[4], -x + y - z); ma[4] = max(ma[4], -x + y - z);
    }
    ll L = -1, R = inf;
    while (R - L > 1) {
      ll M = (L + R) >> 1;
      if (check(M)) R = M;
      else L = M;
    }
    check(R);
    printf("%I64d %I64d %I64d
", resx, resy, resz);
//    cout << resx << ' ' << resy << ' ' << resz << endl;
  }
  return 0;
}