武装直升机

Undead2008 · 2024-03-05 12:51:23 · 个人记录

殴打鸡蛋壳

对代码做了微调，可以支持本地测试\ 提交到平台上时请删除第一行的 define 语句

#define LocalTest 
namespace fastio {
    const int MAXBUF=1<<23;
    char buf[MAXBUF],*p1=buf,*p2=buf;
    char pbuf[MAXBUF],*pp=pbuf;
    inline char getc(){return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,MAXBUF,stdin),p1==p2)?EOF:*p1++;}
    inline void putc(char c){(pp==pbuf+MAXBUF)&&(fwrite(pbuf,1,MAXBUF,stdout),pp=pbuf),*pp++=c;}
    inline void print_final(){fwrite(pbuf,1,pp-pbuf,stdout),pp=pbuf;}
}
#ifndef LocalTest
    using fastio::getc;
    using fastio::putc;
    using fastio::print_final;
#else
    #define getc getchar
    #define putc putchar
    void print_final(){}
#endif
template <class _Tp>inline _Tp& read(_Tp& x){
    bool sign=0;
    char ch=getc();
    for(;!isdigit(ch);ch=getc())sign|=(ch=='-');
    for(x=0;isdigit(ch);ch=getc())x=x*10+(ch^48);
    return sign?(x=-x):x;
}
template <class _Tp>inline void write(_Tp x){
    if(x<0)putc('-'),x=-x;
    if(x>9)write(x/10);
    putc((x%10)^48);
}
template <typename _Tp,typename ...Args>inline void write(_Tp x,Args ...args){
    write(x),putc(' '),write(args...);
}
template<typename _Tp,typename ...Args>inline bool read(_Tp& x,Args& ...args) {
    return read(x)&&read(args...);
}
inline bool Vl(char x){return 33<=x&&x<=126;}
inline void reads(char* it){
    while(!Vl(*it=getc()));
    while(Vl(*it))it++,*it=getc();
    *it='\0';
}
inline void writes(char* it){
    while(*it!='\0')putc(*it),it++;
    putc('\n');
}

爆改矿务局

#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")

砍伐冷冻库

#pragma GCC optimize("Ofast,no-stack-protector,fast-math",2,3)
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2")

摩擦妙脆角

mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int Rd(int l,int r){return rnd()%(r-l+1)+l;}
char Rc(int l,int r){return rnd()%(r-l+1)+l;}

#include <cstdint>

class RNG {
private:
    uint64_t state;

    static uint64_t splitmix64(uint64_t &x) {
        uint64_t z = (x += 0x9e3779b97f4a7c15);
        z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
        z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
        return z ^ (z >> 31);
    }

public:
    explicit RNG(uint64_t seed = 0xdeadbeef12345678) : state(seed) {}

    // 返回下一个随机的 uint64_t
    uint64_t next() {
        return splitmix64(state);
    }

    // 返回一个在 [low, high] 范围内的随机数
    uint64_t next(uint64_t low, uint64_t high) {
        return low + next() % (high - low + 1);
    }
};

#include <iostream>

int main() {
    RNG rng(20240522); // 用固定种子初始化

    for (int i = 0; i < 10; ++i) {
        std::cout << rng.next(1, 100) << "\n"; // 打印 1~100 之间的随机数
    }

    return 0;
}

浓缩螺丝孔

功能：还原对大质数取模的分数，分子分母 \le \sqrt{2\times \rm mo} 有唯一解，\rm mo 为模数。

详情可见 EI 博客。

double Rec(int X,int Lim=2e4){
    int x=X,y=mo,a=1,b=0;
    while(x>Lim){
        swap(x,y),swap(a,b);
        a-=x/y*b,x%=y;
    }
    return 1.0*x/a;
}

破坏数据袋

struct Barrett{
    long long m,p;
    void init(int pp){m=((__int128)1<<64)/pp;p=pp;}
    long long operator ()(long long x){
        return x-((__int128(x)*m)>>64)*p;
    }
}Ba;

记住输出前要手动取模确保正确性！

枪毙脑神经

v.erase(v.unique(v.begin(),v.end()),v.end());

揭发平顶山

#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/hash_policy.hpp>
#include<ext/pb_ds/trie_policy.hpp>
#include<ext/pb_ds/priority_queue.hpp>
using namespace __gnu_pbds;

tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>Tr;

盘问髋关节

template<int Ln=1>
void solve(int n){
    if(n>Ln)return solve<Ln*2>(n);
    //solution using bitset<Ln>
}

打倒明信片

Can't compile file:
In file included from C:/Programs/gcc13-64-winlibs/include/c++/13.2.0/x86_64-w64-mingw32/bits/extc++.h:83,
                 from program.cpp:1:
C:/Programs/gcc13-64-winlibs/include/c++/13.2.0/ext/codecvt_specializations.h:42:10: fatal error: iconv.h: No such file or directory
   42 | #include <iconv.h>
      |          ^~~~~~~~~
compilation terminated.

#undef _GLIBCXX_HAVE_ICONV
#include "bits/extc++.h"
using namespace __gnu_pbds;

进口破网络

import sys
sys.set_int_max_str_digits(500000)
n=int(input())
print(n*n)

误解迷彩裤

const int mo = 998244353;
const int g = 3;
const int Ig = 332748118;
inline int Ksm(int b,int t){
    int r=1;
    while(t){
        if(t&1)r=1ll*r*b%mo;
        b=1ll*b*b%mo,t>>=1;
    }
    return r;
}
inline int Inv(const int& x){return Ksm(x,mo-2);}
struct Poly{
    int Ln,Lg,Ln_;
    vector<int>v,rev;
    Poly(){Ln=Lg=Ln_=0,v.clear(),rev.clear();}
    inline int size(){return v.size();}
    inline void Up(int x){Ln=1,Lg=0;while(Ln<x)Ln<<=1,Lg++;}
    inline void Resize(int x){Ln_=max(Ln_,x),Up(Ln_);v.resize(Ln),rev.resize(Ln);}
    inline void Read(int x){for(int i=0;i<=x;i++)cin>>v[i];}
    inline void Write(int x){for(int i=0;i<=x;i++)cout<<v[i]<<' ';}
    inline void NTT(int I,int LN){
        int LG=__lg(LN);
        for(int i=0;i<LN;i++)
            rev[i]=(rev[i>>1]>>1)|((i&1)<<(LG-1));
        for(int i=0;i<LN;i++)if(i<rev[i])swap(v[i],v[rev[i]]);
        for(int L=2;L<=LN;L<<=1){
            int gM=Ksm((I==1?g:Ig),(mo-1)/L);
            for(int l=0;l+L-1<LN;l+=L){
                int r=l+L-1,M=(l+r)>>1,hL=L>>1;
                for(int i=l,G=1;i<=M;i++,G=1ll*G*gM%mo){
                    int x=v[i],y=1ll*G*v[i+hL]%mo;
                    v[i]=(x+y)%mo,v[i+hL]=(x-y+mo)%mo;
                }
            }
        }
        if(I==-1)
            for(int i=0,I=Inv(LN);i<LN;i++)
                v[i]=1ll*v[i]*I%mo;
    }
    inline void dMul(const Poly &y){
        for(int i=0;i<Ln;i++)
            v[i]=1ll*v[i]*y.v[i]%mo;
    }
    inline void Mul(Poly y){
        int Lt=Ln_+y.Ln_+1;
        Resize(Lt),y.Resize(Lt);
        NTT(1,Ln),y.NTT(1,y.Ln),dMul(y),NTT(-1,Ln);
    }
    inline Poly Invr(int N){
        Poly R,Th;
        R.Resize(0),R.v[0]=Inv(v[0]);
        for(int k=2,K=4;k<N*2;k=K,K<<=1){
            Th.Resize(K),Resize(k);
            for(int i=0;i<k;i++)Th.v[i]=v[i];
            Poly Nw=R;
            Nw.Resize(k),R.Resize(K);
            Th.NTT(1,K),R.NTT(1,K);
            for(int i=0;i<K;i++)
                R.v[i]=(1ll*R.v[i]*R.v[i]%mo)*Th.v[i]%mo;
            R.NTT(-1,K);
            for(int i=0;i<k;i++)
                Nw.v[i]=(2ll*Nw.v[i]-R.v[i]+mo)%mo;
            R=Nw;
        }
        for(int i=N;i<R.v.size();i++)R.v[i]=0;
        return R;
    }
    inline Poly Direv(){
        Poly X=*this;
        for(int i=0;i+1<X.v.size();i++)
            X.v[i]=1ll*(i+1)*v[i+1]%mo;
        X.v[Ln-1]=0;
        return X;
    }
    inline Poly Inter(){
        Poly X=*this;
        for(int i=1;i<X.v.size();i++)
            X.v[i]=1ll*v[i-1]*Inv(i)%mo;
        X.v[0]=0;
        return X;
    }
    inline Poly Lyn(int N){
        Poly A=Direv(),B=Invr(N);
        A.Mul(B);
        return A.Inter();
    }
    inline Poly Exp(int N){
        Poly R,Th;
        R.Resize(0),R.v[0]=1;
        for(int k=2,K=4;k<N*2;k=K,K<<=1){
            Th.Resize(K),R.Resize(K),Resize(k);
            Poly Ly=R.Lyn(k);
            for(int i=0;i<k;i++)Th.v[i]=(mo-Ly.v[i]+v[i])%mo;
            Th.v[0]=(Th.v[0]+1)%mo;
            Th.NTT(1,K),R.NTT(1,K);
            for(int i=0;i<K;i++)Th.v[i]=1ll*Th.v[i]*R.v[i]%mo;
            Th.NTT(-1,K);
            R=Th;
        }
        for(int i=N;i<R.v.size();i++)R.v[i]=0;
        return R;
    }
};