2018 集训队互测 Day 1 简要题解

最新推荐文章于 2022-09-29 23:06:59 发布
最新推荐文章于 2022-09-29 23:06:59 发布
阅读量2.2k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxh010910/article/details/79814239
版权

完美的队列：

如果能求出每个加入的数在所有队列中都被移出去的时刻，那就可以很方便地计算答案了。

对序列分块，先考虑整块的，更新跨过整个块的区间答案，记 bi b i 表示队列要弹出当前的数需要的容量，那么每次操作实际上是对 bi b i 进行区间减法，注意到大部分时候是对整块打标记，如果不是整块打标记直接暴力就行了。当 所有 bi<0 b i < 0 的时候，就是所有东西都被弹出去的时候，可以利用双指针更新答案。

离散的块实际上也可以类似处理，预处理跨过整块的东西的前缀和，同样枚举每个位置和跨过它的区间，然后类似整块也可以双指针求出答案，这部分细节详见代码。

#include <bits/stdc++.h>

using namespace std;

#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define Debug(...) fprintf(stderr, __VA_ARGS__)

typedef long long LL;
typedef long double LD;
typedef unsigned int uint;
typedef pair <int, int> pii;
typedef unsigned long long uLL;

template <typename T> inline void Read(T &x) {
  char c = getchar();
  bool f = false;
  for (x = 0; !isdigit(c); c = getchar()) {
    if (c == '-') {
      f = true;
    }
  }
  for (; isdigit(c); c = getchar()) {
    x = x * 10 + c - '0';
  }
  if (f) {
    x = -x;
  }
}

template <typename T> inline bool CheckMax(T &a, const T &b) {
  return a < b ? a = b, true : false;
}

template <typename T> inline bool CheckMin(T &a, const T &b) {
  return a > b ? a = b, true : false;
}

const int N = 100005;
const int B = 325;
const int inf = 0x3f3f3f3f;

int n, m, ans, a[N], b[N], f[N], l[N], r[N], x[N], all[N], sum[N], pos[N], qry[N];
vector <int> v[N];

int main() {
#ifdef wxh010910
  freopen("d.in", "r", stdin);
#endif
  Read(n), Read(m);
  for (int i = 1; i <= n; ++i) {
    Read(a[i]);
  }
  for (int i = 1; i <= m; ++i) {
    Read(l[i]), Read(r[i]), Read(x[i]);
  }
  for (int L = 1, R; L <= n; L += B) {
    R = min(L + B - 1, n);
    int val = -inf, tag = 0, cnt = 0, tot = 0;
    for (int i = L; i <= R; ++i) {
      b[i] = a[i], CheckMax(val, b[i]);
    }
    for (int i = 1, j = 2; i <= m; ++i) {
      if (i > 1 && val + tag <= 0) {
        if (l[i] <= L && R <= r[i]) {
          ++tag;
        } else if (l[i] <= R && L <= r[i]) {
          val = -inf;
          for (int k = L; k <= R; ++k) {
            if (k >= l[i] && k <= r[i]) {
              ++b[k];
            }
            CheckMax(val, b[k]);
          }
        }
      }
      for (; val + tag > 0 && j <= m; ++j) {
        if (l[j] <= L && R <= r[j]) {
          --tag;
        } else if (l[j] <= R && L <= r[j]) {
          val = -inf;
          for (int k = L; k <= R; ++k) {
            if (k >= l[j] && k <= r[j]) {
              --b[k];
            }
            CheckMax(val, b[k]);
          }
        }
      }
      sum[i] = sum[i - 1];
      if (l[i] <= L && R <= r[i]) {
        CheckMax(f[i], val + tag > 0 ? m + 1 : j - 1);
        ++sum[i], all[++tot] = i;
      } else if (l[i] <= R && L <= r[i]) {
        qry[++cnt] = i, pos[cnt] = tot;
      }
    }
    for (int i = L; i <= R; ++i) {
      for (int j = 1, k = 2, val = a[i]; j <= cnt; ++j) {
        if (j > 1) {
          val += sum[qry[j]] - sum[qry[j - 1]];
          if (l[qry[j]] <= i && i <= r[qry[j]]) {
            ++val;
          }
        }
        for (; val > 0 && k <= cnt; ++k) {
          val -= sum[qry[k]] - sum[qry[k - 1]];
          if (l[qry[k]] <= i && i <= r[qry[k]]) {
            --val;
          }
        }
        if (l[qry[j]] <= i && i <= r[qry[j]]) {
          if (val > 0) {
            CheckMax(f[qry[j]], sum[m] - sum[qry[cnt]] < val ? m + 1 : all[pos[cnt] + val]);
          } else {
            CheckMax(f[qry[j]], l[qry[k - 1]] <= i && i <= r[qry[k - 1]] ? val ? all[pos[k - 1] + val + 1] : qry[k - 1] : all[pos[k - 1] + val]);
          }
        }
      }
    }
  }
  memset(sum, 0, sizeof sum);
  for (int i = 1; i <= m; ++i) {
    if (!sum[x[i]]++) {
      ++ans;
    }
    v[f[i]].pb(x[i]);
    for (auto x : v[i]) {
      if (!--sum[x]) {
        --ans;
      }
    }
    printf("%d\n", ans);
  }
#ifdef wxh010910
  Debug("My Time: %.3lfms\n", (double)clock() / CLOCKS_PER_SEC);
#endif
  return 0;
}

完美的集合：

注意到合法的关键点连成了一棵树，所以可以容斥，用 i i 合法的减去 i 和 pari p a r i 都合法的。

枚举之后将树处理出来，变成了一棵有根树，可以利用DFS序DP求出最大权值以及方案数。

剩下就是组合数取模的问题了，就是要快速求 ∏1≤i≤n,imod5≠0i ∏ 1 ≤ i ≤ n , i mod 5 ≠ 0 i ，考虑维护一个多项式 fn(x)=∏1≤i≤n,imod5≠0(x+i) f n ( x ) = ∏ 1 ≤ i ≤ n , i mod 5 ≠ 0 ( x + i ) ，然后找到一个最大的 k k 满足 10k≤n ，那么考虑计算 f10k(x) f 10 k ( x ) ，剩下的暴力乘上去。 f10k(x)=f5k(x)+f5k(x+5k) f 10 k ( x ) = f 5 k ( x ) + f 5 k ( x + 5 k ) ，而注意到每次展开 f(x+5k) f ( x + 5 k ) 的时候，到了 23 23 项之后它的贡献就变成 0 0 了，所以多项式次数不超过 23 ，暴力维护就行了。

#include <bits/stdc++.h>

using namespace std;

#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define Debug(...) fprintf(stderr, __VA_ARGS__)

typedef long long LL;
typedef long double LD;
typedef unsigned int uint;
typedef pair <int, int> pii;
typedef unsigned long long uLL;

template <typename T> inline void Read(T &x) {
  char c = getchar();
  bool f = false;
  for (x = 0; !isdigit(c); c = getchar()) {
    if (c == '-') {
      f = true;
    }
  }
  for (; isdigit(c); c = getchar()) {
    x = x * 10 + c - '0';
  }
  if (f) {
    x = -x;
  }
}

template <typename T> inline bool CheckMax(T &a, const T &b) {
  return a < b ? a = b, true : false;
}

template <typename T> inline bool CheckMin(T &a, const T &b) {
  return a > b ? a = b, true : false;
}

const int N = 65;
const int M = 10005;
const LL mod = 11920928955078125;

LL ans, lim, val_max, pwd[N], c[N][N], f[N][M], g[N][M];
int n, m, k, tim, v[N], w[N], dfn[N], seq[N], siz[N];
vector <pii> adj[N];
bool b[N];

inline LL Qul(LL x, LL y) {
  return (__int128)x * y % mod;
}

inline LL Qow(LL x, LL y) {
  LL r = 1;
  for (; y; y >>= 1, x = Qul(x, x)) {
    if (y & 1) {
      r = Qul(r, x);
    }
  }
  return r;
}

struct Poly {
  LL a[N];

  Poly() {
    for (int i = 0; i < 23; ++i) {
      a[i] = 0;
    }
  }

  Poly operator * (const Poly &b) const {
    Poly c;
    for (int i = 0; i < 23; ++i) {
      for (int j = 0; j <= i; ++j) {
        c.a[i] = (c.a[i] + Qul(a[j], b.a[i - j])) % mod;
      }
    }
    return c;
  }

  inline Poly Extend(LL x) {
    Poly b;
    pwd[0] = 1;
    for (int i = 1; i < 23; ++i) {
      pwd[i] = Qul(pwd[i - 1], x);
    }
    for (int i = 0; i < 23; ++i) {
      for (int j = i; j < 23; ++j) {
        b.a[i] = (Qul(a[j], Qul(pwd[j - i], c[j][i])) + b.a[i]) % mod;
      }
    }
    return b;
  }
};

map <LL, Poly> h;

inline Poly G(LL n) {
  if (h.find(n) != h.end()) {
    return h[n];
  }
  Poly r, t;
  r.a[0] = 1;
  if (n <= 20) {
    for (int i = 1; i <= n; ++i) {
      if (i % 5) {
        t.a[0] = i, t.a[1] = 1, r = r * t;
      }
    }
  } else {
    LL val = n / 2 / 5 * 5;
    Poly u = G(val - 1), v = u.Extend(val);
    r = u * v;
    for (LL i = val << 1; i <= n; ++i) {
      if (i % 5) {
        t.a[0] = i, t.a[1] = 1, r = r * t;
      }
    }
  }
  return h[n] = r;
}

inline LL F(LL n) {
  LL r = 1;
  for (LL i = 1; i <= n; i *= 5) {
    r = Qul(r, G(n / i).a[0]);
  }
  return r;
}

inline LL C(LL x, LL y) {
  if (x < y) {
    return 0;
  }
  int c = 0;
  for (LL i = 5; i <= x; i *= 5) {
    c += x / i - y / i - (x - y) / i;
  }
  if (c >= 23) {
    return 0;
  }
  LL r = 1;
  for (int i = 1; i <= c; ++i) {
    r = 5 * r % mod;
  }
  return Qul(Qul(r, F(x)), Qow(Qul(F(y), F(x - y)), mod / 5 * 4 - 1));
}

inline void Build(int x, int p, LL d) {
  if (v[x] && d >= (lim + v[x] - 1) / v[x]) {
    b[x] = false;
    return ;
  }
  for (auto e : adj[x]) {
    if (e.X != p) {
      Build(e.X, x, d + e.Y);
    }
  }
}

inline void DFS(int x, int p) {
  seq[dfn[x] = ++tim] = x, siz[x] = 1;
  for (auto e : adj[x]) {
    int y = e.X;
    if (y != p && b[y]) {
      DFS(y, x), siz[x] += siz[y];
    }
  }
}

inline void DP() {
  for (int i = tim; i; --i) {
    int x = seq[i];
    for (int j = 0; j <= m; ++j) {
      if (j < w[x]) {
        f[x][j] = f[seq[i + siz[x]]][j], g[x][j] = g[seq[i + siz[x]]][j];
      } else {
        if (f[seq[i + siz[x]]][j] > f[seq[i + 1]][j - w[x]] + v[x]) {
          f[x][j] = f[seq[i + siz[x]]][j];
          g[x][j] = g[seq[i + siz[x]]][j];
        } else if (f[seq[i + siz[x]]][j] < f[seq[i + 1]][j - w[x]] + v[x]) {
          f[x][j] = f[seq[i + 1]][j - w[x]] + v[x];
          g[x][j] = g[seq[i + 1]][j - w[x]];
        } else {
          f[x][j] = f[seq[i + siz[x]]][j];
          g[x][j] = g[seq[i + siz[x]]][j] + g[seq[i + 1]][j - w[x]];
        }
      }
    }
  }
}

inline pair <LL, LL> Solve(int x) {
  tim = 0, DFS(x, 0), seq[tim + 1] = 0, DP(), --g[x][0];
  LL u = 0, v = 0;
  for (int i = 0; i <= m; ++i) {
    if (CheckMax(u, f[x][i])) {
      v = g[x][i];
    } else if (u == f[x][i]) {
      v += g[x][i];
    }
  }
  return mp(u, v);
}

inline pair <LL, LL> Solve(int x, int y) {
  tim = 0, DFS(x, y), seq[tim + 1] = 0, DP(), --g[x][0];
  tim = 0, DFS(y, x), seq[tim + 1] = 0, DP(), --g[y][0];
  for (int i = 1; i <= m; ++i) {
    if (CheckMax(f[x][i], f[x][i - 1])) {
      g[x][i] = g[x][i - 1];
    } else if (f[x][i] == f[x][i - 1]) {
      g[x][i] += g[x][i - 1];
    }
  }
  LL u = 0, v = 0;
  for (int i = 0; i <= m; ++i) {
    if (CheckMax(u, f[x][i] + f[y][m - i])) {
      v = g[x][i] * g[y][m - i];
    } else if (u == f[x][i] + f[y][m - i]) {
      v += g[x][i] * g[y][m - i];
    }
  }
  return mp(u, v);
}

int main() {
#ifdef wxh010910
  freopen("d.in", "r", stdin);
#endif
  Read(n), Read(m), Read(k), Read(lim), ++lim, g[0][0] = 1;
  for (int i = 0; i <= 23; ++i) {
    c[i][0] = 1;
    for (int j = 1; j <= i; ++j) {
      c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
    }
  }
  for (int i = 1; i <= m; ++i) {
    f[0][i] = -(1LL << 60);
  }
  for (int i = 1; i <= n; ++i) {
    Read(w[i]);
  }
  for (int i = 1; i <= n; ++i) {
    Read(v[i]);
  }
  for (int i = 1, x, y, w; i < n; ++i) {
    Read(x), Read(y), Read(w);
    adj[x].pb(mp(y, w)), adj[y].pb(mp(x, w));
  }
  for (int i = 1; i <= n; ++i) {
    b[i] = true;
  }
  for (int i = 1; i <= n; ++i) {
    CheckMax(val_max, Solve(i).X);
  }
  for (int i = 1; i <= n; ++i) {
    for (int j = 1; j <= n; ++j) {
      b[j] = true;
    }
    Build(i, 0, 0);
    pair <LL, LL> ret = Solve(i);
    if (ret.X == val_max) {
      ans = (ans + C(ret.Y, k)) % mod;
    }
  }
  for (int i = 1; i <= n; ++i) {
    for (auto e : adj[i]) {
      if (e.X > i) {
        for (int j = 1; j <= n; ++j) {
          b[j] = true;
        }
        int j = e.X;
        Build(i, 0, 0), Build(j, 0, 0);
        if (!b[i] || !b[j]) {
          continue;
        }
        pair <LL, LL> ret = Solve(i, j);
        if (ret.X == val_max) {
          ans = (ans - C(ret.Y, k) + mod) % mod;
        }
      }
    }
  }
  printf("%lld\n", ans);
#ifdef wxh010910
  Debug("My Time: %.3lfms\n", (double)clock() / CLOCKS_PER_SEC);
#endif
  return 0;
}

完美的旅行：

首先预处理 f(i,j) f ( i , j ) 表示标号的与为 i i ，路径长度为 j 的方案数，这个相当于求 A1,A2,A3,⋯,Am A 1 , A 2 , A 3 , ⋯ , A m 。

考虑暴力求出特征多项式之后，因为只关心 f(i,j) f ( i , j ) 的答案，可以直接对 f(i,j) f ( i , j ) 而不是整个矩阵进行线性变换，这样就把复杂度降下来了。

计算答案的时候，首先可以FWT求出集合交卷积对应的多项式 F F ，那么就是要求 F+F2+F3⋯=11−F−1 ，多项式求逆即可。

#include <bits/stdc++.h>

using namespace std;

#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define Debug(...) fprintf(stderr, __VA_ARGS__)

typedef long long LL;
typedef long double LD;
typedef unsigned int uint;
typedef pair <int, int> pii;
typedef unsigned long long uLL;

template <typename T> inline void Read(T &x) {
  char c = getchar();
  bool f = false;
  for (x = 0; !isdigit(c); c = getchar()) {
    if (c == '-') {
      f = true;
    }
  }
  for (; isdigit(c); c = getchar()) {
    x = x * 10 + c - '0';
  }
  if (f) {
    x = -x;
  }
}

template <typename T> inline bool CheckMax(T &a, const T &b) {
  return a < b ? a = b, true : false;
}

template <typename T> inline bool CheckMin(T &a, const T &b) {
  return a > b ? a = b, true : false;
}

const int N = 65;
const int M = 65540;
const int G = 3;
const int mod = 998244353;

int n, m, D, L, W[N], fac[N], inv[N], val[N], f[M], g[M], R[M], a[N][N], ans[N][M];

struct Matrix {
  int a[N][N];

  Matrix() {
    memset(a, 0, sizeof a);
  }

  Matrix operator * (const Matrix &b) const {
    Matrix c;
    for (int k = 0; k < n; ++k) {
      for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
          c.a[i][j] = (1LL * a[i][k] * b.a[k][j] + c.a[i][j]) % mod;
        }
      }
    }
    return c;
  }
} cur, trs;

inline int Qow(int x, int y) {
  int r = 1;
  for (; y; y >>= 1, x = 1LL * x * x % mod) {
    if (y & 1) {
      r = 1LL * r * x % mod;
    }
  }
  return r;
}

inline int Det() {
  int ret = 1;
  for (int i = 0; i < n; ++i) {
    int p = i;
    for (; p < n && !a[p][i]; ++p);
    if (p == n) {
      return 0;
    }
    if (i != p) {
      for (int j = i; j < n; ++j) {
        swap(a[p][j], a[i][j]);
      }
      ret = mod - ret;
    }
    ret = 1LL * ret * a[i][i] % mod;
    for (int j = i + 1; j < n; ++j) {
      if (a[j][i]) {
        int cof = 1LL * a[j][i] * Qow(a[i][i], mod - 2) % mod;
        for (int k = i; k < n; ++k) {
          a[j][k] = (a[j][k] - 1LL * a[i][k] * cof % mod + mod) % mod;
        }
      }
    }
  }
  return ret;
}

inline void Ini(int l) {
  for (D = 1, L = 0; D < l; D <<= 1, ++L);
  for (int i = 1; i < D; ++i) {
    R[i] = (R[i >> 1] >> 1) | ((i & 1) << L - 1);
  }
  W[0] = Qow(G, mod - 1 >> L);
  for (int i = 1; i < L; ++i) {
    W[i] = 1LL * W[i - 1] * W[i - 1] % mod;
  }
}

inline void IniInv() {
  W[0] = Qow(W[0], mod - 2);
  for (int i = 1; i < L; ++i) {
    W[i] = 1LL * W[i - 1] * W[i - 1] % mod;
  }
}

inline void DFT(int *x) {
  for (int i = 0; i < D; ++i) {
    if (i < R[i]) {
      swap(x[i], x[R[i]]);
    }
  }
  for (int i = 1, l = L - 1; i < D; i <<= 1, --l) {
    for (int j = 0; j < D; j += i << 1) {
      for (int k = 0, w = 1, u, v; k < i; ++k, w = 1LL * w * W[l] % mod) {
        u = x[j + k], v = 1LL * x[j + k + i] * w % mod, x[j + k] = (u + v) % mod, x[j + k + i] = (u - v + mod) % mod;
      }
    }
  }
}

inline void Inv(int *a, int n, int *b) {
  static int x[M], y[M];
  if (n == 1) {
    b[0] = Qow(a[0], mod - 2);
  } else {
    Inv(a, n + 1 >> 1, b), Ini(n << 1);
    for (int i = 0; i < D; ++i) {
      x[i] = i < n ? a[i] : 0, y[i] = i < n + 1 >> 1 ? b[i] : 0;
    }
    DFT(x), DFT(y);
    for (int i = 0; i < D; ++i) {
      x[i] = (2 - 1LL * x[i] * y[i] % mod + mod) * y[i] % mod;
    }
    IniInv(), DFT(x);
    for (int i = 0, v = Qow(D, mod - 2); i < n; ++i) {
      b[i] = 1LL * x[i] * v % mod;
    }
  }
}

int main() {
#ifdef wxh010910
  freopen("d.in", "r", stdin);
#endif
  Read(n), Read(m), fac[0] = fac[1] = inv[0] = inv[1] = 1;
  for (int i = 2; i <= n; ++i) {
    fac[i] = 1LL * fac[i - 1] * i % mod;
    inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod;
  }
  for (int i = 2; i <= n; ++i) {
    inv[i] = 1LL * inv[i - 1] * inv[i] % mod;
  }
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      Read(trs.a[i][j]), cur.a[i][j] = i == j;
    }
  }
  for (int i = 1; i <= n + 1; ++i) {
    cur = cur * trs;
    for (int j = 0; j < n; ++j) {
      for (int k = 0; k < n; ++k) {
        ans[j & k][i] = (ans[j & k][i] + cur.a[j][k]) % mod;
      }
    }
  }
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      trs.a[i][j] = (mod - trs.a[i][j]) % mod;
    }
  }
  for (int i = 0; i <= n; ++i) {
    for (int j = 0; j < n; ++j) {
      for (int k = 0; k < n; ++k) {
        if (j == k) {
          a[j][k] = (trs.a[j][k] + i) % mod;
        } else {
          a[j][k] = trs.a[j][k];
        }
      }
    }
    val[i] = Det();
  }
  for (int i = 1; i <= n; ++i) {
    for (int j = n; j >= i; --j) {
      val[j] = (val[j] - val[j - 1] + mod) % mod;
    }
  }
  f[0] = val[0], g[0] = 1;
  for (int i = 1; i <= n; ++i) {
    for (int j = i; j; --j) {
      g[j] = (g[j - 1] - 1LL * g[j] * (i - 1) % mod + mod) % mod;
    }
    val[i] = 1LL * val[i] * inv[i] % mod, g[0] = 0;
    for (int j = 1; j <= i; ++j) {
      f[j] = (1LL * val[i] * g[j] + f[j]) % mod;
    }
  }
  for (int i = 0; i < n; ++i) {
    for (int j = n + 2; j <= m; ++j) {
      for (int k = 0; k < n; ++k) {
        ans[i][j] = (ans[i][j] - 1LL * f[k] * ans[i][j - n + k] % mod + mod) % mod;
      }
    }
  }
  for (int t = 1; t <= m; ++t) {
    for (int i = 1; i < n; i <<= 1) {
      for (int j = 0; j < n; j += i << 1) {
        for (int k = 0; k < i; ++k) {
          ans[j + k][t] = (ans[j + k][t] + ans[j + k + i][t]) % mod;
        }
      }
    }
  }
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j <= m; ++j) {
      if (!j) {
        f[j] = 1;
      } else {
        f[j] = (mod - ans[i][j]) % mod;
      }
    }
    Inv(f, m + 1, g);
    for (int j = 1; j <= m; ++j) {
      ans[i][j] = g[j];
    }
  }
  for (int t = 1; t <= m; ++t) {
    for (int i = 1; i < n; i <<= 1) {
      for (int j = 0; j < n; j += i << 1) {
        for (int k = 0; k < i; ++k) {
          ans[j + k][t] = (ans[j + k][t] - ans[j + k + i][t] + mod) % mod;
        }
      }
    }
  }
  int ret = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = 1; j <= m; ++j) {
      ret ^= ans[i][j];
    }
  }
  printf("%d\n", ret);
#ifdef wxh010910
  Debug("My Time: %.3lfms\n", (double)clock() / CLOCKS_PER_SEC);
#endif
  return 0;
}
wxh010910
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
IOI2017 Day1 Wiring 题解
imalyd的博客
08-06 3603
第一次写博客，感觉好激动啊~其实这题的Subtask 2很有启发意义。Subtask 2中，由于红点在蓝点左边，所以答案就是...
IOI2020 集训队作业
mayaohua
11-01 3258
终于开始做集训队作业了，预感到了集训被吊打的前景。 cf549E cf674G arc103_f cf594E agc034_f agc030_d cf575E agc035_c agc026_f cf607E agc038_e agc030_c cf611G agc034_d agc024_f cf571E cf696F arc093_e cf573...
牛客国庆集训派对Day1 —— 题解
Scar_Halo
10-01 801
[2015国家集训队互测]口胡
某沙茶的OI代码库
04-07 2147
比赛链接http://uoj.ac/contest/11口胡题解A、【集训队互测2015】Robot直接果断打暴力了。。。这个暴力很好写，我就不废话了B、【集训队互测2015】Marketing network我的10分做法：直接暴力枚举一个二进制状态StatusStatus,表示每条边是否在生成森林里，对每个StatusStatus，用并查集检查给定的SS个点是否都在一个联通块内。
[UOJ]#91. 【集训队互测2015】最大异或和 线性基
TYB的博客
12-25 2814
Description 我有一个数列 a1,a2,…,ana_1,a_2,…,a_na1​,a2​,…,an​，每个aia_iai​ 都是小于 2m2^m2m 的非负整数。 现在请您实现三种操作，格式说明如下： 1&nbsp;x&nbsp;y&nbsp;w1\ x\ y\ w1&nbsp;x&nbsp;y&nbsp;w：对于所有 x≤i≤yx≤i≤yx≤i≤y，将 aiaiai 修改为 ai&nb...
Summer Pockets 2018 简要题解
yfzcsc的博客
10-01 974
已鸽
NOIP2011提高组day1第1题-铺地毯题解
瑶の博客
08-18 8487
题目描述 为了准备一个独特的颁奖典礼，组织者在会场的一片矩形区域（可看做是平面直角坐标系的第一象限）铺上一些矩形地毯。一共有 n 张地毯，编号从 1 到n 。现在将这些地毯按照编号从小到大的顺序平行于坐标轴先后铺设，后铺的地毯覆盖在前面已经铺好的地毯之上。 地毯铺设完成后，组织者想知道覆盖地面某个点的最上面的那张地毯的编号。注意：在矩形地毯边界和四个顶点上的点也算被地毯覆盖。 输入输出格式 ...
【算法题解】 Day1 前缀和
sid10t.
09-29 1万+
今天的算法是 前缀和，“算法题解系列文章旨在精选重点与易错的算法题，总结常见的算法思路与可能出现的错误，以实战习题的形式理解算法，使用算法。”
NOIP2017Day1T1-小凯的疑惑
Mi-Queen
11-11 7718
1．小凯的疑惑  (math.cpp/c/pas)  【问题描述】  小凯手中有两种面值的金币，两种面值均为正整数且彼此互素。每种金币小凯都有无数个。在不找零的情况下，仅凭这两种金币，有些物品他是无法准确支付的。现在小凯想知道在无法准确支付的物品中，最贵的价值是多少金币？注意：输入数据保证存在小凯无法准确支付的商品。  【输入格式】  输入文件名为math.in。  输入数据仅一行
【九日集训】《LeetCode刷题报告》题解内容 Ⅲ
热门推荐
"謓泽"正在路上朝着"攻城狮"方向"前进四"!
02-14 1万+
33. 搜索旋转排序数组 - 力扣（LeetCode） 81. 搜索旋转排序数组 II - 力扣（LeetCode） 153. 寻找旋转排序数组中的最小值 - 力扣（LeetCode） 70. 爬楼梯 - 力扣（LeetCode） 509. 斐波那契数 - 力扣（LeetCode） 1137. 第 N 个泰波那契数 - 力扣（LeetCode）
2019正睿Day1题解.pdf
10-15
正睿2019Day1题解 T1序列seq T2灯泡bulb T3比赛match
NOI2018day2后面两个题的题解pdf
07-22
《NOI2018day2后面两个题的题解pdf》是一份针对全国青少年信息学奥林匹克竞赛（NOI）2018年第二天比赛的深度解析文档，由出题人亲自讲解，旨在帮助参赛者理解和掌握比赛中的关键知识点。这份资源包含两个部分：...
2016山东省NOI省队集训DAY6 题目题解数据标程 NOIP省选集训
04-18
【标题】"2016山东省NOI省队集训DAY6 题目题解数据标程 NOIP省选集训"所涉及的主要知识点包括： 1. NOI（全国青少年信息学奥林匹克竞赛）：NOI是中国最高级别的青少年编程竞赛，旨在选拔优秀的信息学人才参加国际...
2016山东省NOI省队集训DAY2 题目题解数据标程
04-18
《2016山东省NOI省队集训DAY2 题目题解数据标程》 本资源是关于2016年山东省全国信息学奥林匹克（NOI）省队集训第二天的训练题目解析及数据标程。信息学奥林匹克是一项针对中学生的编程竞赛，旨在提升青少年在...
Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印 方便用于小论文写作，方便用于毕业设计
07-20
Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可
K-means聚类算法MATLAB代码.doc
最新发布
07-20
kmeans聚类算法matlab代码
计算机科学与技术_基于Android的新闻管理系统的设计与实现.docx
07-20
计算机科学与技术_基于Android的新闻管理系统的设计与实现
半自动光纤接头组装机_包括零件图_机械3D图可修改打包下载.zip
07-20
半自动光纤接头组装机_包括零件图_机械3D图可修改打包下载.zip
AtCoder Beginner Contest 134 简要题解
05-23
AtCoder Beginner Contest 134 是一场 AtCoder 的入门级比赛，以下是每道题的简要题解： A - Dodecagon 题目描述：已知一个正十二边形的边长，求它的面积。 解题思路：正十二边形的内角为 $150^\circ$，因此可以将正十二边形拆分为 12 个等腰三角形，通过三角形面积公式计算面积即可。 B - Golden Apple 题目描述：有 $N$ 个苹果和 $D$ 个盘子，每个盘子最多可以装下 $2D+1$ 个苹果，求最少需要多少个盘子才能装下所有的苹果。 解题思路：每个盘子最多可以装下 $2D+1$ 个苹果，因此可以将苹果平均分配到每个盘子中，可以得到最少需要 $\lceil \frac{N}{2D+1} \rceil$ 个盘子。 C - Exception Handling 题目描述：给定一个长度为 $N$ 的整数序列 $a$，求除了第 $i$ 个数以外的最大值。 解题思路：可以使用两个变量 $m_1$ 和 $m_2$ 分别记录最大值和次大值。遍历整个序列，当当前数不是第 $i$ 个数时，更新最大值和次大值。因此，最后的结果应该是 $m_1$ 或 $m_2$ 中较小的一个。 D - Preparing Boxes 题目描述：有 $N$ 个盒子和 $M$ 个物品，第 $i$ 个盒子可以放入 $a_i$ 个物品，每个物品只能放在一个盒子中。现在需要将所有的物品放入盒子中，每次操作可以将一个盒子内的物品全部取出并分配到其他盒子中，求最少需要多少次操作才能完成任务。 解题思路：首先可以计算出所有盒子中物品的总数 $S$，然后判断是否存在一个盒子的物品数量大于 $\lceil \frac{S}{2} \rceil$，如果存在，则无法完成任务。否则，可以用贪心的思想，每次从物品数量最多的盒子中取出一个物品，放入物品数量最少的盒子中。因为每次操作都会使得物品数量最多的盒子的物品数量减少，而物品数量最少的盒子的物品数量不变或增加，因此这种贪心策略可以保证最少需要的操作次数最小。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值