Codeforces Round 965 (Div. 2)

写在前面
A
B
C
D
E1
E2
写在最后

写在前面

比赛地址：https://codeforces.com/contest/1998

为了保证队长当前是 1k9 这个事实不变方便劝诱新大神，于是上小号。

比较手速场呃呃，小号大概也能上紫了爽，要是手快点还能更爽。

置顶广告：中南大学 ACM 集训队绝赞招新中！

有信息奥赛基础，获得 NOIP 省一等奖并达到 Codeforces rating 1900+ 或同等水平及以上者，可以直接私聊我与校队队长联系，免选拔直接进校集训队参加区域赛！

没有达到该水平但有志于 XPCX 赛事请关注每学年开始的 ACM 校队招新喵！

到这个时候了还缺队友实在不妙！求求求求快来个大神带我呜呜呜呜

A

签到。

草怎么那么多 fst 的不懂。

复制复制 //
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
//=============================================================
//=============================================================
//=============================================================
int main() {
  //freopen("1.txt", "r", stdin);
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  int T; std::cin >> T;
  while (T --) {
    int xc, yc, k; std::cin >> xc >> yc >> k;
    for (int i = 1; i <= k - k % 2; i += 2) {
      std::cout << xc + (i / 2 + 1) << " " << yc << "\n";
      std::cout << xc - (i / 2 + 1) << " " << yc << "\n";
    }
    if (k % 2) std::cout << xc << " " << yc << "\n";
  }
  return 0;
}

B

思维，结论。

本地 check 了一下发现样例中给定排列与答案里，有且仅有 $[1, n]$ 的和是相等的，于是猜想一定存在一种构造方案，使得两个排列仅有 $[1, n]$ 的和相等。

赛时猜了个结论，直接把所有位置循环向后位移一位即可，本地跑了几组数据 check 了一下发现可行于是交上去过了。

其正确性是显然的，考虑给定的排列 $a$ 与循环向后位移一位得到的排列 $b$ ，对于任意一个长度小于 $n$ 的区间 $[l, r]$ ，一定有：

\sum_{l \leq i \leq r} b_{i} = \sum_{l - 1 \leq i \leq r - 1} a_{i} \neq \sum_{l \leq i \leq r} a_{i}

$\sum_{l\le i\le r} b_i = \sum_{l - 1\le i\le r - 1} a_i \not= \sum_{l\le i\le r} a_i$

 //
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
const int kN = 2e5 + 10;
//=============================================================4
int n, a[kN], ans[kN];
//=============================================================
//=============================================================
int main() {
  //freopen("1.txt", "r", stdin);
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  int T; std::cin >> T;
  while (T --) {
    std::cin >> n;
    for (int i = 1; i <= n; ++ i) std::cin >> a[i];
    for (int i = 2; i <= n; ++ i) ans[i] = a[i - 1];
    ans[1] = a[n];
    for (int i = 1; i <= n; ++ i) std::cout << ans[i] << " ";
 
    // LL cnt = 0;
    // for (int i = 1; i <= n; ++ i) {
    //   for (int j = i; j <= n; ++ j) {
    //     LL s1 = 0, s2 = 0;
    //     for (int k = i; k <= j; ++ k) {
    //       s1 += a[k], s2 += ans[k];
    //     }
    //     if (s1 == s2) ++ cnt;
    //   }
    // }
    // std::cout << cnt << "\n";
    std::cout << "\n";
  } 
  return 0;
}
/*
3
2
1 2
2 1
5
1 2 3 4 5
3 5 4 2 1
7
4 7 5 1 2 6 3
6 2 1 4 7 3 5
*/

C

枚举，数据结构。

考虑枚举最终答案里的 $a_i$ ，再考虑通过修改增大 $a_i$ 和增大中位数的代价：

若有 $b_i = 1$ ，显然一次修改至少使 $a_i:=a_i + 1$ 而不一定使中位数 $+1$ ，显然此时应仅修改 $a_i$ ，对答案的贡献即 $a_i + k + \operatorname{median}(c_i)$ ，直接对顶堆动态维护删去 $a_i$ 的中位数即可。单次检查的时间复杂度为 $O(\log n)$ 级别。

对顶堆维护中位数可见：https://www.cnblogs.com/luckyblock/p/18159496。

若有 $b_i = 0$ ，则此时仅能修改其他位置使中位数增大，一个显然的想法是二分答案枚举增大后的中位数的值 $\operatorname{mid}$ ，则仅需检查能否通过修改使 $c = \left\lfloor\frac{n - 1}{2}\right\rfloor + 1$ 个数不小于 $\operatorname{mid}$ 。

考虑先查询原数列中不小于 $\operatorname{mid}$ 的数的个数 $c'$ ，再查询原数列中小于 $\operatorname{mid}$ 且 $b_i=1$ 的数，则最优的操作是选择其中最大的 $c - c'$ 个数使它们变为 $\operatorname{mid}$ ，查询他们的和与 $(c - c')\times \operatorname{mid}$ 的差值是否不大于 $k$ 即可。

上述原数列中不小于 $\operatorname{mid}$ 的数的个数、以及原数列中小于 $\operatorname{mid}$ 且 $b_i=1$ 的数，均可以通过维护排序后的原数列，再在上面二分得到，在此基础上最大的 $c - c'$ 个数可通过维护前缀和得到，则单次检查的时间复杂度为 $O(\log v\log n)$ 级别。

总时间复杂度 $O(n\log v\log n)$ 级别。

 //
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
#define pr std::pair
#define mp std::make_pair
const int kN = 2e5 + 10;
const LL kMaxa = 2e9;
//=============================================================
int n, k, a[kN], b[kN];
int a1num, sorta1[kN], sorta[kN];
LL sum[kN];
//=============================================================
namespace Set {
  const int kInf = 1e9 + 2077;
  std::multiset<int> less, greater;
  void init() {
    less.clear(), greater.clear();
    less.insert(-kInf), greater.insert(kInf);
  }
  void adjust() {
    while (less.size() > greater.size() + 1) {
      std::multiset<int>::iterator it = (--less.end());
      greater.insert(*it);
      less.erase(it);
    }
    while (greater.size() > less.size()) {
      std::multiset<int>::iterator it = greater.begin();
      less.insert(*it);
      greater.erase(it);
    }
  }
  void add(int val_) {
    if (val_ <= *greater.begin()) less.insert(val_);
    else greater.insert(val_);
    adjust();
  }
  void del(int val_) {
    std::multiset<int>::iterator it = less.lower_bound(val_);
    if (it != less.end()) {
      less.erase(it);
    } else {
      it = greater.lower_bound(val_);
      greater.erase(it);
    }
    adjust();
  }
  int get_middle() {
    return *less.rbegin();
  }
}
void init() {
  std::cin >> n >> k;
  Set::init();
  for (int i = 1; i <= n; ++ i) {
    std::cin >> a[i];
    Set::add(a[i]);
  }
 
  a1num = 0;
  for (int i = 1; i <= n; ++ i) {
    std::cin >> b[i];
    sorta[i] = a[i];
    if (b[i] == 1) sorta1[++ a1num] = a[i];
  }
  std::sort(sorta + 1, sorta + n + 1);
  std::sort(sorta1 + 1, sorta1 + a1num + 1);
  for (int i = 1; i <= a1num; ++ i) sum[i] = sorta1[i] + sum[i - 1];
}
LL solveb1(int pos_) {
  Set::del(a[pos_]);
  LL ret = Set::get_middle();
  Set::add(a[pos_]);
  return ret;
}
LL solveb0(int pos_) {
  LL ret = 0;
  int middle = (n - 1) / 2 + 1;
 
  for (LL l = 1, r = kMaxa; l <= r; ) {
    LL mid = (l + r) >> 1ll;
    int p1 = std::lower_bound(sorta1 + 1, sorta1 + a1num + 1, mid) - sorta1;
    int p2 = std::lower_bound(sorta + 1, sorta + n + 1, mid) - sorta;
    int c1 = p1 - 1, c2 = n - (p2 - 1) - (a[pos_] >= mid);
 
    if (c2 >= middle) {
      ret = mid;
      l = mid + 1;
      continue;
    }
 
    int need = middle - c2;
    if (need > c1) {
      r = mid - 1;
      continue;
    }
 
    if (1ll * sum[c1] - sum[c1 - need] + k < 1ll * need * mid) {
      r = mid - 1;
    } else {
      ret = mid;
      l = mid + 1;
    }
  }
  return ret;
}
//=============================================================
int main() {
  // freopen("1.txt", "r", stdin);
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  int T; std::cin >> T;
  while (T --) {
    init();
    LL ans = 0;
    for (int i = 1; i <= n; ++ i) {
      if (b[i] == 1) {
        ans = std::max(ans, 1ll * a[i] + k + solveb1(i));
      } else {
        ans = std::max(ans, 1ll * a[i] + solveb0(i));
      }
    }
    std::cout << ans << "\n";
  }
  return 0;
}

D

DP。

游戏题照例先先手玩下。以下称先手移动的仅能走边 $(i, i + 1)$ 的牛牛为先手，另一牛牛为后手。边 $(i, i + 1)$ 称为杂鱼边，其他边称为牛逼边。

发现考虑先手必胜需要大力枚举起点比较麻烦，于是取个反考虑起点固定为 1 的后手必胜。

发现对于某个先手的起点 $s$ ，后手必胜的充要条件是存在一条牛逼边 $(u, v)$ ，满足：

$s > u$ ，使得先手不会把岛屿 $u$ 干掉。
记 $f_u$ 为后手从 1 到 $u$ 的最短路的长度，有 $s < v - (f_{u} + 1)$ ，使得后手可以比先手更早地到达 $v$ ，将先手到达终点的必经之路干掉。

于是考虑拓扑排序 DP 求得从 1 到每个节点的最短路径，在此过程中对于每个节点 $u$ 枚举所有出边 $(u, v)$ ，则对于先手的起点 $s\in [u + 1, v - (f_{u} + 1) - 1]$ 均为后手必胜的，可通过差分维护。

最后还原答案序列输出即可，总时间复杂度 $O(n + m)$ 级别。

虽然赛时懒得想了真的写了拓扑排序但实际上并无必要，拓扑序实际上即 $1\sim n$ ，直接大力枚举即可。

 //
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
const int kN = 2e5 + 10;
//=============================================================
int n, m;
int edgenum, into[kN], head[kN], v[kN << 1], ne[kN << 1];
int ans[kN], f[kN];
//=============================================================
void addedge(int u_, int v_) {
  v[++ edgenum] = v_;
  ne[edgenum] = head[u_];
  head[u_] = edgenum;
 
  ++ into[v_];
}
void topsort() {
  std::queue<int> q;
  for (int i = 1; i <= n; ++ i) f[i] = kN;
  f[1] = 0;
  q.push(1);
 
  while (!q.empty()) {
    int u_ = q.front(); q.pop();
    for (int i = head[u_]; i; i = ne[i]) {
      int v_ = v[i];
      f[v_] = std::min(f[v_], f[u_] + 1);
      int l = u_ + 1, r = v_ - (f[u_] + 1) - 1;
      if (l <= r) ++ ans[l], -- ans[r + 1];
 
      if (!(-- into[v_])) q.push(v_);
    }
  }
}
//=============================================================
int main() {
  //freopen("1.txt", "r", stdin);
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  int T; std::cin >> T;
  while (T --) {
    std::cin >> n >> m;
    edgenum = 0;
    for (int i = 1; i <= n; ++ i) head[i] = into[i] = ans[i] = 0;
    for (int i = 1; i < n; ++ i) addedge(i, i + 1);
    for (int i = 1; i <= m; ++ i) {
      int u_, v_; std::cin >> u_ >> v_;
      addedge(u_, v_);
    }
    topsort();
    for (int i = 1; i < n; ++ i) {
      ans[i] += ans[i - 1];
      std::cout << (ans[i] <= 0);
    }
    std::cout << "\n";
  }
  return 0;
}
/*
1
15 3
2 8
4 9
8 15
 
11000111000111
12345678901234
*/

E1

枚举，分治，笛卡尔树

妈的什么东西怎么开局十分钟就有光速过的呃呃，赛后一看我草这直接上笛卡尔树就做完了还是线性的，写完 D 时间不够了就直接下班了没看亏炸呃呃

题意实际上即不断地选择相邻的两个数，并将他们合并到较大的数上，直到只剩一个位置，并检查有哪些位置可作为最终剩下的位置。

显然原数列中最大值的位置一定合法；又发现若位置 $i$ 合法且位置 $j$ 满足 $a_j < a_i$ 且可以通过合并使得合并后 $a'_j \ge a_i$ 且此时 $a'_j$ 与 $a_i$ 相邻，则对位置 $i$ 的操作可以同样地对 $j$ 进行，从而将 $a_i$ 完全合并到 $a'_j$ 中，则最终也可只剩下 $a'_j$ 一个元素推导出位置 $j$ 也合法。

则一个显然的想法是按照权值递减的顺序枚举位置 $j$ ，检查该位置能否通过仅与不大于 $a_j$ 的 $a_k$ 合并，使其变为最大的 $a'_j$ ，使得存在 $a'_j \ge a_i > a_j$ ，且合并后 $a'_j$ 与 $a_i$ 相邻，即可通过位置 $i$ 是否合法递推位置 $j$ 是否合法。

考虑对于某个位置 $j$ 应当如何操作变为最大的 $a'_j$ 。由于仅能相邻的两个数合并，记位置 $j$ 左右两侧第一个大于 $a_j$ 的位置分别为 $L_i, R_i$ ，则其最大合并范围为 $[L_i + 1, R_i - 1]$ 。于是仅需检查 $\sum\limits_{L_i + 1 \le k \le R_i - 1} a_i \ge a_{L_i}$ 和 $\sum\limits_{L_i + 1 \le k \le R_i - 1} a_i \ge a_{R_i}$ 是否成立，若成立则若 $L_i, R_i$ 合法 $j$ 也一定合法即可进行递推。

发现按上述递减枚举元素，并求左右两侧第一个大于该元素的过程，可以看做不断地取区间 $[L, R]$ 的最值 $a_{\operatorname{maxp}}$ ，并将区间以 $\operatorname{maxp}$ 为界分治为两部分 $[L, \operatorname{maxp} - 1],[\operatorname{maxp} + 1, R]$ ，则两部分内权值均不大于 $a_{L - 1}, a_{R + 1}, a_{\operatorname{maxp}}$ ，且有 $a_{\operatorname{maxp}} = \min(a_{L - 1}, a_{R + 1})$ 。于是仅需递归地分治判断子区间之和是否不小于 $a_{\operatorname{maxp}}$ ，若不小于则子区间内的最值的位置 $\operatorname{maxp}'$ 即满足上述可以递推的条件，则可通过 $\operatorname{maxp}$ 是否合法递推。

这个过程显然可以直接放到笛卡尔树上进行。笛卡尔树上节点与区间最值位置一一对应，按照权值递减建立笛卡尔树后，初始化全局最大值位置合法，dfs 维护对应区间 $[L, R]$ ，比较 $[L, R]$ 之和与父节点的最值 $a_{\operatorname{maxp}}$ 的权值大小关系，即可不断地递推当前节点最值位置 $\operatorname{maxp}'$ 是否合法。

代码非常好写，复杂度 $O(n)$ 级别跑得飞快：https://codeforces.com/contest/1998/submission/275679413。

 //
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
const int kN = 2e5 + 10;
const LL kInf = 1e18 + 2077;
//=============================================================
int n, x, yes[kN];
LL a[kN], sum[kN];
int rt, son[kN][2];
int top, st[kN];
//=============================================================
void dfs(int u_, int fa_, int l_, int r_) {
  LL s = sum[r_ - 1] - sum[l_];
  if (s >= a[fa_]) yes[u_] |= yes[fa_];
  if (son[u_][0]) dfs(son[u_][0], u_, l_, u_); 
  if (son[u_][1]) dfs(son[u_][1], u_, u_, r_);
}
//=============================================================
int main() {
  // freopen("1.txt", "r", stdin);
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  int T; std::cin >> T;
  while (T --) {
    std::cin >> n >> x;
    for (int i = 1; i <= n; ++ i) {
      std::cin >> a[i];
      sum[i] = sum[i - 1] + a[i];
    }
    a[0] = a[n + 1] = kInf;
    for (int i = 0; i <= n; ++ i) son[i][0] = son[i][1] = yes[i] = 0;
  
    st[top = 0] = 0;
    for (int i = 1; i <= n; ++ i) {
      while (top && a[st[top]] < a[i]) -- top;
      son[i][0] = son[st[top]][1], son[st[top]][1] = i;
      st[++ top] = i;
    }
    rt = st[1];
 
    yes[rt] = 1;
    dfs(rt, 0, 0, n + 1);
    int ans = 0;
    for (int i = 1; i <= n; ++ i) if (yes[i]) ++ ans;
    std::cout << ans << "\n";
  }
  return 0;
}

E2

枚举，分治，笛卡尔树。

我有一个极其优美的笛卡尔树做法！而且跑得飞快！

同样考虑笛卡尔树。一个显然的想法是在线性建笛卡尔树过程中，对于每个前缀对应的笛卡尔树套用上述做法。显然不行呃呃这就变 $O(n^2)$ 了铁过不去。于是考虑细致地观察 E1 中做法得到的合法位置，在笛卡尔树中呈现什么形态：

一定是以笛卡尔树根为根的，连通的树形的连通块；
每对连通的父子节点间满足：子节点对应区间之和，不小于父节点对应的最值。
答案即为该连通块的大小。

考虑在线性建立笛卡尔树过程中，维护上述以笛卡尔树根为根的，连通的树形的连通块。线性建立笛卡尔树过程中实际上是在维护笛卡尔树的右链，则容易发现，每次新增一个节点时，仅会影响右链上连通块的形态，已遍历过的左侧部分完全不会受影响，于是仅需考虑每次加点对右链上的连通性的影响。

连通性实际上即区间之和与父节点对应最值的大小关系，又区间之和仅会单调递增，加点过程中不会出现失去连通性的情况，于是考虑使用并查集维护连通性，当某个子节点区间之和大于父节点对应最值时，则将它们 merge 起来，并记 merge 后祖先为子节点，也即对应右链上深度较深的节点。

然后基于上述分析，考虑在建树过程中加入 $a_i$ 时如何维护右链：

为保证右链的性质，先将右链上小于 $a_i$ 的点全部弹出。
检查是否有 $a_i$ 的左儿子 $\operatorname{lson}$ 对应区间和不小于 $a_i$ ，若是则将 $\operatorname{lson}$ 与 $i$ merge 起来。
此时右链上所有节点对应区间之和均会增大 $a_i$ ，考虑直接从根暴力下跳右链上的连通块，在此过程中检查相邻连通块之间，是否有子节点对应区间之和不小于父节点对应的最值，若是则可以建立它们之间的连通性，将他们 merge 起来即可。

可以证明：并查集合并后，右链上相邻的连通块 $(u, v)$ 之间一定有： $v$ 的顶部节点对应区间和小于 $u$ 的底部节点最值 $a_u$ 。则可知右链上连通块的个数一定不会超过 $O(\log_2 v)$ 级别，当且仅当右链上最值形如： $2^0 \rightarrow 2^1 \rightarrow 2^2\rightarrow \cdots \rightarrow 2^{\log_2 v}$ 时达到上界。则每次暴跳更新右链信息的复杂度上界仅为 $O(\log v)$ 级别，

此时直接查询根节点所在连通块大小即为答案。

总复杂度 $O(n\log v)$ 级别，但是常数超级小跑得飞快：https://codeforces.com/contest/1998/submission/275684758。

 //
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
const int kN = 2e5 + 10;
const LL kInf = 1e18 + 2077;
//=============================================================
int n, x, ans[kN];
LL a[kN], sum[kN];
int fa[kN], sz[kN], son[kN][2];
int top, st[kN];
//=============================================================
int find(int x_) {
  return (fa[x_] == x_) ? (x_) : (fa[x_] = find(fa[x_]));
}
void merge(int u_, int v_) {
  int fu = find(u_), fv = find(v_);
  if (fu == fv) return ;
  fa[fu] = fv;
  sz[fv] += sz[fu];
}
//=============================================================
int main() {
  // freopen("1.txt", "r", stdin);
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  int T; std::cin >> T;
  while (T --) {
    std::cin >> n >> x;
    for (int i = 1; i <= n; ++ i) {
      std::cin >> a[i];
      sum[i] = sum[i - 1] + a[i];
    }
    a[0] = a[n + 1] = kInf;
    for (int i = 0; i <= n; ++ i) {
      son[i][0] = son[i][1] = ans[i] = 0;
      fa[i] = i, sz[i] = 1;
    }
    st[top = 0] = 0;
    for (int i = 1; i <= n; ++ i) {
      while (top && a[st[top]] < a[i]) -- top;
      son[i][0] = son[st[top]][1], son[st[top]][1] = i;
 
      if (son[i][0] && sum[i - 1] - sum[st[top]] >= a[i]) merge(son[i][0], i);
      st[++ top] = i;
      
      int f = find(st[1]), u = son[f][1];
      while (u) {
        if (sum[i] - sum[f] >= a[f]) merge(f, u);
        f = find(u), u = son[f][1];
      }
      ans[i] = sz[find(st[1])];
    }
 
    for (int i = 1; i <= n; ++ i) std::cout << ans[i] << " ";
    std::cout << "\n";
  }
  return 0;
}

写在最后

学到了什么：

C：想好在写！别看到什么求什么数量啊 k 大值啊就高潮了光速拉个板子过来改了改发现还歹删了唐氏得一批
E1/E2：发现维护过程与某些经典数据结构类似，考虑能否直接扔到上面跑。

你说的对按照常理来说现在又是夹带私货环节，为师已经迫不及待地要看 C104 的【中国翻訳】了口牙

结尾广告：中南大学 ACM 集训队绝赞招新中！

有信息奥赛基础，获得 NOIP 省一等奖并达到 Codeforces rating 1900+ 或同等水平及以上者，可以直接私聊我与校队队长联系，免选拔直接进校集训队参加区域赛！

没有达到该水平但有志于 XPCX 赛事请关注每学年开始的 ACM 校队招新喵！

到这个时候了还缺队友实在不妙！求求求求快来个大神带我呜呜呜呜

posted @ 2024-08-11 01:35 Luckyblock 阅读(956) 评论(1) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 2024牛客暑期多校训练营6

· Codeforces Round 958 (Div. 2)

· 专项训练2

· 【补题】CF I

· Codeforces Round 967 (Div. 2)

阅读排行：
· 地球OL攻略 —— 某应届生求职总结
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 提示词工程——AI应用必不可少的技术
· .NET周刊【3月第1期 2025-03-02】

公告

MathJax 渲染格式改为 SVG，缩放倍率调至 125%，可获得更好的阅读效果。

博客首页仅显示部分高质量博文，大部分博文都位于随笔分类中。请善用下方的搜索功能。

大部分博文密码为某大质数。

昵称： Luckyblock
园龄： 5年6个月
粉丝： 244
关注： 150

+加关注

Luckyblock

身与华落，心将香飞

Codeforces Round 965 (Div. 2)

写在前面

A

B

C

D

E1

E2

写在最后

公告

搜索

积分与排名

随笔分类 (531)

相册 (32)

友链

阅读排行榜

最新评论

	//
	/*
	By:Luckyblock
	*/
	#include <bits/stdc++.h>
	#define LL long long
	//=============================================================
	//=============================================================
	//=============================================================
	int main() {
	//freopen("1.txt", "r", stdin);
	std::ios::sync_with_stdio(0), std::cin.tie(0);
	int T; std::cin >> T;
	while (T --) {
	int xc, yc, k; std::cin >> xc >> yc >> k;
	for (int i = 1; i <= k - k % 2; i += 2) {
	std::cout << xc + (i / 2 + 1) << " " << yc << "\n";
	std::cout << xc - (i / 2 + 1) << " " << yc << "\n";
	}
	if (k % 2) std::cout << xc << " " << yc << "\n";
	}
	return 0;
	}