致——世界上最幸福的女孩——Chtholly

最新推荐文章于 2022-06-20 14:42:24 发布

lwlcagei

最新推荐文章于 2022-06-20 14:42:24 发布

阅读量7.8k

点赞数 5

分类专栏：最爱

本文链接：https://blog.csdn.net/lwlcagei/article/details/78321976

版权

最爱专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Chtholly がんばれ

珂朵莉くとり，がんばれ
Are you going to Scarborough Fair?
Parsley, sage, rosemary, and thyme.
Remember me to one who lives there,
这里写图片描述
She once was the true love of mine.
Tell her to make me a cambric shirt.
Parsley, sage, rosemary, and thyme.
Without no seams nor needlework.
Then she’ll be a true love of mine.
Tell her to find me an acre of land.
Parsley, sage, rosemary, and thyme.

Between the salt water and the sea strand.
Then she’ll be a true love of mine.
Tell her to reap it in a sickle of leather.
Parsley, sage, rosemary, and thyme.
And gather it all in a bunch of heather.
Then she’ll be a true love of mine.
这里写图片描述
Are you going to Scarborough Fair?
Parsley, sage, rosemary, and thyme.
Remember me to one who lives there,
She once was the true love of mine.*

在人类世界毁灭之后的“末日。
500年前，人类制造出的<17兽>失控，将人类毁灭，其他大多种族在“大贤者”的帮助下逃到了浮空岛上。
而在人类制造出灾祸之前，曾有“天灾”和“星神”出现，以毁灭人类为代价保护这片土地，却被人类的勇者阻止，而纵使拥有如此强大的战力，却在兽出现后无能无力，几天后便惨遭灭亡。
500年后，浮空岛上的居民已经有了一定的自卫能力，同时向地面进发，寻找资源，同时发现了之前与星神战役中存活了最后一个人类，准勇者威廉·克梅修（在讨伐“天灾”黑烛公的战役中遭到禁咒反噬石化而存活）
这里写图片描述
在接受任务时受好友推荐进入妖精仓库担任军方管理员，邂逅了珂朵莉和妖精一族。

威廉，500年后不再有家人，甚至是相同的人类，一个人想着曾经的生活，还记得女儿曾对他说过：一定要回来啊！500年后，自己终于归来，迎接他的人却早已不在。
珂朵莉，由星神艾露可的灵魂创造，在他人看来，她出现的意义就是为了保护浮空岛，而自己坚信这一点，对死亡没有一丝恐惧。纵使如此，在她坦然说出：如果四天后我就会死。这句话后，仍然希望能被威廉记住。
威廉，或许因为这份孤独，才让他更快融入妖精集体当中，让他为这个种族付出自己的一切，让他能在最后说出那句话：开什么玩笑，至少，一定要救下这家伙。
珂朵莉，抱歉，我已经没有办法获得幸福了，因为我已经注意到了，我已经早就被幸福包围了。
这里写图片描述

珂朵莉：

我曾发誓要一直和他在一起

可以这样发誓让我无比幸福

我曾经觉得自己非常喜欢这个人

可以有这样的感受让我很幸福

他曾经对我说我一定会让你幸福

能听到他这样说让我很幸福

从他那里得到这么多的幸福

所以现在的我一定

不管别人如何说

一定是这个世界上最幸福的女孩**
这里写图片描述

这里写图片描述

浮游大陆的68号岛

一道使学傻了的人觉醒的好题（比如我）
一看区间查询就想到线段树，于是我就想分块去做
再看查询方式，预处理就超时了，于是最初一脸不可做的弃掉了这个题
之后想做一些有关让自己感动过的番，漫画，或者小说专题的东西。
于是又开始填这个坑，不过很遗憾，现在还要再留一个T3的坑
因为实在是不会，只能先随便扒一个代码扔上来了

因为在一条线段上，所以我们可以先想到处理一个距离的前缀和dis[i]
查询的要求是一段区间移到一个点上
于是我们只要知道每个点的物品重量和距目标点的距离，就能求出
但显然，100%的数据会超时
我们再处理一个重量的前缀和w[i]
这样再处理出到每一个点为止，前面所有物品移到0点的消耗cost[i]
查询时，如果目标点在区间的左边
我们用到右端点的总消耗 - 左端点消耗 cost[r] - cost[l]这样是区间点全部移到
0点的消耗，只要再减去多移的一部分就好了，
区间重量减去多移的距离（w[r] - w[l]）* dis[goal]
但我想不出怎么只用cost来求位于区间右边的情况
于是又开一个last反向处理一个cost，这样用last代替cost同样道理处理区间右边的点
位于中间，就可以看做左区间和右区间来相同处理了
唯一注意的一点就是不要把目标点处理两遍
！！！！最想说的就是，别忘了%，减了就要%，反正错不了

#include<iostream>
#include<cstdio>
#define ll long long
using namespace std;
const ll mod = 19260817;
const int maxn = 200000 + 50 ;
ll dis[maxn],w[maxn],cost[maxn],last[maxn];//前缀和的那些
ll n,m;
ll x;
long long ask(ll goal , ll l ,ll r){
    long long ans = 0;
    if(goal < l)
        ans = ((cost[r] - cost[l-1] + mod)%mod - ((w[r] - w[l-1]+mod)%mod * dis[goal]+mod)%mod+mod)%mod;
    else if(goal > r)
        ans = ((last[l] - last[r+1] + mod)%mod - (w[r] - w[l-1] + mod)%mod * (dis[n] - dis[goal] + mod)%mod+mod)%mod;
    else{
        ans += ((cost[r] - cost[goal-1] + mod)%mod - (w[r] - w[goal-1]+mod)%mod * dis[goal]+mod)%mod;
        ans += ((last[l] - last[goal] + mod)%mod - (w[goal-1] - w[l-1]+mod)%mod * (dis[n] - dis[goal]+mod)%mod+mod)%mod;
    }
    return (ans + mod)%mod;
}
int main(){
    scanf("%lld%lld",&n,&m);ll l, r;
    for(ll i = 2 ; i <= n ; i ++){
        scanf("%lld",&x);//long long ， scanf读入别忘了lld
        x %= mod;
        dis[i] = (dis[i-1] + x)%mod;
    }
    for(ll i = 1 ; i <= n ; i ++){
        scanf("%lld",&x);
        x %= mod;
        w[i] = (w[i-1] + x)%mod;
        cost[i] = (cost[i-1] + x * dis[i])%mod;
    }
    for(ll i = n - 1 ; i > 0 ; i --)
        last[i] = (last[i+1] + (w[i] - w[i-1]+mod)%mod * (dis[n] - dis[i] + mod)%mod)%mod;
    for(int i = 1 ; i <= m ; i ++){
        scanf("%lld%lld%lld",&x,&l,&r);
        printf("%lld\n",ask(x,l,r));
    }
    return 0;
}

Chtholly Nota Seniorious

当时认为唯一可做的题
读题就可以看出是一个二分（较大的最小值），起码现阶段是这样
二分答案（最小极差）因为有了不能转两次弯的限制，所以相对好做了（或许吧）
从第一个点开始，一个点一个点的跑，维护一个最大值maxn，一个最小值minn
如果当前的点加入不会使极差超过当前的答案，标记这个点done[i]
否则停下，将当前点的列数标记limit，下面每一行不能超过这个限制
遍历完后，处理未标记的点的最大值和最小值，求极差
大于答案 l = mid + 1 ，否则 r = mid。
但有情况会出错
例如
5 5
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
5 5 1 1 1
5 5 5 5 5
5 5
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 5 5 5
5 5 5 5 5
这样的话，limit会受到影响而导致后面可以连成块的点并不会跑
较为简单的处理方法就是复制一个镜像的图，这样检测两个图，就可以解决

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn = 2000 + 50;
int a[maxn][maxn],b[maxn][maxn],n,m;
bool done[maxn][maxn];
bool check(int mid){
    memset(done,0,sizeof(done));
    int limit = m + 1;
    int maxn = a[1][1] , minn = a[1][1];
    for(int i = 1 ;  i <= n ; i ++)
        for(int j = 1 ; j < limit ; j ++){
            if(maxn - a[i][j] > mid || a[i][j] - minn > mid){
                limit = j;
            }
            else{
                if(a[i][j] > maxn)maxn = a[i][j];
                if(a[i][j] < minn)minn = a[i][j];
                done[i][j] = 1;
            }
        }
    maxn = 0 , minn = 1e9;
    for(int i = 1 ; i <= n ; i ++){
        for(int j = 1 ; j <= m ; j ++){
            if(!done[i][j]){
                if(a[i][j] > maxn) maxn = a[i][j];
                if(a[i][j] < minn) minn = a[i][j];
                if(maxn - minn > mid)return false;
            }
        }   
    }
    return true;
}
bool check_t(int mid){
    memset(done,0,sizeof(done));
    int limit = m + 1;
    int maxn = b[1][1] , minn = b[1][1];
    for(int i = 1 ;  i <= n ; i ++)
        for(int j = 1 ; j < limit ; j ++){
            if(maxn - b[i][j] > mid || b[i][j] - minn > mid){
                limit = j;
            }
            else{
                if(b[i][j] > maxn)maxn = b[i][j];
                if(b[i][j] < minn)minn = b[i][j];
                done[i][j] = 1;
            }
        }
    maxn = 0 , minn = 1e9;
    for(int i = 1 ; i <= n ; i ++){
        for(int j = 1 ; j <= m ; j ++){
            if(!done[i][j]){
                if(b[i][j] > maxn) maxn = b[i][j];
                if(b[i][j] < minn) minn = b[i][j];
                if(maxn - minn > mid)return false;
            }
        }   
    }
    return true;
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i = 1 ; i <= n ; i ++){
        for(int j = 1 ; j <= m ; j ++){
            scanf("%d",&a[i][j]);
            b[i][m-j+1] = a[i][j];//复制镜像，左右对称即可
        }
    }
    int l = 0 , r = 1e9;
    while(l < r){
        int mid = (l + r)>>1;
        if(check(mid)||check_t(mid))
            r = mid;
        else l = mid + 1;
    }
    printf("%d",l);
}

T3之前我们先贴一个其他的东西

神奇的欧拉函数

这东西是真的强，顺便证明一下费马小定理
这里写图片描述
n 和 a 是正整数，同时互质
将1~n中与n互质的数按顺序排布：x1,x2……xφ(n) （显然，共有φ(n)个数）
（φ(n)）是从1到n为止，与n互质的数的个数
考虑这些：
m1=a*x1;m2=a*x2;m3=a*x3……mφ(n)=a*xφ(n)
因为a与n互质，x与n互质，所以m1……mn中任何两个数都不可能%n同余
其次，所有m/n后重新排列，同余于x1,x2,x3，由上一点可知
也可以手推几组数据（%n不同余，同时n-1个）
这样m1*m2*m3……mφ(n)≡x1*x2*x3……xφ(n) (mod n)
再这样a^[φ(n)]*(x1*x2*x3……xφ(n))≡x1*x2*x3……xφ(n)
K{a^[φ(n)]-1}≡0 ( mod n ) 这里K=x1*x2*x3……xφ(n)。
可知K{a^[φ(n)]-1}被n整除。但K中的因子x1,x2……都与n互质，所以K与n互质。那么a^[φ(n)]-1必须能被n整除，即a^[φ(n)]-1≡0 （mod n），即a^[φ(n)]≡1 （mod n）
费马小定理：
a是不能被质数p整除的正整数，则有a^(p-1) ≡ 1 (mod p)
p是质数，所以φ(p) = p-1，代入欧拉定理。推论：对于任意正整数a，有a^p-1 ≡ 1 (mod p)，因为a能被p整除时结论显然成立。

#include<iostream>
#include<cstdio>
using namespace std;
int s;
int eulur(int n){
    int res = n, a = n;
    for(int i = 2 ; i*i <= a ; i ++){
        if(a % i == 0){
            res = res/i*(i-1);
            while(a%i == 0)
                a/=i;
        }
    }
    if(a > 1)res = res / a * (a - 1);
    return res;
}
int main(){
    scanf("%d",&s);
    printf("%d",eulur(s));
}

毕竟是珂朵莉的应援，T3奈芙莲就放到下一个吧

太陽の傾いたこの世界で -broken chronograph-
空の上の森の中の -late autumn night’s dream-
この戦いが終わったら -starry road to tomorrow-
帰らぬ者と、待ち続けた者たち -dice in pot-
誰も彼もが、正義の名のもとに -from dawn till dusk-
消えない過去、消えていく未来 -no news was good news-
ただいま帰りました -home, sweet home-
いずれその陽は落ちるとしても -slight light, slight hope-
たとえ未来が見えなくても -moonlit sorcery-
いまこの時の輝きを -my happiness-
どうか、忘れないで -evidence of existence-
世界で一番幸せな女の子 -CHTHOLLY-
这里写图片描述