❌

普通视图

发现新文章，点击刷新页面。
昨天以前Lu Shuyu

One More Sunshine Story

✇Lu Shuyu
作者 lushuyu
2024年12月22日 23:40

序言

为什么要写这个？起因就是某个笨蛋的某些话不好意思直接说出口，所以就想在自己博客偷偷写个日记记录一下www

这个标题是什么含义？其实是千歌酱的个人solo曲的名字，正好很符合我将要在这个博文里面要记录的故事嘛XD

2024/12/21（补）

今天凌晨我浏览她的推特，然后突然发现了她说的那些话…我真的以为她在说我…

突然就有一种很强很强的无力感，我能对抗挫折，我能接受失败，我觉得我已经付出了全部身心…但是换来一个被讨厌，被认为「目的性很强」的结果（当时我是这么认为她是这么想的），我是真的不知道该做什么了。

我只能重复地和她说对不起…一遍又一遍对不起。我真的好害怕又一次看到被拉黑的感叹号。

“一旦被讨厌了连朋友都做不到了啊——”

我心里如是想到。

虽然很喜欢她，但我还是愿意等她做出选择。其实能做好好的朋友我就很满意了，这就是我的心理预期。

现在连朋友可能都难做了呀……

对不起……

然后她就被我吵醒了，搞清楚发生了什么之后就连忙和我说，不是说的我。

可我还是很难受呀，我明锐地察觉到，前一天晚上我和她发了很多话，她并没有回复我，紧接着几分钟之后她才在推特上说了那些话…也许就是我的那些话让她不舒服了呢……

她可能感觉到我还是不太开心吧，然后又说了很多话，开导的也好解释的也好。但我只关注到她说自己前一天晚上很不舒服很想吐……并且心里很emo……

我真是无可救药呢，刚刚还在误会之中，见到她说自己不舒服就立刻调转了注意力。

其实想想也对，毕竟自己的情绪压根不重要，无论再难过，睡一觉起来自己总是能解决好一切。

关心了她一阵子之后，我也是彻底理解了她，并且和她说如果下次还有情绪垃圾随时来找我。并且她让我相信她喜欢我诶！！！真的好开心ww

我心里很清楚啦，她快乐的时候我也会跟着一起快乐，她从emo中开心起来，我也会很开心www（真是无可救药x （我好想当垃圾桶啊x

所以，昨晚算是HE？

后半夜的话呢又聊到了别的。我解释了我为什么2022年会有对人性弱点的思考，与当时主流女权主义的不满。（这个必须得解释不如人家会以为我厌女）（其实毫无道理的打拳在我眼里和发癫无异，假如被恶臭男骚扰过我还能理解为什么会打拳，那假如从小到大一直被保护的很好，那压根没道理。另外把社会对每一个人的压力曲解为男女两性矛盾也是很无耻的行为，对于这种路径依赖除了拉黑没有什么好办法了）

和她聊了几句代孕之后，我就觉得她不像是单纯的傻白甜（没有说傻白甜什么的意思，仅为性格参照），我觉得她有自己的思想。虽然认识还很浅，这也足以让我大吃一惊了。我当场就觉得这样的思想在她身边的人里是完全不一样的，是脱颖而出的。

即使认识还比较浅，但是比我大一的时候认识的还要多了。并且她比较open-mind（我不知道如何用中文翻译这个单词），思想会越来越成熟，会越来越好的w

非常好的思想。

和当初的我非常相似。

我人生中第一次遇到如此与我相似的人，我越来越觉得她是我见过的最正确的人了。

好喜欢她。

白天去乡下，顺便聊了聊见面那天的行程。

结果发现她自己也没多玩过那个城市…

果然天天晚自习的学校垃圾 呸

还是我来做攻略吧hhh 我擅长这个

2024/12/22

昨晚直截了当和她说了性格的事情，没想到我的判断还是挺准确的嘛，她的心理老师也这么觉得，未来可期www

我真的嫉妒那个湖北老哥了，咋想的那么多文案，我也想要一直夸她！（）

然后她居然想的是不想让夸她变成我的负担…

我的天哪啊啊啊啊啊啊啊啊啊啊这是什么天使啊啊啊啊啊啊啊啊啊啊

嗯，她说她喜欢蜜雪的茉莉奶绿，今天中午和侄子吃火锅之后顺便买一杯吧。

真的很好喝，茉莉花淡淡的苦香，配合上五分糖激发出奶香的回甜。

确实是苦中寻乐的好方法。

她安利给我的生巧福团到了。

真的很好吃，一点也不苦。很甜。

小心蛀牙。

但我还是想吃。

把有关《985不配你》的焊车门回答转发给她看了，和我预想的一样，她也能看出来这是在焊车门。

这就是我为什么好喜欢她的原因。

因为和她聊天总是仿佛在和自己内心对话。

非常完美。

又稍微讲了一下初中的时候另一个妹子的故事。

她觉得我同桌是在感情欺骗？不过我倒是觉得没那么严重，因为那时候的小屁孩对喜欢的认识都很浅显，一天喜欢一个还挺正常的嘛。

哦我大概知道她为什么在意感情欺骗的问题了。

我是个傻B。

其实还想说更多的，比如再安慰安慰的。

但是我吃饭的时候一直玩手机被我老爸狠狠制裁了TvT

我想保护她哇，有坏人就把我拿出来挡，没问题的。

其实还想写点什么但是有点写累了啊啊比如就此停笔吧。

今天的故事就到这里咯。

2024/12/23

昨晚她看到这个了hhhh

我还能说什么呢，又幸福到了啊啊啊。

好想天天夸她，把她举高高。

上午她想在手机上装ins，我就给了几个安装包，不知道为什么一直装不上。一番鼓捣之后才发现是手机空间不够了。

在空间小尾巴才看到，她用的是荣耀play5T活力版

光是看到活力版三个字就让我眼前一黑了……

我本来说她自拍那么糊是特效的原因，原来单纯是手机像素不好……

再想到她上一次说的自己用的电脑…也不像是什么好东西…

也罢，已经买好了，只能让她下一次买性价比更高的了。

忍住了N次想要给她换手机的冲动（我的思维告诉我直接说出来非常非常不好，像是在施舍）

我只是说，

以后要换电子产品，记得我和说一下，我比较懂，给你推荐性价比高的w

突然想到自己之前崩坏3一个版本氪的金能够买一台性价比手机+性价比电脑……

不想聊起她的家庭背景，这会损伤她的自信心的。

但是她看出来我语塞了…

还是用一个版本崩坏3氪金太多后悔了掩盖过去吧……

虽然近几个版本氪金真的有点多了 咳咳咳

钱还是用在更好的用途上吧。

晚上出去玩，给她分享了一大堆烧烤和蜜雪冰城～

说实话，我以前咋没发现呢，在奶茶里放芒果真的好难喝。。。

本来一个人独自瞎逛神游就很开心，同时能和她聊天我更开心了^ ^

开心过头了拍了一个第一人称发癫蹦蹦跳跳的视频发了过去

特意贴心的调成了60帧

她应该不会说我幼稚吧？！

我：我家猫被我影响了，对垃圾桶特别感兴趣，老把垃圾桶踹翻。

她：你对垃圾桶感兴趣？

我：我想做你的垃圾桶。（这里指的是情绪垃圾桶）

她：哈哈已哭

我：（向她描述我闲逛的路线）

她：这个路线很适合遛狗诶～

我：可我没养狗狗哇

她：我想做你的狗

我：？？？我也想做你的狗蹭蹭蹭蹭

虽然土味但是好喜欢哈哈哈哈哈哈哈哈哈哈哈哈

2024/12/24

和我分享了她以前做的蛋挞。

看起来很好吃ww

总得要找个机会尝尝她的手艺，也让她尝尝我的手艺。

推荐我蜜雪的草莓椰奶露。

但是没有找到TvT

好遗憾。

大冬天给我推荐冷饮也无所谓，喝她推荐的心里就暖暖的。

去吃了蒜蓉生蚝。

她居然也没有吃过。

嘿嘿嘿，成功说服她下次去试试了。

她和我这么像，应该也会喜欢上蒜蓉生蚝的味道吧。

她说：不要对列表这么好！如果不想当列表垃圾桶就当没看见，别影响到自己。

其实我不知道该如何回答这个，因为我确实一直一直都在听朋友说话，并且很喜欢帮他们排忧解难。伤害到自己？也许有吧但我无所谓。

她说她以前也这样，然后发现自己的心情也受到了很大的影响。

「我们之间就不要当垃圾桶了，而是互帮互助的好朋友。」

好吧，我听她的话，也许应该对这个好好思考一下了。

挺好的。她不把我当成垃圾桶。

她说她第一次和别人说这么多。

我很开心。

2024/12/25

昨晚花了一点时间，描改了一张，她出的希儿。

这是圣诞节礼物！

她似乎很开心。

应该吧，我就当她很开心。

她给我转发了一段聊天记录。

是一个她认识很久的男生，问她为什么不用情头。

最后还来了一句「想想也羡慕，能和彼岸小姐做cp什么的」。

感觉好讨厌哇。

不过，

我也很羡慕。

但是我想让她做自己选择。

我又想起她的匿名问答箱的「那一条回答」了。

同时也想起了她空间里的好友的「那一段文字」。

像是两把刀扎在心里。

果然我还是很在意呢。

「那一条回答」「那一段文字」，指引出来的那个人，那段故事…有关这方面的一切，我内心的想法早已成型了，我知道即使我说出来，得到的仅仅是一个确认而已。

这，

真的值得吗？

就像是一个随时都会毁灭一切的定时炸弹。

我相信我自己的情绪管理系统不久之后能把我心里的一切烦恼全部扫进垃圾堆，内心终将重归空白。

那么就让我，此时此刻，

沉浸在这即将消散的悲伤里吧。

因为我自己不会允许负面情绪长时间占据，

所以体验悲伤的情绪对我来说是一种奢求。

没有边界感的人，

就不要回复了吧。

我也要学会这一点。

傍晚她病了，很严重的痛苦，

我怀疑是肠胃急性炎症，一直催促她去医院。

好在她也没有硬撑，去了医院做了检查。

真的非常非常担心她，和她说了很多话。

不过晚上的时候已经好多了。

很开心我的悲伤只存活了一个上午，又被扫进垃圾堆了。

2024/12/26

聊了一下她弟弟，没想到才初一。

据她所说也是比较懂事的那种。

希望他能好好学习改变命运吧，我说有需要我可以教一教他。

她还想说她和弟弟以前的事，但是被我打断了。

往事不可谏，来者犹可追。

果然，我无法在她面前隐藏任何小心思。

「那一条回答」「那一段文字」，一直让我很在意。

于是我就问了。

和我猜测的故事完全一样。

我还想问更多，但是感觉她不愿意说了。

如果对话在上面就结束的话，那可真是太糟糕了。

但是我的特性，再次发动了。

即使我的内心一团乱麻，

即使脆弱的关系中间突然横贯一座大山，

即使她表现出「下次再聊」的意思，

我，

没有任何犹豫地，放开了我自己，

站在了她的一边。

我没有表现出来任何异样，

只是尽可能帮她排除内心的障碍，

我不希望她因为我的突然出现而慌乱。

我早已做好所有的一切都退出的准备，

只等待她最后如果选择离开的时候，

从她的世界里消失，让她放下我，不要再让她记得我。

只希望她能做出她自己的选择，不要被过往的经历束缚住。

具体而言，她说她分不清楚感激和喜欢的区别。

于是我和她聊了聊，以前那个只是因为帮助对抗抑郁而向我表白的女孩子。

希望她能明白。

喜欢是过去的理解、现在的关心、未来的期望的三位一体。

「茫然的感觉」，模糊的未来。

这对吗？

所以我最终没有答应那个女孩的表白。

我真不知道我的特性是好是坏。

和朋友相处的时候总是倾注了内心的所有，

即使自己已经遍体鳞伤。

她晚上和我非常认真地讲了这一点，

她总觉得我人太好了。

确实很对，我也逐渐开始学如何「恨」了。

但对她，

我还是把我的所有的心都交出去了，

因为我相信她呀，相信她永远不会伤害我的。

给我一份关心，我就会还给她两份。

她说她很少有人关心她。

但我愿意。

我很想要关心她。

我想了解她的一切。

我想随时随地解决她的烦恼。

我想第一个知道她的开心。

题外话，

引起我内心不稳定的，我和我别的列表分析过，依旧是「那一条回答」「那一段文字」。

但是我的列表第二天想要追问「那一条回答」「那一段文字」的内容。

我生气了。

这是一个很好的开始。

2024/12/27

如何优雅地使用VSCode写C/C++并自动格式化

✇Lu Shuyu
作者 lushuyu
2022年3月30日 21:56

如何在VSCode里面格式化C/C++代码呢？

1 相关工作

  • 在网上能搜索到的配置办法基本上都是相互复读。
  • 绝大部分使用Powershell调用clang-format生成.clang-format文件的操作对新人不友好。
  • 编辑Settings.json的操作对新人不友好。
  • 一些配置办法无法自定义大括号不换行。
  • 右键格式化在我的VSCode上不好使。
  • 我当初摸索的时候被以上五条整的差点自闭。

2 配置方法

  • 首先，正确安装C/C++插件
  • 打开设置面板，完成以下设置。
  • 搜索 Format on Save 并勾选
  • 搜索 formatter 并选中C/C++
  • 搜索 Clang_format_fallback Style 并在里面写上 {BasedOnStyle: LLVM, IndentWidth: 4}

这样每次保存代码的时候都会自动格式化了。

3 结语

我的方法可能不是最佳方法，但是是比较实用的，没有很繁琐的设置，不用写json。

我的代码习惯是4宽的制表符，并且大括号不换行。在自己自定义的时候可以修改BasedOnStyle改成其他可能的值（在设置列表里面列出了），找到自己最舒服的那种Style。

题解 CCF-CSP-18-C 化学方程式 AcWing 3284

✇Lu Shuyu
作者 lushuyu
2021年11月30日 15:58

题目传送门

题解

这个题是一道恶心人的大模拟，如何处理检查配平情况呢？要找出所有的原子，计数，然后比对等号两边各种原子的数量。

处理原子可以用 unordered_map，但是效率不高切更难写，我们可以开一个 $27*27$ 的数组，把原子转换为数组下标，这样更高效。

关于括号的嵌套，我的想法是开一个 tag 数组，先扫一个化学式，确定括号的位置以及化学计量数，然后更新 tag，正数代表乘，负数代表除。

还有一个容易出现的 bug：数字有可能出现很多位，刚开始我只考虑了一位，所以调了很久。

代码

#include <bits/stdc++.h>
using namespace std;

const int N = 27 * 27 + 5;

#define SIZ s.size()

int a[N], b[N];
int tag[1005];

int n;

int ans;

string s;

void div1(string str) {
    // cout << str << endl;

    for (int i = 0; i < str.size();) {
        int j = i + 1;
        while (str[j] != '+' && j < str.size())
            j++;
        string cur = str.substr(i, j - i);
        i = j + 1;
        int times = 1;
        int now = 0;
        memset(tag, 0, sizeof tag);
        if (cur[0] >= '1' && cur[0] <= '9') {
            int number = 0;

            while (cur[now] >= '0' && cur[now] <= '9') {
                number = number * 10 + cur[now] - '0';
                now++;
            }
            times *= number;
            now--;
        }
        while (now < cur.size()) {
            if (cur[now] == '(') {
                int l = 1, k = now + 1;
                while (1) {
                    if (cur[k] == '(')
                        l++;
                    if (cur[k] == ')')
                        l--;
                    if (l == 0) {
                        int tmp = 0;
                        if (cur[k + 1] < '0' || cur[k + 1] > '9')
                            tmp = 1;
                        int p = k + 1;
                        while (cur[p] >= '0' && cur[p] <= '9') {
                            tmp = tmp * 10 + cur[p] - '0';
                            p++;
                        }

                        tag[now] = tmp;
                        tag[k] = tmp * -1;
                        cerr << "add tag on " << now << " value = " << tmp
                             << endl;
                        break;
                    }
                    k++;
                }
            }
            now++;
        }

        now = 0;
        while (1) {
            if (now >= cur.size())
                break;

            if (tag[now] > 0)
                times *= tag[now];
            if (tag[now] < 0)
                times /= tag[now] * -1;
            if (!((cur[now] >= 'a' && cur[now] <= 'z') ||
                  (cur[now] >= 'A' && cur[now] <= 'Z'))) {
                now++;
                continue;
            }
            int tim = 1;
            if ((cur[now + 1] >= 'A' && cur[now + 1] <= 'Z') ||
                cur[now + 1] == '(' || cur[now + 1] == ')' ||
                now + 1 >= cur.size()) {
                a[(cur[now] - 'A' + 1) * 10] += 1 * times;
                cerr << "find " << cur[now] << " 我们给他加上了 " << 1 * times
                     << endl;
            }
            if ((cur[now + 1] >= '0' && cur[now + 1] <= '9')) {
                int number = 0;
                int p = now + 1;
                while (cur[p] >= '0' && cur[p] <= '9') {
                    number = number * 10 + cur[p] - '0';
                    p++;
                }

                a[(cur[now] - 'A' + 1) * 10] += (number)*times;

                cerr << "find " << cur[now] << number << " 我们给他加上了 "
                     << (number)*times << endl;
                now = p - 1;
            }
            if ((cur[now + 1] >= 'a' && cur[now + 1] <= 'z')) {
                if ((cur[now + 2] >= '0' && cur[now + 2] <= '9')) {

                    int number = 0;
                    int p = now + 2;
                    while (cur[p] >= '0' && cur[p] <= '9') {
                        number = number * 10 + cur[p] - '0';
                        p++;
                    }

                    cerr << "find Aa0" << cur[now] << cur[now + 1]
                         << cur[now + 2] << " 我们给他加上了 " << (number)*times
                         << endl;

                    a[(cur[now] - 'A' + 1) * 10 + cur[now + 1] - 'a' + 1] +=
                        (number)*times;
                    now = p - 1;

                } else {

                    cerr << "find Aa" << cur[now] << cur[now + 1]
                         << " 我们给他加上了 " << 1 * times << endl;

                    a[(cur[now] - 'A' + 1) * 10 + cur[now + 1] - 'a' + 1] +=
                        (1) * times,
                        now++;
                }
            }
            now++;
        }
        // for (int i = 0; i <= 20; i++)
        //     cout << tag[i] << " ";
        // cout << endl;
        // int qaq = 0;
    }
}

void div2(string str) {
    // cout << str << endl;

    for (int i = 0; i < str.size();) {
        int j = i + 1;
        while (str[j] != '+' && j < str.size())
            j++;
        string cur = str.substr(i, j - i);
        i = j + 1;
        int times = 1;
        int now = 0;
        memset(tag, 0, sizeof tag);
        if (cur[0] >= '1' && cur[0] <= '9') {
            int number = 0;

            while (cur[now] >= '0' && cur[now] <= '9') {
                number = number * 10 + cur[now] - '0';
                now++;
            }
            times *= number;
            now--;
        }
        while (now < cur.size()) {
            if (cur[now] == '(') {
                int l = 1, k = now + 1;
                while (1) {
                    if (cur[k] == '(')
                        l++;
                    if (cur[k] == ')')
                        l--;
                    if (l == 0) {
                        int tmp = 0;
                        if (cur[k + 1] < '0' || cur[k + 1] > '9')
                            tmp = 1;
                        int p = k + 1;
                        while (cur[p] >= '0' && cur[p] <= '9') {
                            tmp = tmp * 10 + cur[p] - '0';
                            p++;
                        }
                        tag[now] = tmp;
                        tag[k] = tmp * -1;
                        cerr << "add tag on " << now << " value = " << tmp
                             << endl;
                        break;
                    }
                    k++;
                }
            }
            now++;
        }

        now = 0;
        while (1) {
            if (now >= cur.size())
                break;

            if (tag[now] > 0)
                times *= tag[now];
            if (tag[now] < 0)
                times /= tag[now] * -1;
            if (!((cur[now] >= 'a' && cur[now] <= 'z') ||
                  (cur[now] >= 'A' && cur[now] <= 'Z'))) {
                now++;
                continue;
            }
            int tim = 1;
            if ((cur[now + 1] >= 'A' && cur[now + 1] <= 'Z') ||
                cur[now + 1] == '(' || cur[now + 1] == ')' ||
                now + 1 >= cur.size()) {
                b[(cur[now] - 'A' + 1) * 10] += 1 * times;
                cerr << "find " << cur[now] << " 我们给他加上了 " << 1 * times
                     << endl;
            }
            if ((cur[now + 1] >= '0' && cur[now + 1] <= '9')) {
                int number = 0;
                int p = now + 1;
                while (cur[p] >= '0' && cur[p] <= '9') {
                    number = number * 10 + cur[p] - '0';
                    p++;
                }

                b[(cur[now] - 'A' + 1) * 10] += (number)*times;

                cerr << "find " << cur[now] << number << " 我们给他加上了 "
                     << (number)*times << endl;
                now = p - 1;
            }
            if ((cur[now + 1] >= 'a' && cur[now + 1] <= 'z')) {
                if ((cur[now + 2] >= '0' && cur[now + 2] <= '9')) {

                    int number = 0;
                    int p = now + 2;
                    while (cur[p] >= '0' && cur[p] <= '9') {
                        number = number * 10 + cur[p] - '0';
                        p++;
                    }

                    cerr << "find Aa0" << cur[now] << cur[now + 1]
                         << cur[now + 2] << " 我们给他加上了 " << (number)*times
                         << endl;

                    b[(cur[now] - 'A' + 1) * 10 + cur[now + 1] - 'a' + 1] +=
                        (number)*times;
                    now = p - 1;

                } else {

                    cerr << "find Aa" << cur[now] << cur[now + 1]
                         << " 我们给他加上了 " << 1 * times << endl;

                    b[(cur[now] - 'A' + 1) * 10 + cur[now + 1] - 'a' + 1] +=
                        (1) * times,
                        now++;
                }
            }
            now++;
        }
        // for (int i = 0; i <= 20; i++)
        //     cout << tag[i] << " ";
        // cout << endl;
        // int qaq = 0;
    }
}

void pd() {
    for (int i = 0; i < N; i++)
        if (a[i] != b[i]) {
            cout << "N" << endl;
            return;
        }
    cout << "Y" << endl;
    return;
}

int main() {
    scanf("%d", &n);
    while (n--) {
        cin >> s;
        memset(a, 0, sizeof a);
        memset(b, 0, sizeof b);
        ans = 0;
        for (int i = 0; i < SIZ; i++) {
            if (s[i] != '=')
                continue;
            div1(s.substr(0, i));
            div2(s.substr(i + 1));
        }
        pd();
    }
}

如何调教好广播站的设备

✇Lu Shuyu
作者 lushuyu
2021年10月15日 00:02

今天去观摩广播站，偶遇来修设备的大叔，于是带领我们讲解了一下偶尔的设备故障如何修复。

首先是如何确定哪一个音响出了问题。打开那个门口的大铁箱子，看到里面有一堆空气开关，这里是广播站向外输出信号首先是如何确定哪一个音响出了问题。打开那个门口的大铁箱子，看到里面有一堆空气开关，这里是广播站向外输出信号的地方。拿起大喇叭的两条线，抓住绝缘层，把金属丝怼进两个洞里面，如果连接正常的话会有声音，注意你接触的是220V电压，所以请务必抓好绝缘层以防触电。

如果某一个空气开关没有声音，那么就要检查那两个大柜子了。那两个大柜子是将弱电信号转化为220V电信号的装置，先定位好是哪一个装置没有声音，然后先看装置的仪表。一般电压是220V，电流只要略微的波动（不同的小柜子装置因为功率不同，电流大小也不同），一般电压正常的话就没有问题，但是要注意好电流过大的情况，可能是发生了短路（你们物理这么好就不用我多说了吧）。

假如电压很小（远低于220V），那么就要绕道机箱的后面观察开关是否打开，以及拧一下线，看看是不是线松了。背后还有一个变压器，通过调节节点位置可以调整输出电压为110V或者220V（高中物理经典了），有可能他本来调的就是110V挡位，所以看到输出电压是110V也不要大惊小怪。

假如出现某个地方声音小/大的情况，可以转动小柜子电压表旁边的开关，这个可以控制音量。

如果出现解决不了的情况及时报修。

Codeforces Round #746 (Div. 2)（1592）

✇Lu Shuyu
作者 lushuyu
2021年10月6日 15:56

比赛链接：Codeforces Round #746 (Div. 2)

AB

题就不说了，签到。

A题提交 B题提交

C

假设所有节点的异或和为tot，那么有两种情况

  • tot = 0，那么此时一定可以被分成两份。
  • tot != 0，那么假设可以分成k份，那么最终分出来的每一块异或和就是tot，并且相邻的三份tot可以合为一份tot，异或和不变，最后只剩下3份tot。

针对tot不等于0的情况，我们只需要搜出来3份tot就可以了。

Walk_Alone 学长提出了一个只用dfs一遍的方法：如果子树已经是tot了，那么就不用将子树合并入父节点了，我的代码就是用这个思路写的。

#include<bits/stdc++.h>
using namespace std;

inline int read(){
    int x=0,f=1;
    char ch=getchar();
    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;
}

const int N=1e5+5;

struct edge{
    int to;
    int nxt;
}edg[N<<1];

int head[N],cnt;

inline void add(int u,int v){
    edg[++cnt].to=v;
    edg[cnt].nxt=head[u];
    head[u]=cnt;
}

int t,n,k;

int a[N];

int tot;
int num[N];
int qaq;

inline void init(){
    pd=1;
    qaq=0;
    ohhh=0;
    n=0;k=0;
    memset(a,0,sizeof a);
    memset(num,0,sizeof num);
    memset(head,0,sizeof head);
    cnt=0;
    delu=0,delv=0,tot=0;
}



void dfs1(int now,int fa){
    for(int i=head[now];i;i=edg[i].nxt){
        int to=edg[i].to;
        if(to==fa) continue;
        
        dfs1(to,now);

        if(num[to]==tot)
            qaq++;
        else num[now]^=num[to];
    }
}



int main(){
    t=read();
    while(t--){
        init();
        n=read();k=read();
        for(int i=1;i<=n;i++)
            a[i]=read(),num[i]=a[i];
        for(int i=1;i<n;i++){
            int u,v;
            u=read();v=read();
            add(u,v);
            add(v,u);
        }
        for(int i=1;i<=n;i++)
            tot^=a[i];
        if(tot==0){
            cout<<"YES"<<endl;
            continue;
        }

        dfs1(1,0);

        if(k<=2){
            cout<<"NO"<<endl;
            continue;
        }
        if(qaq>=2){
            cout<<"YES"<<endl;
            continue;
        }
        cout<<"NO"<<endl;
    }
    return 0;
}

AtCoder Beginner Contest 221

✇Lu Shuyu
作者 lushuyu
2021年10月3日 10:15
//A.cpp

#include<bits/stdc++.h>
using namespace std;

inline int read(){
    int x=0,f=1;
    char ch=getchar();
    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;
}

int a,b;

int main(){
    cin>>a>>b;
    long long ans=1;
    for(int i=1;i<=max(a,b)-min(a,b);i++){
        ans*=32;
    }
    cout<<ans<<endl;
    
}
//B.cpp

#include<bits/stdc++.h>
using namespace std;

inline int read(){
    int x=0,f=1;
    char ch=getchar();
    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;
}

string a,b;

int main(){
    cin>>a>>b;
    if(a==b){
        cout<<"Yes"<<endl;
        return 0;
    }
    for(int i=0;i<a.size();i++){
        swap(a[i],a[i+1]);
        if(a==b){
            cout<<"Yes"<<endl;
            return 0;
        }
        swap(a[i],a[i+1]);
    }
    cout<<"No"<<endl;
}
//C.cpp

#include<bits/stdc++.h>
using namespace std;

inline int read(){
    int x=0,f=1;
    char ch=getchar();
    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;
}

int n;
long long ans;
bool st[12];
int size1=0;

void dfs(int now){
    priority_queue<int>a;
    for(int i=1;i<=size1;i++){
        int tmp=n;
        for(int j=1;j<=i-1;j++)
            tmp/=10;
        tmp%=10;
        if(st[i]==0) a.push(tmp);
    }
    int buf=0;
    while(!a.empty()){
        buf=buf*10+a.top();
        a.pop();
    }
    ans=max(1ll*now*buf,ans);
    //cout<<"Now we have "<<now<<" * "<<buf<<" ans= "<<1ll*now*buf<<endl;
    for(int i=1;i<=size1;i++){
        if(!st[i]){
            int tmp=n;
            for(int j=1;j<=i-1;j++)
                tmp/=10;
            tmp%=10;
            st[i]=1;
            dfs(now*10+tmp);
            st[i]=0;
        }
    }
}

int main(){
    n=read();
    int qaq=n;
    while(qaq){qaq/=10;size1++;}
    //cout<<size1<<endl;
    for(int i=1;i<=size1;i++){
        int tmp=n;
        for(int j=1;j<=i-1;j++)
            tmp/=10;
        st[i]=1;
        dfs(tmp%10);
        st[i]=0;
    }
    cout<<ans<<endl;
}
//D.cpp

#include<bits/stdc++.h>
using namespace std;

inline int read(){
    int x=0,f=1;
    char ch=getchar();
    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;
}

const int N=4e5+5;

struct point{
    int type;
    int p;
}p[N];

bool cmp(point x,point y){
  return x.p<y.p;
}

int cnt,n;
int num;
int ans[N];
int last;
int lastnum;
int tot;
int pre[N];
int she[N];
int main(){
    n=read();
    for(int i=1;i<=n;i++){
        int a=read();
        int b=read();
        p[++cnt].p=a;
        p[cnt].type=1;
        p[++cnt].p=a+b;
        p[cnt].type=-1;
    }
    sort(p+1,p+1+cnt,cmp);
    for(int i=1;i<=cnt;i++){
        // if(p[i].p!=p[i-1].p){
        //     tot++;
        //     if(p[i].type==1)
        //         pre[tot]++;
        //     if(p[i].type==2)
        //         pre[tot]--;
        //     she[tot]=p[i].p;
        // }
        // else {
        //     if(p[i].type==1)
        //         pre[tot]++;
        //     if(p[i].type==2)
        //         pre[tot]--;
        // }
        
            num+=p[i-1].type;
            ans[num]+=p[i].p-p[i-1].p;
        
    }
    // for(int i=1;i<=tot;i++){
    //     num+=pre[i];
    //     ans[num]+=she[i]-she[i-1];
    // }
    for(int i=1;i<=n;i++){
        cout<<ans[i]<<" ";
    }
    cout<<endl;
    return 0;
}

题解CF1574B

✇Lu Shuyu
作者 lushuyu
2021年9月24日 20:58

https://codeforces.com/problemset/problem/1574/B

此题比较考思维。

首先abc能组成出来的ans范围一定是一个区间。这个很容易理解，调整两个字母的位置就可以对ans作出1个大小的调整。

其次ans最大的范围可以求。就是a+b+c-3（依次排开）

剩下ans最小的范围。我们不妨设abc最大值为a，a要么很大大过b+c，要么a比较小。a比较小的时候那么我们可以发现把bc插进a里面去，那么a就不能对ans作贡献了，同时bc还可以互相插，那么此刻ans最小就是0。当a很大的时候，那么bc就作为挡板插进a里面，所以此时的ans最小值是a-b-c-1。

代码实现很简单。

#include<bits/stdc++.h>
using namespace std;

inline int read(){
    int x=0,f=1;
    char ch=getchar();
    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;
}

int a,b,c,m,t,maxa,mina;

int main(){
    ios::sync_with_stdio(false);
    t=read();
    while(t--){
        a=read();b=read();c=read();m=read();
        maxa=a+b+c-3;
        mina=max(0,2*max(a,max(b,c))-1-a-b-c);
        if(m<=maxa&&m>=mina) cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
    
}

题解 20CCF-CSP-T3点亮数字人生

✇Lu Shuyu
作者 lushuyu
2021年9月21日 18:05

题目传送门

两次拓扑排序，剩下的就是码力了。

小插曲：用auto遍历会T飞。

#include<bits/stdc++.h>
using namespace std;

inline int read(){
    int x=0,f=1;
    char ch=getchar();
    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;
}

//本题毒瘤

const int N=3000+5;
const int M=1e5+5;

struct edg{
    int from,to,nxt;
}g[M];

int head[N],cnt;

inline void add(int from,int to){
    g[++cnt].nxt=head[from];
    g[cnt].to=to;
    g[cnt].from=from;
    head[from]=cnt;
}

vector<int> in[N];
int d[N],ans[N];

int m,n,k;

void init(){
    memset(head,0,sizeof head);
    memset(d,0,sizeof d);
    cnt=0;
    for(int i=1;i<=n;i++) in[i].clear();
}

int toint(string s){
    int x=0;
    for(int i=1;i<s.size();i++) x=x*10+s[i]-'0';
    return x;

}

int dd[N];

struct que{
    vector<int> v,v2;
}q[10005];

bool topo1(){
    for(int i=m+1;i<=m+n;i++) dd[i]=d[i];
    queue<int>q2;
    int idx=0;
    for(int i=1;i<=m;i++){
        q2.push(i);
    }
    while(!q2.empty()){
        int u=q2.front();
        q2.pop();
        for(int i=head[u];i;i=g[i].nxt){
            int to=g[i].to;
            dd[to]--;
            if(!dd[to]) q2.push(to),idx++;
        }
        
    }
    return idx==n;
}

string ss[N];

int doit(int x){
    string sss=ss[x];
    if(sss=="NOT") {return (in[x][0]^1);}
    else if(sss=="AND"){
        int res=1;
        for(int i=0;i<in[x].size();i++) res=(res&in[x][i]);
        return res;
    }
    else if(sss=="NAND"){
        int res=1;
        for(int i=0;i<in[x].size();i++) res=(res&in[x][i]);
        return (res^1);
    }
    else if(sss=="OR"){
        int res=0;
        for(int i=0;i<in[x].size();i++) res=(res|in[x][i]);
        return res;
    }
    else if(sss=="XOR"){
        int res=0;
        for(int i=0;i<in[x].size();i++) res=(res^in[x][i]);
        return res;
    }
    else if(sss=="NOR"){
        int res=0;
        for(int i=0;i<in[x].size();i++) res=(res|in[x][i]);
        return (res^1);
    }
    else cout<<"wdnmd"<<endl;
}

void topo2(int x){
    queue<int>q2;
    for(int i=1;i<=m;i++) ans[i]=q[x].v[i-1], q2.push(i);
    for(int i=m+1;i<=m+n;i++) in[i].clear();
    while(!q2.empty()){
        int u=q2.front();
        q2.pop();
        for(int i=head[u];i;i=g[i].nxt){
            int to=g[i].to;
            in[to].push_back(ans[u]);
            if(in[to].size()==d[to]){
                ans[to]=doit(to);
                q2.push(to);
            }
        }
    }
}

int main(){
    int T=read();
    while(T--){
        init();
        m=read();n=read();
   //     cout<<"done"<<endl;
        string s;
        for(int i=1;i<=n;i++){
            cin>>ss[i+m]>>k;
     //   cout<<"done2"<<endl;
            d[i+m]=k;
            for(int j=0;j<k;j++){
                cin>>s;
                int x=toint(s);
                if(s[0]=='I') add(x,i+m);
                else add(x+m,i+m);
            }
        }
        int S=read();
        for(int i=0;i<S;i++){
            q[i].v.resize(m);
            for(int j=0;j<m;j++)  q[i].v[j]=read();
        }

        for(int i=0;i<S;i++){
            k=read();
            q[i].v2.resize(k);
            for(int j=0;j<k;j++)  q[i].v2[j]=read();
        }
        if(!topo1()){
            cout<<"LOOP"<<endl;
        }
        else{
            for(int i=0;i<S;i++){
                topo2(i);
                for(int j=0;j<q[i].v2.size();j++){
                    cout<<ans[q[i].v2[j]+m];
                    if(j!=q[i].v2.size()-1) cout<<" ";
                    else cout<<endl;
                }
            }
        }

    }
    return 0;
}

9月CCF-CSP游记与杂感

✇Lu Shuyu
作者 lushuyu
2021年9月20日 00:06

今日去了计院里面参加了CCF-CSP考试，最后得分220/500，只能算一般般吧，在各路大佬里面算是矮了一截。

在打比赛的时候我就很明显地感觉到，一年多没有碰过算法竞赛的我，在重新面对一道道题时有多么吃力。T2的做法其实很容易想到，但是我却在写代码和调试上面花费了大量的时间。T3模拟题做了3h一分未得，先是快读出问题，后是莫名其妙wa，以至于我T4T5没有时间去做了。T4只写了个20pts的暴力，事实上正确做法就是个普通的状压dp，唉，一年多没写了，基本上都丢了。

不过比较好的消息是，参加本次竞赛有学分可拿，某些课程可以申请免修。但我仍然不满足于此啊，OI生涯已经给我留下了很大的遗憾，不能再次放弃机会了，12月的CCF-CSP我还要来！

我心里很明白，我大概率又要走上算法竞赛这一条路了。大学还有四年，未来的路还很长，一定要好好把握。我很努力地看清自己的位置，很认真地远视前方漫长的道路。我知道，我要开始了，从现在，到遥远的未来。

光荣啊！远视未来的人！

AcWing 3412. 邻域均值

✇Lu Shuyu
作者 lushuyu
2021年9月4日 22:35

直接暴力前缀和

#include<bits/stdc++.h>
using namespace std;

inline int read(){
	int x=0,f=1;
	char ch=getchar();
	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;
}

const int N=600+5;

int a[N][N],s[N][N];

int n,L,r,t;
int ans;

bool check(int x,int y){
    long long tmp=1ll*s[min(n,x+r)][min(n,y+r)]+1ll*s[max(0,x-r-1)][max(0,y-r-1)]-1ll*s[max(0,x-r-1)][min(n,y+r)]-1ll*s[min(n,x+r)][max(0,y-r-1)];
//    cerr<<tmp<<"<tmp"<<endl;
    int num=(min(n,x+r)-max(0,x-r-1))*(min(n,y+r)-max(0,y-r-1));
    double qaq=1.0*tmp/num;
 //   cerr<<qaq<<"<qaq"<<endl;
    return qaq<=1.0*t;
}

int main(){
    n=read();L=read();r=read();t=read();
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++){
            a[i][j]=read();
            s[i][j]+=a[i][j];
            s[i][j]+=s[i][j-1];
            s[i][j]+=s[i-1][j];
            s[i][j]-=s[i-1][j-1];
        }
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(check(i,j)) ans++;
    cout<<ans<<endl;
}
❌
❌