Aquabet Talk is cheap. Show me the code. 2022-08-25T16:00:00.000Z http://blog.aquabet.xyz/ Aquabet Hexo 短信同步到teltgram http://blog.aquabet.xyz/TelegramBot/ 2022-08-19T16:00:00.000Z 2022-08-25T16:00:00.000Z 前言

  人在美国，刚下飞机。总之我需要一个手机，接收来自中国的电话卡的短信和紧急的电话，也需要一个手机使用美国的电话卡。出门带两个手机明显不是一个好选择，故有此计划。

  需求清单：

  • 一部在美国能收到信号的安卓手机（OLED屏幕手机优先）

  郑重声明：本文所提及的功能稳定性要求较高，故不适用于中国大陆地区。以下原因造成了本方法在中国大陆地区使用并不稳定。

  • 本方法基于Telegram的Bot功能，该功能在中国大陆地区不提供服务。
  • 通过方法连接上的Telegram网络不稳定。
  • 微信，QQ，以及其他所有在中国大陆地区能用的聊天软件中，没有一款是官方支持Bot的。使用自己搭建的Bot容易导致封号等，使用别人的非官方Bot容易导致数据泄露等。

Telegram配置

TelegramBot

  Telegram官方是支持Bot的，所以我们只需要添加telegram的Bot他爹 @BotFather，输入/start开始使用。

  1. 输入/newbot，新建一个机器人。
  2. 输入想要的机器人显示的名字。
  3. 输入机器人的用户名，需要以_bot为结尾。

  之后他会返回你一个账号，如t.me/xxx_bot，该账号即为你的机器人，添加即可。你应该还会收到一个 token，形如 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11，记下备用，下文使用<token>表示。

获取个人id

  添加telegram的机器人 @GetIDs Bot，开始之后他会返回您的个人信息如下：

├ id: 123456789
├ is_bot: false
├ first_name: xxx
├ username: xxx
└ language_code: xxx

  记住id那一串数字，下一步备用，下文使用<userID>表示。

  请自行替换下文中的<token>和<userID>
  请自行替换下文中的<token>和<userID>
  请自行替换下文中的<token>和<userID>

测试你的Bot

  Bot到目前为止已经配置完全，telegramBot的API为：

1
https://api.telegram.org/bot<token>/METHOD_NAME

（bot<token>的bot三个字母不要删，替换<token>即可）
  我们这里使用的METHOD是sendMessage，详细使用方法点击这里。

  测试只需要给自己发条信息，故请求

1
https://api.telegram.org/bot<token>/sendMessage?chat_id=<userID>&text=Hello%20World!

，Telegram中收到该消息则表示配置成功。

Tasker配置

  手机端需要安装Tasker。请支持正版。

测试tasker任务

  在任务中新建任务，随意命名如短信转发。在任务编辑中新建任务，选择网络中的HTTP Request，方法选择PUT，URL输入上文的测试信息

1
https://api.telegram.org/bot<token>/sendMessage?chat_id=<userID>&text=Hello%20World!

。返回任务编辑界面，左下角运行，Telegram中收到该消息则表示配置成功。

配置tasker任务

  回到HTTP Request的设置，将URL修改为你想要的格式，我使用的是

1
https://api.telegram.org/bot<token>/sendMessage?chat_id=<userID>&text=%SMSRB %0A%0A%0A发件人：%SMSRN %0A时间：%SMSRD %SMSRT

  返回任务编辑界面，左下角运行，Telegram中收到最近接收的一条短信则表示配置成功。

配置tasker事件

  在配置文件中新建事件，选择电话中的收到短信。过滤器等可以按需选择。之后选择刚才配置的任务，如我上文的命名短信转发。

Enjoy

  • 关闭手机的省电优化
  • 打开Tasker的开机自启动
  • （仅限OLED屏幕的手机）安装应用简黑时钟，桌面安装手机支架，选个好位置摆放。
  • 给手机插上充电器。

Enjoy It!

]]> 短信同步到teltgram Codeforces Good Bye 2021: 2022 is NEAR http://blog.aquabet.xyz/Good%20Bye%202021:%202022%20is%20NEAR/ 2021-12-30T16:00:00.000Z 2022-01-01T16:00:00.000Z   这次补了题，发现好多东西都不会了。

先放题目

  Good Bye 2021: 2022 is NEAR

A. Integer Diversity

题目大意

  给定一个数组a，可以对其中任意个数变为相反数 $x \rightarrow -x$ 。问最多可以有多少个不同的数。

思路

  计算每个数的绝对值出现的次数。出现次数大于2的取2，0取1。求和。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void solve() {
    int ans = 0;
    int num;
    cin>>num;
    int nums[101];
    memset(nums, 0, sizeof(nums));
    int thenum;
    for(int i = 0; i < num; i++) {
        cin>>thenum;
        nums[abs(thenum)]++;
    }
    for(int i = 0; i <= 100; i++) {
        if(i == 0 && nums[i] != 0) {
            ans += 1;
        }
        else if(nums[i] > 2) {
            ans += 2;
        } else {
            ans += nums[i];
        }
    }
    cout<<ans<<endl;
}

B. Mirror in the String

题目大意

  题意：给定字符串，选定 $k$，使得 $s_1s_2…s_ks_ks_{k-1}…s_1$ 的字典序最小。

思路

  贪心。

  • 若 $s_1 = s_2$ ，显然 $s_1s_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
void solve() {
    int n;
    string s;
    cin>>n>>s;
    if(n >= 2 && s[0] == s[1]) {
        cout<<s[0]<<s[0]<<'\n';
        return;
    }
    for(int i = 0; i < n-1; i++) {
        if(s[i] < s[i+1]) {
            for(int j = 0; j <= i; j++) {
                cout<<s[j];
            }
            for(int j = i; j >= 0; j--){
                cout<<s[j];
            }
            cout<<'\n';
            return;
        }
    }
    for(int j = 0; j < n; j++) {
        cout<<s[j];
    }
    for(int j = n-1; j >= 0; j--) {
        cout<<s[j];
    }
    cout<<'\n';
}

C. Representative Edges

题目大意

  给定数组，至少要修改几个元素，才能使得数组变为等差数列。

思路

  不变的数最少是2个，直接枚举不变的2个数，计算其他位置是否可以不变，取最小。$1 \leq n \leq 70$，$O(n^3)$，能过。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void solve() {
    int n;
    cin>>n;
    int a[n];
    for(int i = 0;i < n; i++) cin>>a[i];
    int ans = 99;
    if(n <= 2) {
        cout<<0<<'\n';
        return;
    }
    for(int i = 0; i < n; i++) {
        for(int j = i+1; j < n; j++) {
            double d = (a[j] - a[i]) * 1.0 / (j-i);
            int tot = n;
            for(int k = 0; k < n; k++) {
                if(abs(a[k] - (a[i] + (k-i) * d)) <= 1e-10) tot--;
            }
            ans = min(ans, tot);
        }
    }
    cout<<ans<<'\n';
}

D. Keep the Average High

题目大意

  给一个数组a和一个数x。要在a中选择尽可能多的数，使得任意一个长度大于1的子数组 $a_l, a_{l+1} ,…,a_r$ 满足以下条件：

  • 子数组中存在某个数没有被选择
  • $a_l+a_{l+1}+…+a_r \geq x \cdot (r-l+1)$

  问可以选多少个。

思路

  贪心。$a_l+a_{l+1}+…+a_r \geq x \cdot (r-l+1)$ 表明子数组平均值不小于$x$。所以不能取两个相邻且都小于$x$的数。

  首先观察如何判断一个取法是否可行。让大于等于x的标记为x，小于的标记为y，则所有可行的取法的子数组必须满足如下模式：

  • y或者没有y接着若干个x，然后接着一个y再接着若干个x…。比如yxxy,yxyxyxxy, xxy等等。

  注意到：

  • 如果有连续的x，则两部分可以分开判断，子数组为aaaaax xbbbbb，则只需分别判断子数组aaaax 以及xbbbbb是否合法即可。因为两个数的平均数大于等于小的一个。
  • 同理yxyxyxy的情况只需分别判断每个yxy以及yx,xy是否满足条件即可。

  因此要判断一个取法是否可行，则只需判断长度为2和3的子数组即可。
  我们可以从头到尾贪心取，让前i个取尽量多的数，如果数目相同，则尽量让最后一个最靠前。当前位置为i，如果i - 1没取，那么当前位置就可以取，数目加1。
  如果前两个值都取，则判断 a[i] + a[i - 1] + a[i - 2] ≥ 3x 以及 a[i] + a[i - 1] ≥ 2x 是否成立，如果不成立，说明有冲突，选了a[i]就不能选择a[i - 1]，最优肯定是选择a[i - 1]而不是选择a[i]。所以成立就选，不成立不选。
  如果只有 a[i - 1] 被取了，a[i - 2] 没被取，则只需判断 a[i] + a[i - 1] ≥ 2x 是否成立。成立就可以选。

代码

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
void solve() {
    int n, x;
    cin>>n;
    int a[n], vis[n];
    for(int i = 0; i < n; i++) {
        cin>>a[i];
    }
    memset(vis, 0, sizeof(vis));
    cin>>x;
    int ans = 0;
    for(int i = 0; i < n; i++) {
        if (i==0 || !vis[i - 1]) {
            vis[i] = 1;
            ans++;
        }
        else if(i >= 2 && vis[i - 2]) {
            if((a[i] + a[i - 1]) >= 2 * x && (a[i] + a[i - 1] + a[i - 2]) >= 3 * x) {
                ans++;
                vis[i] = 1;
            }
        }
        else if (i >= 1 && (a[i] + a[i - 1]) >= 2 * x) {
            ans++;
            vis[i] = 1;
        }
    }
    cout<<ans<<"\n";
}

E. Lexicographically Small Enough

题目大意

  给定字符串 $s,t$ ，每次操作可以将 $s$ 中的相邻元素交换。问至少需要交换多少组相邻元素可以使得 $s < t$。

思路

  枚举相同前缀的长度，贪心。

  • 假设相同前缀已经固定，长度为 $i(0\le i \le n-1)$，那么最优的情况就是从后面选择一个小于 $t[i]$ 的字符交换过来。最优情况就是选择最近的。
  • 枚举每个$i$，从0开始，要么从后面选择一个最近的小于 $t[i]$ 的字符过来，要么选择一个等于的让前缀相同。每次选择一个等于的过来，维护剩下的字符后缀(i + 1 ~ n)。这样每次移动可能要 $O(n)$ 来维护，总的复杂度需要 $O(n^2)$。我们可以使用树状数组来维护，只需记录每个位置，有多少个本来位于其后的字符启动到前面去。我们用原来的位置加上这个数就是其当前的位置。复杂度 $O(nlogn)$。

代码

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
int n;
vector <int> pos[30];
string a, b;
pair<int, int> ST[4 * 100000];
bool Erase[100000];
 
void Build(int id, int l, int r) {
    ST[id] = {0, 0};
    if(l == r) {
        ST[id] = {l, 0};
        return;
    }
    int mid = (l + r) >> 1;
    Build(id << 1, l, mid);
    Build(id << 1 ^ 1, mid + 1, r);
    ST[id].first = max(ST[id << 1].first, ST[id << 1 ^ 1].first);
}
 
void Down(int id) {
    int tmp = ST[id].second;
    ST[id << 1].first += tmp;
    ST[id << 1].second += tmp;
    ST[id << 1 ^ 1].first += tmp;
    ST[id << 1 ^ 1].second += tmp;
    ST[id].second = 0;
}
 
void Update(int id, int l, int r, int x, int y) {
    if(r < x || y < l) return;
    if(x <= l && r <= y) {
        ST[id].first++;
        ST[id].second++;
        return;
    }
    Down(id);
    int mid = (l + r) >> 1;
    Update(id << 1, l, mid, x, y);
    Update(id << 1 ^ 1, mid + 1, r, x, y);
    ST[id].first = max(ST[id << 1].first, ST[id << 1 ^ 1].first);
}
 
int Get(int id, int l, int r, int i) {
    if(r < i || i < l) return 0;
    if(l == r) return ST[id].first;
    Down(id);
    int mid = (l + r) >> 1;
    return max(Get(id << 1, l, mid, i), Get(id << 1 ^ 1, mid + 1, r, i));
}
 
void solve() {
    pos->clear();
    memset(Erase, 0, sizeof(Erase));
    cin >> n >> a >> b;
    a = ' ' + a; b = ' ' + b;
    for(int i = 1; i <= n; i++)
        if(a[i] != b[i]) {
            if(a[i] < b[i]) {
                cout << 0 << endl;
                return;
            }
            break;
        }
    Build(1, 1, n);
    long long res = INT64_MAX, ans = 0;
    for(int i = n; i >= 1; i--)
        pos[a[i] - 'a'].push_back(i);
    int p = 1;
    for(int i = 1; i <= n; i++) {
        while(p <= n && Erase[p]) {
            p++;
        }
        int Min = n + 1;
        for(int j = 0; j < b[i] - 'a'; j++)
            if(!pos[j].empty()) {
                Min = min(Min, Get(1, 1, n, pos[j].back()));
            }
        if(Min <= n) res = min(res, ans + Min - i);
        if(a[p] == b[i]) {
            pos[a[p] - 'a'].pop_back();
            p++;
        }
        else if(a[p] < b[i]) {
            res = min(res, ans);
            break;
        }
        else {
            if(pos[b[i] - 'a'].empty()) break;
            ans += Get(1, 1, n, pos[b[i] - 'a'].back()) - i;
            Erase[pos[b[i] - 'a'].back()] = 1;
            Update(1, 1, n, 1, pos[b[i] - 'a'].back());
            pos[b[i] - 'a'].pop_back();
        }
    }
    cout << (res == INT64_MAX ? -1 : res) << endl;
}

F. Tricolor Triangles

题目大意

  给定一个无向图，至多64个点，至多256条边。要给这些边涂上3种颜色之一，其中有些边已经有颜色，有些未涂色。要求一个涂色方案，使得任何一个构成三角形的三条边颜色要么都相同，要么各不相同。如果不存在合法的涂色方案，输出-1。

思路

  三条边的颜色a,b,c满足相同或各不相同这个条件，可以转化为 $(a + b + c) \% 3 = 0$。

  建立一个矩阵A，每一行表示每个三角形，每一列表示一条边。每一行有三个位置为1，表示组成这个三角形的三条边。则问题等价于一个同余线性方程$Ax \equiv b mod 3$，其中$x$为每条边的颜色，b为全0。已知 $A,b$，求 $x$。

  线性同余方程可以用高斯消元求解。由于三角形的个数上界为$m\sqrt{m}$，所以总复杂度为$O(m^3 \sqrt{m})$。

后记 2021年度总结

  2021也是过的一塌糊涂。回望过去，发现又是啥都没干的一年，唯一收获的证书是驾照(x。绩点始终上不去，比赛参加一场崩一场，项目做一个烂一个，最后考雅思又被西安疫情打乱。
  天天在宿舍neet也不知道在干嘛。好像番也没看几部，游戏也没上分。只有偶尔刷刷题能抚慰下我焦躁的内心。然后发现好多算法、数据结构都忘了，或者只能口胡，打不出来。然后就跳过，也懒得复习，更不必说学新的算法了。
  新年愿望啊，愿望是啥呢？好像啥都没有。雅思上岸？绩点飞升？感觉都随缘了，我的人生如果能一直neet下去就好了。
  那就希望2022每天都能洗澡吧（x
      –来自西安疫区在宿舍隔离澡堂不开已经18天没洗澡的我
  Update：2022/1/2 看来愿望没实现呢，是说出来就不灵了吗：）

]]> <p>&emsp;&emsp;这次补了题，发现好多东西都不会了。</p> Codeforces Round #761 (Div. 2) 解题报告 http://blog.aquabet.xyz/Codeforces%20Round%20761%20(Div.%202)/ 2021-12-16T16:00:00.000Z 2021-12-17T16:00:00.000Z   好久没打cf了，因为疫情困宿舍没事干，老年选手出来活动下筋骨。只写了ABC，困了就睡了。也懒得复盘补题了。

先放题目

  Codeforces Round #761 (Div. 2)

A

题目大意

  给俩字符串S，T，其中T为字符串"abc"的排列。求S的排列S'，使得T不是S'的字串且S'字典序最小。

思路

  • 如果S中包含了a，b，c三个字母，且T =="abc"，将S排序后交换b和c的位置，即为答案S'。
  • 否则则S'就是S的最小字典序。将S排序输出即可。

代码

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<bits/stdc++.h>
using namespace std;

int main() {
    // freopen("test.in", "r", stdin);
    int n;
    scanf("%d", &n);
    while(n--) {
        string s, t;
        cin>>s>>t;
        int lens = s.length();
        sort(s.begin(), s.end());
        if(t == "abc") {
            int bBegin = lower_bound(s.begin(), s.end(), 'b') - s.begin();
            int cEnd = upper_bound(s.begin(), s.end(), 'c') - s.begin() - 1;
            if(bBegin < lens - 1 && s[cEnd] == 'c' && bBegin > 0) {
                while(bBegin < cEnd) {
                    if(s[bBegin] == s[cEnd]) {
                        break;
                    }
                    swap(s[bBegin], s[cEnd]);
                    bBegin++;
                    cEnd--;
                }
            }
        }
        cout<<s<<"\n";
    }
}

B

题目大意

  给定一个数n，求三个数a，b，c，使得$a+b+c=n$，且 $gcd(a,b)=c$， 且$a \neq b \neq c$。

思路

  • 直接暴力令$c=1$
  • 如果n为偶数，$a=n/2 , b=n/2 + 1 , c=1$
  • 如果n为奇数，
    • 如果 $n/2$ 为偶数，$a=n/2 - 1 , b=n/2 + 1, c=1$
    • 如果 $n/2$ 为奇数，$a=n/2 - 2 , b=n/2 + 2, c=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
#include<bits/stdc++.h>
using namespace std;

inline int gcd(int a, int b) {
    return b > 0 ? gcd(b, a%b) : a;
}

int main() {
    // freopen("test.in", "r", stdin);
    int n;
    cin>>n;
    while(n--) {
        int number;
        cin >> number;
        if(number % 2 == 1) {
            int gap = 1;
            while(gcd(number/2-gap, number/2+gap) != 1) {
                gap++;
            }
            cout<<number/2-gap<<" "<<number/2+gap<<" "<<1<<endl;
        }
        else {
            cout<<number/2 - 1<<" "<<number/2<<" "<<1<<endl;
        }
    }
}

C

题目大意

  给定一个n，以及一个长度为n的数组。每次操作，选择其中一个数字a，以及任取一个正整数x，让$a = a % x$。问能不能将数组通过若干次操作后变成1 ~ n的一个排列，如果不能，输出-1，能的话输出最少操作次数。

思路

  注意到，一个数模另一个小于它的数，肯定是变小的，a → a % x。并且$2 * (a \% x) \leq a$。

  首先为了最优性，那些刚好能填补1 ~ n的位置的数，先填补上，这部分肯定是不变的。
  我们贪心，从小到大，查找空缺的位置，如果存在空缺k，则需要在剩下的数中取大于2k的一个数a，通过操作后，填补k的位置。为了最优，肯定是取最小的，且没有被使用过的数。
  可以通过优先队列来维护每次最小值。遇到一个空缺位置k，如果当前最小值 < 2k，则无解，否则将这个数使用来填补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
#include <bits/stdc++.h>
using namespace std;

int a[100003], vis[100003];
int main() {
    int t;
    cin>>t;
    while (t--) {
        int n;
        cin>>n;
        memset(vis, 0, sizeof(vis));
        priority_queue<int, vector<int>, greater<int> > que;
        for(int i = 0; i < n; i++) {
            cin>>a[i];
            if (a[i] <= n && a[i] >= 1) {
                if (++vis[a[i]] > 1) {
                    que.push(a[i]);
                }
            }
            else {
                que.push(a[i]);
            }
        }
        int ans = 0;
        for(int i = 0; i < n; i++) {
            if (vis[i]) {
                continue;
            }
            if (que.top() <= 2 * i) {
                ans = -1;
                break;
            }
            que.pop();
            ++ans;
        }
        printf("%d\n", ans);
    }
    return 0;
}
]]> <p>&emsp;&emsp;好久没打cf了，因为疫情困宿舍没事干，老年选手出来活动下筋骨。只写了ABC，困了就睡了。也懒得复盘补题了。</p> 完整的个人RSS使用分享 http://blog.aquabet.xyz/RSS/ 2021-12-06T16:00:00.000Z 2022-08-25T20:12:59.000Z 前文回顾

  逃离知乎计划

本次目标

  首先是搭建一个 RSSHub 的个人服务器。虽然开发者提供了服务器给大家使用，仍有下列问题：

  1. 偶尔需要翻墙才能连上。
  2. 个人的关注还比较多，老白嫖人家服务器不太好。
  3. 官方Demo有比较慢，同步不了的情况。

  故最好还是自己搭个RSS服务器。

  然后是个人的RSS同步服务器 TTRSS。我需要将哪些信息看过、哪些没看过保持同步。这样电脑看过的信息，就可以在手机上被标记为已读。

搭建RSSHub服务器

  还没干，继续白嫖中。:()

搭建TTRSS服务器

  参照 Awesome TTRSS 的文档，很简单就能部署在自己的VPS的docker里。官方文档很详细，过程不赘述，有问题可以找我。

客户端使用

  在Android平台，我目前使用的是 知微，在 Tiny Tiny RSS 的偏好设置中，安装插件fever，打开 允许外部客户端通过 API 来访问该账户，然后直接用你的TTRSS服务器域名/plugins/fever/和账号密码登录就行。
  在iOS 和 macOS 平台可以使用Reeder，至少我很喜欢它在macOS的界面设计。
  Windows和Linux平台，可以使用Fluent Reader，当然也可以直接使用TTRSS的网页端。
  kindle本来想直接文章推送的，后来感觉推送太多kindle首页太乱，在网页还搭了个阅读器 xizeyoupan/kinss。注意下kindle的内置浏览器好像https支持有问题，页面别开强制https即可。

]]> 辣鸡软件都可以从我手机滚出去了！ 力扣杯2021秋团队赛解题报告 http://blog.aquabet.xyz/LCCUP21FT/ 2021-09-24T16:00:00.000Z 2021-09-25T16:00:00.000Z

先放题目

  LCP 44. 开幕式焰火
  LCP 45. 自行车炫技赛场
  LCP 46. 志愿者调配
  LCP 47. 入场安检
  LCP 48. 无限棋局
  LCP 49. 环形闯关游戏

A题

  签到，二叉树的遍历 + map

B题

  队友做的，记忆化搜索？

C题

  以最后一天的情况建立一个一元一次方程，递推回到第0天，解方程。
  我在这题遇到一个大坑：Leetcode中文版C++不支持对负数的左移<<位运算，会RE，我以为是哪里爆int了，检查了半天QAQ。

D题

  队友说是01背包。

E题

  语文题，理解题意后一个（大？）模拟。

F题

  惯例:(

代码

  详见我的github仓库

]]> 解题报告 力扣杯2021秋个人赛解题报告 http://blog.aquabet.xyz/LCCUP21FP/ 2021-09-10T16:00:00.000Z 2021-09-14T16:00:00.000Z

先放题目

  LCP 39. 无人机方阵
  LCP 40. 心算挑战
  LCP 41. 黑白翻转棋
  LCP 42. 玩具套圈
  LCP 43. 十字路口的交通

A题B题

  俩签到题
  A题：两组哈希存下每种颜色的个数，然后 ans += map[0][i]-map[1][i] , return ans/2 。
  B题：贪心 从大到小排序，取前cnt个的和sum，并记录在前cnt个中最小的奇数oddMin和最小的偶数evenMin。然后在剩下的数里面找最大的奇数oddMax和最大的偶数evenMax。（注意：这里的oddMin，evenMin要大于等于oddMax，evenMax）如果sum为偶数， return sum 。如果sum是奇数， return max(sum-oddMin+evenMax, sum-evenMin+oddMax) 。

C题

  模拟。首先找到图上所有的白点，然后对白点进行搜索。搜索包含三个方向，横着，竖着，斜着。对目标点三个方向分别向前，向后遍历。遇到黑点、空格或者边界就停下来。如果两边截止点都是黑就 ans += 中间的棋数 。如果有一个黑一个空就 putChess = max(putChess, 中间的棋数) （记得记录每颗白棋在三个方向是否遍历过，如果已经遍历过就跳过，可以剪枝）。遍历完之后 ans += putChess。最后还有一个检查while(上一轮检查有棋能翻转){检查所有白棋能不能被翻，能翻就翻了并且ans += num}。

D题

  最开始以为是个计算几何， $O(n^2)$ T了两次优化不过
  后来想起这个里 P2249 【深基13.例1】查找 题解 用户Graphcity的胡扯莫队。于是我按照这个思路，过了这题，具体如下：
  首先对所有圆和玩具按x坐标进行排序，x坐标相同的按y排序。然后开始查询，对每一个圈适配玩具，并将该圆圈的圆心减半径$X_i-r$之后的第一个玩具记为nowMinX，如果下一个圆圈的$X_{i+1}$与$X$不等，此时搜索直接从nowMinX开始，对玩具的Y坐标同样进行类似处理，当$circles_i$和$circles_{i+1}$的$X$坐标相同时，就可以从nowMinY开始。

E题

  惯例不做

代码

  详见我的github仓库

]]> 解题报告 比赛用模板 http://blog.aquabet.xyz/index/ 2021-09-08T16:00:00.000Z 2021-09-08T16:00:00.000Z Leetcode
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
#include<bits/stdc++.h>
using namespace std;

#define LOCAL

#define PB push_back
#define PF push_front

typedef long long ll;
typedef unsigned long long ull;

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

ll gcd(ll a, ll b) {
    return b ? gcd(b, a%b) : a;
}

ll exgcd(ll l,ll r,ll &x,ll &y) {
    if(r == 0) {
        x = 1;
        y = 0;
        return l;
    } else {
        ll d = exgcd(r, l%r, y, x);
        y -= l/r*x;
        return d;
    }
}

ll MOD(ll a, ll m) {
    a %= m;
    if(a < 0)a += m;
    return a;
}
//乘法逆元
ll inverse(ll a, ll m) {
    a = MOD(a, m);
    if(a <= 1)return a;
    return MOD((1 - inverse(m, a) * m) / a, m);
}
//快速幂
ll kasumi(ll a, ll b, ll mod) {
    a %= mod;
    if(b < 0)a = inverse(a, mod), b = -b;
    ll ans = 1;
    while(b) {
        if(b & 1)ans = ans * a % mod;
        a = a * a % mod;
        b /= 2;
    }
    return ans % mod;
}
//二叉树的序列化
string serialize(TreeNode* root) {
        if (!root) {
            return "X";
        }
        auto left = "(" + serialize(root->left) + ")";
        auto right = "(" + serialize(root->right) + ")";
        return left + to_string(root->val) + right;
    }

inline TreeNode* parseSubtree(const string &data, int &ptr) {
    ++ptr; // 跳过左括号
    auto subtree = parse(data, ptr);
    ++ptr; // 跳过右括号
    return subtree;
}

inline int parseInt(const string &data, int &ptr) {
    int x = 0, sgn = 1;
    if (!isdigit(data[ptr])) {
        sgn = -1;
        ++ptr;
    }
    while (isdigit(data[ptr])) {
        x = x * 10 + data[ptr++] - '0';
    }
    return x * sgn;
}

TreeNode* parse(const string &data, int &ptr) {
    if (data[ptr] == 'X') {
        ++ptr;
        return nullptr;
    }
    auto cur = new TreeNode(0);
    cur->left = parseSubtree(data, ptr);
    cur->val = parseInt(data, ptr);
    cur->right = parseSubtree(data, ptr);
    return cur;
}
//二叉树的反序列化
TreeNode* deserialize(string data) {
    int ptr = 0;
    return parse(data, ptr);
}

#ifdef LOCAL

int main() {
    freopen("testdata.in", "r", stdin);
}
#endif

Codeforces

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<bits/stdc++.h>
using namespace std;

#define PB push_back
#define PF push_front

typedef long long ll;
typedef unsigned long long ull;

inline int read() {
    char ch = getchar(); int x = 0, f = 1;
    while(ch<'0'||ch>'9') {if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

ll gcd(ll a, ll b) {
    return b ? gcd(b, a%b) : a;
}

ll exgcd(ll l,ll r,ll &x,ll &y) {
    if(r == 0) {
        x = 1;
        y = 0;
        return l;
    } else {
        ll d = exgcd(r, l%r, y, x);
        y -= l/r*x;
        return d;
    }
}

ll MOD(ll a, ll m) {
    a %= m;
    if(a < 0)a += m;
    return a;
}
//乘法逆元
ll inverse(ll a, ll m) {
    a = MOD(a, m);
    if(a <= 1)return a;
    return MOD((1 - inverse(m, a) * m) / a, m);
}
//快速幂
ll kasumi(ll a, ll b, ll mod) {
    a %= mod;
    if(b < 0)a = inverse(a, mod), b = -b;
    ll ans = 1;
    while(b) {
        if(b & 1)ans = ans * a % mod;
        a = a * a % mod;
        b /= 2;
    }
    return ans % mod;
}

void solve() {
    //
}

int main() {
    solve();
}
]]> 比赛用模板 Leetcode第255场周赛 解题报告 http://blog.aquabet.xyz/Leetcode_Contest_255/ 2021-08-21T16:00:00.000Z 2022-08-25T20:12:59.000Z

先放题目

  1979. 找出数组的最大公约数
  1980. 找出不同的二进制字符串
  1981. 最小化目标值与所选元素的差
  1982. 从子集的和还原数组

A题B题

  俩签到题
  A题：排序之后求个gcd
  B题：bitset + next_permutation + to_string 循环nums.find() 找不到的就return

C题

  本题的一眼解有点像 16. 最接近的三数之和 的改编。但仔细思考之后发现，如果使用双指针，在70*70的矩阵下面，时间复杂度是$O(n^{68})$。

  接着便想到到了之前学过的背包九讲中有一种分组背包问题。

有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。
这些物品被划分为若干组，每组中的物品互相冲突，最多选一件。
K求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

  于是DP直接A掉。

D题

  我太菜了，不会:(

代码

  详见我的github仓库

]]> 解题报告 数位dp http://blog.aquabet.xyz/Digital_DP/ 2021-08-09T16:00:00.000Z 2021-11-09T16:00:00.000Z 前言

  数位dp就是套模板 ——lwz[0]

  本文将通过对模板本身进行分析，以及通过一些例题来了解如何使用模板来解决问题。
  既然是模板，首先当然要清楚数位dp可以用来解决什么样的问题。总结来说，数位dp可以用于解决在给定区间 $[A,B]$ 内，符合条件 $f(i)$ 的数 $i$ 的个数。条件 $f(i)$ 一般与数的大小无关，而与数的组成有关。如同其名字一样，数位dp便是按照数位来进行dp状态的分析和转移。数位dp解决的问题很多时候看起来很简单，甚至直接的暴力方法都仅有$O(n)$的时间复杂度。但是当这些问题的规模变大，即当 $n$ 在 $10^{19}$ 的级别下，$O(n)$的时间复杂度就完全无法应对，而数位dp是按位dp，数的大小对复杂度的影响很小，很多情况下能够达到$O(log(n))$级别，用来解决这样的问题再合适不过了。

  从起点向下搜索，到最底层得到方案数，一层一层向上返回答案并累加，最后从搜索起点得到最终答案。这便是数位dp解决问题的过程。而对于 $[l,r]$ 区间问题，我们一般把他转化为两次数位dp,即找 $[0,r]$ 和 $[0,l-1]$ 两段，再将结果相减就得到了我们需要的 $[l,r]$。

  如同大多数dp一般，数位dp有两种实现方式，递推和记忆化搜索。我个人更喜欢记忆化搜索，同时相比递推方式，记忆化搜索更适合作为模板，因此接下来的数位dp的模板以记忆化搜索的形式呈现。

题目1

  首先我们从这道题开始了解数位dp：leetcode 233题

题目描述

  给定一个整数 n，计算所有小于等于 n 的非负整数中数字 1 出现的个数。

示例 1：
  输入：n = 13
  输出：6
示例 2：
  输入：n = 0
  输出：0
提示：
  $0 <= n <= 10^9$

代码

  这道题在leetcode上的标签是困难。$10^9$的数据范围，使得直接的暴力算法无法达到要求。从这道条件比较简单的题开始，对模板涉及到的内容进行分析。先附上AC代码，并将其作为基础模板：

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
class Solution {
public:
int dp[15][15];
int num[15];
int dfs(int pos, int sum, int limit) {
    if(pos == 0) {
        return sum;
    }
    if(limit == 0 && dp[pos][sum] != -1) {
        return dp[pos][sum];
    }
    int up = 9;
    if(limit == 1) {
        up = num[pos];
    }
    int ans = 0;
    for(int i = 0; i <= up; i++) {
        ans = ans + dfs(pos-1, sum+(i == 1), i == up && limit);
    }
    if(limit == 0) {
        dp[pos][sum] = ans;
    }
    return ans;
}
    int countDigitOne(int n) {
    int pos = 0;
    while(n != 0) {
        pos++;
        num[pos] = n % 10;
        n = n / 10;
    }
    memset(dp, -1, sizeof(dp));
    return dfs(pos, 0, 1);
    }
};

// 执行用时: 0 ms
// 内存消耗: 5.9 MB

分析

  从核心的dfs部分开始看。dfs部分 dfs(int pos,int sum,int limit) 涉及到三个参数，pos，sum以及limit。其中pos表示当前的数位，我们从最高位开始进行dp，sum表示当前状态数码1的个数，是对应这道题目要求而增添的变量，limit表示当前状态是否达到最高位限制。这三个参数中，需要进行解释的主要是limit参数。

最高位标记limit

  在搜索的数位的过程中，搜索范围可能发生变化。

举个例子：我们在搜索 [0,555] 的数时，显然最高位搜索范围是 0 ~ 5 ，而后面的位数的取值范围会根据上一位发生变化：

  • 当最高位是 1 ~ 4 时，第二位取值为 [0,9]；
  • 当最高位是 5 时，第二位取值为 [0,5] （再往上取就超出右端点范围了）

  为了分清这两种情况，我们引入了 limit 标记：

  • 若当前位 limit = 1 而且已经取到了能取到的最高位时，下一位 limit = 1 ；
  • 若当前位 limit = 1 但是没有取到能取到的最高位时，下一位 limit = 0 ；
  • 若当前位 limit = 0 时，下一位 limit = 0 。
1
2
3
4
5
int up = 9;
if(limit == 1) {
    up = num[pos];
}
int ans = 0;

  这一部分中的up便是表示当前能取到的最高位数，下一位limit的状态自然是i == up && limit。
  接下来还有一个需要分析的地方：

1
2
3
4
5
6
if(limit == 0 && dp[pos][sum] != -1) {
    return dp[pos][sum];
}
if(limit == 0) {
    dp[pos][sum] = ans;
}

  也就是dp值的保存和取用问题。

举个例子：
假设存在如下约束：数位上不能出现连续的两个1(11、112、211都是不合法的)
假设就是$[1,210]$这个区间的个数
状态dp[pos][pre]:当前枚举到pos位，前面一位枚举的是pre(更加前面的位已经合法了)，的个数(假设pos从0开始)。

  先看错误的方法计数，就是不判limit直接dfs。

  那么假设我们第一次枚举了百位是0，显然后面的枚举limit = false，也就是数位上0到9的枚举，然后当我十位枚举了1，此时考虑dp[0][1],就是枚举到个位，前一位是1的个数，显然dp[0][1]=9;(个位只有是1的时候是不满足的)，这个状态记录下来，继续dfs，一直到百位枚举了2，十位枚举了1，显然此时递归到了pos=0,pre=1的层，而dp[0][1]的状态已经有了即dp[pos][pre] != -1；此时程序直接return dp[0][1]了，然而显然是错的，因为此时是有limit的个位只能枚举0，根本没有9个数，状态之间存在冲突。(也可以从上面第一题从数学的角度分析一下，我们记录的是0~9这样的重复状态，而limit == 1实际上是属于特殊状态)因此我们可以得到一个结论：当 limit = 1 时，不能记录和取用dp值。
  类似上述的分析过程，我们也可以得出：当 lead = 1 时，也不能记录和取用dp值。(lead用于表示前导零，在后面会讲到，提到时可以翻回来看看)
  当然也没有这么绝对，一起都是以实际题目为准。
  由此我们发现，模板中需要根据实际情况修改的部分就是下面这一部分：

1
2
3
for(int i=0;i <= up;i++) {
    ans = ans + dfs(pos-1, sum+(i == 1), i == up && limit);
}

  根据实际题目要求，修改其中的约束条件，就可以利用模板来解决问题了。
  接下来再看看另一个重要参数，也就是前面提到的lead。

前导0标记lead

  举个例子：假如我们要从 $[0,1000]$ 找任意相邻两数相等的数。

  显然 111,222,888 等等是符合题意的数
  但是我们发现右端点 1000 是四位数
  因此我们搜索的起点是 0000 ，而三位数的记录都是 0111,0222,0888 等等
  而这种情况下如果我们直接找相邻位相等则 0000 符合题意而 0111,0222,0888 都不符合题意了
  所以我们要加一个前导0标记

  • 如果当前位 lead = 1 而且当前位也是0，那么当前位也是前导0， pos + 1 继续搜；
  • 如果当前位 lead = 1 但当前位不是0，则本位作为当前数的最高位， pos + 1 继续搜；（注意这次根据题意其他参数可能发生变化）

  当然前导 0 有时候是不需要判断的，上述的例子是一个有关数字结构上的性质，0会影响数字的结构，所以必须判断前导0；而如果我们研究的是数字的组成（例如这个数字有多少个 1 之类的问题），0并不影响我们的判断，这样就不需要前导0标记了。

题目2

接下来看一个前导零的例子：leetcode 902

题目描述

  我们有一组排序的数字 D，它是  {‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’} 的非空子集。（请注意，’0’ 不包括在内。）
  现在，我们用这些数字进行组合写数字，想用多少次就用多少次。例如 D = {‘1’, ‘3’, ‘5’}，我们可以写出像 ‘13’, ‘551’, ‘1351315’ 这样的数字。
  返回可以用 D 中的数字写出的小于或等于 N 的正整数的数目。

示例 1：
  输入：D = [“1”,”3”,”5”,”7”], N = 100
  输出：20
  解释：
  可写出的 20 个数字是：
  1, 3, 5, 7, 11, 13, 15, 17, 31, 33, 35, 37, 51, 53, 55, 57, 71, 73, 75, 77.
示例 2：
  输入：D = [“1”,”4”,”9”], N = 1000000000
  输出：29523
  解释：
  我们可以写 3 个一位数字，9 个两位数字，27 个三位数字，81 个四位数字，243 个五位数字，729 个六位数字，2187 个七位数字，6561 个八位数字和 19683 个九位数字。总共，可以使用D中的数字写出 29523 个整数。
提示：
  D 是按排序顺序的数字 ‘1’-‘9’ 的子集。$1 <= N <= 10^9$

代码

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
class Solution {
public:
int in[10];
int dp[15];
int nums[15];
int dfs(int pos,int limit,int lead) {
    if(pos == 0)  return !lead;
    if(limit == 0 && lead == 0 && dp[pos] != -1)  return dp[pos];
    int up = 9;
    if(limit == 1) up = nums[pos];
    int ans = 0;
    for(int i = 0; i <= up; i++) {
        if(lead == 1 && i == 0) {
            ans = ans + dfs(pos-1, limit && i == up, lead && i == 0);
        }
        else if(in[i] == 1) {
            ans = ans + dfs(pos-1, limit && i == up, lead && i == 0);
        }
    }
    if(limit == 0 && lead == 0)  dp[pos] = ans;
    return ans;
}
    int atMostNGivenDigitSet(vector<string>& digits, int n) {
    int size = digits.size();
    memset(dp, -1, sizeof(dp));
    memset(in, 0, sizeof(in));
    for(int i = 0; i < size; i++) {
        in[digits[i][0]-'0'] = 1;
    }
    int pos = 0;
    while(n != 0) {
        pos++;
        nums[pos] = n % 10;
        n = n / 10;
    }
    return dfs(pos, 1, 1);//最高位默认有前导零
    }
};

分析

  其中

1
2
3
4
5
if(lead == 1 && i == 0) {
    ans = ans + dfs(pos-1, limit && i == up, lead && i == 0);
} else if(in[i] == 1) {
    ans = ans + dfs(pos-1, limit && i == up, lead && i == 0);
}

  便是增加前导零后的处理逻辑的变化，至于具体的要根据实际情况来进行变化。
  另外对于状态的记录，最好把所有的额外状态都进行记录，避免状态存在重复和遗漏。虽然这会增加记录数组的维数，但是一般增加的状态都是0,1状态，所以内存方面不会有太多的压力。

  数位dp的状态能记录的最好都记录上 ——lwz

  附上洛谷制作的搜索步骤的图：

PIC

  接下来就可以利用模板刷题了，随着使用的次数++，熟练度也会不断++的。数位dp说难也难，说难也不难，通过大量的练习就可以熟练掌握。

题目3

  HDU3555

题目描述

  The counter-terrorists found a time bomb in the dust. But this time the terrorists improve on the time >bomb. The number sequence of the time bomb counts from 1 to N. If the current number sequence >includes the sub-sequence “49”, the power of the blast would add one point.
  Now the counter-terrorist knows the number N. They want to know the final points of the power. Can you help them?
Input
  The first line of input consists of an integer T (1 <= T <= 10000), indicating the number of test cases. >For each test case, there will be an integer N (1 <= N <= 2^63-1) as the description.
  The input terminates by end of file marker.
Output
  For each test case, output an integer indicating the final points of the power.

Sample Input
  3
  1
  50
  500
Sample Output
  0
  1
  15
Hint
  From 1 to 500, the numbers that include the sub-sequence “49” are “49”,”149”,”249”,”349”,”449”,”490”,”491”,”492”,”493”,”494”,”495”,”496”,”497”,”498”,”499”,so the answer is 15.

分析&&代码

  因为查找的数是一个两位数，所以我们增加pre参数，表示当前数位的前一位，来帮助进行约束判断。AC代码如下：

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
#include<bits/stdc++.h>
using namespace std;
long long num[30];
long long dp[30][20][2];
long long dfs(long long pos, long long pre, long long limit, long long check)
{
    if(pos == 0) {
        return check;
    }
    if(limit == 0 && dp[pos][pre][check] != -1) {
        return dp[pos][pre][check]
    }
    long long up = 9;
    if(limit == 1) {
        up = num[pos];
    }
    long long ans = 0;
    for(long long i = 0; i <= up; i++) {
        ans = ans + dfs(pos-1, i, i == up && limit, ((i == 9) && (pre == 4)) || check);
    }
    if(limit == 0) {
        dp[pos][pre][check] = ans;
    }
    return ans;
}

int main()
{
    long long t;
    cin >> t;
    memset(dp, -1, sizeof(dp));
    for(long long i = 0; i < t; i++) {
        long long x;
        cin>>x;
        long long pos = 0;
        while(x != 0) {
            pos++;
            num[pos] = x % 10;
            x = x / 10;
        }
        cout<<dfs(pos, 0, 1, 0)<<endl;
    }
    return 0;
}

  PS：这题要爆int，记得开long long。

题目4

最后再来道家乡の题: [CQOI2016]手机号码

题目描述

  人们选择手机号码时都希望号码好记、吉利。比如号码中含有几位相邻的相同数字、不含谐音不吉利的数字等。手机运营商在发行新号码时也会考虑这些因素，从号段中选取含有某些特征的号码单独出售。为了便于前期规划，运营商希望开发一个工具来自动统计号段中满足特征的号码数量。
  工具需要检测的号码特征有两个：号码中要出现至少 3 个相邻的相同数字；号码中不能同时出现 8 和 4。号码必须同时包含两个特征才满足条件。满足条件的号码例如：13000988721、23333333333、14444101000。而不满足条件的号码例如：1015400080、10010012022。
  手机号码一定是 11 位数，前不含前导的 0。工具接收两个数 L 和 R，自动统计出 [L,R] 区间内所有满足条件的号码数量。L 和 R 也是 11 位的手机号码。
输入格式
  输入文件内容只有一行，为空格分隔的 2 个正整数 L,R。
输出格式
  输出文件内容只有一行，为 1 个整数，表示满足条件的手机号数量。

输入样例
  12121284000 12121285550
输出样例
  5
说明/提示
  样例解释：满足条件的号码： 12121285000、 12121285111、 12121285222、 12121285333、 12121285550。

数据范围：$10^{10} \le L\le R < 10^{11}$

分析&&代码

  只需要增加check8，check4，连续段检查三个状态，同时注意前导零的处理就可以了。早生几年我也能混进省队了
AC代码如下：

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 <bits/stdc++.h>
using namespace std;
long long dp[20][20][20][2][2][2];
long long num[60];
long long dfs(long long pos, long long pre1, long long pre2, long long limit, long long lead, long long check8, long long check4, long long checkll) {
    if (pos == 0) {
        return checkll && !(check4 == 1 && check8 == 1);
    }
    if (limit == 0 && lead == 0 && dp[pos][pre1][pre2][check8][check4][checkll] != -1) {
        return dp[pos][pre1][pre2][check8][check4][checkll];
    }
    long long up = 9;
    if (limit == 1) {
        up = num[pos];
    }
    long long ans = 0;
    for (long long i = 0; i <= up; i++) {
        if (lead == 1 && i == 0)  {
            ans = ans + dfs(pos - 1, pre2, i, limit && i == up, lead && i == 0, check8, check4, 0);
        }
        else if (lead == 1) {
            ans = ans + dfs(pos - 1, pre2, i, limit && i == up, lead && i == 0, check8 || i == 8, check4 || i == 4, 0);
        }
        else {
            ans = ans + dfs(pos - 1, pre2, i, limit && i == up, lead && i == 0, check8 || i == 8, check4 || i == 4, checkll || (i == pre2 && pre2 == pre1));
        }
    }
    if (limit == 0 && lead == 0) {
        dp[pos][pre1][pre2][check8][check4][checkll] = ans;
    }
    return ans;
}

long long solve(long long x)
{
    long long pos = 0;
    while (x != 0) {
        pos++;
        num[pos] = x % 10;
        x = x / 10;
    }
    return dfs(pos, 0, 0, 1, 1, 0, 0, 0);
}

int main() {
    long long x, y;
    cin >> x >> y;
    memset(dp, -1, sizeof(dp));
    cout << solve(y) - solve(x - 1);
    return 0;
}

参考文献

[0] 洛谷日报第84期
[1] 数位dp总结之从入门到模板

]]> 数位dp就是套模板 ——lwz KMP算法 http://blog.aquabet.xyz/kmp/ 2021-04-27T16:00:00.000Z 2021-04-27T16:00:00.000Z

字符串匹配问题

  字符串匹配，是指“字符串 P 是否为字符串 S 的子串？如果是，它出现在 S 的哪些位置？”的问题，其中S称为主串，P称为模式串。我们假设 S 串长度为 n , P 串长度为 m ，其中 n > m。

Brute-Force

  容易想到朴素暴力匹配，从前往后逐字符比较，遇到不同的字符就continue ； P 串结束了返回 True ， S 串结束而 P 串未结束返回 False 。具体流程如下：

  • 枚举 $i\in[0,n-m)$
  • 将 S[i] ~ S[i+m] 与 P 作比较。如果一致，则找到了一个匹配。

  此方法被称为 Brute-Force 法，最坏的时间复杂度$O(nm)$。

例如：

  主串：

主串

  模式串：

模式串

  全匹配流程如下图所示：

继续匹配

  其中数字表示匹配的顺序。

改进的思路

  我们无法改变 P 串或者 S 串的复杂度，因此只能在匹配次数上进行优化。可以发现，在 Brute-Force 算法中，在最坏情况下，例如S=”aaaaaaaaaab”,P=”aaaab”时，会进行 $n-m+1$ 次位移，每次位移最多会进行 m 次匹配，因此总时间复杂度是$O((n-m+1)*(m))$，也就是$O(mn)$的。

  回到最初，我们需要实现的任务是“字符串匹配”，而每一次失败都会给我们带来一些信息——主串的某一个子串等于模式串的某一个前缀。这个前缀便是优化的关键之处。

next数组的引入

  next数组是对于模式串而言的。 P 的 next 数组定义为： next[i] 表示 P[0] ~ P[i] 这一个子串，使得 前 k 个字符 恰等于 后 k 个字符 的最大的 k 。特别地， k 不能取 i+1 （因为这个子串一共才 i+1 个字符，自己肯定与自己相等，就没有意义了）。

next数组

  上面给出了一个例子。P=”abaabac”时， next[4] = 2 ，这是因为 P[0] ~ P[4] 这个子串是”abaab”，前两个字符与后两个字符相等，因此 next[4] 取 2 。而 next[6] = 0 ，是因为”abaabac”找不到前缀与后缀相同，因此只能取0。

  如果把模式串视为一把标尺，在主串上移动，那么 Brute-Force 就是每次失配之后只右移一位；改进算法则是每次失配之后，移很多位，跳过那些不可能匹配成功的位置。但是该如何确定要移多少位呢？

KMP

  如上，在 S[0] 尝试匹配，失配于 S[3] <=> P[3] 之后，我们直接把模式串往右移了两位，让 S[3] 对准 P[1]。 接着继续匹配，失配于 S[8] <=> P[6], 接下来我们把 P 往右平移了三位，把 S[8] 对准 P[3]. 此后继续匹配直到成功。

  我们应该如何移动这把标尺？很明显，如图中箭头所示，旧的后缀要与新的前缀一致（如果不一致，那就肯定没法匹配上了）！

  回忆next数组的性质：P[0] 到 P[i] 这一段子串中，前 next[i] 个字符与后 next[i] 个字符一模一样。既然如此，如果失配在 P[r] , 那么 P[0] ~ P[r-1] 这一段里面，前 next[r-1] 个字符恰好和后 next[r-1] 个字符相等——也就是说，我们可以拿长度为 next[r-1] 的那一段前缀，来顶替当前后缀的位置，让匹配继续下去！

  那么，如何分析这个字符串匹配的复杂度呢？乍一看，pos值可能不停地变成next[pos-1]，代价会很高；但我们使用摊还分析，显然pos值一共顶多自增len(S)次，因此pos值减少的次数不会高于len(S)次。由此，不难分析出整个匹配算法的时间复杂度:$O(m+n)$。

求next数组

  终于来到了我们最后一个问题——如何构建next数组。
  回顾next数组的完整定义：

  • 定义 “k-前缀” 为一个字符串的前 k 个字符； “k-后缀” 为一个字符串的后 k 个字符。k 必须小于字符串长度。
  • next[x] 定义为： P[0] ~ P[x] 这一段字符串，使得k-前缀恰等于k-后缀的最大的k。

  这个定义中，不知不觉地就包含了一个匹配——前缀和后缀相等。接下来，我们考虑采用递推的方式求出next数组。如果next[0], next[1], … next[x-1]均已知，那么如何求出 next[x] 呢？

  来分情况讨论。首先，已经知道了 next[x-1]（以下记为now），如果 P[x] 与 P[now] 一样，那最长相等前后缀的长度就可以扩展一位，很明显 next[x] = now + 1. 图示如下。

next数组

  刚刚解决了 P[x] = P[now] 的情况。那如果 P[x] 与 P[now] 不一样，又该怎么办？

next数组

  如图。长度为 now 的子串 A 和子串 B 是 P[0]~P[x-1] 中最长的公共前后缀。可惜 A 右边的字符和 B 右边的那个字符不相等，next[x]不能改成 now+1 了。因此，我们应该缩短这个now，把它改成小一点的值，再来试试 P[x] 是否等于 P[now].

  now该缩小到多少呢？显然，我们不想让now缩小太多。因此我们决定，在保持“P[0]~P[x-1]的now-前缀仍然等于now-后缀”的前提下，让这个新的now尽可能大一点。 P[0]~P[x-1] 的公共前后缀，前缀一定落在串A里面、后缀一定落在串B里面。换句话讲：接下来now应该改成：使得A的k-前缀等于B的k-后缀的最大的k.

  您应该已经注意到了一个非常强的性质——串A和串B是相同的！B的后缀等于A的后缀！因此，使得A的k-前缀等于B的k-后缀的最大的k，其实就是串A的最长公共前后缀的长度 —— next[now-1]！

把now更改为next[now-1]之后：

next数组

  来看上面的例子。当P[now]与P[x]不相等的时候，我们需要缩小now——把now变成next[now-1]，直到P[now]=P[x]为止。P[now]=P[x]时，就可以直接向右扩展了。

  应用摊还分析，不难证明构建next数组的时间复杂度是$O(m)$的。至此，我们以$O(n+m)$的时间复杂度，实现了构建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
#include<bits/stdc++.h>
using namespace std;
int lens, lenp;
int next1[1000001];
char S[1000001];
char P[1000001];

void get_next() { //求出next数组
    int t1 = 0, t2;
    next1[0] = t2 = -1;
    while(t1 < lenp) {
        if(t2 == -1 || P[t1] == P[t2]) {
            next1[++t1] = ++t2;
        } else {
            t2 = next1[t2];
        }
    }
}

void KMP() {
    int t1 = 0, t2 = 0;
    while(t1 < lens) {
        if(t2 == -1 || S[t1] == P[t2]) {
            t1++,t2++;
        } else {
            t2 = next1[t2];
        }
        if(t2 == lenp) {
            printf("%d\n", t1 - lenp + 1);
            t2 = next1[t2];
        }
    }
}

int mian() {
    cin>>S>>P;
    lens = strlen(S);
    lenp = strlen(P);
    get_next();
    KMP();
}
]]> KMP算法 并查集 http://blog.aquabet.xyz/Disjoint_Set_Union/ 2021-01-10T16:00:00.000Z 2021-01-10T16:00:00.000Z

前言C

  最近刷每日一题，连着两天出了并查集，分别是 547. 省份数量 和 1202. 交换字符串中的元素 下面以 547. 省份数量 为例，简单阐述下并查集。

原理

  并查集是一种简洁实用的数据结构，通常用于判断两元素是否属于同一集合时使用。并查集只有两种操作，合并集合和查询集合。
  并查集中引入了代表元素的概念，即用一个元素来代替整个集合。可以把并查集类比为一颗树，树是从上往下的有向图，并查集是从下往上的有向图。这样，一个树上的所有节点最终都能找到树的根节点，也就是说，集合的所有元素都能找到并查集的代表元素。

初始化

  将每个元素的父节点初始化为自己。

1
2
3
4
int fa[n];
for(int i = 0; i < n; i++) {
    fa[i] = i;
}

并操作

  并操作将两个集合合并到同一集合。只需要一个元素的代表元素(A)认另一个元素的代表元素(B)当爹就行。这样，A集合和B集合都变为了B集合，两个集合合并为了同一个集合。

1
2
3
4
5
6
7
for(int i = 0; i < n; i++) {
    for(int j = 0; j < i; j++) {
        if(isConnected[i][j] == 1) {//如果联通，合并。
            fa[findfa(fa,j)] = findfa(fa,i);
        }
    }
}

查操作

  查操作通常使用递归，不停地找父节点。直到找到一个节点的父节点是这个节点本身，那么这个节点就是待查元素的代表元素。

1
2
3
4
5
6
int findfa(int *fa, int p) {
    if(fa[p] != p) {
        return findfa(fa,fa[p]);
    }
    return p;
}

  理解了并查集的基本操作，剩下就顺着题意写就完事。

完整代码

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
class Solution {
public:
    int findfa(int *fa, int p) {
        if(fa[p] != p) {
            return findfa(fa,fa[p]);
        }
        else {
            return p;
        }
    }

    int findCircleNum(vector<vector<int>>& isConnected) {
        int n = isConnected.size();
        if(n == 0) return 0;
        int fa[n];
        int ans = 0;
        bool read[n];
        memset(read, false, sizeof(read));
        for(int i = 0; i < n; i++) {
            fa[i] = i;
        }
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < i; j++) {
                if(isConnected[i][j] == 1) {
                    fa[findfa(fa,j)] = findfa(fa,i);
                }
            }
        }
        for(int i = 0; i < n; i++) {
            int thisfa = findfa(fa,i);
            if(read[thisfa] == false) {
                ans++;
                read[thisfa] = true;
            }
        }
        return ans;
    }
};

路径压缩

  对于层数较高且查询的次数要求较高时，上面所示的并查集并不能高效地完成所需要求。因此我们引入了并查集的路径压缩。对于路径压缩，我们只需要修改并操作的代码，把构造一个棵树改为构造一棵层数为1的树仙人掌。在一般情况下，路径压缩的并查集把并操作的效率略微降低，查操作的效率提高，在刷题时可以取舍使用。

更多

  并查集是应用极广的数据结构，最小生成树的Kruskal算法也常通过并查集来写。
  Kruskal算法的主要思想：以边为主导地位，始终选择当前可用的最小边权的边（sort或priority_queue）并加入集合，下面展示Kruskal的核心代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int father(int x) {//找代表元素，并查集的一部分
    if(fat[x] != x) {
        return father(fat[x]);
    }
    return x;
}

void unionn(int x, int y) {//加入团体，并查集的一部分
    fat[father(y)] = father(x);
}

if(father(edge[i].from) != father(edge[i].to)) {//假如不在一个团体
    unionn(edge[i].from, edge[i].to);//加入 
    tot += edge[i].dis;//记录边权 
    k++;//已连接边数+1 
}
]]> 并查集&LeetCode547 LaTeX公式基础 http://blog.aquabet.xyz/latex/ 2021-01-07T16:00:00.000Z 2021-01-07T16:00:00.000Z 行内模式

使用 $ ... $ 或者 \( ... \) 包裹公式

特显模式

使用 $$ ... $$ 或者 \[ ... \] 包裹公式

占用字符

# $ % & _ { } 为占用字符，输入时使用 \ 进行转义，例如 \# \$ \& 的方式进行输入。

此外，在数学模式中输入中文会报错，最好的方式是使用 \mabox{中文内容} 。

上下标

使用 ^ 来表示上标，使用 _ 来表示下标。例如 $C^3_5$ 写作 C^3_5 。
在使用上下标时，有多个字符需使用{ }包裹，例如$x^{10}$ 写作x^{10}。

希腊字母

字母代码字母代码字母代码
$\alpha$\alpha$\beta$\bata$\Gamma$\Gamma
$\gamma$\gamma$\delta$\delta$\Delta$\Delta
$\epsilon$\epsilon$\varepsilon$\varepsilon$\Theta$\Theta
$\zeta$\zeta$\eta$\eta$\Lambda$\Lambda
$\theta$\theta$\vartheta$\vartheta$\Xi$\Xi
$\iota$\iota$\kappa$\kappa$\Pi$\Pi
$\lambda$\lambda$\mu$\mu$\Sigma$\Sigma
$\nu$\nu$\xi$\xi$\Upsilon$\Upsilon
$o$o$\pi$\pi$\Phi$\Phi
$\varpi$\varpi$\rho$\rho$\Psi$\Psi
$\varrho$\varrho$\sigma$\sigma$\Omega$\Omega
$\varsigma$\varsigma$\tau$\tau
$\upsilon$\upsilon$\phi$\phi
$\varphi$\varphi$\chi$\chi
$\psi$\psi$\omega$\omega

分数和开方

分数用\frac{分子}{分母}，例如 $\frac{1}{\pi}$ 写作：\frac{1}{\pi}。
开方用\sqrt[n]{表达式}，例如 $\sqrt[2]{1+k+k^2}$ 写作：\sqrt[2]{1+k+k^2}。

省略号

符号代码符号代码
$\dots$\dots$\vdots$\vdots
$\cdots$\cdots$\ddots$\ddots

括号和分隔符

(),[],|可以直接输入，{}使用时应输入\{\}，||使用时应输入\|。显示大号的括号或者分隔符时，需对应使用\left和\right,例如：

$f(x,y,z) = 3y^2 z \left(3+\frac{7x+5}{1+y^2}\right).$ 写作：f(x,y,z) = 3y^2 z \left(3+\frac{7x+5}{1+y^2}\right).。
$\left.\frac{du}{dx}\right|_{x=0}$ 写作：\left.\frac{du}{dx}\right|_{x=0}。

矩阵

$$
\left(\begin{array}{ccc}
a & b & c \\
d & e & f \\
g & h & i
\end{array}\right)
$$

使用代码

1
2
3
4
5
\left(\begin{array}{ccc}
a & b & c \\
d & e & f \\
g & h & i
\end{array}\right)

$$
\chi(\lambda) = \left|
\begin{array}{ccc}
\lambda - a & -b & -c \\
-d & \lambda - e & -f \\
-g & -h & \lambda - i
\end{array} \right|.
$$

使用代码

1
2
3
4
5
6
\chi(\lambda) = \left|
\begin{array}{ccc}
\lambda - a & -b & -c \\
-d & \lambda - e & -f \\
-g & -h & \lambda - i
\end{array} \right|.

导数，极限，求和，积分

$$\frac{du}{dt}\text{ and }\frac{d^2 u}{dx^2}$$

使用代码

1
\frac{du}{dt}\text{ and }\frac{d^2 u}{dx^2}

部分符号和极限表达式：

$$\lim_{x \to +\infty},\inf_{x > s},\sup_K$$

使用代码

1
\lim_{x \to +\infty},\inf_{x > s},\sup_K
]]> 基础公式，不包含宏包介绍使用 线段树模板 http://blog.aquabet.xyz/segment_tree/ 2021-01-07T16:00:00.000Z 2021-01-07T16:00:00.000Z

  线段树模板带快读快出，忘了从哪位大神抄来的了

  OI时期代码，不保证正确性。

单点修改，区间查询

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
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
#define MAXN 100010
#define INF 10000009
#define MOD 10000007
#define LL long long
#define in(a) a=read()
#define REP(i,k,n) for(long long i=k;i<=n;i++)
#define DREP(i,k,n) for(long long i=k;i>=n;i--)
#define cl(a) memset(a,0,sizeof(a))
/*相当于：{
    long long a;
    scanf("%lld",&a);
    return a;
}
*/
inline long long read(){
    long long x=0,f=1;char ch=getchar();
    for(;!isdigit(ch);ch=getchar()) if(ch=='-') f=-1;
    for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';
    return x*f;
}
/*相当于：{
    printf("%lld",a);
}
*/
inline void out(long long x){
    if(x<0) putchar('-'),x=-x;
    if(x>9) out(x/10);
    putchar(x%10+'0');
}
long long n,m,p;
long long input[MAXN];
struct node{
    long long l,r;
    long long sum,mlz,plz;
}tree[4*MAXN];//线段树记得开四倍空间
inline void build(long long i,long long l,long long r){
    tree[i].l=l;
    tree[i].r=r;
    tree[i].mlz=1;
    if(l==r){
        tree[i].sum=input[l]%p;
        return ;
    }
    long long mid=(l+r)>>1;
    build(i<<1,l,mid);
    build(i<<1|1,mid+1,r);
    tree[i].sum=(tree[i<<1].sum+tree[i<<1|1].sum)%p;
    return ;
}
inline void pushdown(long long i){
    long long k1=tree[i].mlz,k2=tree[i].plz;
    tree[i<<1].sum=(tree[i<<1].sum*k1+k2*(tree[i<<1].r-tree[i<<1].l+1))%p;
    tree[i<<1|1].sum=(tree[i<<1|1].sum*k1+k2*(tree[i<<1|1].r-tree[i<<1|1].l+1))%p;
    tree[i<<1].mlz=(tree[i<<1].mlz*k1)%p;
    tree[i<<1|1].mlz=(tree[i<<1|1].mlz*k1)%p;
    tree[i<<1].plz=(tree[i<<1].plz*k1+k2)%p;
    tree[i<<1|1].plz=(tree[i<<1|1].plz*k1+k2)%p;
    tree[i].plz=0;
    tree[i].mlz=1;
    return ;
}
inline void mul(long long i,long long l,long long r,long long k){
    if(tree[i].r<l || tree[i].l>r)  return ;
    if(tree[i].l>=l && tree[i].r<=r){
        tree[i].sum=(tree[i].sum*k)%p;
        tree[i].mlz=(tree[i].mlz*k)%p;
        tree[i].plz=(tree[i].plz*k)%p;
        return ;
    }
    pushdown(i);
    if(tree[i<<1].r>=l)  mul(i<<1,l,r,k);
    if(tree[i<<1|1].l<=r)  mul(i<<1|1,l,r,k);
    tree[i].sum=(tree[i<<1].sum+tree[i<<1|1].sum)%p;
    return ;
}
inline void add(long long i,long long l,long long r,long long k){
    if(tree[i].r<l || tree[i].l>r)  return ;
    if(tree[i].l>=l && tree[i].r<=r){
        tree[i].sum+=((tree[i].r-tree[i].l+1)*k)%p;
        tree[i].plz=(tree[i].plz+k)%p;
        return ;
    }
    pushdown(i);
    if(tree[i<<1].r>=l)  add(i<<1,l,r,k);
    if(tree[i<<1|1].l<=r)  add(i<<1|1,l,r,k);
    tree[i].sum=(tree[i<<1].sum+tree[i<<1|1].sum)%p;
    return ;
}
inline long long search(long long i,long long l,long long r){
    if(tree[i].r<l || tree[i].l>r)  return 0;
    if(tree[i].l>=l && tree[i].r<=r)
        return tree[i].sum;
    pushdown(i);
    long long sum=0;
    if(tree[i<<1].r>=l)  sum+=search(i<<1,l,r)%p;
    if(tree[i<<1|1].l<=r)  sum+=search(i<<1|1,l,r)%p;
    return sum%p;
}
int main(){
    in(n);    in(m);in(p);
    REP(i,1,n)  in(input[i]);
    build(1,1,n);

    REP(i,1,m){
        long long fl,a,b,c;
        in(fl);
        if(fl==1){
            in(a);in(b);in(c);
            c%=p;
            mul(1,a,b,c);
        }
        if(fl==2){
            in(a);in(b);in(c);
            c%=p;
            add(1,a,b,c);
        }
        if(fl==3){
            in(a);in(b);
            printf("%lld\n",search(1,a,b));
        }
    }
    return 0;
}
/*
5 4 1000
1 2 3 4 5
3 1 5
2 1 5 1
1 1 5 2

3 1 5
*/

区间修改，单点查询

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
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
using namespace std;
int n,m;
int ans;
int input[500010];
struct node
{
    int left,right;
    int num;
}tree[2000010];
void build(int left,int right,int index)
{
    tree[index].num=0;
    tree[index].left=left;
    tree[index].right=right;
       if(left==right)
        return ;
    int mid=(right+left)/2;
    build(left,mid,index*2);
    build(mid+1,right,index*2+1);
}
void pls(int index,int l,int r,int k)
{
    if(tree[index].left>=l && tree[index].right<=r)
    {
        tree[index].num+=k;
        return ;
    }
    if(tree[index*2].right>=l)
       pls(index*2,l,r,k);
    if(tree[index*2+1].left<=r)
       pls(index*2+1,l,r,k);
}
void search(int index,int dis)
{
    ans+=tree[index].num;
    if(tree[index].left==tree[index].right)
        return ;
    if(dis<=tree[index*2].right)
        search(index*2,dis);
    if(dis>=tree[index*2+1].left)
        search(index*2+1,dis);
}
int main()
{
    int n,m;
    cin>>n>>m;
    build(1,n,1);
    for(int i=1;i<=n;i++)
        scanf("%d",&input[i]);
    for(int i=1;i<=m;i++)
    {
        int a;
        scanf("%d",&a);
        if(a==1)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            pls(1,x,y,z);
        }
        if(a==2)
        {
            ans=0;
            int x;
            scanf("%d",&x);
            search(1,x);
            printf("%d\n",ans+input[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
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
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#define init long long
using namespace std;
init n,m;
struct node
{
    init l,r,data;
    init lt;
}tree[1000010];
init arr[1000010];
void build(init l,init r,init index,init arr[])
{
    tree[index].lt=0;
    tree[index].l=l;
    tree[index].r=r;
    if(l==r)
    {
        tree[index].data=arr[l];
        return ;
    }
    init mid=(l+r)/2;
    build(l,mid,index*2,arr);
    build(mid+1,r,index*2+1,arr);
    tree[index].data=tree[index*2].data+tree[index*2+1].data;
    return ;
}
void push_down(init index)
{
    if(tree[index].lt!=0)
    {
        tree[index*2].lt+=tree[index].lt;
        tree[index*2+1].lt+=tree[index].lt;
        init mid=(tree[index].l+tree[index].r)/2;
        tree[index*2].data+=tree[index].lt*(mid-tree[index*2].l+1);
        tree[index*2+1].data+=tree[index].lt*(tree[index*2+1].r-mid);
        tree[index].lt=0;
    }
    return ;
}
void up_data(init index,init l,init r,init k)
{
    if(tree[index].r<=r && tree[index].l>=l)
    {
        tree[index].data+=k*(tree[index].r-tree[index].l+1);
        tree[index].lt+=k;
        return ;
    }
    push_down(index);
    if(tree[index*2].r>=l)
        up_data(index*2,l,r,k);
    if(tree[index*2+1].l<=r)
        up_data(index*2+1,l,r,k);
    tree[index].data=tree[index*2].data+tree[index*2+1].data;
    return ;
}
init search(init index,init l,init r)
{
    if(tree[index].l>=l && tree[index].r<=r)
        return tree[index].data;
    push_down(index);
    init num=0;
    if(tree[index*2].r>=l)
        num+=search(index*2,l,r);
    if(tree[index*2+1].l<=r)
        num+=search(index*2+1,l,r);
    return num;
}
int main()
{
    cin>>n>>m;
    for(init i=1;i<=n;i++)
        cin>>arr[i];
    build(1,n,1,arr);
    for(init i=1;i<=m;i++)
    {
        init f;
        cin>>f;
        if(f==1)
        {
            init a,b,c;
            cin>>a>>b>>c;
            up_data(1,a,b,c);
        }
        if(f==2)
        {
            init a,b;
            cin>>a>>b;
            printf("%lld\n",search(1,a,b));
        }
    }
}

区间乘法

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
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
#define MAXN 100010
#define INF 10000009
#define MOD 10000007
#define LL long long
#define in(a) a=read()
#define REP(i,k,n) for(long long i=k;i<=n;i++)
#define DREP(i,k,n) for(long long i=k;i>=n;i--)
#define cl(a) memset(a,0,sizeof(a))
inline long long read(){
    long long x=0,f=1;char ch=getchar();
    for(;!isdigit(ch);ch=getchar()) if(ch=='-') f=-1;
    for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';
    return x*f;
}
inline void out(long long x){
    if(x<0) putchar('-'),x=-x;
    if(x>9) out(x/10);
    putchar(x%10+'0');
}
long long n,m,p;
long long input[MAXN];
struct node{
    long long l,r;
    long long sum,mlz,plz;
}tree[4*MAXN];
inline void build(long long i,long long l,long long r){
    tree[i].l=l;
    tree[i].r=r;
    tree[i].mlz=1;
    if(l==r){
        tree[i].sum=input[l]%p;
        return ;
    }
    long long mid=(l+r)>>1;
    build(i<<1,l,mid);
    build(i<<1|1,mid+1,r);
    tree[i].sum=(tree[i<<1].sum+tree[i<<1|1].sum)%p;
    return ;
}
inline void pushdown(long long i){
    long long k1=tree[i].mlz,k2=tree[i].plz;
    tree[i<<1].sum=(tree[i<<1].sum*k1+k2*(tree[i<<1].r-tree[i<<1].l+1))%p;
    tree[i<<1|1].sum=(tree[i<<1|1].sum*k1+k2*(tree[i<<1|1].r-tree[i<<1|1].l+1))%p;
    tree[i<<1].mlz=(tree[i<<1].mlz*k1)%p;
    tree[i<<1|1].mlz=(tree[i<<1|1].mlz*k1)%p;
    tree[i<<1].plz=(tree[i<<1].plz*k1+k2)%p;
    tree[i<<1|1].plz=(tree[i<<1|1].plz*k1+k2)%p;
    tree[i].plz=0;
    tree[i].mlz=1;
    return ;
}
inline void mul(long long i,long long l,long long r,long long k){
    if(tree[i].r<l || tree[i].l>r)  return ;
    if(tree[i].l>=l && tree[i].r<=r){
        tree[i].sum=(tree[i].sum*k)%p;
        tree[i].mlz=(tree[i].mlz*k)%p;
        tree[i].plz=(tree[i].plz*k)%p;
        return ;
    }
    pushdown(i);
    if(tree[i<<1].r>=l)  mul(i<<1,l,r,k);
    if(tree[i<<1|1].l<=r)  mul(i<<1|1,l,r,k);
    tree[i].sum=(tree[i<<1].sum+tree[i<<1|1].sum)%p;
    return ;
}
inline void add(long long i,long long l,long long r,long long k){
    if(tree[i].r<l || tree[i].l>r)  return ;
    if(tree[i].l>=l && tree[i].r<=r){
        tree[i].sum+=((tree[i].r-tree[i].l+1)*k)%p;
        tree[i].plz=(tree[i].plz+k)%p;
        return ;
    }
    pushdown(i);
    if(tree[i<<1].r>=l)  add(i<<1,l,r,k);
    if(tree[i<<1|1].l<=r)  add(i<<1|1,l,r,k);
    tree[i].sum=(tree[i<<1].sum+tree[i<<1|1].sum)%p;
    return ;
}
inline long long search(long long i,long long l,long long r){
    if(tree[i].r<l || tree[i].l>r)  return 0;
    if(tree[i].l>=l && tree[i].r<=r)
        return tree[i].sum;
    pushdown(i);
    long long sum=0;
    if(tree[i<<1].r>=l)  sum+=search(i<<1,l,r)%p;
    if(tree[i<<1|1].l<=r)  sum+=search(i<<1|1,l,r)%p;
    return sum%p;
}
int main(){
    in(n);    in(m);in(p);
    REP(i,1,n)  in(input[i]);
    build(1,1,n);

    REP(i,1,m){
        long long fl,a,b,c;
        in(fl);
        if(fl==1){
            in(a);in(b);in(c);
            c%=p;
            mul(1,a,b,c);
        }
        if(fl==2){
            in(a);in(b);in(c);
            c%=p;
            add(1,a,b,c);
        }
        if(fl==3){
            in(a);in(b);
            printf("%lld\n",search(1,a,b));
        }
    }
    return 0;
}
/*
5 4 1000
1 2 3 4 5
3 1 5
2 1 5 1
1 1 5 2

3 1 5
*/

区间根号，没有找到合适的模板题

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
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#define MAXN 1000010
#define REP(i,k,n) for(int i=k;i<=n;i++)
#define in(a) a=read()
using namespace std;
int read(){
    int x=0,f=1;
    char ch=getchar();
    for(;!isdigit(ch);ch=getchar())
        if(ch=='-')
          f=-1;
    for(;isdigit(ch);ch=getchar())
        x=x*10+ch-'0';
    return x*f;
}
struct node{
    int l,r;
    long long lz,sum,maxx,minn;
}tree[MAXN<<2];
int n,m,input[MAXN];
inline void build(int i,int l,int r){
    tree[i].l=l;tree[i].r=r;
    if(l==r){
        tree[i].sum=tree[i].minn=tree[i].maxx=input[l];
        return ;
    }
    int mid=(l+r)>>1;
    build(i*2,l,mid);
    build(i*2+1,mid+1,r);
    tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;
    tree[i].minn=min(tree[i*2].minn,tree[i*2+1].minn);
    tree[i].maxx=max(tree[i*2].maxx,tree[i*2+1].maxx);
    return ;
}
inline void push_down(int i){
    if(!tree[i].lz)  return ;
    long long k=tree[i].lz;
    tree[i*2].lz+=k;
    tree[i*2+1].lz+=k;
    tree[i*2].sum-=(tree[i*2].r-tree[i*2].l+1)*k;
    tree[i*2+1].sum-=(tree[i*2+1].r-tree[i*2+1].l+1)*k;
    tree[i*2].minn-=k;
    tree[i*2+1].minn-=k;
    tree[i*2].maxx-=k;
    tree[i*2+1].maxx-=k;
    tree[i].lz=0;
    return ;
}
inline void Sqrt(int i,int l,int r){
    if(tree[i].l>=l && tree[i].r<=r && (tree[i].minn-(long long)sqrt(tree[i].minn))==(tree[i].maxx-(long long)sqrt(tree[i].maxx))){
        long long u=tree[i].minn-(long long)sqrt(tree[i].minn);
        tree[i].lz+=u;
        tree[i].sum-=(tree[i].r-tree[i].l+1)*u;
        tree[i].minn-=u;
        tree[i].maxx-=u;
            //cout<<"i"<<i<<" "<<tree[i].sum<<endl;
        return ;
    }
    if(tree[i].r<l || tree[i].l>r)  return ;
    push_down(i);
    if(tree[i*2].r>=l)  Sqrt(i*2,l,r);
    if(tree[i*2+1].l<=r)  Sqrt(i*2+1,l,r);
    tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;
    tree[i].minn=min(tree[i*2].minn,tree[i*2+1].minn);
    tree[i].maxx=max(tree[i*2].maxx,tree[i*2+1].maxx);
    //cout<<"i"<<i<<" "<<tree[i].sum<<endl;
    return ;
}
inline long long search(int i,int l,int r){
    if(tree[i].l>=l && tree[i].r<=r)
        return tree[i].sum;
    if(tree[i].r<l || tree[i].l>r)  return 0;
    push_down(i);
    long long s=0;
    if(tree[i*2].r>=l)  s+=search(i*2,l,r);
    if(tree[i*2+1].l<=r)  s+=search(i*2+1,l,r);
    return s;
}
int main(){
    in(n);
    REP(i,1,n)  in(input[i]);
    build(1,1,n);
    in(m);
    int a,b,c;
    REP(i,1,m){
        in(a);in(b);in(c);
        if(a==1)
            printf("%lld\n",search(1,b,c));
        if(a==2){
            Sqrt(1,b,c);
            //for(int i=1;i<=7;i++)
            //    cout<<tree[i].sum<<" ";
           // cout<<endl;
        }
    }
}
]]> 仅模板，讲解下次一定 LeetCode百题纪念 http://blog.aquabet.xyz/leetcode_100_mark/ 2020-12-26T16:00:00.000Z 2020-12-26T16:00:00.000Z   百题突破。真·突破。

  POJ没过百题，Codeforces没过百题，洛谷事实上也算没过百题。今天终于把LeetCode水过了百题。翻了下统计数据，大概过半的AC都在凌晨，过半的WA都在白天。以前晚上是玩手机等12点，登游戏打每日，睡觉。现在是登LeetCode，A掉每日一题，睡觉。

  自从去年，决定不打ACM之后，就很少进行系统性的算法训练了。刚开始刷LeetCode，还能在一道Easy题上卡三四次提交。后来越来越熟练，逐渐找回了切题手感，经常能在12：30以前睡觉。

  前百题都是C++提交的，因为C++招的太少了，未来提交的代码，可能就不再会仅限于C++了。

  可能是作为前OIer的缘故，个人感觉，LeetCode的题普遍比较水。比如 327. 区间和的个数 ，用线段树可以说是随便切(挖个坑，写题解)。各种标着困难的DP读一遍题就能写转移方程（挖个坑，DP专题）。还有大部分题的数据点都挺弱，随便乱搞贪心暴力都能过。但，不可否认的，在实际工作中，LeetCode的题，提供的思路，远比竞赛中的**玩意有用。LeetCode还能使用几乎所有库，妈妈再也不用担心我不会手写红黑树了。

  本来重建博客是为了存点题解模板的，因为写完睡觉的习惯，似乎很少有时间能写题解。

  最近也期末了，刷每日一题的时间都是少女前线&&碧蓝航线给的，等考完期末，也许会好好把前面刷过的题，稍微整理下吧。

]]> <p>&emsp;&emsp;百题突破。真·突破。</p> 优先队列+自定义排序 http://blog.aquabet.xyz/priority_queues/ 2020-12-04T16:00:00.000Z 2020-12-04T16:00:00.000Z 自定义比较函数

1
2
3
4
5
struct cmp {
    bool operator () (node a, node b) {
        return a.value < b.value;//按value的小根堆
    }
};

声明一个优先队列

1
priority_queue<node, vector<node >, cmp > aPriorityQueue;
]]> 优先队列+自定义排序模板 洗牌算法 http://blog.aquabet.xyz/shuffle_cards_algorithm/ 2020-12-04T16:00:00.000Z 2020-12-04T16:00:00.000Z   一个简单的算法 实现打乱arr[]数组
  正好做东西用上的

1
2
for(int i = n-1; i >= 0; i--)
    swap(arr[i],arr[rand()%(i+1)]);//调换arr[i]和arr[rand(0,i)];

时间复杂度O(n)

]]> 一个简单的算法 实现打乱arr[]数组 C++对拍模板 http://blog.aquabet.xyz/checkCode/ 2020-09-29T16:00:00.000Z 2020-10-19T16:00:00.000Z 各文件如下：

1
2
3
4
5
6
7
8
9
@echo off
:loop
MakeData.exe #造数据的程序
answer.exe #待对拍文件
baoli.exe #暴力（保证正确的代码）
fc answer.out baoli.out #输出文件的文件名
if not  errorlevel 1 goto loop
pause
:end
1
2
3
4
5
6
7
8
/*
  MakeData.cpp，添加这两句话 并用rand()初始化数据
*/
int main() {
    freopen("data.in","w",stdout);
    srand(time(NULL));
    ......//生成数据并cout
}
1
2
3
4
5
6
7
8
/*
  待测试文件
*/
int main() {
    freopen("data.in","r",stdin);
    freopen("answer.out","w",stdout);
    ......//执行程序并cout
}
1
2
3
4
5
6
7
8
/*
  确认正确的文件/暴力文件
*/
int main() {
    freopen("data.in","r",stdin);
    freopen("baoli.out","w",stdout);
    ......//执行程序并cout
}

用如Dev-cpp等软件将MakeData.cpp，answer.cpp，baoli.cpp分别编译并生产.exe文件，运行Compare.bat，如果遇到答案不同时，Compare.bat将自动停下来并输出有问题的数据。

]]> 对拍模板 Visual Studio Code C++ gdb 断点调试 配置指南 http://blog.aquabet.xyz/vscode_gdb/ 2019-11-26T16:00:00.000Z 2020-10-19T16:00:00.000Z 在Workspace下的.vscode目录下新建两个文件，分别为launch.json，task.json。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{//launch.json
    "version": "0.2.0",
    "configurations": [
        {
            "name": "(gdb) Launch",
            "type": "cppdbg",
            "request": "launch",
            "targetArchitecture": "x86"
            "program": "${workspaceRoot}\\${fileBasenameNoExtension}.exe"
            "miDebuggerPath":"C:\\mingw\\bin\\gdb.exe",  //此处修改为自己的目录
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceRoot}",
            "externalConsole": true,
            "preLaunchTask": "g++"
            }
    ]
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{//task.json
    "version":"2.0.0",
    "command": "g++",
    "args": ["-g","-std=c++11","${file}","-o","${workspaceRoot}\\${fileBasenameNoExtension}.exe"],
    "problemMatcher": {
        "owner": "cpp",
        "fileLocation": ["relative", "${workspaceRoot}"],
        "pattern": {
            "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
            "file": 1,
            "line": 2,
            "column": 3,
            "severity": 4,
            "message": 5
        }
    }
}
]]> <p>在Workspace下的.vscode目录下新建两个文件，分别为launch.json，task.json。</p> Visual Studio Code Windows10 C++ 配置指南 http://blog.aquabet.xyz/vscode_c++/ 2019-10-27T16:00:00.000Z 2020-10-19T16:00:00.000Z 注意：因为不同电脑系统原因，所有操作建议在管理员模式下运行

下载所需要的文件

首先进入以下网址下载Visual Studio Code

进入以下网址下载MinGW

安装并配置MinGW

安装MinGW

打开MinGW，左侧目录中，进入Basic Setup，点击mingw32-gcc-g++-bin前的小方块，点击Mark for Installation，再点左上角的Installation，再点Apply Changes，等待安装完成。关闭。

如果需要进行gdb调试，还需要在All Packages里找到mingw32-gdb-bin，安装后才能进行单步调试。

配置环境变量

点击Windows系统左下角的搜索 -> 输入”环境”两个字 -> “编辑系统环境变量” -> 高级 -> 环境变量。在系统变量中找到Path，双击进入，新建，浏览，将MinGW安装目录\MinGW\bin添加进去，比如我的是"C:\MinGW\bin"

配置Visual Studio Code

安装必要扩展

打开Visual Studio Code，在左侧边栏中找到扩展，搜索并安装C/C++, Code Runner。
ctrl+shift+P打开Command Palette,运行C/Cpp: Edit configurations生成c_cpp_properties.json。编译器路径选MinGW安装目录\MinGW\bin\g++.exe。

测试能否正常使用

随便打开一个c/cpp文件或者新建一个文件，复制以下代码

1
2
3
4
5
#include<bits/stdc++.h>
using namespace std;
int mian() {
    cout<<"Hello World!"<<endl;
}

按Ctrl+S保存后，按右上角的三角形，即可开始编译运行。

一些可选的可选推荐

Code Runner设置

按Ctrl+,，进入设置，搜索Code Runner。

勾选Run In Terminal，可以使代码在VSCode自带的终端中运行，不弹出新的黑框框。

勾选Save File Before Run，可以在运行时自动保存。

断点调试设置

详见此文

其他推荐使用的拓展插件

下次新开一篇，下次一定。

]]> <p>注意：因为不同电脑系统原因，所有操作建议在<strong>管理员</strong>模式下运行</p> Visual Studio Code中配置Github http://blog.aquabet.xyz/vscode_github/ 2019-10-21T16:00:00.000Z 2020-10-29T16:00:00.000Z 安装Git

百度或者进入以下网站
下载并安装git

配置GitHub

打开GitHub首页
点击左侧New新建一个空repository
确认后显示SSH地址 形如git@github.com:xxxx/xxxx.git
在仓库中点击绿色code 选择SSH 亦可查询自己的SSH地址

创建Git本地文件夹

在目标文件夹中 点击右键 选择Git Bash Here
依次输入如下代码

1
2
3
4
5
6
7
git init
git config user.name '你的名字' -g    #你的名字替换为你的GitHub ID
git config user.email '你的邮箱' -g    #你的邮箱为你的Github注册邮箱
git add .    #意为选择所有文件
git commit -m "update"    #添加更新说明
git remote add origin git@github.com:xxxx/xxxx.git    #替换为你的SSH地址
git push -u origin master    #推送到master分支

常见问题

如果在输出最后一行报错fatal:Could not read from remote repository
则需要设置SSH key
右上角个人图标—Settings—左边栏SSH and GPG keys—New SSH key
title随便取
在Git Bash中执行以下命令
ssh-keygen -t rsa -b 4096 -C "你的邮箱"
一路回车 直到一堆泡泡出现
再输入
cat ~/.ssh/id_rsa.pub
得到一串字符串
将其复制到新建SSH时的密码栏 保存
再次执行
git push -u origin master 就能正常执行推送服务了

]]> <h2 id="安装Git"><a href="#安装Git" class="headerlink" title="安装Git"></a>安装Git</h2><p>百度或者进入<a href="https://git-scm.com/">以下网站</a><br>下载并安装git</p>