Oier 一生最重要的是什么？

在这个世界上，每一个人都会遇到一些不顺心的事，或大或小。但每一次面对这些事时，我们都应该做到心中有数，千万不能让自己陷入困境。

生活，就像一面镜子，你对它哭，它也会对你哭；你对它笑，它也会对你笑。

所以说，人生没有过不去的坎。

每一个人都应该明白，不管遇到什么事都要有一颗平常心。

俗话说，人生不如意事十之八九。

人这一生，每个人都不可能一帆风顺。而生活中，总有一些人在面对困境时，失去了应有的快乐和幸福。

在遇到事情时，我们要学会用一颗平常心去看待得失成败，不因一时的得失而气馁，不因一时的失败而悲伤。

那么，人这一生，最重要的是什么呢？其实，不外乎以下这四样！

看淡得失，知足常乐

人这一生，你有什么东西，是该得到的，就应该牢牢抓住，千万不能让它从你手中溜走。

就像《诗经》中说的：“既见君子，云胡不喜。”

意思是说，见到一个人后，见到他有什么好东西，就喜欢得不得了。但生活中有很多人却不明白这个道理。

在这个世界上，有些东西是我们不能强求的。

比如，爱情和亲情，这是上天注定的。

你不能改变它，也改变不了它，所以我们只需要顺其自然就好。

人活着，最重要的是开心自在，只有自己内心快乐了，生活才会变得更加美好。

学会放下，不念过往

不念过往，不惧未来。

人生就是这样，没有一帆风顺的事。每一件事，都会教会我们一些道理。曾经的过去，就让它过去吧！

现在是当下，我们只有把握现在才是最重要的。

有一句话说：“过去的事，就让它过去吧！”

这句话告诉我们的道理是什么？过去的事已经无法改变，不管它多么的令人伤心、愤怒，你也不必再去回忆。

每一天都要往前看，别让昨天的事影响了今天。

活好当下，珍惜眼前

生命，是我们一生中最宝贵的东西。因为生命只有一次，失去了就不会再来。

所以，我们应该珍惜生命，在这短暂而又美好的岁月里，去做一些有意义的事。

别总是等到失去了才知道后悔，人生就像一杯没有加糖的咖啡，喝起来是苦涩的，回味起来却有久久不会退去的余香。

有人说：“岁月，是一本太仓促的书。”

在岁月里，我们每个人都是过客，来来往往中，谁也不知道自己会在哪一站下车。

但人生，又有多少人可以做到不留遗憾呢？

其实，不管我们曾有过怎样的遗憾和错过，都要学会珍惜眼前，把握现在。

因为活好当下，才是对自己最好的负责。

人这一生总会遇到一些事，总会失去一些东西，重要的是我们要学会放下和忘记。

这一生，我们只要做最好的自己就足够了，不要再去纠结太多了，要相信自己。

拥有一个良好的码风

在这个世界上，每个人都有自己的码风，但他们要做的就是让自己能看懂且别人看不懂。

不管遇到什么事，都要保持好的码风，就算遇到签到题也要不慌不乱地码完缺省源。

正如【数据删除】所说：“码风简单了，调题就简单了，AK也就简单了。”

人这一生，最重要的是什么？

其实，并没有太多的东西，我们要学会拥有好码风，遇事不慌，才能让自己切得更开心。

在日常生活中，每个人都会遇到微小的错误。有的人被繁琐的 debug 打趴下了，有的人则越挫越勇，把调试当作人生的磨砺，最终取得成功。

我们在生活中，遇到的每一件事情，都是上天在教你如何成长，唯有保持好的心态，遇事不慌才能笑到最后。

有句话说得好：“一个 Oier 的码风决定着他一生的命运。”

良好的码风应满足以下几点：

不用万能头

#pragma GCC optimize(3)
#pragma GCC target("avx,sse2,sse3,sse4,mmx")
#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")
#include <assert.h>　　　　
#include <ctype.h>　　　　 
#include <errno.h>　　　
#include <float.h>　　
#include <iso646.h>   
#include <limits.h>　
#include <locale.h>　
#include <math.h>　
#include <setjmp.h>  
#include <signal.h>        
#include <stdarg.h>      
#include <stddef.h>       
#include <stdio.h>　　　
#include <stdlib.h>　
#include <string.h>
#include <time.h>
#include <wchar.h>　　
#include <wctype.h>
#include <fstream.h>　
#include <iomanip.h>　
#include <iostream.h>
#include <strstrea.h>
#include <algorithm>
#include <bitset>
#include <cctype>  
#include <cerrno> 
#include <cfloat>　
#include <ciso646>    
#include <climits>
#include <clocale>
#include <cmath>
#include <complex>　
#include <csignal> 
#include <csetjmp> 
#include <cstdarg> 
#include <cstddef>
#include <cstdio> 
#include <cstdlib> 
#include <cstring> 
#include <ctime>
#include <cwchar>
#include <cwctype> 　　　　
#include <deque>
#include <exception>　　　 
#include <fstream>
#include <functional>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include<new>
#include <numeric>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream> 
#include <istream>　　　　 
#include <iterator>
#include <ostream>　　　　 
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>　　　 
#include <streambuf>
#include <string>　　　　　
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;

每行代码之间都要空一行

#include<bits/stdc++.h>

using namespace std;

#define rint register int 

#define int long long

#define I_WANT_TLE ios::sync_with_stdio(0),cout.tie(0),cin.tie(0) 

#define N 10010

int low[N],dfn[N],ins[N],a[N],b[N];int gd[N];

int n,m,cnt;

struct HS_xh

{

    int to,next;

}e[N];int head[N];

inline void add(int x,int y)

{

    cnt++;

    e[cnt].to=y;

    e[cnt].next=head[x];

    head[x]=cnt;

    cnt++;

    e[cnt].to=x;

    e[cnt].next=head[y];

    head[y]=cnt;

}int tot=0;

inline void clear()

{

    tot=0;m=0;

    memset(low,0,sizeof(low));

    memset(dfn,0,sizeof(dfn));memset(ins,0,sizeof ins);

    memset(a,0,sizeof(a));memset(gd,0,sizeof gd);

    memset(b,0,sizeof(b));memset(e,0,sizeof(e));

    cnt=0;memset(head,0,sizeof head);

}

void Tarjan(int x,int fa)

{

    int son=0;

    dfn[x]=low[x]=++tot;

    for(rint i=head[x];i;i=e[i].next)

    {

        int y=e[i].to;

        if(!dfn[y]) 

        {

            son++;

            Tarjan(y,x);

            low[x]=min(low[x],low[y]);

            if(low[y]>=dfn[x])

            {

                gd[x]=1;

            }

        }

        else if(y!=fa)

        {

            low[x]=min(low[x],dfn[y]);

        }

    }

    if(son<2&&fa==0)gd[x]=0;

}

int group,num,cut;

void dfs(int x)

{

    num++;ins[x]=group;

    for(rint i=head[x];i;i=e[i].next)

    {

        int y=e[i].to;

        if(ins[y]!=group&&gd[y]==1)

        {

            cut++;ins[y]=group;

        }

        else if(!ins[y])dfs(y);

    }

}

signed main()

{

    n=-114514;int stl=0;

    while(1)

    { 



        stl++;

        cin>>n;if(n==0)break;

        for(rint i=1;i<=n;++i)

        {

            cin>>a[i]>>b[i];

            add(a[i],b[i]);

            m=max(a[i],max(b[i],m));

        }

        for(rint i=1;i<=m;++i)

        {

            if(!dfn[i])Tarjan(i,0);

        }

        int tot1=0,tot2=1;group=0;

        for(rint i=1;i<=m;++i)

        {

            if(!ins[i]&&!gd[i])

            {

                group++;

                num=0,cut=0;

                dfs(i);

                if(cut==1)

                {

                    tot1+=1;

                    tot2*=num;

                }

                if(cut==0)

                {

                    tot1+=2;

                    tot2*=((num-1)*num/2);

                }

            }

        }

        cout<<"Case "<<stl<<": "<<tot1<<' '<<tot2<<'\n';clear();

    }

}

从不删除调试

#include<bits/stdc++.h>
using namespace std;
char s[100010],us[100010];
int f[20],l1,l2,l3,size;
unsigned long long h[100010],p[20],power[100010];
long long n,point;
bool ansout=0;
//signed main()
//  cout<<ansout;
queue <int> q;
void pre(char* x)
{
    l2=strlen(x+1);
    //cout<<l2;
    h[0]=0;
    for(int i=1;i<=l2;i++)
        h[i]=h[i-1]*(unsigned long long)131+(unsigned long long)x[i]-(unsigned long long)'a'+(unsigned long long)1;
        //cout<<h[i];
}
unsigned long long find(int st,int ed)
{
    return h[ed]-h[st]*power[ed-st];
    //cout<<h[ed]-h[st]*power[ed-st];
}
int main()
{
    //freopen("1.in","r",stdin);
    //freopen("1.out","w",stdout);
    scanf("%s",s+1);
    scanf("%lld",&n);
    l1=strlen(s+1);
    f[0]=1;
    for(int i=1;i<=l1;i++)
    {
        if(s[i]=='*'||s[i]=='?')
        {
            size++;
            f[size]=i;
        }
        else
        {
            p[size]=(unsigned long long)131*p[size]+(unsigned long long)s[i]-(unsigned long long)'a'+(unsigned long long)1;
            //cout<<i<<endl;
        }
    }
    power[0]=1;
    for(int i=1;i<=l1;i++)
        power[i]=power[i-1]*131;
        //cout<<power[i];
    for(int z=1;z<=n;z++)
    {
        ansout=false;
        scanf("%s",us+1);
        l3=strlen(us+1);
        pre(us);
        q.push(0);
        //cout<<0;
        if(f[0]!=f[1])
        {
            if(p[0]!=find(0,f[1]-1))
            {
                ansout=true;
                //cout<<ansout;
                printf( "NO\n" ) ; 
                continue ; 
            }
            q.pop();
            q.push(f[1]-1);
            //cout<<f[1]-1;
        }
        f[size+1]=l1+1;
        //cout<<f[size+1];
        for(int i=1;i<=size;i++)
        {
            if(q.empty())
            {
                ansout=true;
                printf( "NO\n" );
                break;
            }
            l2=q.size();
            //cout<<l2;
            if(s[f[i]]=='?')
            {
                for(int j=1;j<=l2;j++)
                {
                    //cout<<find(q.front()+1,f[i+1]-1)<<" "<<p[i]<<endl;
                    //cout<<q.front()+1<<" "<<f[i+1]-1<<endl;
                    //cout<<find(22,41)<<" "<<p[1]<<endl;
                    if(q.front()+f[i+1]-f[i]<=l3)
                        if(p[i]==find(q.front()+1,q.front()+f[i+1]-f[i]))
                        {
                            q.push(q.front()+f[i+1]-f[i]);
                            //cout<<q.push(q.front()+f[i+1]-f[i]);
                            //cout<<"Aa";
                        }
                    q.pop();
                    //cout<<q.front();
                }
            }
            else if(s[f[i]]=='*')
            {
                //cout<<i<<endl;
                for(int j=q.front(),k=f[i+1]-1-f[i]+q.front();k<=l3;j++,k++)
                {
                    //cout<<j<<" "<<k<<" "<<find(j,k)<<" "<<p[i]<<endl;
                    if(find(j,k)==p[i])
                        q.push(k);
                        //cout<<q.push(k);
                }
                for(int j=1;j<=l2;j++)
                    q.pop();
                    //cout<<q.front();
            }
            /*for(int i=1;i<=q.size();i++)
            {
                q.push(q.front());
                cout<<q.front()<<" ";
                q.pop();
            }
            cout<<'\n';*/
        }
        
        while(!q.empty())
        {
            if(q.front()==l3)
            {
                //cout<<'YES';
                printf("YES\n");
                ansout=true;
                //cout<<ansout;
            }
            q.pop();
            //cout<<q.front();
        }
        if(ansout==false)
            //cout<<ansout;
            printf( "NO\n" );
            //cout<<'NO';
    }
    return 0;
    //cout<<0;
}

常用 define，以及使用大写字母代替小写字母，常年开着 CapsLock.

#include<bits/stdc++.h>
#define INT int
#define SIGNED signed
#define MAIN main
#define USING using
#define LONG long
#define NAMESPACE namespace
#define STRUCT struct
#define STD std
#define CONST const
#define IF if
#define ELSE else
#define RETURN return
#define VOID void
#define INLINE inline
#define FOR for
#define CIN cin
#define COUT cout
#define MID (L+R)>>1
#define LSON L,MID,T[RT].L
#define RSON MID+1,R,T[RT].R
#define LS T[RT].L
#define RS T[RT].R
USING NAMESPACE STD;
NAMESPACE Watarai_Hinami
{
    INLINE VOID CLOSE(){std::ios::sync_with_stdio(false);std::cin.tie(0);std::cout.tie(0);}
    INLINE VOID FIRE(){freopen(".in","r",stdin);freopen(".out","w",stdout);}
}
NAMESPACE Chongyun
{
    INLINE INT READ(){INT s = 0,w = 1;char ch = getchar();while(ch<'0'||ch>'9'){ if(ch == '-') w = -1;ch = getchar();}while(ch>='0'&&ch<='9'){ s = s*10+ch-'0';ch = getchar();}return s*w;}
    INLINE VOID WRITE(INT x){char F[20];INT tmp=x>0?x:-x,cnt=0;;if(x<0)putchar('-') ;while(tmp>0){F[cnt++]=tmp%10+'0';tmp/=10;}while(cnt>0)putchar(F[--cnt]);}
}
USING NAMESPACE Watarai_Hinami;
USING NAMESPACE Chongyun;
CONST INT n=5e5+10;
CONST INT INF=1e9+5;

STRUCT TREE
{
    INT L,R,SUM;
}T[n*32];
INT SZ=1;
INLINE INT FIND(INT L,INT R,INT RT,INT l,INT r)
{
    INT ANS=0;
    IF(L>=l && R<=r)
        RETURN T[RT].SUM;
    IF(MID>=l) ANS+=FIND(LSON,l,r);
    IF(MID<r) ANS+=FIND(RSON,l,r);
    RETURN ANS;
}
INLINE VOID UPDATE(INT L,INT R,INT &RT,INT POS)
{
    IF(!RT) RT=++SZ;
    IF(L==R)
    {
        T[RT].SUM++;
        RETURN;
    }
    IF(MID>=POS) UPDATE(LSON,POS);
    ELSE UPDATE(RSON,POS);
    T[RT].SUM=T[LS].SUM+T[RS].SUM;
}
SIGNED MAIN()
{
    INT N=READ();
    LONG LONG ANS(0);
    INT ROOT=1;
    FOR(INT I=1;I<=N;++I)
    {
        INT X=READ();
        ANS+=FIND(1,INF,1,X+1,INF);
        UPDATE(1,INF,ROOT,X);
    }
    COUT<<ANS;
}

namespace 夹藏私货
```
Code 同4
```

分号在每一行最开头

#include<bits/stdc++.h>
#define INT int
#define SIGNED signed
#define MAIN main
#define USING using
#define LONG long
#define NAMESPACE namespace
#define STRUCT struct
#define STD std
#define CONST const
#define IF if
#define ELSE else
#define RETURN return
#define VOID void
#define INLINE inline
#define FOR for
#define CIN cin
#define COUT cout
#define MID (L+R)>>1
#define LSON L,MID,T[RT].L
#define RSON MID+1,R,T[RT].R
#define LS T[RT].L
#define RS T[RT].R
USING NAMESPACE STD
;
NAMESPACE Watarai_Hinami
{
INLINE VOID CLOSE(){
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);}
INLINE VOID FIRE(){
freopen(".in","r",stdin);
freopen(".out","w",stdout);}}
NAMESPACE Chongyun
{
INLINE INT READ(){
INT s = 0,w = 1
;
char ch = getchar();
while(ch<'0'||ch>'9'){
if(ch == '-') w = -1
;
ch = getchar();}
while(ch>='0'&&ch<='9'){
s = s*10+ch-'0';
ch = getchar();}
return s*w
;}
INLINE VOID WRITE(INT x){char F[20];
INT tmp=x>0?x:-x,cnt=0
;;
if(x<0)putchar('-') ;
while(tmp>0){F[cnt++]=tmp%10+'0';
tmp/=10
;}
while(cnt>0)putchar(F[--cnt]);}}
USING NAMESPACE Watarai_Hinami
;
USING NAMESPACE Chongyun
;
CONST INT n=5e5+10
;
CONST INT INF=1e9+5
;
STRUCT TREE
{
INT L,R,SUM
;}
T[n*32];
INT SZ=1
;
INLINE INT FIND(INT L,INT R,INT RT,INT l,INT r){
INT ANS=0
;
IF(L>=l && R<=r)
RETURN T[RT].SUM
;
IF(MID>=l) ANS+=FIND(LSON,l,r);
IF(MID<r) ANS+=FIND(RSON,l,r);
RETURN ANS
;}
INLINE VOID UPDATE(INT L,INT R,INT &RT,INT POS){
IF(!RT) RT=++SZ
;
IF(L==R){
T[RT].SUM++;
RETURN
;}
IF(MID>=POS) UPDATE(LSON,POS);
ELSE UPDATE(RSON,POS);
T[RT].SUM=T[LS].SUM+T[RS].SUM
;}
SIGNED MAIN(){
INT N=READ();
LONG LONG ANS(0);
INT ROOT=1
;
FOR(INT I=1
;
I<=N
;++I){
INT X=READ();
ANS+=FIND(1,INF,1,X+1,INF);
UPDATE(1,INF,ROOT,X);}
COUT<<ANS
;}

综上所述，正确的码风应是这样的：

点击查看代码


#pragma GCC optimize(3)

#pragma GCC target("avx,sse2,sse3,sse4,mmx")

#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")

#include <assert.h>

#include <ctype.h>

#include <errno.h>

#include <float.h>

#include <iso646.h>   

#include <limits.h>

#include <locale.h>

#include <math.h>

#include <setjmp.h>  

#include <signal.h>        

#include <stdarg.h>      

#include <stddef.h>       

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <wchar.h>

#include <wctype.h>

#include <fstream.h>

#include <iomanip.h>

#include <iostream.h>

#include <strstrea.h>

#include <algorithm>

#include <bitset>

#include <cctype>  

#include <cerrno> 

#include <cfloat>

#include <ciso646>    

#include <climits>

#include <clocale>

#include <cmath>

#include <complex>

#include <csignal> 

#include <csetjmp> 

#include <cstdarg> 

#include <cstddef>

#include <cstdio> 

#include <cstdlib> 

#include <cstring> 

#include <ctime>

#include <cwchar>

#include <cwctype> 

#include <deque>

#include <exception>

#include <fstream>

#include <functional>

#include <limits>

#include <list>

#include <locale>

#include <map>

#include <memory>

#include<new>

#include <numeric>

#include <iomanip>

#include <ios>

#include <iosfwd>

#include <iostream> 

#include <istream>

#include <iterator>

#include <ostream>

#include <queue>

#include <set>

#include <sstream>

#include <stack>

#include <stdexcept>

#include <streambuf>

#include <string>

#include <typeinfo>

#include <utility>

#include <valarray>

#include <vector>

using namespace std

;

#define INT int

#define SIGNED signed

#define MAIN main

#define USING using

#define LONG long

#define NAMESPACE namespace

#define STRUCT struct

#define STD std

#define CONST const

#define IF if

#define ELSE else

#define RETURN return

#define VOID void

#define INLINE inline

#define FOR for

#define CIN cin

#define COUT cout

#define MID (L+R)>>1

#define LSON L,MID,T[RT].L

#define RSON MID+1,R,T[RT].R

#define LS T[RT].L

#define RS T[RT].R

USING NAMESPACE STD

;

NAMESPACE Watarai_Hinami

{

INLINE VOID CLOSE()

{

std::ios::sync_with_stdio(false)

;

std::cin.tie(0)

;

std::cout.tie(0)

;

}

INLINE VOID FIRE()

{

freopen(".in","r",stdin)

;

freopen(".out","w",stdout)

;

}

}

NAMESPACE Chongyun

{

INLINE INT READ()

{

INT s = 0,w = 1

;

char ch = getchar()

;

while(ch<'0'||ch>'9')

{

if(ch == '-') w = -1

;

ch = getchar()

;

}

while(ch>='0'&&ch<='9')

{

s = s*10+ch-'0'

;

ch = getchar()

;

}

return s*w

;

}

INLINE VOID WRITE(INT x)

{

char F[20];

INT tmp=x>0?x:-x,cnt=0

;;

if(x<0)putchar('-') ;

while(tmp>0)

{

F[cnt++]=tmp%10+'0';

tmp/=10

;

}

while(cnt>0)putchar(F[--cnt]);}}

USING NAMESPACE Watarai_Hinami

;

USING NAMESPACE Chongyun

;

CONST INT n=5e5+10

;

CONST INT INF=1e9+5

;

STRUCT TREE

{

INT L,R,SUM

;}

T[n*32];

INT SZ=1

;

INLINE INT FIND(INT L,INT R,INT RT,INT l,INT r)

{

INT ANS=0

//  COUT<<ANS;

;

IF(L>=l && R<=r)

RETURN T[RT].SUM

//COUT<<T[RT].SUM;

;

IF(MID>=l) ANS+=FIND(LSON,l,r);

//COUT<<L<<MID<<T[RT].L;

IF(MID<r) ANS+=FIND(RSON,l,r);

//COUT<<MID+1<<R<<T[RT].R;

RETURN ANS

//COUT<<ANS;
;

}

INLINE VOID UPDATE(INT L,INT R,INT &RT,INT POS)

{

IF(!RT) RT=++SZ

//COUT<<SZ<<RT;

;

IF(L==R)

{

T[RT].SUM++;

//COUT<<T[RT].SUM;

RETURN

;

}

IF(MID>=POS) UPDATE(LSON,POS);

ELSE UPDATE(RSON,POS);

T[RT].SUM=T[LS].SUM+T[RS].SUM

//COUT<<T[RT].SUM;

;

}

SIGNED MAIN()

{

INT N=READ();

LONG LONG ANS(0);

//COUT<<ANS;

INT ROOT=1

//COUT<<ROOT;

;

FOR(INT I=1

;

I<=N

;++I)

{

INT X=READ();

ANS+=FIND(1,INF,1,X+1,INF);

UPDATE(1,INF,ROOT,X);}

COUT<<ANS

;

}

的确，OI 这条路上，没有绝对的一帆风顺，只有坦然面对磨难的心以及优良的码风才能助力各省 Oier 们在省选取得好成绩，这才是最重要的。

posted @ 2024-01-31 21:27 HS_xh 阅读(69) 评论(1) 编辑收藏举报

刷新页面返回顶部

黄色协会

Oier 一生最重要的是什么？

公告