<![CDATA[QuarterGeek]]> 2015-10-18T12:25:38+08:00 https://quartergeek.com/ Octopress <![CDATA[[Codeforces Round 193 (Div. 2)] C. Students Revenge]]> 2013-11-06T00:00:00+08:00 https://quartergeek.com/cf332c 非常厉害的一题贪心题。Orz Lazycal。题目大意是：

  • 有 n 条命令，你要从中选出恰好 p 条命令作为候选命令，然后主席会从中选出恰好 k 条命令执行。
  • 每条命令有两个属性：如果执行那么主席的会变白的头发数 Ai，如果不执行那么委员会的不满意指数 Bi 。
  • 对于主席来说，她首先希望不执行的那 p-k 条给委员会带来的不满意指数最小，然后希望那 k 条命令使自己变白的头发最少。
  • 对于你来说（，由于某些原因），你首先希望主席变白的头发最多，然后希望委员会的不满意指数最大。
  • 现在让你求应该选出哪 p 条命令。

分析一下：首先我们不能很high地直接把 Ai 最大的 k 条选出来，因为很有可能剩下的 p-k 条会使得我们取不到最好情况。实质上，我们和主席的价值观不一样，所以会导致直接取最大失败。我们应该设下挖坑让主席跳下去，我们可以先确定可被选到的最凶残的 k 条，让主席不得不选它们，然后再考虑剩下的 p-k 使得委员会不满意指数最大，同时又不影响主席选择那 k 条。我们不妨从主席的角度考虑。

我们把 n 条命令按照主席的意愿 (-Bi, +Ai) 排序，那么主席就会按照排序后的顺序从前到后选取命令来执行。注意到最后的 p-k 条命令我们是没必要选出来的，因为选了这其中的任意一条，都会被主席放在最后（很有可能不执行），然后就算这几条的 Ai 再大，也发挥不了用处。

好了，我们知道了主席的顺序，现在我们想让主席的头发白掉，所以我们把前 n-(p-k) 条命令按照我们的意愿 (-Ai) 稳定排序。选出前 k 条，这就是主席必选的 k 条。

现在我们考虑选出剩下的 p-k 条，这 p-k 条不能影响到前面 k 条的选取。因此我们可以先找到 k 条必选命令中，主席最后执行的命令是哪条（也就是第一次排序的结果中最靠后的），然后从这条后面选取。显然，在保证不会影响 k 条的情况下，我们按我们的意愿 (-Bi) 排序选出剩下的 p-k 条即可！

代码

Codeforces 332 C 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <cstdio>
#include <algorithm>
using std::sort;

const int MAXN = 100000;
struct Order { int hair, anger, index, _i; };
Order a[MAXN], b[MAXN];
int n, p, k;
int main()
{
  scanf("%d%d%d", &n, &p, &k);
  for (int i = 0; i < n; ++i)
  {
    scanf("%d%d", &a[i].hair, &a[i].anger);
    a[i].index = i+1;
  }
  sort(a, a+n, [](const Order& lhs, const Order& rhs)
    { return lhs.anger > rhs.anger || (lhs.anger == rhs.anger && lhs.hair < rhs.hair); });
  for (int i = 0; i < n-p+k; ++i)
    b[i] = {a[i].hair, a[i].anger, a[i].index, i};
  sort(b, b+n-p+k, [](const Order& lhs, const Order& rhs)
    { return lhs.hair > rhs.hair || (lhs.hair == rhs.hair && lhs._i < rhs._i); });
  int latest = -1;
  for (int i = 0; i < k; ++i)
  {
    latest = std::max(latest, b[i]._i);
    printf("%d ", b[i].index);
  }
  sort(a+latest+1, a+n, [](const Order& lhs, const Order& rhs)
    { return lhs.anger > rhs.anger; });
  for (int i = 0; i < p-k; ++i)
    printf("%d ", a[latest+1+i].index);
}
]]> <![CDATA[[TYVJ1319]count]]> 2013-06-18T00:00:00+08:00 https://quartergeek.com/1319-count 题目大概就是说，让你根据下面规则，生成字符串\(S_n\)，然后求出一个模式串在\(S_n\)中出现次数：

\[ \begin{eqnarray*} S_0 &=& 0\\ S_1 &=& 1\\ S_n &=& S_{n-2} S_{n-1} \end{eqnarray*} \]

这题好像是吴翼出的NOIP模拟题，十分的厉害（真心不是NOIP难度啊）。一眼看到这题和这题的数据范围，我就冒出了矩阵和KMP这两个想法，但是看到模式串长度\(M \leq 10000\)，完全不懂得如何写递推式了……

后来Orz了一下xietutu的题解，发现这题有个非常巧妙的转化。

设\(F_n\)为\(S_n\)中模式串出现的次数，显然有\(F_n=F_{n-2}+F_{n-1}+C_n\)，其中\(C_n\)就是拼接产生的匹配。这个还是很显然的，大家都想得到，但是这个\(C_n\)如何搞到还真是一个问题。

要搞到\(C_n\)还是得利用KMP。我们在对\(S_n\)这个串做KMP的时候，可以发现，如果在\(i\)这个位置匹配是\(S_{n-2} S_{n-1}\)拼接产生的匹配，那么\(i-M+1 \leq len(S_{n-2}) < i\)。这样我们就利用了KMP求出了\(C_n\)。

最神的地方在于：存在一个正整数\(\alpha\)，使得对任意\(2n\geq\alpha\)，都有\(C_{2n} = C_\alpha\)和\(C_{2n+1} = C_{\alpha+1}\)成立。更形象的说，就是当串\(S_n\)的长度达到一定程度的时候，那么拼接产生的匹配的次数将只由\(n\)的奇偶决定，分别为一个定值。这个还是非常好理解的。

那么分奇偶如何能矩阵乱搞呢？注意到

\[ \begin{eqnarray*} F_n &=& F_{n-2} + F_{n-1} + t_1\\ F_{n-1} &=& F_{n-3} + F_{n-2} + t_2 \end{eqnarray*} \]

那么我们两个式子相加一下，就可以得到

\[ F_n = F_{n-3} + 2F_{n-2} + t_1 + t_2 \]

我们分奇偶求出了\(t_1\)和\(t_2\)之后，就可以构造出如下矩阵了：

\[ \begin{bmatrix} F_n\\ F_{n-1}\\ F_{n-2}\\ t_1 + t_2 \end{bmatrix} = \begin{bmatrix} 0 & 2 & 1 & 1\\ 1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} F_{n-1}\\ F_{n-2}\\ F_{n-3}\\ t_1 + t_2 \end{bmatrix}\\ = \begin{bmatrix} 0 & 2 & 1 & 1\\ 1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 0 & 1 \end{bmatrix}^{n-\alpha} \begin{bmatrix} F_{\alpha}\\ F_{\alpha-1}\\ F_{\alpha-2}\\ t_1 + t_2 \end{bmatrix} \]

然后我们就对\(\alpha\)以内的暴力求出来，后面再矩阵快速幂。

代码

count 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

#include <cstdio>
#include <cstring>
#include <algorithm>

int N, M, P, l[24], p[80000];
long long f[24], t[24];
char a[80000], s[3][80000];
struct Matrix
{
  int m[4][4];
  Matrix(): m() { }
} I;
inline Matrix operator*(const Matrix& a, const Matrix& b)
{
  Matrix c;
  for (int k = 0; k < 4; ++k)
    for (int i = 0; i < 4; ++i)
      for (int j = 0; j < 4; ++j)
        c.m[i][j] = (c.m[i][j] + static_cast<long long>(a.m[i][k])*b.m[k][j]) % P;
  return c;
}
inline Matrix power(Matrix base, int k)
{
  Matrix res(I);
  for (; k; k >>= 1)
  {
    if (k & 1) res = res*base;
    base = base*base;
  }
  return res;
}
int kmp(const char *s, const int n, const int last, long long& mid)
{
  int cnt = 0;
  for (int i = 0, j = -1; i < n; ++i)
  {
    while (j > -1 && a[j+1] != s[i]) j = p[j];
    if (a[j+1] == s[i]) ++j;
    if (j == M-1)
    {
      ++cnt;
      if (i >= last && last > i-M) ++mid;
      j = p[j];
    }
  }
  return cnt;
}
int main()
{
  freopen("count.in", "r", stdin);
  freopen("count.out", "w", stdout);

  I.m[0][0] = I.m[1][1] = I.m[2][2] = I.m[3][3] = 1;
  scanf("%d%d%d%s", &N, &M, &P, a);
  p[0] = -1;
  for (int i = 1, j = -1; i < M; ++i)
  {
    while (j > -1 && a[j+1] != a[i]) j = p[j];
    if (a[j+1] == a[i]) ++j;
    p[i] = j;
  }
  s[0][0] = '0', l[0] = 1;
  s[1][0] = '1', l[1] = 1;
  for (int i = 2, now = 2; i < 24; ++i, now = (now+1)%3)
  {
    strcpy(s[now], s[(now+1)%3]);
    strcpy(s[now]+l[i-2], s[(now+2)%3]);
    f[i] = kmp(s[now], l[i] = l[i-1]+l[i-2], l[i-2], t[i]);
  }
  if (N < 24)
  {
    printf("%d", static_cast<int>(f[N] % P));
    fclose(stdin);fclose(stdout);
    return 0;
  }
  Matrix mat;
  mat.m[0][0] = 0, mat.m[0][1] = 2, mat.m[0][2] = 1, mat.m[0][3] = 1;
  mat.m[1][0] = 1, mat.m[1][1] = 0, mat.m[1][2] = 0, mat.m[1][3] = 0;
  mat.m[2][0] = 0, mat.m[2][1] = 1, mat.m[2][2] = 0, mat.m[2][3] = 0;
  mat.m[3][0] = 0, mat.m[3][1] = 0, mat.m[3][2] = 0, mat.m[3][3] = 1;
  const Matrix res = power(mat, N-23);
  printf("%d", static_cast<int>((res.m[0][0]*f[23]+res.m[0][1]*f[22]+res.m[0][2]*f[21]+res.m[0][3]*(t[23]+t[22]))%P));

  fclose(stdin);fclose(stdout);
}
]]> <![CDATA[[POJ3222]Edge Pairing]]> 2013-06-12T00:00:00+08:00 https://quartergeek.com/poj3222 这道题觉得十分的厉害，因为看了之后一点想法都没有。不得不Orz Discuss里面的神犇。这题要的是配对，配对这种东西一般是用二分图匹配做的，但是这题完全不懂如何构造出二分图。

Discuss里面的神犇提供了另外一种思路：“图分治”！嗯，这是一个非常神奇的东西，比树分治还神奇。

example
example

如果你把一个点u拿出来，然后DFS它所有相邻的点。

对于一个还没有访问过的点v，做完它有2种可能性：

  1. 它剩下一条边(v, w)无法匹配。那我们就构造(u, v, w)这样一对
  2. 它完美的被解决了，那么我们(u, v)这条边就会悬空，不过没关系，我们可以等待下一次发生这样的事情，比方说是(u, s)，那么我们可以配对(v, u, s)

对于一个比u时间戳大的点v，显然我们就不再考虑去做他了，因为他已经做过了。但是(u, v)这条边还是要考虑的，处理方法和上面2一样。

如果一个点结束的时候还有一条边没有配对，那就返回这条边，让调用它的那个点解决，也就是上面的1。

总之是一个非常神的方法。

poj3222Edge Pairing 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

#include <cstdio>

const int MAXN = 20000, MAXM = 100000;
struct Edge
{
  int v;
  Edge *next;
} g[MAXM*2], *header[MAXN];
void AddEdge(const int x, const int y)
{
  static int LinkSize;
  Edge* const node = g+(LinkSize++);
  node->v = y;
  node->next = header[x];
  header[x] = node;
}
int timestamp, n, m, cnt, dfn[MAXN], ans[MAXM/2][3];
int dfs(const int u)
{
  dfn[u] = ++timestamp;
  int v = -1;
  for (Edge *e = header[u]; e; e = e->next)
    if (!dfn[e->v])
    {
      const int w = dfs(e->v);
      if (w != -1)
        ans[cnt][0] = u, ans[cnt][1] = e->v, ans[cnt++][2] = w;
      else if (v != -1)
        ans[cnt][0] = v, ans[cnt][1] = u, ans[cnt++][2] = e->v, v = -1;
      else
        v = e->v;
    }
    else if (dfn[e->v] > dfn[u])
    {
      if (v != -1)
        ans[cnt][0] = v, ans[cnt][1] = u, ans[cnt++][2] = e->v, v = -1;
      else
        v = e->v;
    }
  return v;
}
int main()
{
  scanf("%d%d", &n, &m);
  for (int i = 0, x, y; i < m; ++i)
  {
    scanf("%d%d", &x, &y);
    --x, --y;
    AddEdge(x, y);
    AddEdge(y, x);
  }
  if (dfs(1) == -1)
    for (int i = 0; i < cnt; ++i)
      printf("%d %d %d\n", ans[i][0]+1, ans[i][1]+1, ans[i][2]+1);
  else
    printf("NO");
}
]]> <![CDATA[PKUSC2012 Round1]]> 2013-06-12T00:00:00+08:00 https://quartergeek.com/pkusc2012a About

地址：http://poj.grids.cn/summercamp2012a/

据说都是POJ原题……ABCDE都是一眼题吧，F非常巧妙，G这题第二次遇到还是不会，H完全看不懂。

A: 勇敢与鲁莽

询问Fib[i]是否整除Fib[j]。

可以证明（或者打表发现），问题等价于i是否整除j。需要特判Fib[2]这一项。

B: 一个有意义的校庆

给定若干对事件的先后顺序，求字典序最小的顺序。

拓扑……

C: 雷涛的小猫

有若干个柱子，柱子某些位置上有东西，可以从任意柱子的顶端出发，每次可以向下一格，或者跳到任意柱子上并且掉下delta个位置，问到达地上时最多拿到多少物品。

F[i, j] = max{ F[i-1, j], max(F[i-delta, k]) }

D: Edge Detection

给定一张很大的图像，让你产生一个输出，每个格子的值是原图它和上下左右差的最小值。图像用不多于1000组的数对(value, times)表示接下来有连续times个value。

觉得就是细节处理题吧……估计大家都不爱写，考场上只有3人写，1人AC。

E: Priest John’s Busiest Day

有n个人要结婚并且婚礼时间是[Si, Ti]，在婚礼的开始或者结束，需要Di分钟让神父为他们祝福，也就是[Si, Si+Di]或者[Ti-Di, Ti]，问能否安排使得全部人都能收到祝福。

应该是2-SAT吧，没写过，得补一下。

F: 边配对

给出一个有n个顶点、m条边的简单无向连通图，其中m为偶数。求一个边的一个配对，使得每一对边共用一个顶点。

example
example

非常巧妙的一个DFS构造。不得不膜拜Discuss里面的神犇。见另外一篇题解。

G: Color a Tree

给定一棵带点权的树，要求对树染色，第i次染色花费为i*v[node]，一个点仅当它的父亲被染色他才能被染色。求最小花费。

神贪心，上次考试的时候出过，不会，现在还是不会……一开始每个点自己为一个集合，然后按照sum[s]/size[s]贪心，一个集合一个集合地并到父亲节点上。

H: ATP

看不懂题目我会乱说？

]]> <![CDATA[[BZOJ2883]gss2加强版]]> 2013-06-10T00:00:00+08:00 https://quartergeek.com/bzoj2883 其实这题跟GSS2毛线关系都没有，求的根本不一样么，这题求的就是区间和，GSS2那题求的是区间和的最大值……但是相同的是：都是每个数只算一次。

其实看到这题我的想法就是线段树套动态分配的权值线段树，外层的线段树用来限制区间，顺便维护区间和，内层的权值线段树记下每个数出现的次数，这样修改的时候只要对每个数次数次数由0变1或者由1变0进行特判，更新区间和即可。然后就很高兴的去打了，结果连样例都过不去，才发现这样还是有BUG：在外层线段树查询的时候，左右子树的并还是可能有重复的数……后来YY了一下，干脆query就构造一棵内层的线段树，时间复杂度看起来不会很糟糕，但是事实证明空间复杂度相当高（后来下了数据，发现时间复杂度也非常高），所以这是一种非常不可行的方法。

后来请教了下ygy副队，发现对于这种一个数只记一次的题目有一种通用的方法：一维转二维。我们把a[i]转成一个二维点：(last[i], i)，last[i]为i之前a[i]出现的位置，呃，因为这题要求和嘛，所以我们可以给这个二维点一个值a[i]，这样我们就完美的把一维的数转成了二维的点。

接下来查询区间[L, R]就十分愉悦了，直接查找x在[0, L-1]并且y在[L, R]的所有点的和。

然后就是修改了，考虑一下修改一个数会改变多少个点，修改相当于去掉一个数，再添上一个数。对于去掉一个数a[i]，显然会影响到a[i]相邻两个和他相同的数。所以去掉一个数会影响3个点，所以一次修改操作会影响6个点。为了方便的维护一个数和他相同数的位置，可以维护一棵平衡树。

实际写起来还是很好写的，内存也不是很大。

bzoj2883gss2加强版 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#include <set>
#include <cstdio>
#include <vector>
#include <algorithm>
using std::set;
using std::vector;

const int MAXN = 100001;
const int MEMORYSIZE = 1024*1024*4;
//------1D SegmentTree
struct Segment1D
{
  long long sum;
  Segment1D *lef, *rig;
} _memory[MEMORYSIZE], *_memory_top = _memory;
int n, _n;
class SegmentTree1D
{
#define CREATE_AND_GO(func, node, ...) { if (!node) node = _memory_top++; func(node, __VA_ARGS__); }
  Segment1D *root;
  long long query(Segment1D* const node, const int lef, const int rig, const int st, const int ed)
  {
    if (!node->sum) return 0;
    if (st <= lef && rig <= ed) return node->sum;
    const int mid = (lef+rig)/2;
    long long sum = 0;
    if (st <= mid && node->lef) sum += query(node->lef, lef, mid, st, ed);
    if (mid+1 <= ed && node->rig) sum += query(node->rig, mid+1, rig, st, ed);
    return sum;
  }
  void modify(Segment1D* const node, const int lef, const int rig, const int pos, const int delta)
  {
    node->sum += delta;
    if (lef == rig) return;
    const int mid = (lef+rig)/2;
    if (pos <= mid) CREATE_AND_GO(modify, node->lef, lef, mid, pos, delta)
    else CREATE_AND_GO(modify, node->rig, mid+1, rig, pos, delta)
  }
#undef CREATE_AND_GO
public:
  long long Query(const int lef, const int rig) { return query(root, 1, n, lef, rig); }
  void Modify(const int pos, const int delta) { modify(root, 1, n, pos, delta); }
  SegmentTree1D(): root(_memory_top++) { }
};
//------2D BIT
SegmentTree1D C[MAXN*2];
inline void Modify(const int x, const int y, const int delta)
{
  for (int i = x+1; i <= _n; i += i&-i)
    C[i].Modify(y, delta);
}
inline long long Query(const int x, const int y1, const int y2)
{
  long long res = 0;
  for (int i = x+1; i; i -= i&-i)
    res += C[i].Query(y1, y2);
  return res;
}
//------Main Program
int m, a[MAXN], x[MAXN], y[MAXN];
char o[MAXN];
set<int> sets[MAXN*2];
int main()
{
  scanf("%d", &n);
  vector<int> v;
  for (int i = 1; i <= n; ++i)
  {
    scanf("%d", a+i);
    v.push_back(a[i]);
  }
  scanf("%d", &m);
  for (int i = 0; i < m; ++i)
  {
    scanf("\n%c%d%d", o+i, x+i, y+i);
    if (o[i] == 'U') v.push_back(y[i]);
  }
  std::sort(v.begin(), v.end());
  v.resize(std::unique(v.begin(), v.end())-v.begin());
  _n = n+1;

  for (size_t i = 0; i < v.size(); ++i) sets[i].insert(0);
  for (int i = 1; i <= n; ++i)
  {
    const int cur = std::lower_bound(v.begin(), v.end(), a[i])-v.begin();
    const int last = *sets[cur].rbegin();
    Modify(last, i, +a[i]);
    sets[cur].insert(i);
  }
  for (int i = 0; i < m; ++i)
  {
    if (o[i] == 'Q')
      printf("%lld\n", Query(x[i]-1, x[i], y[i]));
    else
    {
      const int pos = x[i], value = y[i];

      const int pre = std::lower_bound(v.begin(), v.end(), a[pos])-v.begin();
      set<int>::iterator target = sets[pre].find(pos), succ, prev;
      Modify(*--(prev = target), pos, -a[pos]);
      if (++(succ = target) != sets[pre].end())
      {
        Modify(pos, *succ, -a[pos]);
        Modify(*prev, *succ, +a[pos]);
      }
      sets[pre].erase(target);

      const int cur = std::lower_bound(v.begin(), v.end(), value)-v.begin();
      sets[cur].insert(pos);
      target = sets[cur].find(pos);
      Modify(*--(prev = target), pos, +value);
      if (++(succ = target) != sets[cur].end())
      {
        Modify(*prev, *succ, -value);
        Modify(pos, *succ, +value);
      }

      a[pos] = value;
    }
  }
  //printf("\n\n%10d\n%10d\n%.6fMBytes\n", _memory_top-_memory, MEMORYSIZE, (sizeof(_memory)+sizeof(x)+sizeof(y)+sizeof(o)+sizeof(C))/1024.0/1024.0);
}
]]> <![CDATA[[BZOJ2795][Poi2012]A Horrible Poem]]> 2013-06-10T00:00:00+08:00 https://quartergeek.com/bzoj2795 这题我记得去年福建集训有出过，当时太弱了，完全不懂。现在做到这题才突然想起来可以Hash。

首先无论是Hash还是KMP，要验证循环节，都是用一个方法：如果s[A..A+len-1]是s[A..B]的循环节，那么s[A..B-len+1] == s[A+len-1..B]。所以判定的话直接RK Hash就可以搞定了。

但是这题的数据范围有点大，如何破呢？

注意到，如果len是循环节，那么最短循环节必定是len的约数，同时，如果L1和L2都是循环节，那么lcm(L1, L2)必然是循环节！所以我们可以把len质因数分解了，对于每个质因数找出最短的循环节长度，总的最短循环节长度就是它们的积。

我的错误

像我这种沙茶，连这种题都会犯很沙茶的错误：

  • RK Hash之后，h[i]的最高次明显比h[i+k]来的低，但是我想反了……
  • 质因数分解O(sqrtn)竟然会写成O(n)的……

代码

bzoj2795[Poi2012]A Horrible Poem 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#include <cstdio>
#include <cstring>
#include <algorithm>

const int MAXN = 500001, MAXQ = 2000000;
const unsigned long long P = 131;
struct Link
{
  int prime, times;
  Link *next;
} g[1405799], *header[MAXN];
void AddLink(const int x, const int prime, const int times)
{
  static int LinkSize;
  Link* const node = g+(LinkSize++);
  node->prime = prime;
  node->times = times;
  node->next = header[x];
  header[x] = node;
}
int n, q, primes, prime[MAXN];
unsigned long long h[MAXN], p[MAXN] = {1};
char s[MAXN];
void GetPrimes(const int n)
{
  static bool com[MAXN];
  for (int i = 2; i <= n; ++i)
  {
    if (!com[i]) prime[primes++] = i;
    for (int j = 0; j < primes && i*prime[j] <= n; ++j)
    {
      com[i*prime[j]] = true;
      if (i%prime[j] == 0) break;
    }
  }
}
int main()
{
  scanf("%d%s%d", &n, s+1, &q);
  for (int i = 1; i <= n; ++i) p[i] = p[i-1]*P;
  for (int i = 1; i <= n; ++i) h[i] = h[i-1]*P+s[i]-'a';
  GetPrimes(n);
  for (int i = 2, j, x, cnt; i <= n; ++i)
  {
    for (x = i, j = 0; j < primes && prime[j]*prime[j] <= x; ++j)
    {
      for (cnt = 0; x % prime[j] == 0; x /= prime[j]) ++cnt;
      if (cnt) AddLink(i, prime[j], cnt);
    }
    if (x) AddLink(i, x, 1);
  }
  for (int a, b; q--; )
  {
    scanf("%d%d", &a, &b);
    int ans = b-a+1;
    for (Link *e = header[b-a+1]; e; e = e->next)
    {
      int x = 1;
      for (int i = 0; i < e->times; ++i) x *= e->prime;
      for (; x > 1; x /= e->prime)
      {
        const int l = (b-a+1)/x;
        const unsigned long long tmp1 = h[b-l] - h[a-1]*p[b-a+1-l];
        const unsigned long long tmp2 = h[b] - h[a+l-1]*p[b-a+1-l];
        if (tmp1 == tmp2) { ans /= x; break; }
      }
    }
    printf("%d\n", ans);
  }
}
]]> <![CDATA[[BZOJ3123][Sdoi2013]森林]]> 2013-06-02T00:00:00+08:00 https://quartergeek.com/bzoj3123 这题一开始我想，嗯，这不就是水水的动态树嘛……后来被xietutu神犇吐槽了一下：你仔细看下题目。嗯，我果然沙茶，动态树怎么维护第k大了……后来又请教了下ygy副队，果然又沙茶了：可持久化线段树+启发式合并。

先说启发式合并吧，就是合并两棵树（不管是可持久化线段树还是splay）的时候，把小的树插到的树里面。看起来很暴力的方法，据说可以证明复杂度是log的。

然后这题就是，按DFS序建可持久化线段树，然后对于L操作，就把整棵小树的DFS序插入大树的DFS序列，然后重新建立小树的可持久化线段树。朴素的查询和建树可以参考[BZOJ2588]Spoj 10628. Count on a Tree。

代码

bzoj3123[Sdoi2013]森林 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
using std::vector;

const int MAXN = 80001;
//------Segment Tree
struct Node
{
  int value;
  Node *lef, *rig;
} _memory[MAXN*250], *_memory_top = _memory;
int _n, _x, _st;
Node* _new_archive(Node* const pre, const int lef, const int rig)
{
  Node* const node = _memory_top++;
  node->value = pre->value+_x, node->lef = pre->lef, node->rig = pre->rig;
  if (lef == rig) return node;
  const int mid = (lef+rig)/2;
  if (_st <= mid) node->lef = _new_archive(pre->lef, lef, mid);
  else node->rig = _new_archive(pre->rig, mid+1, rig);
  return node;
}
int _query(Node* const u, Node* const v, Node* const lca, Node* const p, const int lef, const int rig)
{
  if (lef == rig) return lef;
  const int value = u->lef->value + v->lef->value - lca->lef->value - p->lef->value;
  const int mid = (lef+rig)/2;
  if (value >= _x) return _query(u->lef, v->lef, lca->lef, p->lef, lef, mid);
  _x -= value;
  return _query(u->rig, v->rig, lca->rig, p->rig, mid+1, rig);
}
Node* Build(const int lef, const int rig)
{
  Node* const node = _memory_top++;
  node->lef = node->rig = 0, node->value = 0;
  if (lef == rig) return node;
  const int mid = (lef+rig)/2;
  node->lef = Build(lef, mid);
  node->rig = Build(mid+1, rig);
  return node;
}
inline Node* NewArchive(Node* const pre, const int pos, const int delta)
  { _st = pos, _x = delta; return _new_archive(pre, 1, _n); }
inline int Query(Node* const u, Node* const v, Node* const lca, Node* const p, const int k)
  { _x = k; return _query(u, v, lca, p, 1, _n); }
//------Doubling Algorithm LCA
int p[MAXN][20], deep[MAXN];
int GetLCA(int u, int v)
{
  if (deep[u] < deep[v]) std::swap(u, v);
  for (int j = 19; deep[u] != deep[v]; u = p[u][j])
    while (j > 0 && deep[p[u][j]] < deep[v]) --j;
  for (int j = 19; u != v; u = p[u][j], v = p[v][j])
    while (j > 0 && p[u][j] == p[v][j]) --j;
  return u;
}
//------Graph
struct Edge
{
  int v;
  Edge *next;
} g[MAXN*4], *header[MAXN];
int LinkSize;
void AddEdge(const int x, const int y)
{
  Edge* const node = g+(LinkSize++);
  node->v = y;
  node->next = header[x];
  header[x] = node;
}

//------Main Program
Node* first[MAXN];
int n, m, t, lastans, trees, w[MAXN];
struct Tree
{
  int size, u;
  vector<Node*> root;
  Tree() { }
  Tree(const int v): size(0), u(v), root() { }
  void DFS(const int, Tree* const);
  void Initialize();
} tree[MAXN], *treeroot[MAXN];
vector<int> v;
void Tree::DFS(const int u, Tree* const _change_to = 0)
{
  root.push_back(NewArchive(root.back(), w[u], +1)), first[u] = root.back();
  if (_change_to) treeroot[u] = _change_to;
  for (int i = 1; i < 20; ++i) p[u][i] = p[p[u][i-1]][i-1];
  deep[u] = deep[p[u][0]]+1;
  for (Edge *e = header[u]; e; e = e->next)
    if (e->v != p[u][0])
    {
      p[e->v][0] = u;
      DFS(e->v, _change_to);
    }
  root.push_back(NewArchive(root.back(), w[u], -1));
}
void Tree::Initialize()
{
  root.push_back(first[0]);
  DFS(u);
}
char c;
void BuildTree(const int u, Tree* const tr)
{
  ++tr->size;
  treeroot[u] = tr;
  w[u] = std::lower_bound(v.begin(), v.end(), w[u])-v.begin()+1;
  for (Edge *e = header[u]; e; e = e->next)
    if (e->v != p[u][0])
    {
      deep[e->v] = 1;
      p[e->v][0] = u;
      BuildTree(e->v, tr);
    }
}
void solve()
{
  scanf("%d%d%d", &n, &m, &t);
  trees = lastans = LinkSize = 0, _memory_top = _memory, _n = n;
  v.clear();
  memset(header, 0, sizeof(header));
  memset(deep, 0, sizeof(deep));
  for (int i = 1; i <= n; ++i)
  {
    scanf("%d", w+i);
    v.push_back(w[i]);
  }
  for (int i = 0, x, y; i < m; ++i)
  {
    scanf("%d%d", &x, &y);
    AddEdge(x, y);
    AddEdge(y, x);
  }
  std::sort(v.begin(), v.end());
  v.resize(std::unique(v.begin(), v.end())-v.begin());
  for (int i = 1; i <= n; ++i)
    if (!deep[i])
    {
      tree[trees] = Tree(i);
      BuildTree(i, tree+(trees++));
    }
  first[0] = Build(1, n);
  ++_memory_top;
  for (int i = 0; i < trees; ++i)
    tree[i].Initialize();

  for (int i = 0, x, y, k; i < t; ++i)
  {
    scanf("\n%c%d%d", &c, &x, &y);
    x ^= lastans, y ^= lastans;
    if (c == 'Q')
    {
      scanf("%d", &k);
      k ^= lastans;
      const int lca = GetLCA(x, y), plca = p[lca][0];
      lastans = Query(first[x], first[y], first[lca], first[plca], k);
      lastans = v[lastans-1];
      printf("%d\n", lastans);
    }
    else
    {
      if (treeroot[x]->size > treeroot[y]->size) std::swap(x, y);
      treeroot[y]->size += treeroot[x]->size;
      treeroot[y]->root.clear();
      AddEdge(x, y);
      AddEdge(y, x);
      p[x][0] = y;
      treeroot[y]->root.push_back(first[y]);
      treeroot[y]->DFS(x, treeroot[y]);
    }
  }
}
int main()
{
  scanf("%*d");
  solve();
}
]]> <![CDATA[[BZOJ3122][Sdoi2013]随机数生成器]]> 2013-06-02T00:00:00+08:00 https://quartergeek.com/bzoj3122 首先，很容易看出来，这个式子是[秦九韶算法](http://en.wikipedia.org/wiki/Horner’s_method)，不考虑取模的话就是：

\[ X_n=a^{n-1}X_1+b\sum_{k=0}^{n-2}a^k \]

嗯，我们可以套上一个等比数列求和公式，变成

\[ t\equiv a^{n-1}X_1+b\cdot\frac{1-a^{n-1}}{1-a} \pmod{p} \]

乘过去

\[ t\left(1-a\right)\equiv \left[\left(1-a\right)X_1-b\right]a^{n-1}+b \pmod{p} \]

这个时候自然是想再除过来，这里有个很明显的坑应该大家都发现了，就是逆元要存在。

\[ a^{n-1}\equiv\frac{t-ta-b}{\left(1-a\right)X_1-b} \pmod{p} \]

然后就是水水的BSGS了。

特殊情况

我就是傻傻这样，结果发现全部WA了……原因是多组数据、然后特殊情况完全没有考虑到。其实下面的特殊情况列出来会觉得很傻逼，但是我觉得比较需要思考的是：为什么会被特殊数据卡？

当\(a=1\)时： \(\left[X_1+b(n-1)\right]\equiv t \pmod{p}\)，显然就是扩展欧几里得了。为什么这个BSGS会挂呢？原因是：BSGS那个式子用到了等比数列求和，但是显然比为1的数列不是等比数列。

当\(a=0\)时：ans = b == t ? 2 : -1。这个连数列都没了

当\(X_1=t\)时：ans = 1。什么都没了……

所以这题给我最大的启示就是：千万不要轻视细节……

代码

bzoj3122[Sdoi2013]随机数生成器 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>

typedef long long Int64;
struct Triple
{
  Int64 x, y, z;
  Triple(const Int64 a, const Int64 b, const Int64 c): x(a), y(b), z(c) { }
};
Triple exgcd(const Int64 a, const Int64 b)
{
  if (!b) return Triple(1, 0, a);
  const Triple last = exgcd(b, a%b);
  return Triple(last.y, last.x - a / b * last.y, last.z);
}
class Hash
{
  static const int HASHMOD = 7679977;
  Int64 k[HASHMOD+100];
  int time[HASHMOD+100], v[HASHMOD+100], timestamp;
  int locate(const Int64 key)
  {
    int h = key%HASHMOD;
    while (time[h] == timestamp && k[h] != key) ++h;
    return h;
  }
public:
  void clear() { ++timestamp; }
  void set(const Int64 key, const int value)
  {
    const int h = locate(key);
    if (time[h] != timestamp) time[h] = timestamp, k[h] = key, v[h] = value;
  }
  int get(const Int64 key)
  {
    const int h = locate(key);
    return time[h] == timestamp ? v[h] : -1;
  }
} hash;
int bsgs(Int64 A, Int64 B, Int64 C)
{
  hash.clear();
  Int64 base = 1, D = 1;
  const int m = static_cast<int>(std::ceil(std::sqrt(C)));
  for (int i = 0; i < m; ++i, base = base*A%C) hash.set(base, i);
  for (int i = 0; i <= m; ++i)
  {
    Triple gcd = exgcd(D, C);
    const int j = hash.get((gcd.x*B%C+C)%C);
    if (j != -1) return i*m+j;
    D = D*base%C;
  }
  return -1;
}

Int64 T, p, a, b, x1, t;
int solve()
{
  scanf("%lld%lld%lld%lld%lld", &p, &a, &b, &x1, &t);
  if (x1 == t) return 1;
  if (a == 0) return b == t ? 2 : -1;
  if (a == 1)
  {
    Triple gcd = exgcd(b, p);
    if (std::abs(gcd.z) != 1) return -1;
    return ((t-x1)/gcd.z*gcd.x%p+p)%p+1;
  }
  const Int64 tmp1 = (1-a)*x1-b;
  const Triple gcd = exgcd(tmp1, p);
  if (std::abs(gcd.z) != 1) return -1;
  const Int64 tmp2 = (t-t*a-b) % p * gcd.x / gcd.z % p;
  const int res = bsgs(a, (tmp2+p)%p, p)+1;
  return res < 1 ? -1 : res;
}
int main()
{
  scanf("%lld", &T);
  while (T--)
    printf("%d\n", solve());
}
]]> <![CDATA[[BZOJ3093][Fdu校赛2012] A Famous Game]]> 2013-06-01T00:00:00+08:00 https://quartergeek.com/bzoj3093 这题是概率论入门的好题啊，用到了条件概率公式和全概率公式，甚至还用了一点组合公式和代数式的转化

题意

盒子里有\(n\)个球，每个球为红色或者蓝色，其中红球数量\(m\in \left\{ 1..n \right\}\)等概率分布。已知在抽出并扔掉\(p\)个球的情况下有\(q\)个球是红球。问再抽一个球是红球的概率。

预备知识

首先是条件概率公式，在已知事件\(B\)发生的条件下事件\(A\)发生的概率：

\[ P\left(A\right)=\frac{P\left(AB\right)}{P\left(B\right)} \]

接下来就是全概率公式，事件\(A\)发生的概率就是各个情况\(B_k\)下事件\(A\)发生概率的和：

\[ P\left(A\right)=\sum_k{P\left( A|B_k\right)P\left(B_k\right)} \]

最后就是一个奇妙的组合公式：

\[ \sum_{k=0}^s{\binom{k}{n}\binom{s-k}{m}}=\binom{s+1}{n+m+1} \]

这个可以这么理解：要从\(s+1\)个数中选出\(n+m+1\)个数，那么\(k\)相当于在枚举第\(n+1\)个数。

解法

有了上面预备知识，下面的推导就很好理解了：

令\(A\)表示下一个球取出来是红色的，\(B\)表示一开始抽出\(p\)个球有\(q\)个是红球，\(N_k\)表示最早袋子里面有\(k\)个红球。那么：

\[ \begin{eqnarray*} P\left(A|B\right)&=&\frac{P\left(AB\right)}{P\left(B\right)} \\ &=&\frac{\sum_{k=0}^n{P\left(AB|N_k\right)P\left(N_k\right)}}{\sum_{k=0}^n{ P\left(A|N_k\right)P\left(N_k\right)}} \\ &=&\frac{\sum_{k=0}^n{P\left(A|BN_k\right)P\left(B|N_k\right)P\left(N_k\right)}}{\sum_{k=0}^n{P\left(B|N_k\right)P\left(N_k\right)}} \end{eqnarray*} \]

又因为：

\[ \begin{eqnarray*} P\left(A|BN_k\right)&=&\frac{k-q}{n-p} \\ P\left(N_k\right)&=&\frac 1{n+1} \\ P\left(B|N_k\right)&=&\frac{\binom{k}{q}\binom{n-k}{p-q}}{\binom{n}{p}} \end{eqnarray*} \]

所以

\[ \begin{eqnarray*} P\left(A|B\right)&=&\frac{\sum_{k=0}^n \binom{k}{q} \binom{n-k}{p-q} (k-q)}{\sum_{k=0}^n \binom{k}{q} \binom{n-k}{p-q} (n-p)} & (*) \\ &=&\frac{\sum_{k=0}^n \binom{k}{q+1} \binom{n-k}{p-q} (q+1)}{\sum_{k=0}^n \binom{k}{q} \binom{n-k}{p-q} (n-p)} \\ &=&\frac{q+1}{n-p} \cdot \frac{\sum_{k=0}^n \binom{k}{q+1} \binom{n-k}{p-q}}{\sum_{k=0}^n \binom k q \binom{n-k}{p-q}} \\ &=&\frac{q+1}{n-p} \cdot \frac{\binom{n+1}{p+2}}{\binom{n+1}{p+1}} \\ &=&\frac{q+1}{p+2} \end{eqnarray*} \]

非常神奇吧，看起来十分复杂的题目竟然最后的答案如此简单。其实我推到\((*)\)式的时候，以为要用各种数论变换处理，把复杂度降到O(n)。后来才发现，这题没有mod，而且原来竟然有更神奇的代数变换和组合数变换。

这题是在太神！

代码

bzoj3093[Fdu校赛2012] A Famous Game 
1
2
3
4
5
6
7
8

#include <stdio.h>
main(void)
{
  int n, p, q, T = 0;
  while (scanf("%d%d%d", &n, &p, &q) != EOF)
    printf("Case %d: %.4f\n", ++T, (q+1.)/(p+2));
  return 0;
}

后记

其实这篇题解跟贾教的题解差不多，原因是就是看着他题解做的……Orz贾教

那么本文的目的是什么呢，其实只是\(\LaTeX\)测试而已。

]]> <![CDATA[[BZOJ3143][Hnoi2013]游走]]> 2013-05-29T00:00:00+08:00 https://quartergeek.com/bzoj3143 最近真的是智商跌到谷底，基本什么题都得看题解，就连这种水题都是在做HNOI2013 Day1的时候不小心瞄到wjmzbmr的题解的前提下才想出来。

如果我们知道每条边期望走过的次数，那么显然排序后贪心地标号即可。但是要知道每条边走过的次数还是比较困难的，我们可以考虑每个点i期望经过的次数p[i]。

显然，一个点能从除n外所有和他相邻的点j走过来，并且从j点走过来的概率为1/deg[j]。所以，p[i] = sigma(p[j]/deg[j])。另外，要注意到，点1到达次数明显会多1。

接下来我们就会发现，这是一个n-1个未知数、n-1个方程的方程组（为什么？因为不可能从n走到点i，并且n的期望次数为1），然后就可以很愉悦的高斯消元即可。

求出每个点的期望次数p[i]后，每条边(u, v)期望经过的次数ex[i]，ex[i] = p[u]/deg[u] + p[v]/deg[v]。当然了，因为还是不可能从n走出来，所以如果一个端点在n，那么就只有一端可以走。

然后排个序，编号就完了。

精度

这题的精度不知道如何破？反正我自己手测官方数据是过不去，交bzoj也过不去。后来改成long double和EPS = 1e-9就过了bzoj（但跟官方数据还是差0.1以上）。不管如何，反正是浪费了几乎一个小时……

代码

bzoj3143[Hnoi2013]游走 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>

const int MAXN = 501;
const long double EPS = 1e-9;
struct Edge
{
  int v;
  Edge *next;
} g[MAXN*MAXN], *header[MAXN];
void AddEdge(const int x, const int y)
{
  static int LinkSize = 0;
  Edge* const node = g+(LinkSize++);
  node->v = y;
  node->next = header[x];
  header[x] = node;
}
int n, m, deg[MAXN], x[MAXN*MAXN], y[MAXN*MAXN], pos[MAXN*MAXN];
long double mat[MAXN][MAXN+1], ex[MAXN*MAXN];
void elimination(const int n)
{
  for (int i = 1; i <= n; ++i)
  {
    int k = i;
    for (int j = i+1; j <= n; ++j)
      if (std::fabs(mat[j][i]) > std::fabs(mat[k][i]))
        k = j;
    for (int j = 1; j <= n+1; ++j)
      std::swap(mat[i][j], mat[k][j]);
    if (std::fabs(mat[i][i]) <= EPS)
      continue;
    for (int j = n+1; j >= i; --j)
      mat[i][j] /= mat[i][i];
    for (int j = 1; j <= n; ++j)
      if (j != i)
        for (int k = n+1; k >= i; --k)
          mat[j][k] -= mat[j][i]*mat[i][k];
  }
}
inline bool cmp(const int lhs, const int rhs) { return ex[lhs]-ex[rhs] > EPS; }
int main()
{
  scanf("%d%d", &n, &m);
  for (int i = 0; i < m; ++i)
  {
    scanf("%d%d", x+i, y+i);
    ++deg[x[i]], ++deg[y[i]];
    AddEdge(x[i], y[i]);
    AddEdge(y[i], x[i]);
  }
  for (int i = 1; i <= n-1; ++i)
  {
    mat[i][i] = 1;
    for (Edge *e = header[i]; e; e = e->next)
      if (e->v != n)
        mat[i][e->v] = static_cast<long double>(-1)/deg[e->v];
  }
  mat[1][n] = 1;
  elimination(n-1);
  for (int i = 0; i < m; pos[i] = i, ++i)
    ex[i] = mat[x[i]][n]/deg[x[i]] + mat[y[i]][n]/deg[y[i]];
  std::sort(pos, pos+m, cmp);
  long double ans = 0;
  for (int i = 0; i < m; ++i) ans += ex[pos[i]]*(i+1);
  printf("%.3Lf", ans);
}
]]> <![CDATA[[BZOJ3140][Hnoi2013]消毒]]> 2013-05-29T00:00:00+08:00 https://quartergeek.com/bzoj3140 首先由均值不等式可以得到，min{a, b, c} <= 17，不妨假设最短的那条边为a。接下来考虑消除，答案肯定不会超过a，因为可以做若干次1*b*c的消除。

一开始看到这个结论我还是非常傻逼的以为，只要把需要消毒的每一片1*b*c都消毒即可，还傻傻问副队哪来的二分图……经过副队的教导才意识到这样不一定最优，比较科学的做法是：2^a枚举每层是否消掉，然后用a*1*c和a*b*1的片覆盖，也就是转成二维的最小棋盘覆盖。

所谓最小棋盘覆盖就是说，每次可以覆盖掉棋盘的一整行或一整列，问把所有标记点覆盖的最小次数。嗯，这个也不会做……Google了一下，看到搜索结果里面最小点覆盖和行列拆开这两个关键词才突然意识到，这不就是个水水的二分图匹配嘛。

考虑把所有行放在左边，所有列放在右边，然后如果(i, j)需要被覆盖，那么连边(Xi, Yj)。之后就是一个最小点覆盖的问题了（选择最少的点，使得每条边都至少有一个端点被选择），因为最小点覆盖=最大匹配，所以轻松做掉了。（这个时候突然很庆幸前不久刚学匈牙利，明显这种时候用匈牙利跑匹配比网络流省事多了=v=）

常数

虽然写程序的时候已经在清数组的时候注意了，但是手测第一个点还是TLE得非常严重（吐槽一下，所有数据都是10K……）。后来看到副队博客上还有一句话，发现有一个非常卡BUG的优化方法：因为1的数量非常少，所以可以把1用链表串起来。嗯，加了优化后就可以过了。不知道不卡BUG是如何做的= =?

代码

bzoj3140[Hnoi2013]消毒 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

#include <cstdio>
#include <cstring>
#include <algorithm>

struct Edge
{
  int v;
  Edge *next;
} g[10000], *header[5000], *head[5000];
int LinkSize, _link_size;
void AddEdge(Edge *&head, const int y)
{
  Edge* const node = g+(LinkSize++);
  node->v = y;
  node->next = head;
  head = node;
}
int T, a, b, c, ans, mat[5000], match[5000];
bool used[20], vis[5000];
inline int getid(const int x, const int y, const int z) { return x*b*c + y*c + z; }
bool find(const int u)
{
  for (Edge *e = header[u]; e; e = e->next)
  {
    if (vis[e->v]) continue;
    vis[e->v] = true;
    if (match[e->v] == -1 || find(match[e->v]))
    {
      match[e->v] = u;
      return true;
    }
  }
  return false;
}
void dfs(const int step, int cnt)
{
  if (cnt >= ans) return;
  if (step == a)
  {
    LinkSize = _link_size;
    memset(header, 0, sizeof(*header)*b);
    for (int j = 0; j < b; ++j)
      for (int k = 0; k < c; ++k)
      {
        bool flag = false;
        for (Edge *e = head[j*c+k]; e && !flag; e = e->next)
          flag = !used[e->v];
        if (!flag) continue;
        AddEdge(header[j], k);
      }
    memset(match, 0xFF, sizeof(*match)*c);
    for (int i = 0; i < b; ++i)
    {
      memset(vis, 0, sizeof(*vis)*b);
      if ((cnt += find(i)) >= ans) return;
    }
    ans = cnt;
    return;
  }
  used[step] = true; dfs(step+1, cnt+1);
  used[step] = false;dfs(step+1, cnt);
}
int solve()
{
  scanf("%d%d%d", &a, &b, &c);
  if (a <= b && a <= c)
    for (int i = 0; i < a; ++i)
      for (int j = 0; j < b; ++j)
        for (int k = 0; k < c; ++k)
          scanf("%d", mat+getid(i, j, k));
  else if (b <= a && b <= c)
  {
    std::swap(a, b);
    for (int j = 0; j < b; ++j)
      for (int i = 0; i < a; ++i)
        for (int k = 0; k < c; ++k)
          scanf("%d", mat+getid(i, j, k));
  }
  else
  {
    std::swap(a, c);
    for (int k = 0; k < c; ++k)
      for (int j = 0; j < b; ++j)
        for (int i = 0; i < a; ++i)
          scanf("%d", mat+getid(i, j, k));
  }
  LinkSize = 0;
  for (int j = 0; j < b; ++j)
    for (int k = 0; k < c; ++k)
    {
      head[j*c+k] = 0;
      for (int i = 0; i < a; ++i)
        if (mat[getid(i, j, k)])
          AddEdge(head[j*c+k], i);
    }
  _link_size = LinkSize;
  ans = a;
  dfs(0, 0);
  return ans;
}
int main()
{
  scanf("%d", &T);
  while (T--)
    printf("%d\n", solve());
}
]]> <![CDATA[[BZOJ2402]陶陶的难题II]]> 2013-05-28T00:00:00+08:00 https://quartergeek.com/bzoj2402 Orz福州一中lyk。

首先我们来看，对于每个询问，如果答案的分母是固定的话，那么变成了在树链上找两个点使得Yi+Qj最大，这个很简单吧，直接树链剖分然后线段树里面找两个最大的数。 好，其实，这个跟这题一点关系都没有。

但是我们可以二分答案`k`，那么问题变成了判定是否存在i, j使得
    (Yi+Qj)/(Xi+Pj) >= k
也就是
    k*Xi-Yi + k*Pj-Qj <= 0
因为加号左右基本是一样的，考虑左边，右边同理。不妨令
    B = k*Xi-Yi
也就是
    Yi = k*Xi - B
嗯，很像斜率优化，把(Xi, Yi)看成座标系上的点，那么实际上我们就是要在一堆点里面找到一个点使得截距-B最大

接下来就是维护凸壳了，我们只要先做树链剖分，顺便求出dfs序，然后按照dfs序建线段树。线段树节点[L, R]表示dfs序上[L, R]的点构成的上凸壳（其实这题要维护两个上凸壳，因为完全独立，所以也没什么好说的）。然后这题就解决了。

错误

我出现一个比较沙茶的错误，没有发现其实建线段树的时候，插入[L, R]这段的点的横座标并没有升序，结果样例最后一个点死活都是错的……debug了才发现……后来就用类似于归并的东西把所有点排序了。

代码

bzoj2402陶陶的难题II 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

#include <cstdio>
#include <cstring>
#include <algorithm>

const int MAXN = 30001;
struct Edge
{
  int v;
  Edge *next;
} g[MAXN*2], *header[MAXN];
void AddEdge(const int x, const int y)
{
  static int LinkSize = 0;
  Edge* const node = g+(LinkSize++);
  node->v = y;
  node->next = header[x];
  header[x] = node;
}
struct Point
{
  double x, y;
  Point() { }
  Point(const double a, const double b): x(a), y(b) { }
};
inline bool operator<(const Point& lhs, const Point& rhs) { return lhs.x < rhs.x || (lhs.x == rhs.x && lhs.y < rhs.y); }
const Point O(0, 0);
inline double cross(const Point& A, const Point& B, const Point& C, const Point& D)
{
  const double x1 = B.x-A.x, y1 = B.y-A.y;
  const double x2 = D.x-C.x, y2 = D.y-C.y;
  return x1*y2-x2*y1;
}
//------Segment Tree
struct Segment { Point *Q; int tail; };
Point point[2][MAXN], _memory[MAXN*32], *_memory_top = _memory;
Segment s[2][MAXN*4];
int _t, _st, _ed, n, m, pos[2][MAXN];
double _k;
double _query(const int p, const int lef, const int rig)
{
  if (_st <= lef && rig <= _ed)
  {
    Point *Q = s[_t][p].Q;
    int l = 0, r = s[_t][p].tail-1;
    while (l <= r)
    {
      const int m = (l+r)/2;
      if (cross(Q[m], Q[m+1], O, Point(1, _k)) >= -1e-6) r = m-1;
      else l = m+1;
    }
    return Q[l].x * _k - Q[l].y;
  }
  const int mid = (lef+rig)/2;
  double res = 1e10;
  if (_st <= mid) res = _query(p*2, lef, mid);
  if (mid+1 <= _ed) res = std::min(res, _query(p*2+1, mid+1, rig));
  return res;
}
inline bool cmp(const int lhs, const int rhs) { return point[lhs] < point[rhs]; }
void Build(const int p, const int lef, const int rig)
{
  static int tmp[2][MAXN];
  const int mid = (lef+rig)/2;
  if (lef != rig)
  {
    Build(p*2, lef, mid);
    Build(p*2+1, mid+1, rig);
  }
  for (int t = 0; t < 2; ++t)
  {
    for (int i = lef, l1 = lef, l2 = mid+1; i <= rig; ++i)
      if (l2 > rig || (l1 <= mid && point[t][pos[t][l1]] < point[t][pos[t][l2]])) tmp[t][i] = pos[t][l1++];
      else tmp[t][i] = pos[t][l2++];
    memcpy(pos[t]+lef, tmp[t]+lef, sizeof(*tmp[t])*(rig-lef+1));
    Point *&Q = s[t][p].Q;
    int& tail = s[t][p].tail;
    Q = _memory_top, tail = -1, _memory_top += rig-lef+1;
    for (int i = lef; i <= rig; ++i)
    {
      while (tail >= 1 && cross(Q[tail], Q[tail-1], Q[tail], point[t][pos[t][i]]) <= 1e-6) --tail;
      Q[++tail] = point[t][pos[t][i]];
    }
  }
}
inline double Query(const int t, const int lef, const int rig, const double k)
{
  _t = t, _st = lef, _ed = rig, _k = k;
  return _query(1, 1, n);
}
//------Heavy Light Decomposition
typedef int Array[MAXN];
Array number, dfn, hson, top, parent, depth, size;
void dfs1(const int u)
{
  size[u] = 1;
  for (Edge *e = header[u]; e; e = e->next)
    if (e->v != parent[u])
    {
      parent[e->v] = u;
      depth[e->v] = depth[u]+1;
      dfs1(e->v);
      size[u] += size[e->v];
      if (size[e->v] > size[hson[u]])
        hson[u] = e->v;
    }
}
void dfs2(const int u, const int tp)
{
  static int timestamp;
  number[u] = ++timestamp, dfn[timestamp] = u, top[u] = tp;
  if (hson[u])
    dfs2(hson[u], tp);
  for (Edge *e = header[u]; e; e = e->next)
    if (e->v != parent[u] && e->v != hson[u])
      dfs2(e->v, e->v);
}
double query(int a, int b, double k)
{
  double ans0 = 1e10, ans1 = 1e10;
  for (int ta = top[a], tb = top[b]; ta != tb; a = parent[ta], ta = top[a])
  {
    if (depth[ta] < depth[tb])
      std::swap(ta, tb), std::swap(a, b);
    ans0 = std::min(ans0, Query(0, number[ta], number[a], k));
    ans1 = std::min(ans1, Query(1, number[ta], number[a], k));
  }
  if (depth[a] > depth[b]) std::swap(a, b);
  ans0 = std::min(ans0, Query(0, number[a], number[b], k));
  ans1 = std::min(ans1, Query(1, number[a], number[b], k));
  return ans0+ans1;
}

int main()
{
  scanf("%d", &n);
  for (int i = 1; i <= n; ++i) scanf("%lf", &point[0][i].x);
  for (int i = 1; i <= n; ++i) scanf("%lf", &point[0][i].y);
  for (int i = 1; i <= n; ++i) scanf("%lf", &point[1][i].x);
  for (int i = 1; i <= n; ++i) scanf("%lf", &point[1][i].y);
  for (int i = 1, x, y; i < n; ++i)
  {
    scanf("%d%d", &x, &y);
    AddEdge(x, y);
    AddEdge(y, x);
  }
  dfs1(1);
  dfs2(1, 1);
  for (int i = 1; i <= n; ++i) pos[0][i] = pos[1][i] = dfn[i];
  Build(1, 1, n);
  scanf("%d", &m);
  for (int i = 0, x, y; i < m; ++i)
  {
    scanf("%d%d", &x, &y);
    double lef = 0, rig = 1e10;
    while (rig-lef > 1e-8)
    {
      const double mid = (lef+rig)/2;
      if (query(x, y, mid) >= -1e-6) rig = mid;
      else lef = mid;
    }
    printf("%.4f\n", rig);
  }
}
]]> <![CDATA[Word 2010 制作可填表格]]> 2013-05-25T00:00:00+08:00 https://quartergeek.com/create-form-with-word-2010 前言

前不久刚填完 sjtu 的夏令营报名表，怎么说呢，我个人一直对朴素的Word文档填表很反感。大概是上次因为帐户问题需要填 BudgetVM 的各种证明，这才发现国外比较通用的做法是使用可填式pdf或者word文档。 这类文档制作起来比较麻烦，但是对于填表人来说，个人感觉会方便许多 。

后来Google了一下如何制作可填式pdf，发现都要用Adobe Acrobat，印象中Adobe的东西都是很贵的，于是乎只好转向比较大众化的Word。因为目前大家Word版本都比较高，起码都2007了，所以本文就放弃doc格式，以Word 2010为例。

方法

依次点击【文件 - 选项 - 自定义功能区 - 主选项卡】，勾选【开发工具】。

Step 1
Step 1

然后在需要填表的地方，选择【开发工具-纯文本内容控件】。有需要的话可以插入控件之后点击【属性】进行设置。

Step 2
Step 2

设置完控件效果如下。如果要去掉那些字的话，可以用空格代替。

Step 3
Step 3

接下来要限制编辑。【开发工具-限制编辑-仅允许文档中进行此类型的编辑】，选择【填写窗体】，然后启动保护，设置密码。

Step 4
Step 4

大功告成！如果需要解除限制，就得输入刚才的密码。分发的时候只要不分发那个密码即可。

例子

做了一份例子，可以在这里下载到。密码是123456。

]]> <![CDATA[Fast Fourier Transform]]> 2013-05-22T00:00:00+08:00 https://quartergeek.com/fast-fourier-transform 为什么需要FFT

我们都知道对于两个多项式f(x)和g(x)，朴素的方法计算它们的乘积h(x) = f(x) * g(x)需要O(n^2)的时间。这里隐含了一个条件：f(x)和g(x)都是系数形式表示的多项式，比如说： f(x) = a0x^0 + a1x^1 + a2x^2 + ... + an-1x^n-1 。

实际上多项式还有一种点值表示法，就是 f = {(p1, f(p1)), (p2, f(p2)), (p3, f(p3)), ..., (pn, f(pn))} ，也就是初中熟悉的待定系数法求多项式。这种看起来十分反人类的表示方法其实有一个非常大的好处：在两个多项式的采样点相同的时候，它们的四则运算都是O(n)的复杂度。比如说对于f = {(pi, f(pi))}和g = {(pi, g(pi))}，求h = f*g，那么很容易得到h = {(pi, f(pi)*g(pi))}，也就是x不变，y相乘。

于是，就有了一种比较曲折的计算f(x)*g(x)的方法：

  1. 对f(x)和g(x)求值（系数形式转成点值形式 DFT）
  2. 在f和g点值形式上进行乘法得到h
  3. 对h插值，得到h(x)（点值形式转成系数形式 IDFT）

对于朴素方法，上面三步的复杂度分别为O(n^2), O(n), O(n^3)，然而巧妙的使用单位负根可以使复杂度变成O(nlogn), O(n), O(nlogn)，赶快去膜拜傅立叶大神吧！

什么时候需要多项式乘法呢？比如高精乘，比如卷积（h[i] = f[j]*g[i-j]）

Discrete Fourier Transform

DFT的作用就是把一个系数形式的多项式转换成点值形式。IDFT就是反过来。FFT和IFFT实际上就是用O(nlogn)的时间完成DFT和IDFT。

单位复根

FFT利用的是单位复根的一些非常有意思的性质。

欧拉恒等式告诉我们e^ix = cos(x) + isin(x)，而n次单位复根Wn则是指e^(2πi/n)，可以发现Wn的0到n-1次幂正好把一个复平面上的单位圆平均分成了n份。有一些性质：

  • Wn^j = -Wn^(j+n/2) 这个是因为它们在复平面上方向相反
  • W(an)^(aj) = Wn^j 这个叫做相消引理
  • (Wn^j)^2 = W(n/2)^j 这个由相消引理容易得到
  • {(Wn^j)^2 | j = 0..n-1} = {W(n/2)^k | k = 0..n/2-1} 这个叫做折半引理，实际上就是上面的集合形式

Fast Fourier Transform

FFT的精髓在于，选取n个n次单位复根作为采样点，由折半引理可以知道，只需要计算n/2个采样值，递归下去做，由主定理就可以得到总的复杂度为O(nlogn)。为了方便起见，一般把n补充为2^k的形式。

1
2
3
4
5
6
7

如果把
    f(x)  = a0x^0 + a1x^1 + a2x^2 + a3x^3 + ... + an-1x^n-1
拆成
    f0(x) = a0x^0 + a2x^1 + a4x^2 + ... + an-2x^n/2-1
    f1(x) = a1x^0 + a3x^1 + a5x^2 + ... + an-1x^n/2-1
那么就有
    f(x)  = f0(x^2) + x*f1(x^2)

写成程序大概就是

1
2
3
4
5
6
7
8
9

Recursive_FFT(A[n])
    Wn, w = e^(2πi/n), 1
    Y0 = Recursive_FFT(A[0], A[2], A[4], ...)
    Y1 = Recursive_FFT(A[1], A[3], A[5], ...)
    For (k=0;k<n/2;k++)
        Y[k]     = Y0[k] + w*Y1[k]
        Y[k+n/2] = Y0[k] - w*Y1[k]
        w=w*wn
    Return(Y)

Inversed Fast Fourier Transform

转回来的方法就是：单位复根Wn转成e^(-2πi/n)，然后把y[i] /= n。

避免递归

上面那个递归版本的FFT实际上常数很大，因为要复制数组。我们观察一下递归树，假设这是一个长度为8的多项式。

1
2
3
4
5
6
7
8
9

+===============================================+
| 000   001   010   011   100   101   110   111 |
+-----------------------------------------------+
| 000   010   100   110 | 001   011   101   111 |
+-----------------------------------------------+
| 000   100 | 010   110 | 001   101 | 011   111 |
+-----------------------------------------------+
| 000 | 100 | 010 | 110 | 001 | 101 | 011 | 111 |
+===============================================+

实际上，从叶子往上做的话就是把每个数的二进制位颠倒过来。

C++ Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

struct Complex
{
  double real, imag;
  Complex(const double r = .0, const double i = .0): real(r), imag(i) { }
};
const Complex ZERO(.0, .0);
inline Complex operator+(const Complex& lhs, const Complex& rhs) { return Complex(lhs.real+rhs.real, lhs.imag+rhs.imag); }
inline Complex operator-(const Complex& lhs, const Complex& rhs) { return Complex(lhs.real-rhs.real, lhs.imag-rhs.imag); }
inline Complex operator*(const Complex& lhs, const Complex& rhs) { return Complex(lhs.real*rhs.real-lhs.imag*rhs.imag, lhs.real*rhs.imag+lhs.imag*rhs.real); }
inline int bit_reverse(const int x, const int n)
{
  int res = 0;
  for (int i = 0; i < n; ++i)
    res |= (x>>i&1)<<(n-i-1);
  return res;
}
void fft(Complex y[], const Complex a[], const int n, const int rev)
{
  const int len = 1<<n;
  for (int i = 0; i < len; ++i) y[i] = a[bit_reverse(i, n)];
  for (int d = 1; d <= n; ++d)
  {
    const int m = 1<<d;
    const Complex wn(std::cos(2*PI/m*rev), std::sin(2*PI/m*rev));
    for (int k = 0; k < len; k += m)
    {
      Complex w(1., .0);
      for (int j = 0; j < m/2; ++j)
      {
        const Complex u = y[k+j], t = w*y[k+j+m/2];
        y[k+j] = u+t, y[k+j+m/2] = u-t;
        w = w*wn;
      }
    }
  }
  if (rev == -1)
    for (int i = 0; i < len; ++i) y[i].real /= len, y[i].imag = .0;
}
void convolution(Complex c[], Complex a[], Complex b[], const int la, const int lb)
{
  static Complex tmp1[MAXN], tmp2[MAXN];
  int n = 0, len = 1<<n;
  for (; len < 2*la || len < 2*lb; ++n) len <<= 1;
  std::fill(a+la, a+len, ZERO);
  std::fill(b+lb, b+len, ZERO);
  fft(tmp1, a, n, 1);
  fft(tmp2, b, n, 1);
  for (int i = 0; i < len; ++i) tmp1[i] = tmp1[i]*tmp2[i];
  fft(c, tmp1, n, -1);
}

FNT

有时候答案不会很大，可以用mod p的剩余系来代替复数。因为对于质数p的原根g，有g^(p-1) mod p = 1，所以可以把g^(p-1)/n作为单位根使用。p可以选取形如c*2^k + 1的质数。

IFNT的时候，只需要把1~n-1翻过来，并且乘上n的乘法逆元即可。

C++ Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

const long long P = 1004535809LL, G = 3;
inline long long powmod(long long base, long long k, const long long mod)
{
  long long ans = 1;
  for (; k; k >>= 1)
  {
    if (k & 1) ans = ans*base%mod;
    base = base*base%mod;
  }
  return ans;
}
inline int bit_reverse(const int x, const int n)
{
  int res = 0;
  for (int i = 0; i < n; ++i)
    res |= (x>>i&1)<<(n-i-1);
  return res;
}
void fnt(long long y[], const long long a[], const int n, const int rev = 1)
{
  const int len = 1<<n;
  for (int i = 0; i < len; ++i) y[i] = a[bit_reverse(i, n)];
  for (int d = 1; d <= n; ++d)
  {
    const int m = 1<<d;
    const long long wn = powmod(G, (P-1)/m, P);
    for (int k = 0; k < len; k += m)
    {
      long long w = 1;
      for (int j = 0; j < m/2; ++j)
      {
        const long long u = y[k+j], t = w*y[k+j+m/2];
        y[k+j] = (u+t)%P, y[k+j+m/2] = (u-t)%P;
        w = w*wn%P;
      }
    }
  }
  if (rev == 1) return;
  const long long inv = powmod(len, P-2, P);
  for (int i = 0; i < len; ++i) y[i] = (y[i]*inv%P+P)%P;
  std::reverse(y+1, y+len);
}
void convolution(long long c[], long long a[], long long b[], const int la, const int lb)
{
  static long long tmp1[MAXN], tmp2[MAXN];
  int n = 0, len = 1<<n;
  for (; len < 2*la || len < 2*lb; ++n) len <<= 1;
  std::fill(a+la, a+len, 0);
  std::fill(b+lb, b+len, 0);
  fnt(tmp1, a, n);
  fnt(tmp2, b, n);
  for (int i = 0; i < len; ++i) tmp1[i] = tmp1[i]*tmp2[i]%P;
  fnt(c, tmp1, n, -1);
}
]]> <![CDATA[VPS上配置Git+Octopress]]> 2013-05-18T00:00:00+08:00 https://quartergeek.com/deploy-octopress-git-on-vps 终于用了一整天的时间，把博客从Wordpress换到了Octopress。我是希望在本地能不装ruby但是服务器能自动更新，并且希望支持历史版本，在网上找了一整天也试了一整天，整理出下面代码备忘：

Create git repository on VPS 
1
2
3
4
5
6

server$ cd ~
server$ mkdir oi.abcdabcd987.com.git
server$ cd oi.abcdabcd987.com.git
server$ git init --bare
server$ pwd
/home/quartergeek/oi.abcdabcd987.com.git
Install Octopress on VPS 
1
2
3
4
5
6
7
8
9
10
11

server$ cd /tmp
server$ git clone git://github.com/imathis/octopress.git octopress
server$ cd octopress
server$ bundle install
server$ rake install
server$ git add .
server$ git commit -m 'init octopress'
server$ git remote rename origin octopress
server$ git remote add origin /home/quartergeek/oi.abcdabcd987.com.git
server$ git config branch.master.remote origin
server$ git push origin master
Setup auto generate on VPS 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

server$ cd /home/quartergeek/oi.abcdabcd987.com.git
server$ echo <<EOF > hooks/post-receive
> #!/bin/bash -l
> GIT_REPO=/home/quartergeek/oi.abcdabcd987.com.git
> TMP_GIT_CLONE=/tmp/oi.abcdabcd987.com
> PUBLIC_WWW=/home/wwwroot/oi.abcdabcd987.com/octopress
> 
> git clone $GIT_REPO $TMP_GIT_CLONE
> cd $TMP_GIT_CLONE
> bundle install
> time rake generate
> cp -Rf public/* $PUBLIC_WWW
> rm -Rf $TMP_GIT_CLONE
> exit
> EOF
server$ chmod +x hooks/post-receive
Clone repository on laptop 
1
2
3
4
5

laptop$ git clone ssh://quartergeek@209.141.57.185/home/quartergeek/oi.abcdabcd987.com.git
laptop$ cd oi.abcdabcd987.com
laptop$ vim _config.yml
laptop$ vim source/_posts/2013-05-18-deploy-octopress-git-on-vps.markdown
laptop$ git push
]]> <![CDATA[LocalOrz 0.1 dev 发布]]> 2013-05-16T00:00:00+08:00 https://quartergeek.com/localorz-0-1-dev-release 简介

LocalOrz是一个运行于Linux，类似于Cena的本地评测机。目前 LocalOrz 仍属于开发阶段，本来我也不想这么早把它放出来，但是考虑到接下来得认真准备NOI，可能没什么时间继续写，所以还是只能先放出来。好在核心的功能都是有的。

首先列出它现在支持的功能：

  • 支持添加编译器和修改编译器选项
  • 支持数据路径自动完成
  • 支持自动添加其他数据
  • 支持评测全部选手
  • 支持评测某个选手的单题
  • 支持多个输入文件的测试点（未经测试）
  • 支持需要额外文件的题目（比如交互式。未经测试）
  • 支持Special Judge
  • 支持部分分

因为LocalOrz最初的设计目标就是代替Cena，所以Cena有的核心功能都有。当然还有很多Cena的其他功能来不及写，这个可能得等NOI忙完再说了（话说到时候我跟OI毛关系？）。我比较自豪的部分是做数据的部分，做数据很方便，鼠标点一点就能做完，像Cena一样。

因为只是dev阶段，所以有一些十分重要但是并非核心的功能还没有写进去：

  • 不支持选手的排序
  • 不支持题目/选手信息统计
  • 不支持导出
  • 不支持收取文件
  • 不支持修改题目或测试点配置（这个如果真的需要的话，可以直接修改data/dataconf.xml）
  • 不支持评测单个选手
  • 不支持评测指定选手
  • 不支持提交答案题（这个可以程序生成器+自定义校验器解决）
  • 不支持检验 无输出、无输入 等各种状态

另外，还有许许多多的BUG。如果遇到了BUG或者觉得有什么需要改进的地方，欢迎到提交Issue。

安装说明

因为处于dev阶段，所以就不打包了，麻烦各位手动安装。以Ubuntu为例：

$ sudo apt-get update
$ sudo apt-get install -y gcc g++ fpc
$ sudo apt-get install -y git python3

$ git clone https://github.com/facebook/tornado.git
$ cd tornado
$ python3 setup.py build
$ sudo python3 setup.py install

$ cd ~
$ git clone https://github.com/abcdabcd987/LocalOrz.git
$ cd LocalOrz/core
$ gcc judge_client.c -o judge_client -O2
$ g++ normal_judge.cc -o normal_judge -O2

使用说明

目前为了方便Linux各环境使用，所以使用了WebUI。在终端运行：

$ ~/LocalOrz/LocalOrz.py

保持这个终端不要关闭。接下来，在浏览器中打开，即可见到一个简陋的WebUI。

在/test/contest可以：

  • 新建、打开竞赛
  • 添加编译器
  • 添加试题和数据

在/test/person可以：

  • 查看选手成绩
  • 评测选手程序

具体的可以参考视频。切记，每次运行LocalOrz之后，必须Open Contest！

Special Judge

argv[1]: Full score
argv[2]: Standard Answer
argv[3]: Competitor Answer

Judge Information  =>  stdout
Score              =>  __score.txt

详细见core/normal_judge.cc。

技术细节

内核使用python3写成。WebUI使用python3, Tornado, jQuery, Bootstrap。内核在源代码的core/目录，其余UI均可调用内核。我个人比较倾向于用python再写一个GTK3的UI，比较方便。

欢迎随时Create issues和Push code！

]]> <![CDATA[[BZOJ2877][Noi2012]魔幻棋盘]]> 2013-04-14T00:00:00+08:00 https://quartergeek.com/bzoj2877 这题很囧，去年被炫教抓到题目（虽然炫教抓到的是一维的），可惜我们学校的人恰好都没有去省队培训……唉……首先讲一下一维怎么做吧。

欧几里得说过gcd(a, b, c, d) = gcd(b-a, c-b, d-c, a)。嗯，所以我们就对数列进行差分，b[i] = a[i]-a[i-1]，这样我们在查询[L, R]的gcd的时候，只要查询gcd(a[L], gcd(b[L+1] ... b[R])即可，而修改的时候，只要修改a[L..R]和b[L], b[R+1]即可。这样做法就很明显了，用两个线段树分别维护a和b。实际上做的时候，维护a可以直接用树状数组维护前缀和sum：对区间[L, R]加c，等同于sum[L] += c, sum[R+1] -= c，查询i直接求sum[i]即可。

我们再来看一下二维的怎么做。。然后我们换一种维护的方法。因为题目要求一定会查询到守护者a[x, y]，所以我们以(x, y)为原点，建立直角座标系。二维的一样是得差分，对于第四象限的点：b[i, j] = a[i, j] - a[i-1, j] - a[i, j-1] + a[i-1, j-1]，其他三个象限类似。

  • 原点的值：就是原点的值
  • 座标轴上的值：用离原点比较远的那个点-和他相邻、离原点近的点
  • 某个象限上的值：同理，用离原点远的点+离原点近的点-2个旁边的点。

查询的时候，很愉悦的在线段树里面查询[x1, y1]到[x2, y2]即可。

但是修改就很麻烦了，四个象限、座标轴、原点分别单点修改（有关象限的4个点，有关座标轴2个点，有关原点1个点）。

题外话：其实这题的主要思想就是把区间乃至矩阵修改转化成单点修改，因为二维线段树无法实现区间修改。做这题的时候一直忽略守护者一定会被计算，变成随意查询和修改，程序打完才发现根本无法保证修改的时间复杂度。后来十分努力的研读了一下题解才发现必须得用到守护者这个条件，似乎没有这个条件的话就做不了了。

果然还是很弱，数据结构都虐不过。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

#include <cstdio>
#include <algorithm>

//------Common things & Memory pool
inline long long gcd(long long a, long long b)
{
  if (a < 0) a = -a;
  if (b < 0) b = -b;
  for (long long r; b; a = b, b = r) r = a%b;
  return a;
}
const int MAXN = 500002;
char _memory[1<<26], *_memory_top = _memory;
template<typename T> inline T* newmemory(const size_t length)
{
  _memory_top += length * sizeof(T);
  return reinterpret_cast<T*>(_memory_top - length * sizeof(T));
}

//------1D Segment Class
class SegmentTree
{
  int n, st, ed, mul;
  long long *s, x;
  void build(const int p, const int lef, const int rig, const long long *a)
  {
    if (lef == rig) { s[p] = a[lef]; return; }
    const int mid = (lef+rig)/2;
    build(p*2, lef, mid, a);
    build(p*2+1, mid+1, rig, a);
    s[p] = gcd(s[p*2], s[p*2+1]);
  }
  long long query(const int p, const int lef, const int rig)
  {
    if (st <= lef && rig <= ed) return s[p];
    const int mid = (lef+rig)/2;
    long long res = 0;
    if (st <= mid) res = query(p*2, lef, mid);
    if (mid+1 <= ed) res = gcd(res, query(p*2+1, mid+1, rig));
    return res;
  }
  void modify(const int p, const int lef, const int rig)
  {
    if (lef == rig) { s[p] = s[p]*mul+x; return; }
    const int mid = (lef+rig)/2;
    if (st <= mid) modify(p*2, lef, mid);
    else modify(p*2+1, mid+1, rig);
    s[p] = gcd(s[p*2], s[p*2+1]);
  }
public:
  SegmentTree(const int length, const long long* a): n(length), s(newmemory<long long>((n+1)*4)) { build(1, 1, n, a); }
  long long Query(const int lef, const int rig) { st = lef, ed = rig; return query(1, 1, n); }
  void Modify(const int pos, const long long value) { st = pos, x = value, mul = 0; modify(1, 1, n); }
  void Add(const int pos, const long long value) { st = pos, x = value, mul = 1; modify(1, 1, n); }
};

//------2D Matrix & Segment Class
typedef long long** Matrix;
class SegmentTree2D
{
  int n, m, stx, sty, edx, edy;
  long long x;
  SegmentTree* s;
  void build(const int p, const int lef, const int rig, const Matrix& mat)
  {
    if (lef == rig) { s[p] = SegmentTree(m, mat[lef]); return; }
    const int mid = (lef+rig)/2;
    build(p*2, lef, mid, mat);
    build(p*2+1, mid+1, rig, mat);
    long long *tmp = newmemory<long long>(m+1);
    for (int i = 1; i <= m; ++i) tmp[i] = gcd(s[p*2].Query(i, i), s[p*2+1].Query(i, i));
    s[p] = SegmentTree(m, tmp);
  }
  long long query(const int p, const int lef, const int rig)
  {
    if (stx <= lef && rig <= edx) return s[p].Query(sty, edy);
    const int mid = (lef+rig)/2;
    long long res = 0;
    if (stx <= mid) res = query(p*2, lef, mid);
    if (mid+1 <= edx) res = gcd(res, query(p*2+1, mid+1, rig));
    return res;
  }
  void modify(const int p, const int lef, const int rig)
  {
    if (lef == rig) { s[p].Add(sty, x); return; }
    const int mid = (lef+rig)/2;
    if (stx <= mid) modify(p*2, lef, mid);
    else modify(p*2+1, mid+1, rig);
    s[p].Modify(sty, gcd(s[p*2].Query(sty, sty), s[p*2+1].Query(sty, sty)));
  }
public:
  SegmentTree2D(const int a, const int b, const Matrix& mat): n(a), m(b), s(newmemory<SegmentTree>(4*(n+1))) { build(1, 1, n, mat); }
  long long Query(const int x1, const int y1, const int x2, const int y2)
  {
    stx = x1, sty = y1, edx = x2, edy = y2;
    return query(1, 1, n);
  }
  void Modify(const int i, const int j, const long long value)
  {
    if (i < 1 || j < 1 || i > n || j > m) return;
    stx = edx = i, sty = edy = j, x = value;
    modify(1, 1, n);
  }
};

//------Main program & functions
int n, m, t, x, y;
long long c;
int main()
{
  freopen("bzoj2877.in", "r", stdin);
  freopen("bzoj2877.out", "w", stdout);
  scanf("%d%d%d%d%d", &n, &m, &x, &y, &t);
  Matrix mat = newmemory<long long*>(n+1);
  for (int i = 0; i <= n; ++i) mat[i] = newmemory<long long>(m+1);

  for (int i = 1; i <= n; ++i)
    for (int j = 1; j <= m; ++j)
      scanf("%I64d", &mat[i][j]);
  for (int i = 1; i < x; ++i)
  {
    for (int j = 1; j < y; ++j) mat[i][j] += mat[i+1][j+1]-mat[i][j+1]-mat[i+1][j];
    for (int j = m; j > y; --j) mat[i][j] += mat[i+1][j-1]-mat[i][j-1]-mat[i+1][j];
  }
  for (int i = n; i > x; --i)
  {
    for (int j = 1; j < y; ++j) mat[i][j] += mat[i-1][j+1]-mat[i][j+1]-mat[i-1][j];
    for (int j = m; j > y; --j) mat[i][j] += mat[i-1][j-1]-mat[i][j-1]-mat[i-1][j];
  }
  for (int i = 1; i < y; ++i) mat[x][i] -= mat[x][i+1];
  for (int i = m; i > y; --i) mat[x][i] -= mat[x][i-1];
  for (int i = 1; i < x; ++i) mat[i][y] -= mat[i+1][y];
  for (int i = n; i > x; --i) mat[i][y] -= mat[i-1][y];
  SegmentTree2D seg(n, m, mat);

  for (int i = 0, op, x1, y1, x2, y2; i < t; ++i)
  {
    scanf("%d%d%d%d%d", &op, &x1, &y1, &x2, &y2);
    if (op == 0)
      printf("%I64d\n", seg.Query(x-x1, y-y1, x+x2, y+y2));
    else
    {
      scanf("%I64d", &c);
      if (x1<=x && y1<=y) seg.Modify(x1-1, y1-1,  c); else
      if (x1> x && y1> y) seg.Modify(x1  , y1  ,  c); else
      if (x1<=x && y1> y) seg.Modify(x1-1, y1  , -c); else
      if (x1> x && y1<=y) seg.Modify(x1  , y1-1, -c);

      if (x2< x && y2< y) seg.Modify(x2  , y2  ,  c); else
      if (x2>=x && y2>=y) seg.Modify(x2+1, y2+1,  c); else
      if (x2< x && y2>=y) seg.Modify(x2  , y2+1, -c); else
      if (x2>=x && y2< y) seg.Modify(x2+1, y2  , -c);

      if (x1<=x && y2>=y) seg.Modify(x1-1, y2+1,  c); else
      if (x1> x && y2< y) seg.Modify(x1  , y2  ,  c); else
      if (x1<=x && y2< y) seg.Modify(x1-1, y2  , -c); else
      if (x1> x && y2>=y) seg.Modify(x1  , y2+1, -c);

      if (x2< x && y1> y) seg.Modify(x2  , y1  ,  c); else
      if (x2>=x && y1<=y) seg.Modify(x2+1, y1-1,  c); else
      if (x2< x && y1<=y) seg.Modify(x2  , y1-1, -c); else
      if (x2>=x && y1> y) seg.Modify(x2+1, y1  , -c);

      if (x1<=x && x2>=x)
      {
        if (y1<=y) seg.Modify(x, y1-1, -c); else seg.Modify(x, y1  ,  c);
        if (y2>=y) seg.Modify(x, y2+1, -c); else seg.Modify(x, y2  ,  c);
      }
      if (y1<=y && y2>=y)
      {
        if (x1<=x) seg.Modify(x1-1, y, -c); else seg.Modify(x1  , y,  c);
        if (x2>=x) seg.Modify(x2+1, y, -c); else seg.Modify(x2  , y,  c);
      }

      if (x1<=x && x2>=x && y1<=y && y2>=y) seg.Modify(x, y, c);
    }
  }
}
]]> <![CDATA[[BZOJ2876][Noi2012]骑行川藏]]> 2013-04-14T00:00:00+08:00 https://quartergeek.com/bzoj2876 这题如果会拉格朗日乘数法的话，那就是裸题了。首先大概讲一下这题的意思。给定s[], k[], v'[], E，求一组v[]，满足E = sum{ k[i]*s[i]*(v[i]-v'[i])^2 }，并且使得t = sum{ s[i]/v[i] }最小。

很明显这个就是一个多元函数求最值的问题，拉格朗日乘数法就是解决这种问题的方法。

拉格朗日乘数法的核心是：对于多元函数f和约束方程g = 0，存在一个负数λ，使得∇f = λ ∇g，其中∇f为f的梯度向量，也就是对每个元取偏导构成的向量。所谓偏导，就是把某一个元看作是变量，其他的当作常量，求导数。然后，通过方程组∇f = λ ∇g以及g = 0就可以解出取最值的时候，所有变量的值了。

对于这题，可以得到：

-s1 / v1^2 = λ * 2 * k1 * s1 * (v1 - v'1)
-s2 / v2^2 = λ * 2 * k2 * s2 * (v2 - v'2)
...

sum{ ki * si * (vi - v'i) ^ 2 } = E

然后解这个方程组就可以解出vi和λ。但是解出来之后能干嘛呢？

我们观察到，如果λ变大（注意，λ是负数，也就是绝对值变小），那么vi就会变大，接下来就会导致所需要的能量变大。也就是说，我们可以二分λ，然后解出vi，计算sum{ ki * si * (vi - v'i) ^ 2 }直到等于E。

解vi的话，可以用二分也可以用牛顿法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

#include <cmath>
#include <cstdio>
#include <algorithm>

inline double sqr(const double x) { return x*x; }
inline double cube(const double x) { return x*x*x; }
struct quad
{ //Ax^3 + Bx^2 + Cx + D
  double A, B, C, D;
  quad(const double a, const double b, const double c, const double d): A(a), B(b), C(c), D(d) { }
  double operator()(const double x) const { return A*cube(x)+B*sqr(x)+C*x+D; }
};
int n;
double E, lef = -1e3, rig, s[10000], k[10000], x[10000], v[10000], maxv[10000];
inline double solve(const quad& f, double x)
{
  const quad d(0, 3*f.A, 2*f.B, f.C);
  double x0;
  do x0 = x, x -= f(x)/d(x);
  while (std::fabs(x-x0) > 1e-12);
  return x;
}
inline double check(const double lambda)
{
  double sum = 0;
  for (int i = 0; i < n; ++i)
  {
    x[i] = solve(quad(2*lambda*k[i], -2*lambda*k[i]*v[i], 0, 1), (std::max(v[i], .0)+maxv[i])/2);
    sum += k[i]*s[i]*sqr(x[i]-v[i]);
  }
  return sum;
}
int main()
{
  scanf("%d%lf", &n, &E);
  for (int i = 0; i < n; ++i)
  {
    scanf("%lf%lf%lf", s+i, k+i, v+i);
    maxv[i] = s[i] > 1e-12 ? std::sqrt(E/(k[i]*s[i]))+v[i] : 0;
    rig = std::min(rig, -1/(2*k[i]*(maxv[i]-v[i])*sqr(maxv[i])));
  }
  while (rig-lef > 1e-12)
  {
    const double mid = (lef+rig)/2;
    if (check(mid) >= E) rig = mid;
    else lef = mid;
  }
  double ans = 0;
  for (int i = 0; i < n; ++i) ans += s[i]/x[i];
  printf("%.10f", ans);
}
]]> <![CDATA[关于gcd的8题]]> 2013-03-28T00:00:00+08:00 https://quartergeek.com/eight-gcd-problems 发现其实有关gcd的题目还是挺多的，这里根据做题顺序写出8题。

[bzoj2818: Gcd] gcd(x,y)=质数, 1<=x,y<=n的对数

做这题的时候，懂得了一个非常重要的转化：求(x, y) = k, 1 <= x, y <= n的对数等于求(x, y) = 1, 1 <= x, y <= n/k的对数！所以，枚举每个质数p（线性筛素数的方法见：线性时间内筛素数和欧拉函数），然后求(x, y) = 1, 1 <= x, y <= n/p的个数。

那(x, y) = 1的个数如何求呢？其实就是求互质的数的个数。在[1, y]和y互质的数有phi(y)个，如果我们令x < y，那么答案就是sigma(phi(y))。因为x, y是等价的，所以答案*2，又因为(1, 1)只有一对，所以-1。最终答案为sigma(sigma(phi(n/prime[i])) * 2 - 1)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <cstdio>
#include <algorithm>

const int MAXN = 10000001;
int n, primes;
long long prime[MAXN], phi[MAXN];
bool com[MAXN];
int main()
{
  scanf("%d", &n);
  for (int i = 2; i <= n; ++i)
  {
    if (!com[i])
    {
      prime[primes++] = i;
      phi[i] = i-1;
    }
    for (int j = 0; j < primes && i*prime[j] <= n; ++j)
    {
      com[i*prime[j]] = true;
      if (i % prime[j])
        phi[i*prime[j]] = phi[i] * (prime[j]-1);
      else
        { phi[i*prime[j]] = phi[i] * prime[j]; break; }
    }
  }
  phi[1] = 1;
  for (int i = 2; i <= n; ++i) phi[i] += phi[i-1];
  long long ans = 0;
  for (int i = 0; i < primes; ++i) ans += phi[n/prime[i]]*2-1;
  printf("%lld", ans);
}

[bzoj2190: [SDOI2008]仪仗队] 求gcd(x,y)=1, 0<=x,y<=n的对数

嗯……似乎这题在上一题的时候解决了。不过要注意的是，这题范围是从0开始的，所以，会多出(1, 0)和(0, 1)这两组，答案就是sigma(phi(i)) - 1 + 2。

[bzoj2005: [Noi2010]能量采集] 求sigma(gcd(x,y)), 1<=x<=n, 1<=y<=m

令f[d]为(x, y) = d的对数，那么答案就是sigma(f[i]*((i-1)*2+1))

f[i]怎么求呢？在1 <= x <= n, 1 <= y <= m中，gcd(x, y) | d的有[n/d] * [m/d]个。不过我们要扣掉所有的倍数，f[i] = [n/d] * [m/d] - f[2i] - f[3i] - f[4i] - ...。逆序做即可。

后来我在想：

  • 为什么上面几题不用这题的方法呢？嗯，因为x, y的取值不一样，这样的话就不得不把莫比乌斯反演搬出来了。
  • 为什么这题不用上面几题的方法呢？嗯，因为这个的复杂度是O(nlogn)（O(n/1 + n/2 + ... + n/n) = O(nlogn)），而上面的复杂度只有O(n + n/logn)（质数个数是n/logn级别的）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <cstdio>
#include <algorithm>

const int MAXN = 100001;
int n, m;
long long f[MAXN];
int main()
{
  scanf("%d%d", &n, &m);
  if (n > m) std::swap(n, m);
  long long ans = 0;
  for (int i = n; i >= 1; --i)
  {
    f[i] = static_cast<long long>(n/i) * (m/i);
    for (int j = i+i; j <= n; j += i)
      f[i] -= f[j];
    ans += f[i]*(2*i-1);
  }
  printf("%lld", ans);
}

[SPOJ VLATTICE] gcd(i,j,k)=1, 0<=i,j,k<=n 的个数

莫比乌斯反演（Möbius inversion formula）终于出现了！莫比乌斯反演的基本形式就是：

g(n) = sigma(d|n, f(d))
f(n) = sigma(d|n, μ(n/d) * g(d))

还有另外一个形式是：

g(n) = sigma(d|n, f(d))
f(n) = sigma(n|d, μ(n) * g(n/d))

通俗的来说，g(n)和f(n)的关系，就是包含和仅包含的关系。

令g(x)为满足x | (i, j, k)的个数，f(x)为满足(i, j, k) = x的个数。显然g(n) = sigma(d|n, f(d)) = [n/x] * [n/x] * [n/x]，所以答案f(1)就可以用下面那个公式算出来了，也就是sigma(μ(d) * [n/d] * [n/d] * [n/d])。

不过需要注意的是，这题的范围可以取0，所以我们还需要加上某一维为0的，某两维为0的方案（基本一样啦）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <cstdio>
#include <algorithm>

const int MAXN = 1000000;
inline long long sqr(const long long x) { return x * x; }
inline long long cube(const long long x) { return x * x * x; }
int Testcase, n, primes, prime[MAXN+1], mu[MAXN+1];
void GetPrimes()
{
  static bool com[MAXN+1];
  mu[1] = 1;
  for (int i = 2; i <= MAXN; ++i)
  {
    if (!com[i])
      { prime[primes++] = i; mu[i] = -1; }
    for (int j = 0; j < primes && i*prime[j] <= MAXN; ++j)
    {
      com[i*prime[j]] = true;
      if (i % prime[j]) mu[i*prime[j]] = -mu[i];
      else { mu[i*prime[j]] = 0; break; }
    }
  }
}
int main()
{
  GetPrimes();
  for (scanf("%d", &Testcase); Testcase--; )
  {
    scanf("%d", &n);
    long long ans = 3;
    for (int i = 1; i <= n; ++i) ans += mu[i] * cube(n/i);
    for (int i = 1; i <= n; ++i) ans += mu[i] * sqr(n/i) * 3;
    printf("%lld\n", ans);
  }
}

[bzoj1101: [POI2007]Zap] 求有多少对数满足 gcd(x,y)=d, 1<=x<=a, 1<=y<=b

首先肯定想到转化成求gcd(x, y) = 1, 1 <= x <= a/d, 1 <= y <= b/d的对数，和上面一题一样。虽然上面那题复杂度很优，只有O(n)，但是对于这边的多组数据完全就无法承受了。

其实，只有O(sqrt(n))个不同的n/i的取值，因此我们可以求mu[i]的前缀和然后分块做！分块可以参考[CQOI2007]余数之和sum bzoj1257。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <cstdio>
#include <algorithm>

const int MAXN = 50000;
inline long long sqr(const long long x) { return x * x; }
int Testcase, n, m, d, primes, prime[MAXN+1], mu[MAXN+1], sum[MAXN+1];
void GetPrimes()
{
  static bool com[MAXN+1];
  mu[1] = 1;
  for (int i = 2; i <= MAXN; ++i)
  {
    if (!com[i])
      { prime[primes++] = i; mu[i] = -1; }
    for (int j = 0; j < primes && i*prime[j] <= MAXN; ++j)
    {
      com[i*prime[j]] = true;
      if (i % prime[j]) mu[i*prime[j]] = -mu[i];
      else { mu[i*prime[j]] = 0; break; }
    }
  }
  for (int i = 1; i <= MAXN; ++i) sum[i] = sum[i-1] + mu[i];
}
int main()
{
  GetPrimes();
  for (scanf("%d", &Testcase); Testcase--; )
  {
    scanf("%d%d%d", &n, &m, &d);
    if (n > m) std::swap(n, m);
    long long ans = 0;
    n /= d, m /= d;
    for (int i = 1, last; i <= n; i = last+1)
    {
      last = std::min(n/(n/i), m/(m/i));
      ans += (sum[last]-sum[i-1]) * static_cast<long long>(n/i) * (m/i);
    }
    printf("%lld\n", ans);
  }
}

[bzoj2301: [HAOI2011]Problem b] 求有多少对数满足 gcd(x,y)=k, a<=x<=b, c<=y<=d

和上面那题几乎一样，只是多了x, y的下界。其实这个可以在算方案的时候yy一下，但是总觉得可能会哪里边界算错，于是就是用了一种偷懒的方法：容斥原理。事实上，这种方法并不会比只算一次的方法来的慢多少。

记f[a, b]为满足(x, y) = 1, 1 <= x <= a, 1 <= y <= b的对数，那么答案就是f[B/K, D/K] - f[(A-1)/K, D/K] - f[B/K, (C-1)/K] + f[(A-1)/K, (C-1)/K]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#include <cstdio>
#include <algorithm>

const int MAXN = 50000;
inline long long sqr(const long long x) { return x * x; }
int Testcase, A, B, C, D, K, primes, prime[MAXN+1], mu[MAXN+1], sum[MAXN+1];
void GetPrimes()
{
  static bool com[MAXN+1];
  mu[1] = 1;
  for (int i = 2; i <= MAXN; ++i)
  {
    if (!com[i])
      { prime[primes++] = i; mu[i] = -1; }
    for (int j = 0; j < primes && i*prime[j] <= MAXN; ++j)
    {
      com[i*prime[j]] = true;
      if (i % prime[j]) mu[i*prime[j]] = -mu[i];
      else { mu[i*prime[j]] = 0; break; }
    }
  }
  for (int i = 1; i <= MAXN; ++i) sum[i] = sum[i-1] + mu[i];
}
long long Process(int n, int m)
{
  long long res = 0;
  if (n > m) std::swap(n, m);
  for (int i = 1, last; i <= n; i = last+1)
  {
    last = std::min(n/(n/i), m/(m/i));
    res += (sum[last]-sum[i-1]) * static_cast<long long>(n/i) * (m/i);
  }
  return res;
}
int main()
{
  GetPrimes();
  for (scanf("%d", &Testcase); Testcase--; )
  {
    scanf("%d%d%d%d%d", &A, &B, &C, &D, &K);
    long long ans = Process(B/K, D/K);
    ans -= Process((A-1)/K, D/K);
    ans -= Process(B/K, (C-1)/K);
    ans += Process((A-1)/K, (C-1)/K);
    printf("%lld\n", ans);
  }
}

[bzoj2820: YY的GCD] 求1<=x<=N, 1<=y<=M且gcd(x,y)为质数有多少对

如果枚举质数的话就要给这个多组数据跪成傻逼了。

ans = sigma(p, sigma(d, μ(d) * (n/pd) * (m/pd)))

Let s = pd, then

ans = sigma(s, sigma(p, μ(s/p) * (n/s) * (m/s)))
    = sigma(s, (n/s) * (m/s) * sigma(p, μ(s/p)))

Let g(x) = sigma(p, μ(x/p)), then

ans = sigma(s, (n/s) * (m/s) * g(s))

如果我们能预处理g(x)的话就能和前面一样分块搞了。这个时候我们多么希望g(x)和μ(x)一样是积性函数。看完题解后，发现有一个不是积性函数，胜似积性函数的性质。由于题解没有给证明，所以就意淫了一个证明。

考虑质数p'，g(p'x) = sigma(p | p'x, μ(p'x/p))。

  • 当x % p' == 0，那么考虑sigma中的变量p的所有取值，它和g(x)中p是相同的。而μ(x)这个函数，如果x有平方因子的话就等于0，因此当p != p'时μ(p'x/p) = 0，当p == p'是，μ(p'x/p) = μ(x)。所以g(p'x) = μ(x)。
  • 当x % p' != 0，同样考虑p，会发现它的取值只比g(x)中的p多出一个p'。同理按照p是否等于p'讨论，可以得到g(p'x) = -g(x) + μ(x)。

因此g(x)可以在线性筛素数的时候算出。剩下的就是前缀和、分块了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <cstdio>
#include <algorithm>

const int MAXN = 10000000;
int Testcase, n, m, primes, prime[MAXN+1], mu[MAXN+1], g[MAXN+1], sum[MAXN+1];
void GetPrimes()
{
  static bool com[MAXN+1];
  mu[1] = 1;
  for (int i = 2; i <= MAXN; ++i)
  {
    if (!com[i])
      prime[primes++] = i, mu[i] = -1, g[i] = 1;
    for (int j = 0; j < primes && i*prime[j] <= MAXN; ++j)
    {
      com[i*prime[j]] = true;
      if (i % prime[j]) mu[i*prime[j]] = -mu[i], g[i*prime[j]] = -g[i] + mu[i];
      else { mu[i*prime[j]] = 0, g[i*prime[j]] = mu[i]; break; }
    }
  }
  for (int i = 1; i <= MAXN; ++i) sum[i] = sum[i-1] + g[i];
}
int main()
{
  GetPrimes();
  for (scanf("%d", &Testcase); Testcase--; )
  {
    scanf("%d%d", &n, &m);
    if (n > m) std::swap(n, m);
    long long ans = 0;
    for (int i = 1, last; i <= n; i = last+1)
    {
      last = std::min(n/(n/i), m/(m/i));
      ans += (n/i) * static_cast<long long>(m/i) * (sum[last]-sum[i-1]);
    }
    printf("%lld\n", ans);
  }
}

[bzoj2705: [SDOI2012]Longge的问题] 求 sigma(gcd(i,n), 1<=i<=n<2^32)

又是令gcd(i, n) = d，答案就是sigma(phi(n/d))，但是我们不能预处理出phi[]数组，因为开不了数组……

注意到因数个数是O(2sqrt(n))级别的，我们枚举所有的n/d，一边dfs一边算phi。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <cmath>
#include <cstdio>

int n, cnt, p[30], c[30];
long long ans = 0;
void dfs(const int step, int pdt, int phi)
{
  if (step == cnt)
  {
    ans += phi;
    return;
  }
  dfs(step+1, pdt, phi);
  phi = phi / p[step] * (p[step]-1);
  for (int i = 1; i <= c[step]; ++i)
    dfs(step+1, pdt *= p[step], phi);
}
int main()
{
  scanf("%d", &n);
  int x = n;
  for (int i = 2; i*i <= x; ++i)
    if (x % i == 0)
    {
      for (; x % i == 0; x /= i) ++c[cnt];
      p[cnt++] = i;
    }
  if (x > 1) c[cnt] = 1, p[cnt++] = x;

  dfs(0, 1, n);
  printf("%lld\n", ans);
}
]]> <![CDATA[[SPOJ GSS2]Can you answer these queries II]]> 2013-03-17T00:00:00+08:00 https://quartergeek.com/gss2 这道题非常的有意思，它查询区间和，但是还不计重复。说实话，看到不计重复这种诡异的条件，往可持久化想了，然后完全就没了思路。Orz 网上各种题解。这题有一个比较仁慈的地方：没有修改操作！所以可以离线。

按照右端点排序询问。我们令s[i]为不重复的sum[i..x]，其中x在最外层循环中从1~n。x每前进一位，把s[last[x]+1]到s[x]全部加上a[x]，其中last[x]是x上一次出现的位置。现在，当x等于某一个询问的右端点r的时候，我们的询问[l, r]，相当于询问所有历史中（包括现在）出现的最大的s[k] (k <= r)。听到历史这个词，很容易想到可持久化数据结构，或者说二维数据结构（比如套一个时间维）。但是实际上，这题要求的历史，是从一开始的历史，而不是从某个时间点开始的，因此，还是可以直接使用线段树的。

线段树节点[L, R]记录四个东西：

max:     现在的s[L..R]中最大的一个
tag:     现在还有多少数没有下传给孩子
evermax: 历史到现在的s[L..R]中最大的一个
evertag: 从上一次清除tag到现在最大的tag

然后clear过程就是一个非常纠结的事情。

son.evertag = max(son.evertag, son.tag + p.evertag);
son.evermax = max(son.evermax, son.max + p.evertag);
son.tag += p.tag;
son.max += p.tag;
p.tag = p.evertag = 0;

后面三句很好理解就不说了。第一句是因为tag是一个累加变量，而距离上一次clear我们还有p.evertag没有下传给孩子，所以说孩子还有son.tag+p.evertag这么多没有给孩子的孩子- -|| 而第二句的话就同理了，参照第三句和第四句的关系以及第一句的意义。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

#include <cstdio>
#include <algorithm>

const int MAXN = 100001;
struct Node
{
  int max, tag, evermax, evertag;
} s[MAXN*4];
struct Question
{
  int l, r, index;
  Question() { }
  Question(const int a, const int b, const int i): l(a), r(b), index(i) { }
} q[MAXN];
inline bool operator<(const Question& lhs, const Question& rhs) { return lhs.r < rhs.r; }
int n, m, _st, _ed, _x, a[MAXN], _[MAXN*2], ans[MAXN];
int* const last = _+MAXN+1;
inline void clear(const int p, const int lef, const int rig)
{
  if (lef == rig) return;
  const int lc = p*2, rc = p*2+1;
  s[lc].evertag = std::max(s[lc].evertag, s[lc].tag + s[p].evertag);
  s[lc].evermax = std::max(s[lc].evermax, s[lc].max + s[p].evertag);
  s[lc].tag += s[p].tag;
  s[lc].max += s[p].tag;

  s[rc].evertag = std::max(s[rc].evertag, s[rc].tag + s[p].evertag);
  s[rc].evermax = std::max(s[rc].evermax, s[rc].max + s[p].evertag);
  s[rc].tag += s[p].tag;
  s[rc].max += s[p].tag;

  s[p].tag = s[p].evertag = 0;
}
inline void update(const int p, const int lef, const int rig)
{
  s[p].max = std::max(s[p*2].max, s[p*2+1].max);
  s[p].evermax = std::max(s[p*2].evermax, s[p*2+1].evermax);
}
void _modify(const int p, const int lef, const int rig)
{
  if (_st <= lef && rig <= _ed)
  {
    s[p].tag += _x;
    s[p].max += _x;
    s[p].evertag = std::max(s[p].evertag, s[p].tag);
    s[p].evermax = std::max(s[p].evermax, s[p].max);
    clear(p, lef, rig);
    return;
  }
  clear(p, lef, rig);
  const int mid = (lef+rig)/2;
  if (_st <= mid) _modify(p*2, lef, mid);
  if (mid+1 <= _ed) _modify(p*2+1, mid+1, rig);
  clear(p*2, lef, mid);
  clear(p*2+1, mid+1, rig);
  update(p, lef, rig);
}
int _query(const int p, const int lef, const int rig)
{
  clear(p, lef, rig);
  if (_st <= lef && rig <= _ed) return s[p].evermax;
  const int mid = (lef+rig)/2;
  int res = 0;
  if (_st <= mid) res = _query(p*2, lef, mid);
  if (mid+1 <= _ed) res = std::max(res, _query(p*2+1, mid+1, rig));
  return res;
}
inline void Modify(const int lef, const int rig, const int delta)
{
  _st = lef, _ed = rig, _x = delta;
  _modify(1, 1, n);
}
inline int Query(const int lef, const int rig)
{
  _st = lef, _ed = rig;
  return _query(1, 1, n);
}
int main()
{
  scanf("%d", &n);
  for (int i = 1; i <= n; ++i)
    scanf("%d", a+i);
  scanf("%d", &m);
  for (int i = 0; i < m; q[i].index = i, ++i)
    scanf("%d%d", &q[i].l, &q[i].r);
  std::sort(q, q+m);
  for (int i = 1, j = 0; i <= n; ++i)
  {
    Modify(last[a[i]]+1, i, a[i]);
    last[a[i]] = i;
    for (; j < m && q[j].r == i; ++j)
      ans[q[j].index] = Query(q[j].l, q[j].r);
  }
  for (int i = 0; i < m; ++i)
    printf("%d\n", ans[i]);
}
]]>