暴力分又没骗满sad.....

Problem A 走路

　　$O(n^2)$动态规划是显然的。

　　更新方式有两种：一种是枚举它的倍数转移，一种是转移到它的约数。

　　考虑利用分块来平衡一下（像分块FWT一样）。

　　注意到若$x = ab, y = cd, (a, b) = 1, (c, d) = 1$，那么$x | y$的充分必要条件是$a | c, b | d$或者$a | d, b | c$。

　　那么我们可以把$v_1$拆成$AB, (A, B) = 1$，使得$A$和$B$的约数个数尽量相等。

　　对于每一部分，离散化后暴力处理整除关系。每次修改或查询时固定一维动另一维。

　　时间复杂度$O(nV^{0.25})$。

Code

  1.  #include <algorithm>
  2.  #include <iostream>
  3.  #include <cassert>
  4.  #include <cstdlib>
  5.  #include <cstdio>
  6.  #include <vector>
  7.  #include <ctime>
  8.  #ifndef WIN32
  9.  #define Auto "%lld"
  10.  #else
  11.  #define Auto "%I64d"
  12.  #endif
  13.  using namespace std;
  14.  typedef bool boolean;
  15.  
  16.  #define ll long long
  17.  #define ull unsigned long long
  18.  
  19.  template <typename T>
  20.  T add(T a, T b, T m) {
  21.      return ((a += b) >= m) ? (a - m) : (a);
  22.  }
  23.  
  24.  template <typename T>
  25.  T sub(T a, T b, T m) {
  26.      return ((a -= b) < ) ? (a + m) : (a);
  27.  }
  28.  
  29.  template <typename T>
  30.  void pcopy(T* pst, const T* ped, T* pval) {
  31.      for ( ; pst != ped; *(pst++) = *(pval++));
  32.  }
  33.  
  34.  template <typename T>
  35.  void pfill(T* pst, const T* ped, T val) {
  36.      for ( ; pst != ped; *(pst++) = val);
  37.  }
  38.  
  39.  ll mul(ll a, ll b, ll m) {
  40.  //    return (__int128)a * b % m;
  41.      ll rt = , pa = a;
  42.      for ( ; b; b >>= , pa = add(pa, pa, m))
  43.          if (b & )
  44.              rt = add(rt, pa, m);
  45.      return rt;
  46.  }
  47.  
  48.  ll qpow(ll a, ll p, ll m) {
  49.      ll rt = , pa = a;
  50.      for ( ; p; p >>= , pa = mul(pa, pa, m))
  51.          if (p & )
  52.              rt = mul(rt, pa, m);
  53.      return rt;
  54.  }
  55.  
  56.  ll gcd(ll a, ll b) {
  57.      return (b) ? (gcd(b, a % b)) : (a);
  58.  }
  59.  
  60.  ll randLL() {
  61.      static ull seed = , msk = (1ull << ) - ;
  62.      return (signed ll) ((seed = seed * seed + seed + ) & msk);
  63.  }
  64.  
  65.  int pri[] = {, , , , , , , };
  66.  
  67.  boolean miller_rabin(ll n) {
  68.      static int T = ;
  69.      for (int i = ; i < ; i++)
  70.          if (!(n % pri[i]))
  71.              return n == pri[i];
  72.      if (n < ) {
  73.          for (int p = ; p * p <= n; p++)
  74.              if (!(n % p))
  75.                  return false;
  76.          return true;
  77.      }
  78.      ll d = n - ;
  79.      int s = ;
  80.      while (!(d & ))
  81.          s++, d >>= ;
  82.      for (int t = ; t < T; t++) {
  83.          ll b = randLL() % n;
  84.          if (!b)
  85.              continue;
  86.          ll tmp = qpow(b, d, n);
  87.          if (tmp ==  || tmp == n - )
  88.              continue;
  89.          for (int i = ; i < s; i++) {
  90.              tmp = mul(tmp, tmp, n);
  91.              if (tmp == n - )
  92.                  goto nextTurn;
  93.              if (tmp ==  || tmp == )
  94.                  return false;
  95.          }
  96.          if (tmp != )
  97.              return false;
  98.          nextTurn:;
  99.      }
  100.      return true;
  101.  }
  102.  
  103.  ll pollard_rho(ll x) {
  104.      ll a, b, c, g;
  105.      if (!(x & ))
  106.          return ;
  107.      while (true) {
  108.          b = a = randLL() % x;
  109.          c = randLL() % ;
  110.          do {
  111.              a = add(mul(a, a, x), c, x);
  112.              b = add(mul(b, b, x), c, x);
  113.              b = add(mul(b, b, x), c, x);
  114.              g = gcd(b - a, x);
  115.              (g < ) ? (g = -g) : ();
  116.              if (g == x)
  117.                  break;
  118.              if (g > )
  119.                  return g;
  120.          } while (a != b);
  121.      }
  122.      assert(false);
  123.      return ;
  124.  }
  125.  
  126.  void get_primary_factors(ll x, vector<ll>& rt) {
  127.      if (miller_rabin(x)) {
  128.          rt.push_back(x);
  129.          return;
  130.      }
  131.      ll a = pollard_rho(x);
  132.      get_primary_factors(a, rt);
  133.      get_primary_factors(x / a, rt);
  134.  }
  135.  
  136.  vector< pair<ll, int> > get_primary_factor(vector<ll>& vec) {
  137.      vector< pair<ll, int> > rt;
  138.      if (vec.empty())
  139.          return rt;
  140.      sort(vec.begin(), vec.end());
  141.      vector<ll>::iterator it = vec.begin();
  142.      rt.push_back(make_pair(*it, ));
  143.      for (it = it +  ; it != vec.end(); it++)
  144.          if (*it == rt.back().first)
  145.              rt.back().second++;
  146.          else
  147.              rt.push_back(make_pair(*it, ));
  148.      return rt;
  149.  }
  150.  
  151.  typedef vector< pair<ll, int> > factor;
  152.  
  153.  /// Template ends
  154.  
  155.  template <typename T>
  156.  class Matrix {
  157.      public:
  158.          T* p;
  159.          int r, c;
  160.  
  161.          Matrix() : p(NULL) {    }
  162.          Matrix(int r, int c) : r(r), c(c) {
  163.              p = new T[r * c];
  164.          }
  165.  
  166.          T* operator [] (int pos) {
  167.              return p + c * pos;
  168.          }
  169.  };
  170.  
  171.  const int Mod = 1e9 + ;
  172.  
  173.  int n;
  174.  ll *v;
  175.  int *f;
  176.  Matrix<int> F;
  177.  vector<int> *g;
  178.  vector<ll> va, vb;
  179.  vector<int> *diva, *divb, *mula, *mulb;
  180.  
  181.  inline void init() {
  182.      scanf("%d", &n);
  183.      g = new vector<int>[(n + )];
  184.      for (int i = , u, v; i < n; i++) {
  185.          scanf("%d%d", &u, &v);
  186.          g[u].push_back(v);
  187.          g[v].push_back(u);
  188.      }
  189.      v = new ll[(n + )];
  190.      for (int i = ; i <= n; i++)
  191.          scanf(Auto, v + i);
  192.  }
  193.  
  194.  ll A = , B;
  195.  int *a, *b;
  196.  
  197.  inline void discrete() {
  198.      vector<ll> _fac;
  199.      get_primary_factors(v[], _fac);
  200.      factor fac = get_primary_factor(_fac);
  201.  
  202.      random_shuffle(fac.begin(), fac.end());
  203.  
  204.      a = new int[(n + )];
  205.      b = new int[(n + )];
  206.      ll da = , db = ;
  207.      for (auto p : fac)
  208.          db *= (p.second + );
  209.      for (auto p : fac) {
  210.  //        cerr << p.first << " " << p.second << '\n';
  211.          if (da * (p.second + ) <= db / (p.second + )) {
  212.              da *= (p.second + ), db /= (p.second + );
  213.              for (int j = ; j < p.second; j++)
  214.                  A *= p.first;
  215.          }
  216.      }
  217.      B = v[] / A;
  218.  //    cerr << da << " " << db << '\n';
  219.  
  220.      for (int i = ; i <= n; i++)
  221.          va.push_back(gcd(v[i], A));
  222.      for (int i = ; i <= n; i++)
  223.          vb.push_back(gcd(v[i], B));
  224.  
  225.      sort(va.begin(), va.end());
  226.      sort(vb.begin(), vb.end());
  227.      va.erase(unique(va.begin(), va.end()), va.end());
  228.      vb.erase(unique(vb.begin(), vb.end()), vb.end());
  229.  
  230.  //    cerr << va.size() << ' ' << vb.size() << '\n';
  231.      F = Matrix<int>(va.size(), vb.size());
  232.      pfill(F[], F[va.size()], );
  233.      for (int i = ; i <= n; i++) {
  234.          a[i] = lower_bound(va.begin(), va.end(), gcd(v[i], A)) - va.begin();
  235.          b[i] = lower_bound(vb.begin(), vb.end(), gcd(v[i], B)) - vb.begin();
  236.      }
  237.  
  238.      diva = new vector<int>[va.size()];
  239.      divb = new vector<int>[vb.size()];
  240.      mula = new vector<int>[va.size()];
  241.      mulb = new vector<int>[vb.size()];
  242.      for (int i = ; i < (signed) va.size(); i++) {
  243.          for (int j = ; j < (signed) va.size(); j++) {
  244.              if (!(va[i] % va[j]))
  245.                  diva[i].push_back(j);
  246.              if (!(va[j] % va[i]))
  247.                  mula[i].push_back(j);
  248.          }
  249.      }
  250.      for (int i = ; i < (signed) vb.size(); i++) {
  251.          for (int j = ; j < (signed) vb.size(); j++) {
  252.              if (!(vb[i] % vb[j]))
  253.                  divb[i].push_back(j);
  254.              if (!(vb[j] % vb[i]))
  255.                  mulb[i].push_back(j);
  256.          }
  257.      }
  258.  }
  259.  
  260.  void dp(int p, int fa) {
  261.      if (p == ) {
  262.          f[p] = ;
  263.      } else {
  264.          for (auto x : mulb[b[p]])
  265.              f[p] = add(f[p], F[a[p]][x], Mod);
  266.      }
  267.      for (auto x : diva[a[p]])
  268.          F[x][b[p]] = add(F[x][b[p]], f[p], Mod);
  269.      for (auto e : g[p])
  270.          if (e ^ fa)
  271.              dp(e, p);
  272.      for (auto x : diva[a[p]])
  273.          F[x][b[p]] = sub(F[x][b[p]], f[p], Mod);
  274.  }
  275.  
  276.  inline void solve() {
  277.      f = new int[(n + )];
  278.      pfill(f + , f + n + , );
  279.      dp(, );
  280.      for (int i = ; i <= n; i++)
  281.          printf("%d\n", f[i]);
  282.  }
  283.  
  284.  int main() {
  285.      srand((unsigned) time (NULL));
  286.      init();
  287.      discrete();
  288.      solve();
  289.      return ;
  290.  }

Problem A

Problem B 走路

　　显然，使得$(1, 1)$和$(n, n)$不连通的方案斜着放车。

　　然后随便容斥一下，得到：

$ans = n! - 2\sum_{i = 1}^{n}(n - i)! + 1 + \sum_{s = 2}^{n}(s - 1)(n - s)!$

　　发现需要阶乘，阶乘的前缀和以及阶乘的前缀和前缀和。

　　不会。分块大表。

　　laofu把数压成若干可见字符的方法真高级。

　　（请手动打表）

Code

  1.  #include <iostream>
  2.  #include <cstdio>
  3.  using namespace std;
  4.  typedef bool boolean;
  5.  
  6.  const int n = 1e7, Mod = 1e9 + ;
  7.  
  8.  int add(int a, int b) {
  9.      return ((a += b) >= Mod) ? (a - Mod) : (a);
  10.  }
  11.  
  12.  int sub(int a, int b) {
  13.      return ((a -= b) < ) ? (a + Mod) : (a);
  14.  }
  15.  
  16.  int mul(int a, int b) {
  17.      return (a * 1ll * b) % Mod;
  18.  }
  19.  
  20.  void exgcd(int a, int b, int& x, int& y) {
  21.      if (!b)
  22.          x = , y = ;
  23.      else {
  24.          exgcd(b, a % b, y, x);
  25.          y -= (a / b) * x;
  26.      }
  27.  }
  28.  
  29.  int inv(int a, int n) {
  30.      int x, y;
  31.      exgcd(a, n, x, y);
  32.      return (x < ) ? (x + n) : (x);
  33.  }
  34.  
  35.  int fac[n + ];
  36.  int sfac[n + ];
  37.  int ssfac[n + ];
  38.  int ans[n + ];
  39.  
  40.  inline void init() {
  41.      fac[] = ;
  42.      for (int i = ; i <= n; i++)
  43.          fac[i] = mul(fac[i - ], i);
  44.      sfac[] = ;
  45.      for (int i = ; i <= n; i++)
  46.          sfac[i] = add(sfac[i - ], fac[i]);
  47.      ssfac[] = ;
  48.      for (int i = ; i <= n; i++)
  49.          ssfac[i] = add(ssfac[i - ], sfac[i]);
  50.  //    ans[1] = ans[2] = 0, ans[3] = 2;
  51.  //    int reduce =
  52.  //    for (in ti = 4; i <= n; i++) {
  53.  //        ans[i] = add(ans[i - 1], fac[i]);
  54.  //        ans[i] = sub(ans[i], fac[i - 1]);
  55.  //        ans[i] = sub(ans[i], mul(fac[i - 1], 2));
  56.  //        ans[i] = add(ans[i], )
  57.  //    }
  58.  }
  59.  
  60.  inline void solve() {
  61.      int T, n;
  62.  //    cerr << fac[300000] << " " << sfac[300000] << " " << ssfac[300000] << '\n';
  63.      scanf("%d", &T);
  64.      while (T--) {
  65.          scanf("%d", &n);
  66.  //        int ans = fac[n];
  67.  //        for (int i = 1; i <= n; i++)
  68.  //            ans = sub(sub(ans, fac[n - i]), fac[n - i]);
  69.  //        ans = add(ans, 1);
  70.  //        for (int s = 2; s <= n; s++)
  71.  //            ans = add(ans, mul(s - 1, fac[n - s]));
  72.          int ans = ((n <= ) ?  : add(fac[n], ));
  73.          if (n > ) {
  74.              ans = sub(ans, mul(sfac[n - ], ));
  75.              ans = add(ans, ssfac[n - ]);
  76.          }
  77.          printf("%d\n", ans);
  78.      }
  79.  }
  80.  
  81.  int main() {
  82.      init();
  83.      solve();
  84.      return ;
  85.  }

Problem B

Problem C 有趣的字符串题

　　好像SD有道是这道题的强制在线的版本，之前有人讲过分块做法。然后就一直陷入了分块的漩涡中。sad....

　　正解是考虑右端点在$r$的时候，询问左端点在每个位置时的答案。

　　考虑移动右端点至$r + 1$时产生的贡献。显然我们只用考虑它的回文border。

　　考虑一些长度构成等差数列的border。

　　对于每一段讨论它会产生贡献的部分。注意向前移动周期个字符的情形以及前一个这中间的最长串的前一个的出现的位置$[x, y]$。

　　若$z$是这些串中最短的一个串出现的左端点。不难得到当左端点在整数区间$(x, z]$中时，会有贡献。

　　对于不同的这样的border，显然每一组可以单独计算贡献。

　　因此我们用一个树状数组维护这个贡献，用线段树维护最后的出现位置，再用回文树维护border，就完事了。

　　时间复杂度$O(n\log^2n + m\log n)$。

Code

  1.  #include <algorithm>
  2.  #include <iostream>
  3.  #include <cstdlib>
  4.  #include <cstring>
  5.  #include <cstdio>
  6.  #include <map>
  7.  using namespace std;
  8.  typedef bool boolean;
  9.  
  10.  template <typename T>
  11.  void pfill(T* pst, const T* ped, T val) {
  12.      for ( ; pst != ped; *(pst++) = val);
  13.  }
  14.  
  15.  typedef class Input {
  16.      protected:
  17.          const static int limit = ;
  18.          FILE* file; 
  19.  
  20.          int ss, st;
  21.          char buf[limit];
  22.      public:
  23.  
  24.          Input():file(NULL)    {    };
  25.          Input(FILE* file):file(file) {    }
  26.  
  27.          void open(FILE *file) {
  28.              this->file = file;
  29.          }
  30.  
  31.          void open(const char* filename) {
  32.              file = fopen(filename, "r");
  33.          }
  34.  
  35.          char pick() {
  36.              if (ss == st)
  37.                  st = fread(buf, , limit, file), ss = ;//, cerr << "str: " << buf << "ed " << st << endl;
  38.              return buf[ss++];
  39.          }
  40.  }Input;
  41.  
  42.  #define digit(_x) ((_x) >= '0' && (_x) <= '9')
  43.  
  44.  Input& operator >> (Input& in, unsigned& u) {
  45.      char x;
  46.      while (~(x = in.pick()) && !digit(x));
  47.      for (u = x - ''; ~(x = in.pick()) && digit(x); u = u *  + x - '');
  48.      return in;
  49.  }
  50.  
  51.  Input& operator >> (Input& in, unsigned long long& u) {
  52.      char x;
  53.      while (~(x = in.pick()) && !digit(x));
  54.      for (u = x - ''; ~(x = in.pick()) && digit(x); u = u *  + x - '');
  55.      return in;
  56.  }
  57.  
  58.  Input& operator >> (Input& in, int& u) {
  59.      char x;
  60.      while (~(x = in.pick()) && !digit(x) && x != '-');
  61.      int aflag = ((x == '-') ? (x = in.pick(), -) : ());
  62.      for (u = x - ''; ~(x = in.pick()) && digit(x); u = u *  + x - '');
  63.      u *= aflag;
  64.      return in;
  65.  }
  66.  
  67.  Input& operator >> (Input& in, long long& u) {
  68.      char x;
  69.      while (~(x = in.pick()) && !digit(x) && x != '-');
  70.      int aflag = ((x == '-') ? (x = in.pick(), -) : ());
  71.      for (u = x - ''; ~(x = in.pick()) && digit(x); u = u *  + x - '');
  72.      u *= aflag;
  73.      return in;
  74.  }
  75.  
  76.  Input& operator >> (Input& in, char* str) {
  77.      for (char x; ~(x = in.pick()) && x != '\n' && x != ' '; *(str++) = x);
  78.  }
  79.  
  80.  Input in (stdin);
  81.  
  82.  const int alpha = ;
  83.  
  84.  typedef class TrieNode {
  85.      public:
  86.          int len, dif, g;
  87.          int in, out, id;
  88.          map<char, TrieNode*> ch;
  89.          TrieNode *fail, *slink;
  90.  }TrieNode;
  91.  
  92.  typedef class PalindromeTree {
  93.      public:
  94.          int len;
  95.          TrieNode *pool;
  96.          TrieNode *top;
  97.          TrieNode *odd, *even;
  98.          TrieNode *last;
  99.          TrieNode **node;
  100.          char *str; 
  101.  
  102.          TrieNode* newnode(int len) {
  103.              top->id = top - pool;
  104.              top->len = len, top->dif = -, top->g = ;
  105.  //            memset(top->ch, 0, sizeof(top->ch));
  106.              top->fail = top->slink = NULL;
  107.              return top++;
  108.          }
  109.  
  110.          PalindromeTree() {        }
  111.          PalindromeTree(int n) {
  112.              node = new TrieNode*[(n + )];
  113.              pool = new TrieNode[(n + )];
  114.              str = new char[(n + )];
  115.              top = pool, len = ;
  116.              odd = newnode(-), even = newnode();
  117.              odd->fail = odd, even->fail = odd;
  118.              odd->dif = even->dif = -, last = even, str[] = ;
  119.          }
  120.  
  121.          TrieNode* extend(TrieNode* p) {
  122.              while (str[len - p->len - ] != str[len])    p = p->fail;
  123.              return p;
  124.          }
  125.  
  126.          void append(char x) {
  127.              str[++len] = x;
  128.              int c = x - 'a';
  129.              last = extend(last);
  130.              if (!last->ch[c]) {
  131.                  TrieNode* p = newnode(last->len + );
  132.                  p->fail = extend(last->fail)->ch[c];
  133.                  if (!p->fail)
  134.                      p->fail = even;
  135.                  last->ch[c] = p;
  136.                  p->dif = p->len - p->fail->len; 
  137.  
  138.                  if (p->dif == p->fail->dif)
  139.                      p->slink = p->fail->slink;
  140.                  else
  141.                      p->slink = p->fail;
  142.              }
  143.              last = last->ch[c];
  144.              node[len] = last;
  145.          }
  146.  
  147.          void build(vector<int>* g) {
  148.              for (TrieNode* p = pool; p != top; p++) {
  149.                  if (p->fail && p->fail != p) {
  150.                      g[p->fail->id].push_back(p->id);
  151.                      g[p->id].push_back(p->fail->id);
  152.                  }
  153.              }
  154.          }
  155.  
  156.          TrieNode* operator [] (int p) {
  157.              return node[p];
  158.          }
  159.  }PalindromeTree;
  160.  
  161.  typedef class Query {
  162.      public:
  163.          int l, r, id;
  164.  
  165.          boolean operator < (Query p) const {
  166.              return r < p.r;
  167.          }
  168.  }Query;
  169.  
  170.  typedef class SegTreeNode {
  171.      public:
  172.          int val;
  173.          SegTreeNode *l, *r;
  174.  
  175.          SegTreeNode() : val(), l(NULL), r(NULL) {    }
  176.  
  177.          void pushUp() {
  178.              val = max(l->val, r->val);
  179.          }
  180.  }SegTreeNode;
  181.  
  182.  const int N = 3e5 + ;
  183.  
  184.  SegTreeNode pool[N << ];
  185.  SegTreeNode *top = pool;
  186.  
  187.  SegTreeNode *newnode() {
  188.      return top++;
  189.  }
  190.  
  191.  typedef class SegTree {
  192.      public:
  193.          int n;
  194.          SegTreeNode* rt;
  195.  
  196.          SegTree() : rt(NULL) {    }
  197.          SegTree(int n) : n(n) {
  198.              build(rt, , n);
  199.          }
  200.  
  201.          void build(SegTreeNode*& p, int l, int r) {
  202.              p = newnode();
  203.              if (l == r)
  204.                  return ;
  205.              int mid = (l + r) >> ;
  206.              build(p->l, l, mid);
  207.              build(p->r, mid + , r);
  208.          }
  209.  
  210.          void modify(SegTreeNode *p, int l, int r, int idx, int val) {
  211.              if (l == r) {
  212.                  p->val = val;
  213.                  return ;
  214.              }
  215.              int mid = (l + r) >> ;
  216.              if (idx <= mid)
  217.                  modify(p->l, l, mid, idx, val);
  218.              else
  219.                  modify(p->r, mid + , r, idx, val);
  220.              p->pushUp();
  221.          }
  222.  
  223.          int query(SegTreeNode* p, int l, int r, int ql, int qr) {
  224.              if (l == ql && r == qr)
  225.                  return p->val;
  226.              int mid = (l + r) >> ;
  227.              if (qr <= mid)
  228.                  return query(p->l, l, mid, ql, qr);
  229.              if (ql > mid)
  230.                  return query(p->r, mid + , r, ql, qr);
  231.              int a = query(p->l, l, mid, ql, mid);
  232.              int b = query(p->r, mid + , r, mid + , qr);
  233.              return (a > b) ? (a) : (b);
  234.          }
  235.  
  236.          void modify(int idx, int val) {
  237.              modify(rt, , n, idx, val);
  238.          }
  239.  
  240.          int query(int ql, int qr) {
  241.              return query(rt, , n, ql, qr);
  242.          }
  243.  }SegTree;
  244.  
  245.  typedef class IndexedTree {
  246.      public:
  247.          int s;
  248.          int *a;
  249.  
  250.          IndexedTree() {    }
  251.          IndexedTree(int n) : s(n) {
  252.              a = new int[(n + )];
  253.              pfill(a, a + n + , );
  254.          }
  255.  
  256.          void add(int idx, int val) {
  257.              for ( ; idx <= s; idx += (idx & (-idx)))
  258.                  a[idx] += val;
  259.          }
  260.  
  261.          void add(int l, int r, int val) {
  262.              add(l, val), add(r + , -val);
  263.          }
  264.  
  265.          int query(int idx) {
  266.              int rt = ;
  267.              for ( ; idx; idx -= (idx & (-idx)))
  268.                  rt += a[idx];
  269.              return rt;
  270.          }
  271.  }IndexedTree;
  272.  
  273.  const int Mod = 1e9 + ;
  274.  
  275.  int add(int a, int b) {
  276.      return ((a += b) >= Mod) ? (a - Mod) : (a);
  277.  }
  278.  
  279.  int sub(int a, int b) {
  280.      return ((a -= b) < ) ? (a + Mod) : (a);
  281.  }
  282.  
  283.  int mul(int a, int b) {
  284.      return a * 1ll * b % Mod;
  285.  }
  286.  
  287.  int n, m;
  288.  char *s;
  289.  Query* qs;
  290.  SegTree st;
  291.  vector<int> *g;
  292.  IndexedTree it;
  293.  PalindromeTree pt;
  294.  
  295.  inline void init() {
  296.      in >> n >> m;
  297.      s = new char[(n + )];
  298.      qs = new Query[(m + )];
  299.      pt = PalindromeTree(n + );
  300.      g = new vector<int>[(n + )];
  301.      in >> s;
  302.      for (int i = ; i < n; i++)
  303.          pt.append(s[i]);
  304.      delete[] s;
  305.      pt.build(g);
  306.      for (int i = ; i <= m; i++)
  307.          in >> qs[i].l >> qs[i].r, qs[i].id = i;
  308.  }
  309.  
  310.  int dfs_clock;
  311.  void dfs(int p, int fa) {
  312.      pt.pool[p].in = ++dfs_clock;
  313.  //    cerr << p << " " << fa << '\n';
  314.      for (auto e : g[p])
  315.          if (e ^ fa)
  316.              dfs(e, p);
  317.      pt.pool[p].out = dfs_clock;
  318.  }
  319.  
  320.  int res = ;
  321.  inline void solve() {
  322.      st = SegTree(n + );
  323.      it = IndexedTree(n);
  324.      dfs(, -);
  325.      sort(qs + , qs + m + );
  326.  
  327.      Query* q = qs + , *qed = qs + m + ;
  328.      for (int i = ; i <= n; i++) {
  329.          for (TrieNode *p = pt[i]; p && p->len; p = p->slink) {
  330.              int left = max(st.query(p->in, p->out) - p->len + , ) + ;
  331.              int right = i - p->dif - ((p->slink) ? (p->slink->len) : ()) + ;
  332.  //            cerr << i << " " << left << " " << right << '\n';
  333.              it.add(left, right, );
  334.          }
  335.          st.modify(pt[i]->in, i);
  336.          while (q != qed && q->r == i) {
  337.              res = add(res, mul(it.query(q->l), q->id));
  338.  //            cerr << "Q: " << it.query(q->l) << " " << q->id << '\n';
  339.              q++;
  340.          }
  341.      }
  342.      printf("%d\n", res);
  343.  }
  344.  
  345.  int main() {
  346.      init();
  347.      solve();
  348.      return ;
  349.  }

Problem C

湖南省队集训 Day 2的更多相关文章

  1. [2018湖南省队集训] 6.24 T1 marshland

    题面在这里! 一开始感觉像一个类似二分图的最小割,于是成功跑偏2333333 很容易发现一个关键性质,'L'的两个角落在的偶数格 的行(或者列)的奇偶性一定不同.... 于是我们再把偶数格按照行(或者 ...

  2. [2018湖南省队集训] 6.28 T3 simulate

    这道模拟题出的我毫无脾气2333 最重要的是先要发现操作顺序不影响最后的答案,也就是每次随便挑一个>=2的数进行操作最后总是可以得到同样的数列. (这个还不太难想qwq) 但是最骚的是接下来的模 ...

  3. [2018湖南省队集训] 6.28 T2 color

    毒瘤计数题2333,(小声)k其实可以出到1e9,不过这样求组合数的时候就要记1000种数的1~1000次下降幂(用到的组合数中第一维在1e9级别的只有1000种左右,第二维都是<=1000), ...

  4. JS省队集训记

    不知不觉省队集训已经结束,离noi也越来越近了呢 论考前实战训练的重要性,让我随便总结一下这几天的考试 Day 1 T1 唉,感觉跟xj测试很像啊?meet in middle,不过这种题不多测是什么 ...

  5. [2018HN省队集训D9T1] circle

    [2018HN省队集训D9T1] circle 题意 给定一个 \(n\) 个点的竞赛图并在其中钦定了 \(k\) 个点, 数据保证删去钦定的 \(k\) 个点后这个图没有环. 问在不删去钦定的这 \ ...

  6. [2018HN省队集训D8T1] 杀毒软件

    [2018HN省队集训D8T1] 杀毒软件 题意 给定一个 \(m\) 个01串的字典以及一个长度为 \(n\) 的 01? 序列. 对这个序列进行 \(q\) 次操作, 修改某个位置的字符情况以及查 ...

  7. [2018HN省队集训D8T3] 水果拼盘

    [2018HN省队集训D8T3] 水果拼盘 题意 给定 \(n\) 个集合, 每个集合包含 \([1,m]\) 中的一些整数, 在这些集合中随机选取 \(k\) 个集合, 求这 \(k\) 个集合的并 ...

  8. [2018HN省队集训D6T2] girls

    [2018HN省队集训D6T2] girls 题意 给定一张 \(n\) 个点 \(m\) 条边的无向图, 求选三个不同结点并使它们两两不邻接的所有方案的权值和 \(\bmod 2^{64}\) 的值 ...

  9. [Luogu P4143] 采集矿石 [2018HN省队集训D5T3] 望乡台platform

    [Luogu P4143] 采集矿石 [2018HN省队集训D5T3] 望乡台platform 题意 给定一个小写字母构成的字符串, 每个字符有一个非负权值. 输出所有满足权值和等于这个子串在所有本质 ...

随机推荐

  1. lua 操作redis

    Redis在2.6推出了脚本功能,允许开发者使用Lua语言编写脚本传到Redis中执行.使用脚本的好处如下: 1.减少网络开销:本来5次网络请求的操作,可以用一个请求完成,原先5次请求的逻辑放在red ...

  2. vue加载流程

    首先加载main.js,main.js中new一个vue实例,这个实例中会有一个id="app"映射到app.vue,启动时候首页映射到index.html,其中<div i ...

  3. qs.stringify和JSON.stringify()

    var a = {name:'hehe',age:10}; qs.stringify(a) // 'name=hehe&age=10' JSON.stringify(a) // '{" ...

  4. VUE-007-通过路由 router.push 传递 query 参数（路由 name 识别，请求链接显示参数传递）

    在前端页面表单列表修改时,经常需要在页面切换的时候,传递需要修改的表单内容,通常可通过路由进行表单参数的传递. 首先,配置页面跳转路由.在 router/index.js 中配置相应的页面跳转路由,如 ...

  5. 干了这杯java之ThreadLocal

    ThreadLocal Java篇 是什么 怎么用 源码 缺点 总结 是什么 ThreadLocal是一个关于创建线程局部变量的类,这个变量只能当前线程使用,其他线程不可用. ThreadLocal提 ...

  6. python类与对象-如何让对象支持上下文管理

    如何让对象支持上下文管理 问题举例 一个telnet客户端的类TelnetClient, 调用实例的connect(),login(),interact方法 启动客户端与服务器交互,交互完毕后需要调用 ...

  7. 网页静态化解决方案-Freemarker demo+语法

    1.网页静态化技术Freemarker 1.1为什么要使用网页静态化技术 网页静态化解决方案在实际开发中运用比较多,例如新闻网站,门户网站中的新闻频道或者是文章类的频道. 对于电商网站的商品详细页来说 ...

  8. 关于信号打断正在读取终端的read与select来监视0文件描述符的问题

    首先说一下对于这个问题外的一些话: 我觉得我们应该有种质疑的态度,因为接下来的这个问题就和我们平常所想的不一样. 介绍一下问题: 曾经一直听说信号可以打断一个正在阻塞的进程,但是今天我试了一下关于信号 ...

  9. 配置php环境的一个nginx.conf

    文件:nginx.conf 内容: #user  nobody;worker_processes  1; #error_log  logs/error.log;#error_log  logs/err ...

  10. Kendo DropDownListFor值传不回去的小坑

    做项目时,在KendoWindow弹框里面写了个表单提交,不小心把AreaId  下拉框设置了Name为“OrderAreaId”.在后台接收不到AreaId的参数.后来才发现是Name的设置强行把A ...