WF 2019

A

把价格相同的瓷砖分为一类然后按序贪心匹配，注意要用小的集合匹配大的集合。

#include <bits/stdc++.h>

#define IL __inline__ __attribute__((always_inline))

#define For(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++ i)
#define FOR(i, a, b) for (int i = (a), i##end = (b); i < i##end; ++ i)
#define Rep(i, a, b) for (int i = (a), i##end = (b); i >= i##end; -- i)
#define REP(i, a, b) for (int i = (a) - 1, i##end = (b); i >= i##end; -- i)

typedef long long LL;

template <class T>
IL bool chkmax(T &a, const T &b) {
  return a < b ? ((a = b), 1) : 0;
}

template <class T>
IL bool chkmin(T &a, const T &b) {
  return a > b ? ((a = b), 1) : 0;
}

template <class T>
IL T mymax(const T &a, const T &b) {
  return a > b ? a : b;
}

template <class T>
IL T mymin(const T &a, const T &b) {
  return a < b ? a : b;
}

template <class T>
IL T myabs(const T &a) {
  return a > 0 ? a : -a;
}

const int INF = 0X3F3F3F3F;
const double EPS = 1E-8, PI = acos(-1.0);

#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#define OK DEBUG("Passing [%s] in LINE %d...\n", __FUNCTION__, __LINE__)

const int MAXN = 500000 + 5;

struct Item {
  int h, val, idx;

  friend bool operator<(const Item &a, const Item &b) {
    return a.h == b.h ? a.idx < b.idx : a.h < b.h;
  }
} a[MAXN], b[MAXN];

std::pair<int, int> answer[MAXN];

IL void GG() {
  puts("impossible");
  exit(0);
}

int main() {
  int n;
  scanf("%d", &n);
  For(i, 1, n) {
    a[i].idx = b[i].idx = i;
  }
  auto comp = [](const Item &a, const Item &b) {
    return a.val < b.val;
  };
  For(i, 1, n) {
    scanf("%d", &b[i].val);
  }
  For(i, 1, n) {
    scanf("%d", &b[i].h);
  }
  std::sort(b + 1, b + n + 1, comp);
  For(i, 1, n) {
    scanf("%d", &a[i].val);
  }
  For(i, 1, n) {
    scanf("%d", &a[i].h);
  }
  std::sort(a + 1, a + n + 1, comp);
  std::set<Item> x, y;
  int cur_x = 1, cur_y = 1;
  For(i, 1, n) {
    if (x.empty()) {
      int cost = a[cur_x].val;
      for (; a[cur_x].val == cost; x.insert(a[cur_x ++]));
    }
    if (y.empty()) {
      int cost = b[cur_y].val;
      for (; b[cur_y].val == cost; y.insert(b[cur_y ++]));
    }
    if (x.size() <= y.size()) {
      auto dx = x.begin(), dy = y.upper_bound({dx->h, dx->val, INF});
      if (dy == y.end()) {
        GG();
      }
      answer[i] = {dx->idx, dy->idx};
      x.erase(dx), y.erase(dy);
    } else {
      auto dy = y.begin(), dx = x.lower_bound({dy->h, dy->val, 0});
      if (dx == x.begin()) {
        GG();
      }
      -- dx;
      answer[i] = {dx->idx, dy->idx};
      x.erase(dx), y.erase(dy);
    }
  }
  For(i, 1, n) {
    printf("%d ", answer[i].second);
  }
  puts("");
  For(i, 1, n) {
    printf("%d ", answer[i].first);
  }
  puts("");
  return 0;
}

B

把半圆剖成两半，对每个点求出左半圆和右半圆最远能到什么地方，这样就可以$O(1)$判断一个拱形是否合法，然后$O(n^2)\text{dp}$即可。

#include <bits/stdc++.h>

#define IL __inline__ __attribute__((always_inline))

#define For(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++ i)
#define FOR(i, a, b) for (int i = (a), i##end = (b); i < i##end; ++ i)
#define Rep(i, a, b) for (int i = (a), i##end = (b); i >= i##end; -- i)
#define REP(i, a, b) for (int i = (a) - 1, i##end = (b); i >= i##end; -- i)

typedef long long LL;

template <class T>
IL bool chkmax(T &a, const T &b) {
  return a < b ? ((a = b), 1) : 0;
}

template <class T>
IL bool chkmin(T &a, const T &b) {
  return a > b ? ((a = b), 1) : 0;
}

template <class T>
IL T mymax(const T &a, const T &b) {
  return a > b ? a : b;
}

template <class T>
IL T mymin(const T &a, const T &b) {
  return a < b ? a : b;
}

template <class T>
IL T myabs(const T &a) {
  return a > 0 ? a : -a;
}

const int INF = 0X3F3F3F3F;
const double EPS = 1E-8, PI = acos(-1.0);

#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#define OK DEBUG("Passing [%s] in LINE %d...\n", __FUNCTION__, __LINE__)

const int MAXN = 10000 + 5;

int cd[MAXN], het[MAXN];
double left[MAXN], right[MAXN];
LL f[MAXN];

int main() {
  int n, h;
  LL x, y;
  scanf("%d%d%lld%lld", &n, &h, &x, &y);
  For(i, 1, n) {
    scanf("%d%d", &cd[i], &het[i]);
  }
  auto getR = [](double a, double b, double c) {
    return sqrt(2.0 * a * (b - c)) + a + b - c;
  };
  For(i, 1, n) {
    left[i] = -INF;
    Rep(j, i, 1) {
      chkmax(left[i], mymin((double)cd[j], cd[i] - 2.0 * getR(cd[i] - cd[j], h, het[j])));
    }
    right[i] = INF;
    For(j, i, n) {
      chkmin(right[i], mymax((double)cd[j], cd[i] + 2.0 * getR(cd[j] - cd[i], h, het[j])));
    }
  }
  memset(f, 0X3F, sizeof f);
  f[1] = x * (h - het[1]);
  For(i, 2, n) {
    REP(j, i, 1) {
      if (left[i] <= cd[j] && right[j] >= cd[i]) {
        chkmin(f[i], f[j] + x * (h - het[i]) + y * (cd[i] - cd[j]) * (cd[i] - cd[j]));
      }
    }
  }
  if (f[n] >= (LL)INF * INF) {
    puts("impossible");
    exit(0);
  }
  printf("%lld\n", f[n]);
  return 0;
}

 C

爆搜。先假定没有棋子，然后逐个按操作需要填，注意不能吃的时候封锁的棋子有两种可能。状态数实际上非常少，所以跑的很快。

考场上谁爱写谁写。

#include <bits/stdc++.h>

#define IL __inline__ __attribute__((always_inline))

#define For(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++ i)
#define FOR(i, a, b) for (int i = (a), i##end = (b); i < i##end; ++ i)
#define Rep(i, a, b) for (int i = (a), i##end = (b); i >= i##end; -- i)
#define REP(i, a, b) for (int i = (a) - 1, i##end = (b); i >= i##end; -- i)

typedef long long LL;

template <class T>
IL bool chkmax(T &a, const T &b) {
  return a < b ? ((a = b), 1) : 0;
}

template <class T>
IL bool chkmin(T &a, const T &b) {
  return a > b ? ((a = b), 1) : 0;
}

template <class T>
IL T mymax(const T &a, const T &b) {
  return a > b ? a : b;
}

template <class T>
IL T mymin(const T &a, const T &b) {
  return a < b ? a : b;
}

template <class T>
IL T myabs(const T &a) {
  return a > 0 ? a : -a;
}

const int INF = 0X3F3F3F3F;
const double EPS = 1E-8, PI = acos(-1.0);

#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#define OK DEBUG("Passing [%s] in LINE %d...\n", __FUNCTION__, __LINE__)

const int MAXN = 30 + 5, MAXM = 100 + 5;
const char F[5] = {0, 'w', 'W', 'b', 'B'};

enum {
  MAX = 32
};

typedef int State[MAXN];

State chess[MAXM]; // -1->unknown,0->empty,1->white,2->white_queen,3->black,4->black_queen
int middle[MAXN][MAXN], origin[MAXN], n;
bool type[MAXN]; // type:left->0,right->1
std::vector<std::pair<int, int>> trans_w[MAXN], trans_b[MAXN], trans_q[MAXN]; // capture:white,black,queen

struct Op {
  int type, start, end;
  std::vector<int> to;
} oper[MAXM];

IL void initTrans() {
  for (int i = 1; i <= MAX; i += 8) {
    type[i] = type[i + 1] = type[i + 2] = type[i + 3] = 1;
  }
  For(i, 1, MAX) {
    if (i > 8 && i % 4) {
      int x = type[i] ? i - 3 : i - 4;
      middle[i][i - 7] = x;
      trans_w[i].emplace_back(x, i - 7);
      trans_q[i].emplace_back(x, i - 7);
    } // right up capture
    if (i > 8 && (i - 1) % 4) {
      int x = type[i] ? i - 4 : i - 5;
      middle[i][i - 9] = x;
      trans_w[i].emplace_back(x, i - 9);
      trans_q[i].emplace_back(x, i - 9);
    } // left up capture
    if (i <= 24 && i % 4) {
      int x = type[i] ? i + 5 : i + 4;
      middle[i][i + 9] = x;
      trans_b[i].emplace_back(x, i + 9);
      trans_q[i].emplace_back(x, i + 9);
    } // right down capture
    if (i <= 24 && (i - 1) % 4) {
      int x = type[i] ? i + 4 : i + 3;
      middle[i][i + 7] = x;
      trans_b[i].emplace_back(x, i + 7);
      trans_q[i].emplace_back(x, i + 7);
    } // left down capture
  }
}

int DFS(int cur, bool p, std::vector<int> &wyp) { // -1:back to start,0:success,1:failure
  if (cur > n) {
    return 0;
  }
  memcpy(chess[cur], chess[cur - 1], sizeof chess[cur]);
  std::vector<int> waiting_l;
  if (p) { // black
    if (!~chess[cur][oper[cur].start]) {
      chess[0][oper[cur].start] = 3 + (oper[cur].start > 28);
      return -1;
    }
    if (chess[cur][oper[cur].start] <= 2) {
      return 1;
    }
    if (oper[cur].type) {
      int pos = oper[cur].start;
      for (auto &x : oper[cur].to) {
        if ((pos > 28 || x < pos) && chess[cur][pos] == 3) {
          chess[0][origin[pos]] = 4;
          return -1;
        }
        int wxh = middle[pos][x];
        if (!~chess[cur][wxh]) {
          chess[0][wxh] = 1;
          return -1;
        }
        if ((chess[cur][wxh] != 1 && chess[cur][wxh] != 2) || chess[cur][x] > 0) {
          return 1;
        }
        chess[cur][x] = chess[cur][pos];
        chess[cur][wxh] = chess[cur][pos] = 0;
        origin[x] = origin[pos];
        origin[wxh] = origin[pos] = 0;
        pos = x;
      }
      if (pos > 28 && chess[cur][pos] == 3) {
        chess[cur][pos] = 4;
      } else {
        for (auto &x : chess[cur][pos] == 3 ? trans_b[pos] : trans_q[pos]) {
          if (chess[cur][x.first] == 1 || chess[cur][x.first] == 2) {
            if (!chess[cur][x.second]) {
              return 1;
            } else if (!~chess[cur][x.second]) {
              waiting_l.push_back(x.second);
            }
          }
        }
      }
    } else {
      For(i, 1, MAX) {
        if (chess[cur][i] == 3 || chess[cur][i] == 4) {
          for (auto &x : chess[cur][i] == 3 ? trans_b[i] : trans_q[i]) {
            if (chess[cur][x.first] == 1 || chess[cur][x.first] == 2) {
              if (!chess[cur][x.second]) {
                return 1;
              } else if (!~chess[cur][x.second]) {
                waiting_l.push_back(x.second);
              }
            }
          }
        }
      }
      int s = oper[cur].start, e = oper[cur].end;
      if (chess[cur][e] > 0) {
        return 1;
      }
      if (chess[cur][s] == 3 && s > e) {
        chess[0][origin[s]] = 4;
        return -1;
      }
      if (e > 28) {
        chess[cur][s] = 4;
      }
      chess[cur][e] = chess[cur][s];
      chess[cur][s] = 0;
      origin[e] = origin[s];
      origin[s] = 0;
    }
  } else { // white
    if (!~chess[cur][oper[cur].start]) {
      chess[0][oper[cur].start] = 1 + (oper[cur].start <= 4);
      return -1;
    }
    if (!chess[cur][oper[cur].start] || chess[cur][oper[cur].start] >= 3) {
      return 1;
    }
    if (oper[cur].type) {
      int pos = oper[cur].start;
      for (auto &x : oper[cur].to) {
        if ((pos <= 4 || x > pos) && chess[cur][pos] == 1) {
          chess[0][origin[pos]] = 2;
          return -1;
        }
        int wxh = middle[pos][x];
        if (!~chess[cur][wxh]) {
          chess[0][wxh] = 3;
          return -1;
        }
        if ((chess[cur][wxh] != 3 && chess[cur][wxh] != 4) || chess[cur][x] > 0) {
          return 1;
        }
        chess[cur][x] = chess[cur][pos];
        chess[cur][wxh] = chess[cur][pos] = 0;
        origin[x] = origin[pos];
        origin[wxh] = origin[pos] = 0;
        pos = x;
      }
      if (pos <= 4 && chess[cur][pos] == 1) {
        chess[cur][pos] = 2;
      } else {
        for (auto &x : chess[cur][pos] == 1 ? trans_w[pos] : trans_q[pos]) {
          if (chess[cur][x.first] == 3 || chess[cur][x.first] == 4) {
            if (!chess[cur][x.second]) {
              return 1;
            } else if (!~chess[cur][x.second]) {
              waiting_l.push_back(x.second);
            }
          }
        }
      }
    } else {
      For(i, 1, MAX) {
        if (chess[cur][i] == 1 || chess[cur][i] == 2) {
          for (auto &x : chess[cur][i] == 1 ? trans_w[i] : trans_q[i]) {
            if (chess[cur][x.first] == 3 || chess[cur][x.first] == 4) {
              if (!chess[cur][x.second]) {
                return 1;
              } else if (!~chess[cur][x.second]) {
                waiting_l.push_back(x.second);
              }
            }
          }
        }
      }
      int s = oper[cur].start, e = oper[cur].end;
      if (chess[cur][e] > 0) {
        return 1;
      }
      if (chess[cur][s] == 1 && s < e) {
        chess[0][origin[s]] = 2;
        return -1;
      }
      if (e <= 4) {
        chess[cur][s] = 2;
      }
      chess[cur][e] = chess[cur][s];
      chess[cur][s] = 0;
      origin[e] = origin[s];
      origin[s] = 0;
    }
  }
  if (waiting_l.empty()) {
    return DFS(cur + 1, !p, wyp);
  } else {
    wyp = waiting_l;
    return -1;
  }
}

bool getChess(bool p, const std::vector<int> &dxd) {
  int cur[MAXN];
  memcpy(cur, chess[0], sizeof cur);
  FOR(S, 0, 1 << dxd.size()) {
    std::vector<int> tp;
    FOR(i, 0, dxd.size()) {
      chess[0][dxd[i]] = (S & (1 << i)) ? 1 : 3;
      if ((chess[0][dxd[i]] == 1 && dxd[i] <= 4) || (chess[0][dxd[i]] == 3 && dxd[i] > 28)) {
        ++ chess[0][dxd[i]];
      }
    }
    while (1) {
      memset(origin, 0, sizeof origin);
      For(i, 1, MAX) {
        if (chess[0][i]) {
          origin[i] = i;
        }
      }
      int val = DFS(1, p, tp);
      if (!val) {
        return 1;
      }
      if (val == 1) {
        break;
      }
      if (!tp.empty()) {
        if (getChess(p, tp)) {
          return 1;
        }
        break;
      }
    }
  }
  memcpy(chess[0], cur, sizeof chess[0]);
  return 0;
}

int main() {
  initTrans();
  static char opt[MAXM];
  scanf("%s%d", opt, &n);
  bool s = opt[0] == 'B';
  For(i, 1, n) {
    scanf("%s", opt);
    int len = strlen(opt), num = 0;
    bool tp = 0;
    FOR(j, 0, len) {
      if (isdigit(opt[j])) {
        num = num * 10 + opt[j] - '0';
      } else if (opt[j] == 'x') {
        tp = 1;
        if (!oper[i].start) {
          oper[i].start = num;
        } else {
          oper[i].to.push_back(num);
        }
        num = 0;
      } else {
        oper[i].start = num;
        num = 0;
      }
    }
    if (tp) {
      oper[i].to.push_back(num);
    } else {
      oper[i].end = num;
    }
    oper[i].type = tp;
  }
  memset(chess[0], -1, sizeof chess[0]);
  getChess(s, std::vector<int>());
  For(i, 1, 8) {
    if (i & 1) {
      For(j, (i - 1) * 4 + 1, i * 4) {
        putchar('-');
        putchar(chess[0][j] <= 0 ? '.' : F[chess[0][j]]);
      }
      putchar(' ');
      For(j, (i - 1) * 4 + 1, i * 4) {
        putchar('-');
        putchar(chess[n][j] <= 0 ? '.' : F[chess[n][j]]);
      }
      putchar('\n');
    } else {
      For(j, (i - 1) * 4 + 1, i * 4) {
        putchar(chess[0][j] <= 0 ? '.' : F[chess[0][j]]);
        putchar('-');
      }
      putchar(' ');
      For(j, (i - 1) * 4 + 1, i * 4) {
        putchar(chess[n][j] <= 0 ? '.' : F[chess[n][j]]);
        putchar('-');
      }
      putchar('\n');
    }
  }
  return 0;
}

 D

把每一个基因类抽出来，可以发现是一个括号序列，扫一遍，线段树维护前缀和最小值即可。

（实际上对每一个类单独考虑合法位置之后差分即可做到线性，我数据结构学傻了.jpg

#include <bits/stdc++.h>

#define IL __inline__ __attribute__((always_inline))

#define For(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++ i)
#define FOR(i, a, b) for (int i = (a), i##end = (b); i < i##end; ++ i)
#define Rep(i, a, b) for (int i = (a), i##end = (b); i >= i##end; -- i)
#define REP(i, a, b) for (int i = (a) - 1, i##end = (b); i >= i##end; -- i)

typedef long long LL;

template <class T>
IL bool chkmax(T &a, const T &b) {
  return a < b ? ((a = b), 1) : 0;
}

template <class T>
IL bool chkmin(T &a, const T &b) {
  return a > b ? ((a = b), 1) : 0;
}

template <class T>
IL T mymax(const T &a, const T &b) {
  return a > b ? a : b;
}

template <class T>
IL T mymin(const T &a, const T &b) {
  return a < b ? a : b;
}

template <class T>
IL T myabs(const T &a) {
  return a > 0 ? a : -a;
}

const int INF = 0X3F3F3F3F;
const double EPS = 1E-8, PI = acos(-1.0);

#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#define OK DEBUG("Passing [%s] in LINE %d...\n", __FUNCTION__, __LINE__)

const int MAXN = 1000000 + 5;

struct SegmentTree {
  int *min, *tag;

#define lc (o << 1)
#define rc (o << 1 | 1)
  void pushUp(int o) {
    min[o] = mymin(min[lc], min[rc]);
  }

  void pushDown(int o) {
    if (tag[o]) {
      min[lc] += tag[o], tag[lc] += tag[o];
      min[rc] += tag[o], tag[rc] += tag[o];
      tag[o] = 0;
    }
  }

  void build(int o, int l, int r) {
    min[o] = INF, tag[o] = 0;
    if (l == r) {
      return;
    }
    int mid = (l + r) >> 1;
    build(lc, l, mid);
    build(rc, mid + 1, r);
  }

  void modify(int o, int l, int r, int p, int x) {
    if (l == r) {
      min[o] = x;
      return;
    }
    int mid = (l + r) >> 1;
    pushDown(o);
    if (p <= mid) {
      modify(lc, l, mid, p, x);
    } else {
      modify(rc, mid + 1, r, p, x);
    }
    pushUp(o);
  }

  void modify(int o, int l, int r, int a, int b, int x) {
    if (l >= a && r <= b) {
      min[o] += x, tag[o] += x;
      return;
    }
    int mid = (l + r) >> 1;
    pushDown(o);
    if (a <= mid) {
      modify(lc, l, mid, a, b, x);
    }
    if (b > mid) {
      modify(rc, mid + 1, r, a, b, x);
    }
    pushUp(o);
  }

  int query(int o, int l, int r, int a, int b) {
    if (l >= a && r <= b) {
      return min[o];
    }
    int mid = (l + r) >> 1, answer = INF;
    pushDown(o);
    if (a <= mid) {
      chkmin(answer, query(lc, l, mid, a, b));
    }
    if (b > mid) {
      chkmin(answer, query(rc, mid + 1, r, a, b));
    }
    pushUp(o);
    return answer;
  }
} seg[MAXN];

std::pair<int, int> gene[MAXN];
std::vector<int> wxh;
int pos[MAXN], sum[MAXN], cnt[MAXN], cur[MAXN];

int main() {
  int n;
  scanf("%d", &n);
  For(i, 1, n) {
    static char opt[15];
    scanf("%s", opt);
    int len = strlen(opt);
    gene[i].second = opt[0] == 's' ? 1 : -1;
    FOR(j, 1, len) {
      gene[i].first = gene[i].first * 10 + opt[j] - '0';
    }
    pos[i] = ++ cnt[gene[i].first];
    sum[gene[i].first] += gene[i].second;
  }
  For(i, 1, n) {
    if (!sum[gene[i].first]) {
      int x = gene[i].first;
      if (!seg[x].min) {
        wxh.push_back(x);
        seg[x].min = new int[cnt[x] * 8 + 5], seg[x].tag = new int[cnt[x] * 8 + 5];
        seg[x].build(1, 1, cnt[x] * 2);
      }
      seg[x].modify(1, 1, cnt[x] * 2, pos[i], cur[x] += gene[i].second);
    }
  }
  int answer = 0, result = 1;
  for (auto &x : wxh) {
    answer += !seg[x].min[1];
  }
  int cur = answer;
  FOR(i, 1, n) {
    if (!sum[gene[i].first]) {
      int x = gene[i].first;
      cur -= !seg[x].query(1, 1, cnt[x] * 2, pos[i], pos[i] + cnt[x] - 1);
      seg[x].modify(1, 1, cnt[x] * 2, pos[i] + 1, pos[i] + cnt[x] - 1, -gene[i].second);
      seg[x].modify(1, 1, cnt[x] * 2, pos[i] + cnt[x], 0);
      cur += !seg[x].query(1, 1, cnt[x] * 2, pos[i] + 1, pos[i] + cnt[x]);
      if (chkmax(answer, cur)) {
        result = i + 1;
      }
    }
  }
  printf("%d %d\n", result, answer);
  return 0;
}

 E

可以发现一个边双里一定没有断头路，所以把边双缩起来之后在进一棵在原图上是树的子树时放标志即可，注意如果联通块是树需要特判（此时在所有叶子处放标志）。

#include <bits/stdc++.h>

#define IL __inline__ __attribute__((always_inline))

#define For(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++ i)
#define FOR(i, a, b) for (int i = (a), i##end = (b); i < i##end; ++ i)
#define Rep(i, a, b) for (int i = (a), i##end = (b); i >= i##end; -- i)
#define REP(i, a, b) for (int i = (a) - 1, i##end = (b); i >= i##end; -- i)

typedef long long LL;

template <class T>
IL bool chkmax(T &a, const T &b) {
  return a < b ? ((a = b), 1) : 0;
}

template <class T>
IL bool chkmin(T &a, const T &b) {
  return a > b ? ((a = b), 1) : 0;
}

template <class T>
IL T mymax(const T &a, const T &b) {
  return a > b ? a : b;
}

template <class T>
IL T mymin(const T &a, const T &b) {
  return a < b ? a : b;
}

template <class T>
IL T myabs(const T &a) {
  return a > 0 ? a : -a;
}

const int INF = 0X3F3F3F3F;
const double EPS = 1E-8, PI = acos(-1.0);

#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#define OK DEBUG("Passing [%s] in LINE %d...\n", __FUNCTION__, __LINE__)

const int MAXN = 500000 + 5;

struct Input {
  char buf[1 << 24], *st, *ed;
  
  Input() {
#ifndef ONLINE_JUDGE
    freopen("LOJ6581.in", "r", stdin);
#endif
  }
  
  char get() {
    if (st == ed) {
      ed = buf + fread(st = buf, 1, 1 << 24, stdin);
    }
    return *st ++;
  }
  
  friend Input &operator>>(Input &io, int &x) {
    x = 0;
    static char ch;
    while (!isdigit(ch = io.get()));
    do {
      x = x * 10 + ch - '0';
    } while (isdigit(ch = io.get()));
    return io;
  }
} cin;

int size[MAXN], bel[MAXN], deg[MAXN], bc[MAXN], fa[MAXN], bcc_cnt, con_cnt;
bool ok[MAXN], is_o[MAXN];
std::vector<int> adj[MAXN], pt[MAXN];
std::vector<std::pair<int, int>> dd[MAXN], answer;

IL void addEdge(int u, int v) {
  ++ deg[bel[v]];
  adj[bel[u]].push_back(bel[v]);
  dd[bel[u]].push_back({u, v});
}

void DFS1(int u) {
  pt[con_cnt].push_back(u);
  bc[u] = con_cnt;
  FOR(i, 0, adj[u].size()) {
    int v = adj[u][i];
    if (v != fa[u]) {
      fa[v] = u;
      DFS1(v);
    }
  }
}

bool DFS2(int u) {
  is_o[u] = size[u] != 1;
  FOR(i, 0, adj[u].size()) {
    int v = adj[u][i];
    if (v != fa[u]) {
      fa[v] = u;
      is_o[u] |= DFS2(v);
    }
  }
  return is_o[u];
}

void DFS3(int u) {
  FOR(i, 0, adj[u].size()) {
    int v = adj[u][i];
    if (v != fa[u]) {
      if (is_o[v]) {
        DFS3(v);
      } else {
        answer.push_back(dd[u][i]);
      }
    }
  }
}

struct Edge {
  int u, v;
} edge[MAXN];

struct Graph {
  int hed[MAXN], nxt[MAXN * 2], to[MAXN * 2], bridge[MAXN * 2], fa[MAXN], dfn[MAXN], low[MAXN], cnt, num;
  bool vis[MAXN];

  Graph() {
    cnt = 1;
  }

  void addEdge(int u, int v) {
    ++ cnt;
    to[cnt] = v;
    nxt[cnt] = hed[u];
    hed[u] = cnt;
  }

  void DFS1(int u) {
    low[u] = dfn[u] = ++ num;
    for (int e = hed[u]; e; e = nxt[e]) {
      int v = to[e];
      if (!dfn[v]) {
        fa[v] = u;
        DFS1(v);
        chkmin(low[u], low[v]);
        if (low[v] >= dfn[u]) {
          bridge[e] = bridge[e ^ 1] = 1;
        }
      } else if (v != fa[u]) {
        chkmin(low[u], dfn[v]);
      }
    }
  }

  void DFS2(int u, int k) {
    ++ size[k];
    bel[u] = k;
    vis[u] = 1;
    for (int e = hed[u]; e; e = nxt[e]) {
      int v = to[e];
      if (!bridge[e] && !vis[v]) {
        DFS2(v, k);
      }
    }
  }
} G;

int main() {
  int n, m;
  cin >> n >> m;
  For(i, 1, m) {
    cin >> edge[i].u >> edge[i].v;
    G.addEdge(edge[i].u, edge[i].v);
    G.addEdge(edge[i].v, edge[i].u);
  }
  For(i, 1, n) {
    if (!G.dfn[i]) {
      G.DFS1(i);
    }
  }
  For(i, 1, n) {
    if (!G.vis[i]) {
      G.DFS2(i, ++ bcc_cnt);
    }
  }
  For(i, 1, m) {
    if (bel[edge[i].u] != bel[edge[i].v]) {
      addEdge(edge[i].u, edge[i].v);
      addEdge(edge[i].v, edge[i].u);
    }
  }
  For(i, 1, bcc_cnt) {
    if (!bc[i]) {
      ++ con_cnt;
      DFS1(i);
    }
  }
  For(i, 1, bcc_cnt) {
    ok[bc[i]] |= size[i] != 1;
  }
  For(i, 1, con_cnt) {
    if (ok[i]) {
      for (auto &x : pt[i]) {
        if (size[x] > 1) {
          fa[x] = 0;
          DFS2(x);
          DFS3(x);
          break;
        }
      }
    } else {
      for (auto &x : pt[i]) {
        if (deg[x] == 1) {
          answer.push_back(dd[x].front());
        }
      }
    }
  }
  std::sort(answer.begin(), answer.end());
  printf("%u\n", answer.size());
  for (auto &x : answer) {
    printf("%d %d\n", x.first, x.second);
  }
  return 0;
}

 F

先把线段按从下往上的顺序拓扑排序，这个可以扫描线。

然后问题变成了这样：

初始有一个序列$V$，形如一段$\infty$接一段$0$再接一段$\infty$。

有$n$次操作，每次操作给定区间$[l,r]$，然后对于$i\in[l,r]$，将$V_i$变为$\min(V_l,1+\min_{j=l}^iV_j)$或$\min(V_r,1+\min_{j=i}^rV_j)$。

注意到这个序列一定是单谷的，所以可以用线段树维护。

#include <bits/stdc++.h>

#define IL __inline__ __attribute__((always_inline))

#define For(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++ i)
#define FOR(i, a, b) for (int i = (a), i##end = (b); i < i##end; ++ i)
#define Rep(i, a, b) for (int i = (a), i##end = (b); i >= i##end; -- i)
#define REP(i, a, b) for (int i = (a) - 1, i##end = (b); i >= i##end; -- i)

typedef long long LL;

template <class T>
IL bool chkmax(T &a, const T &b) {
  return a < b ? ((a = b), 1) : 0;
}

template <class T>
IL bool chkmin(T &a, const T &b) {
  return a > b ? ((a = b), 1) : 0;
}

template <class T>
IL T mymax(const T &a, const T &b) {
  return a > b ? a : b;
}

template <class T>
IL T mymin(const T &a, const T &b) {
  return a < b ? a : b;
}

template <class T>
IL T myabs(const T &a) {
  return a > 0 ? a : -a;
}

const int INF = 0X3F3F3F3F;
const double EPS = 1E-8, PI = acos(-1.0);

#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#define OK DEBUG("Passing [%s] in LINE %d...\n", __FUNCTION__, __LINE__)

const int MAXN = 1000000 + 5;

struct Input {
  char buf[1 << 25], *s;

  Input() {
    fread(s = buf, 1, 1 << 25, stdin);
  }

  friend Input &operator>>(Input &io, int &x) {
    x = 0;
    while (!isdigit(*io.s)) {
      ++ io.s;
    }
    while (isdigit(*io.s)) {
      x = x * 10 + *io.s ++ - '0';
    }
    return io;
  }
} cin;

struct Point {
  int x, y;

  Point() {}
  Point(int _x, int _y) : x(_x), y(_y) {}
};

std::pair<Point, Point> seg[MAXN], cc[MAXN];
std::vector<int> bg[MAXN * 2], ed[MAXN * 2];
int ts[MAXN * 2], L, R, cur;

struct Comp {
  double calc_c(int c, const std::pair<Point, Point> &s) {
    return (double)(c - s.first.x) / (s.first.x - s.second.x) * (s.first.y - s.second.y) + s.first.y;
  }

  bool operator()(int a, int b) {
    return calc_c(cur, cc[a]) < calc_c(cur, cc[b]);
  }
};

std::set<int, Comp> s;
std::vector<int> adj[MAXN];
int deg[MAXN], topo[MAXN];

struct SegmentTree {
  int min[MAXN * 8], pos[MAXN * 8], tag1[MAXN * 8], tag2[MAXN * 8];

  SegmentTree() {
    memset(tag2, -1, sizeof tag2);
  }

#define lc (o << 1)
#define rc (o << 1 | 1)
  void pushUp(int o) {
    min[o] = mymin(min[lc], min[rc]);
    if (min[lc] <= min[rc]) {
      pos[o] = pos[lc];
    } else {
      pos[o] = pos[rc];
    }
  }

  void pushDown(int o) {
    if (~tag2[o]) {
      min[lc] = tag2[o], tag1[lc] = 0, tag2[lc] = tag2[o];
      min[rc] = tag2[o], tag1[rc] = 0, tag2[rc] = tag2[o];
      tag2[o] = -1;
    }
    if (tag1[o]) {
      min[lc] += tag1[o], tag1[lc] += tag1[o];
      min[rc] += tag1[o], tag1[rc] += tag1[o];
      tag1[o] = 0;
    }
  }

  void build(int o, int l, int r) {
    if (l == r) {
      min[o] = l >= L && l <= R ? 0 : INF;
      pos[o] = l;
      return;
    }
    int mid = (l + r) >> 1;
    build(lc, l, mid);
    build(rc, mid + 1, r);
    pushUp(o);
  }

  void add(int o, int l, int r, int a, int b, int x) {
    if (a > b) {
      return;
    }
    if (l >= a && r <= b) {
      min[o] += x, tag1[o] += x;
      return;
    }
    int mid = (l + r) >> 1;
    pushDown(o);
    if (a <= mid) {
      add(lc, l, mid, a, b, x);
    }
    if (b > mid) {
      add(rc, mid + 1, r, a, b, x);
    }
    pushUp(o);
  }

  void set(int o, int l, int r, int a, int b, int x) {
    if (a > b) {
      return;
    }
    if (l >= a && r <= b) {
      min[o] = x, tag1[o] = 0, tag2[o] = x;
      return;
    }
    int mid = (l + r) >> 1;
    pushDown(o);
    if (a <= mid) {
      set(lc, l, mid, a, b, x);
    }
    if (b > mid) {
      set(rc, mid + 1, r, a, b, x);
    }
    pushUp(o);
  }

  std::pair<int, int> query_v(int o, int l, int r, int a, int b) {
    if (l >= a && r <= b) {
      return {min[o], pos[o]};
    }
    int mid = (l + r) >> 1;
    std::pair<int, int> answer(INF, INF);
    pushDown(o);
    if (a <= mid) {
      chkmin(answer, query_v(lc, l, mid, a, b));
    }
    if (b > mid) {
      chkmin(answer, query_v(rc, mid + 1, r, a, b));
    }
    return answer;
  }

  int query1(int o, int l, int r, int a, int b, int x) {
    if (l >= a && r <= b) {
      if (min[o] < x) {
        while (l != r) {
          int mid = (l + r) >> 1;
          pushDown(o);
          if (min[lc] < x) {
            o = lc, r = mid;
          } else {
            o = rc, l = mid + 1;
          }
        }
        return l;
      } else {
        return INF;
      }
    }
    int mid = (l + r) >> 1;
    pushDown(o);
    if (a <= mid) {
      int result = query1(lc, l, mid, a, b, x);
      if (result < INF) {
        return result;
      }
    }
    if (b > mid) {
      int result = query1(rc, mid + 1, r, a, b, x);
      if (result < INF) {
        return result;
      }
    }
    return INF;
  }

  int query2(int o, int l, int r, int a, int b, int x) {
    if (l >= a && r <= b) {
      if (min[o] < x) {
        while (l != r) {
          int mid = (l + r) >> 1;
          pushDown(o);
          if (min[rc] < x) {
            o = rc, l = mid + 1;
          } else {
            o = lc, r = mid;
          }
        }
        return l;
      } else {
        return -INF;
      }
    }
    int mid = (l + r) >> 1;
    pushDown(o);
    if (b > mid) {
      int result = query2(rc, mid + 1, r, a, b, x);
      if (result > -INF) {
        return result;
      }
    }
    if (a <= mid) {
      int result = query2(lc, l, mid, a, b, x);
      if (result > -INF) {
        return result;
      }
    }
    return -INF;
  }
} segt;

int main() {
  int n;
  cin >> L >> R >> n;
  int cnt = 0;
  ts[++ cnt] = L, ts[++ cnt] = R;
  For(i, 1, n) {
    cin >> seg[i].first.x >> seg[i].first.y >> seg[i].second.x >> seg[i].second.y;
    cc[i] = seg[i];
    ts[++ cnt] = seg[i].first.x, ts[++ cnt] = seg[i].second.x;
  }
  std::sort(ts + 1, ts + cnt + 1);
  cnt = std::unique(ts + 1, ts + cnt + 1) - 1 - ts;
  L = std::lower_bound(ts + 1, ts + cnt + 1, L) - ts, R = std::lower_bound(ts + 1, ts + cnt + 1, R) - ts;
  L <<= 1, R <<= 1;
  For(i, 1, n) {
    seg[i].first.x = std::lower_bound(ts + 1, ts + cnt + 1, seg[i].first.x) - ts;
    seg[i].second.x = std::lower_bound(ts + 1, ts + cnt + 1, seg[i].second.x) - ts;
    int p = seg[i].first.x, q = seg[i].second.x;
    if (p < q) {
      bg[p].push_back(i), ed[q].push_back(i);
    } else {
      bg[q].push_back(i), ed[p].push_back(i);
      std::swap(seg[i].first, seg[i].second);
    }
    seg[i].first.x <<= 1, seg[i].second.x <<= 1;
  }
  For(i, 1, cnt) {
    cur = ts[i];
    for (auto &x : bg[i]) {
      auto it = s.insert(x).first;
      if (*it != *s.begin()) {
        auto p = it;
        -- p;
        adj[*p].push_back(x);
        ++ deg[x];
      }
      if (*it != *s.rbegin()) {
        auto p = it;
        ++ p;
        adj[x].push_back(*p);
        ++ deg[*p];
      }
    }
    for (auto &x : ed[i]) {
      s.erase(x);
    }
  }
  cnt <<= 1;
  int l = 1, r = 0;
  For(i, 1, n) {
    if (!deg[i]) {
      topo[++ r] = i;
    }
  }
  while (l <= r) {
    int u = topo[l ++];
    for (auto &x : adj[u]) {
      if (!(-- deg[x])) {
        topo[++ r] = x;
      }
    }
  }
  segt.build(1, 1, cnt);
  For(i, 1, n) {
    int x = topo[i], l = seg[x].first.x, r = seg[x].second.x;
    if (seg[x].first.y < seg[x].second.y) {
      int val = segt.query_v(1, 1, cnt, l, l).first;
      std::pair<int, int> min = segt.query_v(1, 1, cnt, l, r);
      if (min.first == val) {
        segt.set(1, 1, cnt, l, r, val);
      } else {
        segt.set(1, 1, cnt, min.second, r, min.first);
        int p = segt.query1(1, 1, cnt, l, r, val);
        segt.add(1, 1, cnt, p, r, 1);
      }
    } else {
      int val = segt.query_v(1, 1, cnt, r, r).first;
      std::pair<int, int> min = segt.query_v(1, 1, cnt, l, r);
      if (min.first == val) {
        segt.set(1, 1, cnt, l, r, val);
      } else {
        segt.set(1, 1, cnt, l, min.second, min.first);
        int p = segt.query2(1, 1, cnt, l, r, val);
        segt.add(1, 1, cnt, l, p, 1);
      }
    }
  }
  printf("%d\n", segt.query_v(1, 1, cnt, L, R).first);
  return 0;
}

 G

把模式串倒过来建AC自动机，相当于文本串是一个Trie，和是一个单串并没有本质区别，直接跑匹配即可。

#include <bits/stdc++.h>

#define IL __inline__ __attribute__((always_inline))

#define For(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++ i)
#define FOR(i, a, b) for (int i = (a), i##end = (b); i < i##end; ++ i)
#define Rep(i, a, b) for (int i = (a), i##end = (b); i >= i##end; -- i)
#define REP(i, a, b) for (int i = (a) - 1, i##end = (b); i >= i##end; -- i)

typedef long long LL;

template <class T>
IL bool chkmax(T &a, const T &b) {
  return a < b ? ((a = b), 1) : 0;
}

template <class T>
IL bool chkmin(T &a, const T &b) {
  return a > b ? ((a = b), 1) : 0;
}

template <class T>
IL T mymax(const T &a, const T &b) {
  return a > b ? a : b;
}

template <class T>
IL T mymin(const T &a, const T &b) {
  return a < b ? a : b;
}

template <class T>
IL T myabs(const T &a) {
  return a > 0 ? a : -a;
}

const int INF = 0X3F3F3F3F;
const double EPS = 1E-8, PI = acos(-1.0);

#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#define OK DEBUG("Passing [%s] in LINE %d...\n", __FUNCTION__, __LINE__)

const int MAXN = 1000000 + 5;

std::vector<int> adj[MAXN];
int answer[MAXN], val[MAXN], n;
char str[MAXN];

struct AhoCorasickAutomaton {
  int ch[MAXN][26], fail[MAXN], num[MAXN], cnt;
  std::vector<int> id[MAXN], t[MAXN];

  AhoCorasickAutomaton() {
    memset(ch, -1, sizeof (ch));
  }

  void insert(int len, int p) {
    int cur = 0;
    For(i, 1, len) {
      if (!~ch[cur][str[i] - 'A']) {
        ch[cur][str[i] - 'A'] = ++ cnt;
      }
      cur = ch[cur][str[i] - 'A'];
    }
    id[cur].push_back(p);
  }

  void build() {
    static int queue[MAXN];
    int l = 1, r = 0;
    queue[++ r] = 0;
    while (l <= r) {
      int u = queue[l ++];
      FOR(i, 0, 26) {
        if (!~ch[u][i]) {
          ch[u][i] = u ? ch[fail[u]][i] : 0;
          continue;
        }
        fail[ch[u][i]] = u ? ch[fail[u]][i] : 0;
        t[fail[ch[u][i]]].push_back(ch[u][i]);
        queue[++ r] = ch[u][i];
      }
    }
  }

  void DFS(int u) {
    for (auto &x : t[u]) {
      DFS(x);
      num[u] += num[x];
    }
    for (auto &x : id[u]) {
      answer[x] = num[u];
    }
  }
} ac;

void DFS(int u, int cur) {
  cur = ac.ch[cur][val[u]];
  ++ ac.num[cur];
  for (auto &x : adj[u]) {
    DFS(x, cur);
  }
}

int main() {
  int k;
  scanf("%d%d", &n, &k);
  For(i, 1, n) {
    int u;
    scanf("%s%d", str, &u);
    val[i] = str[0] - 'A';
    if (u) {
      adj[u].push_back(i);
    }
  }
  For(i, 1, k) {
    scanf("%s", str + 1);
    int len = strlen(str + 1);
    std::reverse(str + 1, str + len + 1);
    ac.insert(len, i);
  }
  ac.build();
  DFS(1, 0);
  ac.DFS(0);
  For(i, 1, k) {
    printf("%d\n", answer[i]);
  }
  return 0;
}

 H

分成环和树两部分考虑，树上可以长链剖分统计，环上扫一遍即可，做到线性需要比较精细的实现。

（实际上差分就行了，好写的多，我数据结构学傻了.jpg*2

#include <bits/stdc++.h>

#define IL __inline__ __attribute__((always_inline))

#define For(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++ i)
#define FOR(i, a, b) for (int i = (a), i##end = (b); i < i##end; ++ i)
#define Rep(i, a, b) for (int i = (a), i##end = (b); i >= i##end; -- i)
#define REP(i, a, b) for (int i = (a) - 1, i##end = (b); i >= i##end; -- i)

typedef long long LL;

template <class T>
IL bool chkmax(T &a, const T &b) {
  return a < b ? ((a = b), 1) : 0;
}

template <class T>
IL bool chkmin(T &a, const T &b) {
  return a > b ? ((a = b), 1) : 0;
}

template <class T>
IL T mymax(const T &a, const T &b) {
  return a > b ? a : b;
}

template <class T>
IL T mymin(const T &a, const T &b) {
  return a < b ? a : b;
}

template <class T>
IL T myabs(const T &a) {
  return a > 0 ? a : -a;
}

const int INF = 0X3F3F3F3F;
const double EPS = 1E-8, PI = acos(-1.0);

#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#define OK DEBUG("Passing [%s] in LINE %d...\n", __FUNCTION__, __LINE__)

const int MAXN = 500000 + 5;

int to[MAXN], dep[MAXN], m_d[MAXN], son[MAXN], top[MAXN], pool[MAXN], size[MAXN], 
    *que[MAXN], pool_v[MAXN * 2], answer[MAXN], n, K, c_cnt, *cur = pool, *val = pool_v + MAXN;
std::vector<int> adj[MAXN], cycle[MAXN];
bool vis[MAXN], in_cycle[MAXN];

void DFS1(int u) {
  static int stack[MAXN], top;
  static bool in_stack[MAXN];
  vis[u] = 1;
  stack[++ top] = u;
  in_stack[u] = 1;
  if (in_stack[to[u]]) {
    int cur = top;
    ++ c_cnt;
    do {
      cycle[c_cnt].push_back(stack[cur]);
      in_cycle[stack[cur]] = 1;
    } while (stack[cur --] != to[u]);
  } else if (!vis[to[u]]) {
    DFS1(to[u]);
  }
  in_stack[u] = 0;
  -- top;
}

void DFS2(int u) {
  for (auto &x : adj[u]) {
    if (!in_cycle[x]) {
      dep[x] = dep[u] + 1;
      DFS2(x);
      if (dep[m_d[x]] > dep[m_d[son[u]]]) {
        son[u] = x;
      }
    }
  }
  m_d[u] = son[u] ? m_d[son[u]] : u;
}

void DFS3(int u, int t) {
  if (u == t) {
    que[u] = cur;
    cur += size[u] = dep[m_d[u]] - dep[u];
    ++ cur;
  } else {
    que[u] = que[t];
  }
  top[u] = t;
  if (son[u]) {
    DFS3(son[u], t);
  }
  for (auto &x : adj[u]) {
    if (!in_cycle[x] && x != son[u]) {
      DFS3(x, x);
    }
  }
}

int DFS4(int u) {
  int cur = son[u] ? DFS4(son[u]) : 0, delta = dep[u] - dep[top[u]];
  ++ que[u][delta], ++ cur;
  if (delta + K < size[top[u]]) {
    cur -= que[u][delta + K + 1];
  }
  for (auto &x : adj[u]) {
    if (!in_cycle[x] && x != son[u]) {
      DFS4(x);
      For(i, 0, size[x]) {
        que[u][i + delta + 1] += que[x][i];
        assert(i + delta + 1 <= size[top[u]]);
        if (i < K) {
          cur += que[x][i];
        }
      }
    }
  }
  return answer[u] = cur;
}

int main() {
  scanf("%d%d", &n, &K);
  For(i, 1, n) {
    scanf("%d", &to[i]);
    adj[to[i]].push_back(i);
  }
  For(i, 1, n) {
    if (adj[i].empty()) {
      DFS1(i);
    }
  }
  For(i, 1, n) {
    if (!vis[i]) {
      DFS1(i);
    }
  }
  For(i, 1, c_cnt) {
    std::reverse(cycle[i].begin(), cycle[i].end());
    for (auto &x : cycle[i]) {
      DFS2(x);
      DFS3(x, x);
      DFS4(x);
    }
    int max = -INF, min = INF;
    REP(j, cycle[i].size(), 1) {
      int dist = (int)cycle[i].size() - j;
      For(k, 0, mymin(K, size[cycle[i][j]])) {
        val[dist + k] += que[cycle[i][j]][k];
        chkmax(max, dist + k);
        chkmin(min, dist + k);
      }
    }
    int sum = 0;
    For(j, 0, mymin(max, K)) {
      sum += val[j];
    }
    answer[cycle[i].front()] += sum;
    FOR(j, 1, cycle[i].size()) {
      sum -= val[K - j + 1];
      int dist = (int)cycle[i].size() - j;
      For(k, 0, mymin(K, size[cycle[i][j]])) {
        val[dist + k] -= que[cycle[i][j]][k];
        chkmax(max, dist + k);
        chkmin(min, dist + k);
        if (dist + k <= K - j) {
          sum -= que[cycle[i][j]][k];
        }
      }
      For(k, 0, mymin(K, size[cycle[i][j - 1]])) {
        val[k - j + 1] += que[cycle[i][j - 1]][k];
        chkmax(max, k - j + 1);
        chkmin(min, k - j + 1);
        if (k - j + 1 <= K - j) {
          sum += que[cycle[i][j - 1]][k];
        }
      }
      answer[cycle[i][j]] += sum;
    }
    For(j, min, max) {
      val[j] = 0;
    }
  }
  For(i, 1, n) {
    printf("%d\n", answer[i]);
  }
  return 0;
}