Songer https://www.gravatar.com/avatar/9a05f954b2fc05ba0832bb80ced32187 念念不忘，必有回响 2021-12-14T16:39:44.681Z https://blog.songer.xyz/ Songer weixiao.song@outlook.com Hexo Second Large Rectangle [DP] https://blog.songer.xyz/Code/Second%20Large%20Rectangle%20[DP]/ 2019-08-26T13:31:05.000Z 2021-12-14T16:39:44.681Z Second Large Rectangle [DP]

2019牛客 第二场 H

题目来源：Nowcoder

分析

题目要求“次大全1子矩阵”。其实我们将最大全1子矩阵的代码略加改动便可得到答案。

由于我们之前算的是最大子矩阵，所以在代码里，我们每次根据\(i, j\)和\(h_{i,j}\)算出\(l_{i,j}\),\(r_{i,j}\)时，都只用到了\(h_{i,j} \times (r_{i,j} - l_{i,j} + 1)\)这么一种情况去更新答案。也就是说，我们只考虑了最大的情况。那么，这次，我们只需要将\((h_{i,j} - 1) \times (r_{i,j} - l_{i,j} + 1)\)和\(h_{i,j} \times (r_{i,j} - l_{i,j})\)考虑进去就行了。此时我们只需维护最大值和次大值两个值即可。

但是，还有一种特殊情况。当同一行几个相邻点\(h_{i,j}\)相同时，同一答案可能被计算多次。在计算最大子矩阵时不需要在乎此问题，但在这里就需要考虑了。我们可以发现，当几个点在同一行时，它们的\(l_{i,j}\)和\(r_{i,j}\)在一起能共同决定整个矩形。也就是说，我们只要将\((l_{i,j},r_{i,j})\)扔到set里即可。当然，set只需判断在同一行的情况。

代码

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
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <set>

#define MAXN 1010

using namespace std;

int a[MAXN][MAXN];
int h[MAXN][MAXN];
int l[MAXN], r[MAXN];

set<pair<int, int>> s;

int main()
{
    int n, m;
    while (~scanf("%d%d", &n, &m))
    {
        for (int i = 1; i<=n; i++)
        {
            getchar();
            for (int j = 1; j<=m; j++)
                a[i][j] = getchar() - '0';
        }

        for (int i = 1; i<=n; i++)
            for (int j = 1; j<=m; j++)
                if (a[i][j]==1)
                    h[i][j] = h[i-1][j] + 1;
                else
                    h[i][j] = 0;

        int ans = 0, maxn = 0;
        for (int i = 1; i<=n; i++)
        {
            s.clear();

            for (int j = 1; j<=m; j++)
            {
                l[j] = j;

                while ( l[j]>1 && h[i][ l[j] - 1 ] >= h[i][j])
                    l[j] = l[ l[j] - 1];
            }

            for (int j = m; j>=1; j--)
            {
                r[j] = j;

                while ( r[j]<m && h[i][ r[j] + 1 ] >= h[i][j])
                    r[j] = r[ r[j] + 1];

                // cout << l[j] << " " << r[j] << " " << h[i][j] << endl;

                if (s.find(pair<int, int>(l[j], r[j])) == s.end())
                {
                    s.insert(pair<int, int>(l[j], r[j]));

                    int m = (r[j] - l[j] + 1) * h[i][j];

                    if (m > maxn)
                    {
                        ans = maxn;
                        maxn = m;

                        if (m - h[i][j] > ans)
                            ans = m - h[i][j];
                        if (m - (r[j] - l[j] + 1) > ans)
                            ans = m - (r[j] - l[j] + 1);

                    }else if (m > ans)
                        ans = m;
                }

            }
        }

        printf("%d\n", ans);
        // cout << ans << endl;
    }
}
]]> <h1 id="second-large-rectangle-dp">Second Large Rectangle [DP]</h1> <h2 id="牛客-第二场-h">2019牛客 第二场 H</h2> 最大全1子矩阵 [DP] https://blog.songer.xyz/Code/%E6%9C%80%E5%A4%A7%E5%85%A81%E5%AD%90%E7%9F%A9%E9%98%B5%20[DP]/ 2019-08-26T07:26:26.000Z 2021-12-14T16:39:44.685Z 最大全1子矩阵 [DP]

POJ 3494

题目来源：POJ

分析

这也算是一个十分经典的DP题了。给定一个01矩阵，要求求出最大的全1子矩阵。

首先，我们可以通过\(O(n^2)\)的预处理算出\(h[i][j]\)，代表的是\(i,j\)坐标的点 向上的连续1的数目。

然后，我们采用“悬线法”来计算答案。假如\(l_i\)是最靠左的令\(h[x] \geq h[i], (l_i \leq x \leq i)\),\(r_i\)同理。那么\((r_i - l_i + 1) \times 1\)就是高度为\(h_i\)且\(i,j\)在底边上的最大矩形。

那么，问题就在于如何求\(l_i\)和\(r_i\)了。如果我们暴力地去求，那么整个算法地时间复杂度就是\(O(n^3)\)，明显太慢。在这里，我们就要用DP的方法来实现了。

我们令所有的\(j<i\),\(l_j\)都已经算出，那么，当\(h_j < h_i\)时，那么，我们可以保证\(h_{l_j} < h_i\)。然后，我们可以继续比较\(h_{h_j - 1}\)和\(h_i\)。这样，我们可以快速地算出\(l_i\)，\(r_i\)。

代码

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
#include <iostream>
#include <algorithm>
#include <cstdio>

#define MAXN 2010

using namespace std;

int a[MAXN][MAXN];
int h[MAXN][MAXN];
int l[MAXN], r[MAXN];

int getint()
{
    char c = getchar();

    while (c<'0' || c>'9')
        c = getchar();

    int ret = 0;
    while (c>='0' && c<='9')
        ret = ret * 10 + c - '0', c = getchar();

    return ret;
}

int main()
{
    // ios::sync_with_stdio(false);

    int n, m;
    while (~scanf("%d%d", &n, &m))
    {
        for (int i = 1; i<=n; i++)
            for (int j = 1; j<=m; j++)
                a[i][j] = getint();
                // scanf("%d",&a[i][j]);
                // cin >> a[i][j];

        for (int i = 1; i<=n; i++)
            for (int j = 1; j<=m; j++)
                if (a[i][j]==1)
                    h[i][j] = h[i-1][j] + 1;
                else
                    h[i][j] = 0;

        int ans = 0;
        for (int i = 1; i<=n; i++)
        {
            for (int j = 1; j<=m; j++)
            {
                l[j] = j;

                while ( l[j]>1 && h[i][ l[j] - 1 ] >= h[i][j])
                    l[j] = l[ l[j] - 1];

            }
            for (int j = m; j>=1; j--)
            {
                r[j] = j;

                while ( r[j]<m && h[i][ r[j] + 1 ] >= h[i][j])
                    r[j] = r[ r[j] + 1];

                ans = max(ans, (r[j] - l[j] + 1) * h[i][j] );
            }
        }

        printf("%d\n", ans);
        // cout << ans << endl;
    }
}
]]> <h1 id="最大全1子矩阵-dp">最大全1子矩阵 [DP]</h1> <h2 id="poj-3494">POJ 3494</h2> Remainder Problem [思维题] https://blog.songer.xyz/Code/Remainder%20Problem%20[%E6%80%9D%E7%BB%B4%E9%A2%98]/ 2019-08-25T05:45:38.000Z 2021-12-14T16:39:44.681Z Remainder Problem [思维题]

CF Edu 71 F

题目来源：Codeforces

分析

题目给了长度为\(5 \times 10^5\)的全\(0\)数组，然后给出了两种操作：

  1. 1 x y: 令\(a_x\)加\(y\)；
  2. 2 x y: 求下标\(i\)满足\(i \equiv y (\mod x)\)的\(a_i\)的和。

假如我们直接维护一个\(a_i\)数组，那么如果我们暴力进行操作\(2\)的话，时间复杂度显然是\(O\left(\frac{x}{x} \right)\)的。当\(x^2>N\)时，该操作是\(O(n^{\frac{1}{2}})\)的。但是，当\(x\)较小时呢？我们可以直接维护一个\(ans[x][y]\)数组，在每次进行操作\(1\)时，对所有影响的数组进行更新即可。因为\(x^2 \leq N\)，所以插入操作也是\(O(n^{\frac{1}{2}})\)的。所以，我们最后得到了一个\(O(q \sqrt{n})\)的算法。

而实际上，由于大部分\(x\)都是不等于\(\sqrt(n)\)的，所以实际的时间要比\(O(q \sqrt{n})\)要小，所以可以通过该题。

代码

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
#include <iostream>
#include <algorithm>

#define MAXN 500000
#define K 750

using namespace std;

int a[MAXN + 1];
long long ans[K+1][K];

int main()
{
    int q;
    cin >> q;

    for (int i = 1; i<=q; i++)
    {
        int op, x, y;
        cin >> op;
        cin >> x >> y;

        if (op==1)
        {
            a[x] += y;
            for (int j = 1; j<=K; j++)
                ans[j][x % j] += y;
        }else
        {
            if (x>K)
            {
                long long tmp = 0;
                for (int j = y; j<=MAXN; j+=x)
                    tmp += a[j];
                cout << tmp << endl;
            }else
            {
                cout << ans[x][y] << endl;
            }
            
        }
    }
}
]]> <h1 id="remainder-problem-思维题">Remainder Problem [思维题]</h1> <h2 id="cf-edu-71-f">CF Edu 71 F</h2> Integration [数学] https://blog.songer.xyz/Code/Integration%20[%E6%95%B0%E5%AD%A6]/ 2019-08-25T02:12:45.000Z 2021-12-14T16:39:44.681Z Integration [数学]

2019牛客 第一场 B

题目来源：Nowcoder

分析

这道题就是一道纯粹的数学题。。题目要求计算如下公式：

\[ \frac{1}{\pi} \int_0^{\infty} \frac{1}{\prod_{i=1}^n (a_i^2 + x^2)} dx \]

首先，我们先假设一个变量：

\[ c_i = \frac{1}{\prod_{j \neq i}(a_j^2 - a_i^2)}\]

那么，其实第一个公式便可以进行如下的化简：

\[\begin{aligned}&\ \frac{1}{\pi} \int_0^{+\infty} \frac{1}{\prod_{i=1}^n (a_i^2 + x^2)} dx \\= &\ \frac{1}{\pi} \int_0^{+\infty} \sum \frac{c_i}{a_i^2 + x^2} dx (\text{此处由题解给出，我实在不会证}) \\= &\ \frac{1}{\pi} \sum \int_0^{+\infty} \frac{c_i}{a_i^2 + x^2} dx \\= &\ \frac{1}{\pi} \sum \left( \frac{c_i}{a_i} \times \left. \arctan(x/a_i) \right|_0^{+\infty} \right) \\= &\ \frac{1}{\pi} \sum \frac{c_i}{2a_i} \pi \end{aligned}\]

实现细节

这道题主要由两个细节问题：

  1. 不能频繁的进行取乘法逆元操作，否则会超时。应先乘在一起，然后再求逆元。
  2. 注意\(a_j^2 - a_i^2\)可能为负数。

代码

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
#include <iostream>

#define MAXN 1010
#define MOD 1000000007

using namespace std;

long long pow(long long x, long long n, long long mod)
{
    long long ret = 1;
    long long t = x % mod;

    while (n)
    {
        if (n & 1)
            ret = ret * t % mod;

        n /= 2;
        t = t * t % mod;
    }

    return ret;
}

long long reverse(long long x, long long mod)
{
    return pow(x, mod - 2, mod);
}

long long a[MAXN];

int main()
{
    ios::sync_with_stdio(false);

    int n;
    while (cin >> n)
    {
        for (int i = 1; i<=n; i++)
            cin >> a[i];

        long long ans = 0;
        for (int i = 1; i<=n; i++)
        {
            long long tmp = 1;
            for (int j = 1; j<=n; j++)
                if (i!=j)
                {
                    long long m = a[j] * a[j] - a[i] * a[i];
                    m %= MOD;
                    if (m<0)
                        m += MOD;
                    tmp = tmp * m % MOD;
                }

            tmp = tmp * 2 * a[i] % MOD;

            ans = (ans + reverse(tmp, MOD)) % MOD;
        }

        cout << ans << endl;
    }
}
]]> <h1 id="integration-数学">Integration [数学]</h1> <h2 id="牛客-第一场-b">2019牛客 第一场 B</h2> ABBA [DP] https://blog.songer.xyz/Code/ABBA%20[DP]/ 2019-08-24T04:40:45.000Z 2021-12-14T16:39:44.681Z ABBA [DP]

2019牛客多校 第一场 E

题目来源：Nowcoder

分析

我们可以把这个题目看作一个已经拥有\(n\)个AB和\(m\)个BA，把它放入一个数组的过程。那么，题目即为要求有多少种放法。

这个题目的主要限制在于AB中的A一定先于B放入，BA同理。那么，我们可以发现，已放置的A和B的放置顺序对答案没有影响。即，只有“是否已放置”有影响，“放置在哪里”没有影响。那么，很明显，这道题便是一个DP了。我们使用dp[i][j]记录答案，其中i是放置了多少个A，j是放置对了多少个B。那么，很明显，我们需要满足以下两个条件：

  1. \(i \leq n + j\);
  2. \(j \leq m + i\).

在以上两个条件下进行状态转移即可。

代码

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 <iostream>
#include <algorithm>

#define MAXN 1010
#define MOD 1000000007

using namespace std;

long long dp[2 * MAXN][2 * MAXN];

int main()
{
    int n, m;
    
    while (cin >> n >> m)
    {
        for (int i = 0; i<=n+m; i++)
            for (int j = 0; j<=n+m; j++)
                dp[i][j] = 0;

        dp[0][0] = 1;
        for (int i = 0; i<=n + m; i++)
            for (int j = 0; j<=m + n; j++)
            {
                if (i < n + j)
                    dp[i+1][j] = (dp[i+1][j] + dp[i][j]) % MOD;
                if (j < m + i)
                    dp[i][j+1] = (dp[i][j+1] + dp[i][j]) % MOD;

                // cout << i << " " << j << " " << dp[i][j] << endl;
            }   

        cout << dp[n+m][n+m] << endl;
    }
}
]]> <h1 id="abba-dp">ABBA [DP]</h1> <h2 id="牛客多校-第一场-e">2019牛客多校 第一场 E</h2> Equivalent Prefixes [笛卡尔树] https://blog.songer.xyz/Code/Equivalent%20Prefixes%20[%E7%AC%9B%E5%8D%A1%E5%B0%94%E6%A0%91]/ 2019-08-23T14:01:11.000Z 2021-12-14T16:39:44.681Z Equivalent Prefixes [笛卡尔树]

2019牛客多校 第一场 A

题目来源：Nowcoder

分析

题目给定了a[],b[]，要求找出最大的\(p \leq n\)满足\([a_1, a_2, ... , a_p]\)和\([b_1, b_2, ... ,b_p]\)是“相等”的。相等在这个题目中的定义为：对于长度都为n的序列u[]和v[]，任意的\(1 \leq 1 \leq l \leq r \leq n\)都能使\(RMQ(u, l, r) = RMQ(v, l, r)\)。\(RMQ()\)即为区间最小值的下标。

我们先来研究如何判断两个序列是“相等”的。很明显，由于对于任意的\(l\)和\(r\)，\(RMQ(l,r)\)都相同，那么这两个序列中每个数的相对顺序都是一样的。其实，这也就代表着，这两个序列构造出的笛卡尔树的结构是相同的。

但是，答案要求的是“最小的满足条件的\(p\)”。如果我们每次都对笛卡尔树的结构做一次比较的话，由于每次要比较所有的点，所以时间为\(O(n^2)\)，肯定超时了。那么，还有什么能够让我们确定这两个笛卡尔树相同呢？笛卡尔树构造中的单调栈。单调栈能够唯一地反映当前插入的点的位置，只要每次的单调栈相同，那么生成的笛卡尔树一定相同。而且实际上，由于单调栈的长度变化能唯一的反映出插入点位置的变化，所以只需要每次比较单调栈的长度即可。

代码

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
#include <iostream>
#include <algorithm>
#include <stack>

#define L 0
#define R 1
#define MAXN 100100

using namespace std;

struct Node
{
    int val;
    Node *fa;
    Node *son[2];

    Node(int val = 0)
    {
        this->val = val;
        fa = NULL;
        son[L] = NULL;
        son[R] = NULL;
    }
};

struct CartesianTree
{
    stack<Node *> s;
    Node *root;

    CartesianTree()
    {
        root = NULL;
        s = stack<Node *>();
    }

    void insert(int a)
    {
        Node *next = new Node(a);
        Node *last = NULL;

        while (!s.empty())
        {
            if (s.top()->val < next->val)
            {
                Node *tmp = s.top();
                if (tmp->son[R])
                    tmp->son[R]->fa = next;
                next->son[L] = tmp->son[R];
                tmp->son[R] = next;
                next->fa = tmp;
                break;
            }
            last = s.top();
            s.pop();
        }

        if (s.empty() && last)
        {
            next->son[L] = last;
            last->fa = next;

            if (last==root)
                root = next;
        }
        if (root==NULL)
            root = next;

        s.push(next);
    }
};

int a[MAXN], b[MAXN];

int main()
{
    ios::sync_with_stdio(false);

    int n;

    while (cin>>n)
    {
        for (int i = 0; i<n; i++)
            cin >> a[i];
        for (int i = 0; i<n; i++)
            cin >> b[i];

        CartesianTree x, y;

        int i;
        for (i = 0; i<n; i++)
        {
            x.insert(a[i]);
            y.insert(b[i]);

            if (x.s.size() != y.s.size())
                break;
        }

        cout << i << endl;
    }
}
]]> <h1 id="equivalent-prefixes-笛卡尔树">Equivalent Prefixes [笛卡尔树]</h1> <h2 id="牛客多校-第一场-a">2019牛客多校 第一场 A</h2> [学习笔记]笛卡尔树 https://blog.songer.xyz/Code/[%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0]%E7%AC%9B%E5%8D%A1%E5%B0%94%E6%A0%91/ 2019-08-22T08:00:35.000Z 2021-12-14T16:39:44.685Z [学习笔记]笛卡尔树

不知不觉，这估计是自从我用这个博客以来“停更”最长的了。各种奇奇怪怪的原因综合在一起导致连续三个月没有写任何博客。其实过去半年感觉投入到ACM的时间就有点少。最近几天也是。话说笛卡尔树我从前一直没听说过（汗），最近比赛完后看题解才知道这玩意儿。。。

介绍

笛卡尔树是一种特定二叉树数据结构，可由数列构造，在范围最值查、范围top k查询（range top k queries）等问题上有广泛应用。它具有堆的有序性，中序遍历可以输出原数列。笛卡尔树结构由Vuillmin(1980)在解决范围搜索的几何数据结构问题时提出。从数列中构造一棵笛卡尔树可以线性时间完成，需要采用基于栈的算法来找到在该数列中的所有最近小数。

于维基百科上的图例能很好地展现它的性质：

笛卡尔树

实现细节

构造

我们固然可以通过一个个插入来构造笛卡尔树，虽然平均时间复杂度为\(O(n \log n)\)，但是在成链的条件下会退化为\(O(n^2)\)。而若我们使用单调栈，则可以直接实现\(O(n)\)的时间复杂度。

使用单调栈构造的主要思路是：维护一个存储了从根节点一直走右儿子到当前插入节点的所有节点的栈。比如当我们插入完了上图中的\(10\)时，单调栈存储的便为\([1, 8, 10]\)（此时\(8\)还是\(1\)的右儿子）。我们令栈顶的值为now，然后我们尝试取插入下一个数next。此时有如下三种情况：

  1. \(next > now\): 此时我们直接令next为now的右儿子，并且令now原来的右儿子为next的左儿子；
  2. \(next < now\): 将栈顶取出，然后再令当前栈的栈顶为now；
  3. 栈为空：令当前根节点的父亲指向next，并将next设为根节点。

代码实现如下： 

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
stack<Node*> s;
struct CartesianTree
{
    Node *root;

    CartesianTree(int *a, int n)
    {
        s = stack<Node *>();

        for (int i = 0; i<n; i++)
        {
            Node *next = new Node(a[i]);
            Node *last = NULL;
            while (!s.empty())
            {
                if (s.top()->val < next->val)
                {
                    Node *tmp = s.top();

                    if (tmp->son[R])
                        tmp->son[R]->fa = next;
                    next->son[L] = tmp->son[R];

                    tmp->son[R] = next;
                    next->fa = tmp;

                    break;
                }

                last = s.top();
                s.pop();
            }

            if (s.empty() && last)
            {
                next->son[L] = last;
                last->fa = next;
            }

            s.push(next);
        }

        while (!s.empty())
        {
            root = s.top();
            s.pop();
        }
    }
};

例题

hdu 1506

题目来源：hdu

分析

题目给定了长度为\(10^5\)的h[]。要求求出最大的矩形。

我们可以构造一个笛卡尔树。由于笛卡尔树的性质可得，一个节点的子节点一定都大于该节点并且与它相邻。所以对于每个节点，高度为该子节点高度的最大矩形的面积便为\(size \times height\)。取所有节点的\(max\)即可。

代码

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 <iostream>
#include <algorithm>
#include <stack>

#define L 0
#define R 1
#define MAXN 100100

using namespace std;

struct Node
{
    int height;
    int size;
    Node *fa;
    Node *son[2];

    Node(int height = 0)
    {
        this->height = height;
        size = 1;
        fa = NULL;
        son[0] = son[1] = NULL;
    }
};
int cnt;

stack<Node*> s;
struct CartesianTree
{
    Node *root;

    CartesianTree(int *a, int n)
    {
        s = stack<Node *>();

        for (int i = 0; i<n; i++)
        {
            Node *next = new Node(a[i]);
            Node *last = NULL;
            while (!s.empty())
            {
                if (s.top()->height < next->height)
                {
                    Node *tmp = s.top();

                    if (tmp->son[R])
                        tmp->son[R]->fa = next;
                    next->son[L] = tmp->son[R];

                    tmp->son[R] = next;
                    next->fa = tmp;

                    break;
                }

                last = s.top();
                s.pop();
            }

            if (s.empty() && last)
            {
                next->son[L] = last;
                last->fa = next;
            }

            s.push(next);
        }

        while (!s.empty())
        {
            root = s.top();
            s.pop();
        }
    }

    long long run(Node *node = NULL)
    {  
        if (node==NULL)
            node = root;

        long long ans = 0;

        if (node->son[L])
        {
            ans = max(ans, run(node->son[L]));
            node->size += node->son[L]->size;
        }
        if (node->son[R])
        {
            ans = max(ans, run(node->son[R]));
            node->size += node->son[R]->size;
        }

        ans = max(ans, (long long)node->height * (long long)node->size);

        return ans;
    }
};


int h[MAXN];
int main()
{
    ios::sync_with_stdio(false);

    int n;
    cin >> n;

    while (n)
    {
        for (int i = 0; i < n; i++)
            cin >> h[i];

        CartesianTree *ct = new CartesianTree(h, n);

        cout << ct->run() << endl;

        cin >> n;
    }
}

]]> <h1 id="学习笔记笛卡尔树">[学习笔记]笛卡尔树</h1> <blockquote> <p>不知不觉，这估计是自从我用这个博客以来“停更”最长的了。各种奇奇怪怪的原因综合在一起导致连续三个月没有写任何博客。其实过去半年感觉投入到ACM的时间就有点少。最近几天也是。话说笛卡尔树我从前一直没听说过（汗），最近比赛完后看题解才知道这玩意儿。。。</p> </blockquote> 大二下第十五周 https://blog.songer.xyz/Diary/%E5%A4%A7%E4%BA%8C%E4%B8%8B%E7%AC%AC%E5%8D%81%E4%BA%94%E5%91%A8/ 2019-06-09T15:03:11.000Z 2021-12-14T16:39:44.685Z 大二下第十五周

2019 6 9 周日

距离上一次的“日记”已经过去了半年，最近几天又突然有了写一篇的念头。毕竟半年过去了，多少有些能记一下的东西。

这半年过得其实有些庸碌，刷题量明显变少，实验室也终于不去了（虽然我去也没有事情），博客的更新频率也大不如前。所以说，这半年算是“庸碌”的半年。不过，妄想用一个词就概括进两百天明显也是有失偏颇的。

说到博客，最近GFW明显变高，导致我的博客和ss都被墙掉了，所以想要更新就显得更加麻烦。我尝试新开了几个不同地区的VPS，结果都是过了几天就被封掉了。今天我又开了一个阿姆斯特丹的VPS搭了一个openVPN，不知道究竟能不能用到明天（苦笑。

虽说在ACM上算是几乎“毫无进展”，不过最近找到了一本好书。加缪的《堕落(The fall)》，虽然汉译本的翻译略显晦涩，但是加缪所描述的律师突然让我有些共鸣。或许有时间我会专门记一下吧。

另外，最近我刚刚换了一个手机，魅族16th，感觉还行，不过使用白条买的，到现在还没有还清。

不过，我感觉我这半年间，却又越来越有了一种“自以为高雅”的感觉。我自以为高尚，看到低俗的信息就看到厌恶、与不屑。B站我也不太想看了，只是偶尔看看新闻。我尽可能的想要“理性客观”，想要把自己从主观与情绪中剖离出去。不过，这是好是坏呢？

虽说日记本就应该是记一些琐碎事。但是我在之前的几篇日记中频频给自己打鸡血，感觉有些偏离本意。虽说如此，我最近确实算是有些颓废。没有目标，整天有些得过且过。期末考试不会是目标，应付作业也不会是目标。我应该再去找一些“提升自我”的事情做，而不是空闲下来就去打打游戏、玩玩手机。

说起来，还有一件我非常想记下的事情。大概是几天前，其实不只是几天前，这已经是第二次了。我梦见我站在宿舍的阳台上，阳台外是碧蓝到发绿的大海。海上有山，有船，甚至有一个海上乐园。然后就发生了水灾。我看见人被冲来冲去，在水中挣扎，然后便轮到了我。

这突然让我想起了几天前，我看了一遍敦刻尔克。看着里面的士兵在被淹没的船舱里挣扎。我突然感到了科技战争的“冷酷”。即便是死亡，也不再是刀起刀落，而是淹没的船舱，是焚烧的坦克，是孤立无援的绝望。

说来说去，结果有说了一堆毫无头绪的东西。就到这为止吧。

]]> <h1 id="大二下第十五周">大二下第十五周</h1> <h2 id="周日">2019 6 9 周日</h2> Camp Schedule https://blog.songer.xyz/Code/Camp%20Schedule/ 2019-03-20T13:48:53.000Z 2021-12-14T16:39:44.681Z Camp Schedule

CF 1137 B

题目来源：Codeforces

分析

题目给出两个01串s和t，要求对s进行重新排列，令其含有尽可能多的t的子串。最简单的看，我们只需要令s被尽可能多的t的子串构成即可。

但实际上，如果t中存在部分前缀和部分后缀相同的情况的话就会非常麻烦。此外，还有可能t本身就是由数个重复串组成的。这时，我们可以用KMP中的fail[]数组来解决这个问题。

首先，我们需要先找出t中的循环节。注意，这时我们考虑的循环节，包括了t中的最后的后缀是循环节的一部分但并不是一个完整的循环节的情况（譬如，ababa的循环节即为ab，因为a也是ab的前缀，只是不是一个完整的循环节）。找出该循环节，我们其实可以用以下代码实现(参考于Cyclic Nacklace [KMP变型])：

1
2
for (int i = t.length(); i>0; i = fail[i])
        x = max(x, i - fail[i]);

这样，我们其实只需要看s中有多少个t的循环节就好了。然后我们减去t本身有多少个循环节再加一即为答案。

代码

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
#include <iostream>
#include <algorithm>
#include <string>

#define MAXN 500100

using namespace std;

string s, t;

int fail[MAXN];

void getFail(string s)
{
    fail[0] = 0;

    for (int i = 1; i<s.length(); i++)
    {
        int j = fail[i];
        while (j && s[i]!=s[j])
            j = fail[j];
        fail[i+1] = s[i]==s[j]? j+1 : 0;
    }
}

int cnt[2];
int sum[2];
string str;

int main()
{
    cin >> s;
    cin >> t;

    getFail(t);

    str = "";
    int lent = t.length();
    int lens = s.length();
    int x = t.length();

    for (int i = t.length(); i>0; i = fail[i])
        x = max(x, i - fail[i]);

    for (int i = 0; i<lent; i++)
        cnt[ t[i] - '0' ] ++;

    for (int i = 0; i<lens; i++)
        sum[ s[i] - '0' ] ++;

    if (sum[0] >= cnt[0] && sum[1] >= cnt[1])
    {
        cout << t;
        sum[0] -= cnt[0];
        sum[1] -= cnt[1];

        cnt[0] = 0;
        cnt[1] = 0;

        for (int i = fail[lent]; i<lent; i++)
        {
            cnt[ t[i] - '0' ] ++;
            str += t[i];
        }

        while (sum[0] >= cnt[0] && sum[1] >= cnt[1])
        {
            cout << str;
            sum[0] -= cnt[0];
            sum[1] -= cnt[1];
        }

        while (sum[0]--)
            cout << 0;
        while (sum[1]--)
            cout << 1;

        cout << endl;
    }else 
        cout << s << endl;
}
]]> <h1 id="camp-schedule">Camp Schedule</h1> <h1 id="cf-1137-b">CF 1137 B</h1> Skycsrapers https://blog.songer.xyz/Code/Skycsrapers/ 2019-03-20T13:09:21.000Z 2021-12-14T16:39:44.681Z Skycsrapers

CF 1137 A

这是我的第一场Div.1，结果打完之后又掉回Div.2了，结束了我短暂的Div.1生涯。。。

题目来源：Codeforces

分析

题目给出了一个\(n \times m\)的地图mp[][]，假设其由n条横向道路和m条纵向道路组成，并且在每一个路口都有一个摩天大楼，高度为mp[i][j]。然后，我们希望在不更改同一行或同一列的大楼之间的高度关系的情况下，令高度最高的大楼的高度尽可能的小。

这其实就是一个Hash，我们对于每一行或者每一列都Hash映射到尽可能小的数即可。不过我们还要考虑一个点同时对行和列的影响。譬如一个点在行中算出其为10，但是在列中是最小的。所以我们需要令列中的所有数都按照正常Hash的情况再加9。所以实际上，我们可以记录，每个点在行中或者列中，小于等于它的数的Hash值的数目和大于等于的数目，即smaller[i][j][]和bigger[i][j][]。第三维通过0,1来记录行列，然后答案在smaller[i][j][]和bigger[i][j][]中取组合的最大值即可。

代码

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
#include <iostream>
#include <algorithm>
#include <string>

#define MAXN 1010

using namespace std;

struct A
{
    int i, j;
    int x;

    A(){}

    A(int x, int i, int j):x(x), i(i), j(j) {}

    const bool operator < (const A &tmp) const
    {
        return this->x < tmp.x;
    }

    const bool operator != (const A &tmp) const
    {
        return this->x != tmp.x;
    }

}a[MAXN];

int mp[MAXN][MAXN];
int smaller[MAXN][MAXN][2], bigger[MAXN][MAXN][2];

int main()
{
    ios::sync_with_stdio(false);

    int n, m;
    cin >> n >> m;

    for (int i = 1; i<=n; i++)
        for (int j = 1; j<=m; j++)
            cin >> mp[i][j];

    for (int i = 1; i<=n; i++)
    {
        for (int j = 1; j<=m; j++)
            a[j] = A(mp[i][j], i, j);

        sort(a+1, a+1+m);

        int t = 1;
        smaller[ a[1].i ][ a[1].j ][0] = 1;
        for (int j = 2; j<=m; j++)
        {
            if (a[j]!=a[j-1])
                t++;

            smaller[ a[j].i ][ a[j].j ][0] = t;
        }

        for (int j = 1; j<=m; j++)
            bigger[ a[j].i ][ a[j].j ][0] = t - smaller[ a[j].i ][ a[j].j ][0];
    }

    for (int j = 1; j<=m; j++)
    {
        for (int i = 1; i<=n; i++)
            a[i] = A(mp[i][j], i, j);

        sort(a+1, a+1+n);

        int t = 1;
        smaller[ a[1].i ][ a[1].j ][1] = 1;
        for (int i = 2; i<=n; i++)
        {
            if (a[i]!=a[i-1])
                t++;

            smaller[ a[i].i ][ a[i].j ][1] = t;
        }

        for (int i = 1; i<=n; i++)
            bigger[ a[i].i ][ a[i].j ][1] = t - smaller[ a[i].i ][ a[i].j ][1];
    }

    for (int i = 1; i<=n; i++)
    {
        for (int j = 1; j<=m; j++)
        {
            int ans = max(smaller[i][j][0] + bigger[i][j][1], smaller[i][j][1] + bigger[i][j][0]);  
            ans = max(ans, smaller[i][j][0] + bigger[i][j][0]);
            ans = max(ans, smaller[i][j][1] + bigger[i][j][1]);

            cout << ans << " ";
        }
        cout << endl;
    }
}
]]> <h1 id="skycsrapers">Skycsrapers</h1> <h1 id="cf-1137-a">CF 1137 A</h1> <blockquote> <p>这是我的第一场Div.1，结果打完之后又掉回Div.2了，结束了我短暂的Div.1生涯。。。</p> </blockquote> Zero Quantity Maximization https://blog.songer.xyz/Code/Zero%20Quantity%20Maximization/ 2019-03-20T12:30:50.000Z 2021-12-14T16:39:44.685Z Zero Quantity Maximization

CF 1133 D

题目来源：Codeforces

分析

题目给出两个数组a[]和b[]，要求对于满足\(c_i = d \cdot a_i + b_i\)的数组c[]，当d取何值时c[]中有尽可能多的0。

我们只需要假设所有的c[i]都为0，然后求出满足其关系的d，找到出现次数最多的d就可以了。

这题当时做的时候最早没有用map<>，而是使用了排序后手动计算的方法，结果莫名其妙的出现了许多的bug，换成map<>之后就好了。。。此外，这里其实可以不使用Node，而是直接用一个pair<int, int>即可，只需要记住用gcd()将分数化为最简形式即可。

代码

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
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <map>

#define MAXN 200100

using namespace std;

struct Node
{
    long long a, b;
    int k;

    void getK()
    {
        if (this->a * this->b<0)
            this->k = -1;
        else this->k = 1;
    }

    const bool operator < (const Node &tmp)const{
        return abs(this->b * tmp.a) * this->k < abs(tmp.b * this->a) * tmp.k;
    }

}node[MAXN];

map<Node, int> mp;

int main()
{
    ios::sync_with_stdio(false);

    int n;
    cin >> n;

    for (int i = 1; i<=n; i++)
        cin >> node[i].a;

    for (int i = 1; i<=n; i++)
    {
        cin >> node[i].b;
        node[i].getK();
    }

    int cnt = 0;
    for (int i = 1; i<=n; i++)
        if (node[i].a==0 && node[i].b==0)
        {
            cnt ++;
        }else if (node[i].a!=0)
        {
            mp[node[i]]++;
        }

    int ans = 0;
    map<Node, int>::iterator it;
    for (it = mp.begin(); it!=mp.end(); it++)
        ans = max(ans, it->second);

    cout << ans + cnt << endl;
}
]]> <h1 id="zero-quantity-maximization">Zero Quantity Maximization</h1> <h1 id="cf-1133-d">CF 1133 D</h1> Two Cakes [思维题] https://blog.songer.xyz/Code/Two%20Cakes%20[%E6%80%9D%E7%BB%B4%E9%A2%98]/ 2019-03-01T01:18:53.000Z 2021-12-14T16:39:44.681Z Two Cakes [思维题]

CF Contest 542 B

题目来源：codeforces

分析

这道题其实和Wannafly Camp中的夺宝奇兵有异曲同工之妙。我们有两个人，他们分别需要从0走到n，那么我们其实可以发现对于每次从第\(i\)个走到\(i+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
#include <iostream>
#include <algorithm>

#define MAXN 100100

using namespace std;

int a[MAXN][2];

int main()
{
    int n;
    cin >> n;

    for (int i = 1; i<=2*n; i++)
    {
        int x;
        cin >> x;
        if (a[x][0]==0)
            a[x][0] = i;
        else a[x][1] = i;
    }

    long long ans = 0;
    ans += a[1][0] + a[1][1] - 2;
    for (int i = 1; i<n; i++)
    {
        int min1 = abs(a[i][0] - a[i+1][0]) + abs(a[i][1] - a[i+1][1]);
        int min2 = abs(a[i][0] - a[i+1][1]) + abs(a[i][1] - a[i+1][0]);

        ans += min(min1, min2);
    }

    cout << ans << endl;
}
]]> <h1 id="two-cakes-思维题">Two Cakes [思维题]</h1> <h2 id="cf-contest-542-b">CF Contest 542 B</h2> 迷宫 [树，思维题] https://blog.songer.xyz/Code/%E8%BF%B7%E5%AE%AB%20[%E6%A0%91%EF%BC%8C%E6%80%9D%E7%BB%B4%E9%A2%98]/ 2019-02-27T08:52:11.000Z 2021-12-14T16:39:44.685Z 迷宫 [树，思维题]

Wannafly Day 5 A

题目来源：comet OJ

分析

首先很明显，题目中给出的是一颗树。我们需要将所有的人移到根节点，并且一个节点同时刻只能有一个人。

我们先假设如果不会有人的位置发生冲突的话，那么花费的时间其实就等于深度最大的人所花费的时间。但实际情况是有可能会有两个人同时需要进入同一个父节点（发生冲突），所以其中一个需要为另一个让路。那么我们可以发现，深度相同的节点之间一定会早晚发生冲突。两个节点发生冲突的结果就是其中一个需要多花费一个时间节点，那么若是三个节点发生冲突呢？一个节点多花费一个时间节点，还有一个多花费两个时间节点。也就是说，对于深度相同的节点来说，若共有\(n\)个人，那么便需要比起一个人多花费\(n-1\)的时间将所有人走完。

那么，我们便可以系统地考虑一下这道题里的情况了。我们可以令深度更小的节点一定先到达根节点，这可以确保答案最小。然后我们每一层都有两个关键的性质：深度depth和人数n。然后我们用t[i]表示深度为i的人走完后所花费的时间。深度能够决定当前层的第一个人到达根节点的可能最小时间（实际并不一定是，因为可能深度更小的节点的人未走完），人数则表示该层共花费的时间。那么公式便如下：

\[ t[i] = max(t[ i - 1], depth - 1) + n - 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
#include <iostream>
#include <algorithm>
#include <queue>

#define MAXN 100100
#define INF 0x3f3f3f3f

using namespace std;

int a[MAXN];
int dist[MAXN];
bool flag[MAXN];
int maxDepth = 0;

struct Node
{
    struct Edge *edge;
    int num, depth, max;

    Node()
    {
        edge = NULL;
        depth = num = 0;
        max = INF;
    }

}node[MAXN];

struct Edge
{
    Node *from, *to;
    Edge *next;

    Edge()
    {
        from = to = NULL;
        next = NULL;
    }
    Edge(Node *from, Node *to, Edge *next=NULL)  
        :from(from), to(to), next(from->edge)  {}
};

int cnt[MAXN];
queue<Node *> q;
void build(Node *nd)
{
    q.push(nd);

    while (!q.empty())
    {
        Node *node = q.front();
        q.pop();
        for (Edge *e = node->edge; e; e = e->next)
        {
            if (e->to->depth == 0)
            {
                e->to->depth = node->depth + 1;
                if (e->to->num==1)
                    cnt[e->to->depth] ++;

                maxDepth = max(maxDepth, e->to->depth);

                q.push(e->to);
            }
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);

    int n;
    cin >> n;

    for (int i = 1; i<=n; i++)
        cin >> node[i].num;

    for (int i = 1; i<n; i++)
    {
        int x, y;
        cin >> x >> y;
        node[x].edge = new Edge(&node[x], &node[y]);
        node[y].edge = new Edge(&node[y], &node[x]);
    }

    node[1].depth = 1;
    build(&node[1]);
    if (node[1].num==1)
        cnt[1] = 1;

    int t = 0;
    for (int i = 2; i<=maxDepth; i++)
        if (i-1>t && cnt[i])
        {
            t = i - 2 + cnt[i];
        }else if (i-1<=t && cnt[i])
        {
            t += cnt[i];
        }

    cout << t + cnt[1] << endl;

    return 0;
}
]]> <h1 id="迷宫-树思维题">迷宫 [树，思维题]</h1> <h2 id="wannafly-day-5-a">Wannafly Day 5 A</h2> 置置置换 https://blog.songer.xyz/Code/%E7%BD%AE%E7%BD%AE%E7%BD%AE%E6%8D%A2/ 2019-02-27T01:18:43.000Z 2021-12-14T16:39:44.685Z 置置置换

Wannafly Day 3 G

题目来源：comet OJ

分析

这道题我们是套用公式来解的，不过好像可以使用DP来解决。DP的方法日后补充。

代码

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
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
using namespace std;
const int MOD=1000000007;
int n;
long long A[1010];
long long phi(long long k)
{
    long long res=k,tmp=k;
    for(long long i=2;i*i<=tmp;i++)
    {
        if(k%i==0)
        {
            res=res/i*(i-1);
            res%=MOD;
            while(k%i==0) k/=i;
        }
    }
    if(k>1) res=res/k*(k-1);
    return res;
}
long long C[1010][1010];
int main()
{
    scanf("%d",&n);
    A[0]=A[1]=A[2]=1;
    C[1][0]=C[1][1]=1;
truefor (int i=2;i<=1000;i++)
true{
truetrueC[i][0]=1;
truetruefor(int j=1;j<=1000;j++)
        {
            C[i][j]=(C[i-1][j]+C[i-1][j-1]);
            C[i][j]%=MOD;
        }
true}
    for(int i=3;i<=1000;i++)
    {
        for(int j=0;j<=i-1;j++)
        {
            A[i]+=(C[i-1][j]*A[j]%MOD)*A[i-1-j] % MOD;
            A[i]%=MOD;
        }
        A[i]=(A[i] * 500000004)%MOD;
    }
    printf("%lld\n",A[n]);
    /*if(n%2==0) printf("%lld\n",phi(n)%MOD);
    else
    {
        for(int i=0;i<=n;i++)
        {
            ans+=phi(i)*cal(n,i,MOD);
        }
        printf("%lld\n",ans);
    }*/
    return 0;
}
]]> <h1 id="置置置换">置置置换</h1> <h2 id="wannafly-day-3-g">Wannafly Day 3 G</h2> Toy Train [思维题] https://blog.songer.xyz/Code/Toy%20Train%20[%E6%80%9D%E7%BB%B4%E9%A2%98]/ 2019-02-27T01:16:33.000Z 2021-12-14T16:39:44.681Z Toy Train [思维题]

CF Contest 542 D

分析

题目要求对于\(n\)个不同的起点，分别给出将所有糖果送完花费的最小时间。

我们可以先假设起点已经固定。由于我们每次可以携带多个糖果，并且可以卸下多个糖果，所以我们可以发现对于不同的\(j\)，将最初位于节点\(j\)的糖果送完所花费的时间相互之间互不干扰。

那么对于第\(j\)个节点，将这个节点的所有糖果送完所需要花费的时间是多少呢？我们假设起点为\(i\)。那么，我们第一次到达\(j\)所花费的时间就是\((j - i + n) \mod n\)。然后我们假设节点\(j\)共有\(k\)个糖果，那么我们可以发现我们至少需要经过\(j\)节点\(k\)次才能拿到所有糖果。所以拿到所有糖果至少需要\((j - i + n) \mod n + (k - 1) *n\)次移动。

此外，我们可以发现在下一次到达\(j\)点前，我们一定可以将上次从\(j\)点拿走的糖果送出去，所以，我们最后只剩下一个糖果没有送到位置。由于我们想令答案最小，所以只需要令最后送的位置最近即可。

那么，对于起点\(i\),位置\(j\)的\(k\)个糖果\(a_1 - a_k\)（\(k\)必须不为\(0\)），所需花费的时间为:

\[ t[j] = (j - i + n) \mod n + (k - 1) * n + min( (a_i - j + n) \mod n) \]

那么，对于起点\(i\)，所花费的最小时间即为\(min(t[j])\)。

代码

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
#include <iostream>
#include <algorithm>

#define MAXN 5010
#define INF 0x3f3f3f3f

using namespace std;

int cnt[MAXN], nearest[MAXN];

int main()
{
    int n, m;
    cin >> n >> m;

    for (int i = 1; i<=n; i++)
        nearest[i] = INF;

    for (int i =1; i<=m; i++)
    {
        int x, y;
        cin >> x >> y;
        cnt[x] ++;
        nearest[x] = min(nearest[x], (y + n - x) % n );
    }

    for (int i = 1; i<=n; i++)
    {
        int ans = 0;
        for (int j = 1; j<=n; j++)
            if (cnt[j])
                ans = max(ans, (cnt[j] - 1) * n + nearest[j] + (j - i + n) % n );

        cout << ans << " ";
    }
}
]]> <h1 id="toy-train-思维题">Toy Train [思维题]</h1> <h2 id="cf-contest-542-d">CF Contest 542 D</h2> 抢红包机器人 [思维题] https://blog.songer.xyz/Code/%E6%8A%A2%E7%BA%A2%E5%8C%85%E6%9C%BA%E5%99%A8%E4%BA%BA%20[%E6%80%9D%E7%BB%B4%E9%A2%98]/ 2019-02-26T02:19:45.000Z 2021-12-14T16:39:44.685Z 抢红包机器人 [思维题]

Wannafly Day5 G

题目来源：comet OJ

分析

由于题目要求至少存在一个机器人，所以我们必须先假设某一个人是机器人，然后以此向下推，推出所有必须是机器人的人，最后的总数就是机器人的最少数量。

那么，这个问题就变成了“第一个”机器人应该选谁的问题。事实上，由于不同人之间的关系是偏序的，即是可以传递的，譬如i比j快，j比k快，那么i为机器人时k也一定为机器人,所以我们可以直接用类似于floyd的方法推出对于任意的\(i,j\)，\(i\)是否比\(j\)快。然后我们只需要找到能够影响的\(j\)最少的\(i\)即可。

代码

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
#include <iostream>

using namespace std;
int n,m,b,res,c[105],sum;
bool a[105][105];

int main()
{
    cin>>n>>m;
    for(int i=0;i<m;i++)
    {
        cin>>b;
        for(int j=1;j<=b;j++)
        {
            cin>>c[j];
            for(int k=1;k<j;k++)
                a[c[k]][c[j]]=1;
        }
    }
    for(int k = 1; k <= n; ++k)
        for(int i = 1; i <= n; ++i)
            for(int j = 1; j <= n; ++j)
                if(a[i][k] == 1 && a[k][j] == 1)
                    a[i][j] = 1;
    res=105;
    for(int i=1;i<=n;i++){
        sum=0;
        for(int j=1;j<=n;j++)
            sum+=a[j][i];
        if(a[i][i]==0)
            sum++;
        res=min(sum,res);
    }
    cout<<max(1,res)<<endl;
    return 0;
}
]]> <h1 id="抢红包机器人-思维题">抢红包机器人 [思维题]</h1> <h2 id="wannafly-day5-g">Wannafly Day5 G</h2> Special Judge [计算几何] https://blog.songer.xyz/Code/Special%20Judge%20[%E8%AE%A1%E7%AE%97%E5%87%A0%E4%BD%95]/ 2019-02-26T02:19:28.000Z 2021-12-14T16:39:44.681Z Special Judge [计算几何]

Wannafly Day4 J

题目来源：comet OJ

分析

一道计算几何的模板题，难点在于特殊情况的判断很复杂，很容易想漏。我们需要分别对端点对端点，端点对线段，线段对线段，平行，重合并相交，重合但是线段不相交，重合并包含这几种情况分别进行判断。

代码

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
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
using namespace std;

const double eps=1e-8;
const double PI=acos(-1.0);
int sgn(double x)
{
    if(fabs(x)<eps) return 0;
    if(x<0) return -1;
    else return 1;
}
struct Point
{
    double x,y;
    int mark;

    Point(){}
    Point(double _x,double _y)
    {
        x=_x;
        y=_y;
    }
    bool operator == (const Point &b)const
    {
        return sgn(x-b.x)==0&&sgn(y-b.y)==0;
    }
    Point operator - (const Point &b)const
    {
        return Point(x-b.x,y-b.y);
    }
    double operator ^ (const Point &b)const
    {
        return x*b.y-y*b.x;
    }
    double operator * (const Point &b)const
    {
        return x*b.x+y*b.y;
    }
};
struct Line
{
    Point s,e;
    Line(){}
    Line(Point _s,Point _e)
    {
        s=_s;
        e=_e;
    }
};

bool inter(Line l1,Line l2)
{
    return
    max(l1.s.x,l1.e.x)>=min(l2.s.x,l2.e.x)&&
    max(l2.s.x,l2.e.x)>=min(l1.s.x,l1.e.x)&&
    max(l1.s.y,l1.e.y)>=min(l2.s.y,l2.e.y)&&
    max(l2.s.y,l2.e.y)>=min(l1.s.y,l1.e.y)&&
    sgn((l2.s-l1.e)^(l1.s-l1.e))*sgn((l2.e-l1.e)^(l1.s-l1.e))<=0&&
    sgn((l1.s-l2.e)^(l2.s-l2.e))*sgn((l1.e-l2.e)^(l2.s-l2.e))<=0;
}

bool cmp(Point p,Point q)
{
    if(p.x==q.x) return p.y<q.y;
    return p.x<q.x;
}
Point a[1010];
int u[2010],v[2010];
int ans,n,m;
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
        scanf("%d%d",&u[i],&v[i]);
    for(int i=1;i<=n;i++)
    {
        scanf("%lf%lf",&a[i].x,&a[i].y);
    }
    for(int i=1;i<=m;i++)
    {
        for(int j=i+1;j<=m;j++)
        {
            Line l1(a[u[i]],a[v[i]]),l2(a[u[j]],a[v[j]]);
            if(sgn((l1.e-l1.s)^(l2.e-l2.s))==0)
            {
                if(inter(l1,l2))
                {
                    Point b[5];
                    b[1]=a[u[i]];
                    b[1].mark = i;
                    b[2]=a[u[j]];
                    b[2].mark = j;
                    b[3]=a[v[i]];
                    b[3].mark = i;
                    b[4]=a[v[j]];
                    b[4].mark = j;
                    sort(b+1,b+1+4,cmp);

                    if (b[1].mark!=b[2].mark && !(b[2].x == b[3].x && b[2].y == b[3].y))
                        ans ++;

                }
            }
            else
            {
                if(inter(l1,l2)) ans++;
                if(u[i]==u[j]||v[i]==u[j]||u[i]==v[j]||v[i]==v[j]) ans--;
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}
]]> <h1 id="special-judge-计算几何">Special Judge [计算几何]</h1> <h2 id="wannafly-day4-j">Wannafly Day4 J</h2> 欧拉回路 [构造题] https://blog.songer.xyz/Code/%E6%AC%A7%E6%8B%89%E5%9B%9E%E8%B7%AF%20[%E6%9E%84%E9%80%A0%E9%A2%98]/ 2019-02-26T02:19:19.000Z 2021-12-14T16:39:44.685Z 欧拉回路 [构造题]

Wannafly Day3 D

虽说是构造题，实际这题并没有要求构造，只需输出最值即可。

题目来源：comet OJ

分析

对于这题，我们可以向欧拉回路的性质上去靠。首先我们都知道，欧拉回路的所有的点的度数都为偶数。那么，我们可以首先假设所有的边都被走过了一遍，此时我们可以得到一个此时的所有的点各自的度数的值。

那么，我们的目标便是令这些值都为偶数。方法则为将临近的两个奇数度数的点的连边走的次数+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
#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
    int n, m;
    cin >> n >> m;

    int ans = 0;
    ans += (n-1) * m + (m-1) * n;

    if (n%2==0 && m%2==0)
    {
        ans += n - 2 + m - 2;
    }else if (n%2==1 && m%2==1)
    {
        ans += n - 3 + m - 3 + 4;
    }else if (n%2==0 && m%2==1)
    {
        ans += n - 2 + m - 3 + min(3, n - 1);
    }else if (n%2==1 && m%2==0)
    {
        ans += n - 3 + m - 2 + min(3, m - 1);
    }

    cout << ans << endl;
}
]]> <h1 id="欧拉回路-构造题">欧拉回路 [构造题]</h1> <h2 id="wannafly-day3-d">Wannafly Day3 D</h2> <blockquote> <p>虽说是构造题，实际这题并没有要求构造，只需输出最值即可。</p> </blockquote> 小小马 https://blog.songer.xyz/Code/%E5%B0%8F%E5%B0%8F%E9%A9%AC/ 2019-02-26T02:18:52.000Z 2021-12-14T16:39:44.685Z 小小马

Wannafly Day3 F

题目来源：comet OJ

分析

这题其实也是一道思维题。首先，我们先考虑黑点和白点的问题。由于马的跳法，每次\(x\)轴和\(y\)轴的位移一奇一偶，那么下一个点一定和当前点颜色不同。所以，只要起点和终点颜色不同，则此条件一定满足。

然后我们考虑是否能到达的问题。我们来考虑棋盘上马的跳法，可以发现，当棋盘的大小大于\(3\times 3\)时，马可以到达任何地方。而正好等于\(3\times 3\)时，最中间的点无法到达。而棋盘等于\(2 \times n\)的时候也直接判断即可。

代码

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
#include <iostream>
#include <stdlib.h>
using namespace std;
int m,n,sx,sy,ex,ey;
bool res=1;

int main()
{
    cin>>n>>m>>sx>>sy>>ex>>ey;
    if(n==1||m==1||(sx&1)^(sy&1)==(ex&1)^(ey&1))
    {
        res=0;
    }
    else if(n==2)
    {
        if(abs(ey-sy)%2)
            res=0;
        else if(ex!=2-(sx+abs(ey-sy)/2)%2)
            res=0;
    }else if(m==2)
    {
        if(abs(ex-sx)%2)
            res=0;
        else if(ey!=2-(sy+abs(ex-sx)/2)%2+1)
            res=0;
    }
    else if(m==3&&n==3)
    {
        if((ex==2&&ey==2)||(sx==2&&sy==2))
            res=0;
    }
    if(res)
        cout<<"Yes"<<endl;
    else
        cout<<"No"<<endl;
    return 0;
}
]]> <h1 id="小小马">小小马</h1> <h2 id="wannafly-day3-f">Wannafly Day3 F</h2> 夺宝奇兵 [思维题] https://blog.songer.xyz/Code/%E5%A4%BA%E5%AE%9D%E5%A5%87%E5%85%B5%20[%E6%80%9D%E7%BB%B4%E9%A2%98]/ 2019-02-26T02:18:27.000Z 2021-12-14T16:39:44.685Z 夺宝奇兵 [思维题]

Wannafly Day 3 A

题目来源：comet OJ

分析

这道题的关键在于依次从\(1\)到\(n\)然后从\(n\)到\(1\)。我们只考虑从\(i\)到\(i+1\)的情况，因为我们可以发现不同的\(i\)之间是不会相互干扰的，那么：当我们的\(i\)已确定时，我们只需要选择距离最近的\(i+1\)即可。但我们要令\(i\)到\(i+1\)和后来的从\(i+1\)回到\(i\)的距离之和最小，那么只需要组合一下，取和最小的情况即可。

代码

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
#include <iostream>
#include <algorithm>

#define MAXN 100100

using namespace std;

int x[MAXN][2], y[MAXN][2];

int calc(int i, int j)
{
    if (j)
        return abs(x[i+1][0] - x[i][0]) + abs(x[i+1][1] - x[i][1]) + abs(y[i+1][0] - y[i][0]) + abs(y[i+1][1] - y[i][1]);
    else
        return abs(x[i+1][0] - x[i][1]) + abs(x[i+1][1] - x[i][0]) + abs(y[i+1][0] - y[i][1]) + abs(y[i+1][1] - y[i][0]);
}

int main()
{
    int n, m;
    cin >> n >> m;

    for (int i = 1; i<=n; i++)
    {
        cin >> x[i][0] >> y[i][0];
        cin >> x[i][1] >> y[i][1];
    }

    long long ans = 0;
    for (int i = 1; i<n; i++)
        ans += min( calc(i,0), calc(i,1) );

    ans += abs(x[n][0] - x[n][1]) + abs(y[n][0] - y[n][1]);

    cout << ans << endl;
}
]]> <h1 id="夺宝奇兵-思维题">夺宝奇兵 [思维题]</h1> <h2 id="wannafly-day-3-a">Wannafly Day 3 A</h2>