1. 程式人生 > 實用技巧 >第21次CSP認證 題解

第21次CSP認證 題解

A

#include<bits/stdc++.h>
#define N 1100000
#define db double
#define ll long long 
#define ldb long double
#define ull unsigned long long
using namespace std;
const int h=3,ki=149,mo=998244353;
int mod(int x){return (x%mo+mo)%mo;}
int inc(int x,int k){x+=k;return x<mo?x:x-mo;}
int dec(int x,int k){x-=k;return x>=0?x:x+mo;}
int read(){int x;scanf("%d",&x);return x;}
void write(int x){printf("%d",x);}
int main()
{
    int n=read();
    ll ans=0;
    for(int i=1;i<=n;i++)ans+=1ll*read()*read();
    ans=max(ans,0ll);
    printf("%lld",ans);
    return 0;
}

B

#include<bits/stdc++.h>
#define N 1100000
#define db double
#define ll long long 
#define ldb long double
#define ull unsigned long long
using namespace std;
const int h=3,ki=149,mo=998244353;
int mod(int x){return (x%mo+mo)%mo;}
int inc(int x,int k){x+=k;return x<mo?x:x-mo;}
int dec(int x,int k){x-=k;return x>=0?x:x+mo;}
int read(){int x;scanf("%d",&x);return x;}
void write(int x){printf("%d",x);}
struct node
{
    int x,flag;
}p[N];
bool cmp(node a,node b){return a.x<b.x;}
int pre[N],suf[N];//numbers
int main()
{
    int n=read();
    for(int i=1;i<=n;i++)p[i].x=read(),p[i].flag=read();
    sort(p+1,p+n+1,cmp);
    for(int i=1;i<=n;i++)pre[i]=pre[i-1]+(p[i].flag==0);
    for(int i=n;i>=1;i--)suf[i]=suf[i+1]+(p[i].flag==1);
    int t=0,ans=-mo;
    for(int i=1;i<=n;i++)
    if(i==1||p[i].x!=p[i-1].x)
    {
        if(pre[i-1]+suf[i]>=ans)
        {
            ans=pre[i-1]+suf[i];
            t=p[i].x;
        }
    }   
    printf("%d",t);
    return 0;
}

C

#include<bits/stdc++.h>
#define N 1100000
#define db double
#define int long long 
#define ldb long double
#define ull unsigned long long
using namespace std;
const int h=3,ki=149,mo=1e9+7;
int mod(int x){return (x%mo+mo)%mo;}
int inc(int x,int k){x+=k;return x<mo?x:x-mo;}
int dec(int x,int k){x-=k;return x>=0?x:x+mo;}
int read(){int x;scanf("%lld",&x);return x;}
struct node
{
    int flag,sz;
}f[N];
int rt,size;
map<string,int>mp[N];
bool insert()
{
    string s,to;
    cin>>s;
    int x=rt,n=s.size(),value=read();
    for(int i=0;i<n;i++)
    {
        if(s[i]=='/')
        {
            if(!i)continue;
            if(mp[x][to]){if(f[mp[x][to]].flag==1)return false;}
            if(!mp[x][to]){mp[x][to]=++size;f[mp[x][to]].flag=0;}
            x=mp[x][to];
            to.clear();
            continue;
        }
        to=to+s[i];
    }
    if(mp[x][to]){if(f[mp[x][to]].flag==0)return false;}
    if(!mp[x][to]){mp[x][to]=++size;f[mp[x][to]].flag=1;}
    x=mp[x][to];f[x].sz=value;
    return true;
}
bool delate()
{
    string s,to;
    cin>>s;
    int x=rt,n=s.size();
    for(int i=0;i<n;i++)
    {
        if(s[i]=='/')
        {
            if(!i)continue;
            if(!mp[x][to])return true;
            x=mp[x][to];
            to.clear();
            continue;
        }
        to=to+s[i];
    }
    if(!mp[x][to])return true;
    mp[x].erase(to);
    return true;
}
void print(bool flag){if(flag)printf("Y\n");else printf("N\n");}
signed main()
{
    int qnum=read();rt=1;size=1;
    for(int i=1;i<=qnum;i++)
    {
        char fg[3];
        scanf("%s",fg);
        if(fg[0]=='C')print(insert());
        if(fg[0]=='R')print(delate());
    }
    return 0;
}

D

#include<bits/stdc++.h>
#define N 550
#define M 220
#define T 2200
#define db double
#define int long long 
#define ldb long double
#define ull unsigned long long
using namespace std;
const int h=3,ki=149,inf=1e15,mo=998244353;
int mod(int x){return (x%mo+mo)%mo;}
int inc(int x,int k){x+=k;return x<mo?x:x-mo;}
int dec(int x,int k){x-=k;return x>=0?x:x+mo;}
int read(){int x;scanf("%lld",&x);return x;}
struct edge{int to,nxt,w;}e[T*2];
int num,head[T];
void add(int x,int y,int z){e[++num]={y,head[x],z};head[x]=num;}
bool flag[N][N];
int  tot=0,sz[T],dep[T];
void prepare(int x,int fa)
{
    for(int i=head[x];i!=-1;i=e[i].nxt)
    {
        int to=e[i].to;
        if(to==fa)continue;
        prepare(to,x);
        sz[x]+=sz[to];
        dep[x]=max(dep[x],dep[to]+e[i].w);
    }
}
void dfs(int x,int fa)
{
    for(int i=head[x];i!=-1;i=e[i].nxt)
    {
        int to=e[i].to;
        if(to==fa)continue;
        if(sz[to])
        {
            tot+=e[i].w;
            dfs(to,x);
            tot+=e[i].w;
        }
    }
}
struct node{int x,k;}w[N][N];
bool cmp(node a,node b){return a.k<b.k;}
int dp[150][22][2200];
signed main()
{
    int n=read(),m=read(),k=read();
    num=-1;memset(head,-1,sizeof(head));
    for(int i=1;i<=n;i++)for(int j=1;j<=k;j++)flag[i][j]=read();
    for(int i=1;i<n;i++){int x=read(),y=read(),z=read();add(x,y,z);add(y,x,z);}
    for(int x=1;x<=n;x++)
    for(int i=1;i<=k;i++)
    {
        bool ok=false;
        for(int t=1;t<=n;t++)if(flag[t][i])sz[t]=1,dep[t]=0,ok=true;else sz[t]=0,dep[t]=-inf;
        if(!ok)
        {
            w[x][i]={i,0};
            continue;
        }
        prepare(x,x);tot=0;dfs(x,x);
        w[x][i]={i,tot-dep[x]};
    }
    for(int x=1;x<=n;x++)sort(w[x]+1,w[x]+k+1,cmp);

    for(int x=0;x<=n;x++)
    for(int i=0;i<=m+1;i++)
    for(int s=0;s<(1<<k);s++)
    dp[x][i][s]=inf;

    dp[0][0][0]=0;
    for(int x=0;x<n;x++)
    for(int i=0;i<=m;i++)
    for(int s=0;s<(1<<k);s++)
    {
        int o=dp[x][i][s];
        dp[x+1][i][s]=min(dp[x+1][i][s],o);
        for(int p=1,t=0;p<=k;p++)
        {
            t|=1<<(w[x+1][p].x-1);
            dp[x+1][i+1][s|t]=min(dp[x+1][i+1][s|t],max(o,w[x+1][p].k));
        }
    }
    int ans=inf;
    for(int x=1;x<=n;x++)
    for(int i=0;i<=m;i++)
    ans=min(ans,dp[x][i][(1<<k)-1]);
    printf("%lld",ans);
    return 0;
}

E

#include<bits/stdc++.h>
#define N 1100000
#define M 5500000
#define db double
#define ll long long 
#define ldb long double
#define ull unsigned long long
using namespace std;
const int h=3,ki=149,mo=1e9+7;
int mod(int x){return (x%mo+mo)%mo;}
int inc(int x,int k){x+=k;return x<mo?x:x-mo;}
int dec(int x,int k){x-=k;return x>=0?x:x+mo;}
int read(){int x;scanf("%d",&x);return x;}
void write(int x){printf("%d",x);}
struct node{int x,y,z;};
node operator+(node f,node g){return (node){inc(f.x,g.x),inc(f.y,g.y),inc(f.z,g.z)};}
node operator*(node f,int k)
{
    node ans;
    ans.x=1ll*f.x*k%mo;
    ans.y=1ll*f.y*k%mo;
    ans.z=1ll*f.z*k%mo;
    return ans;
}
node sp(node f,int k)
{
    k%=3;
    if(k==0)return (node){f.x,f.y,f.z};
    if(k==1)return (node){f.y,f.z,f.x};
    if(k==2)return (node){f.z,f.x,f.y};
}
struct Segment_Tree
{
    #define lson lc[o]
    #define rson rc[o]
    #define mid ((l+r)>>1)
    node f[M],addv[M];
    int size=0,lc[M],rc[M],mulv[M],revv[M];
    void insert(int &o){if(!o)o=++size,mulv[o]=1;}
    int pushup(int o){f[o]=f[lson]+f[rson];}
    void mul(int o,int k)
    {
        f[o]=f[o]*k;
        addv[o]=addv[o]*k;
        mulv[o]=1ll*mulv[o]*k%mo;
    }
    void rev(int o,int k)
    {
        f[o]=sp(f[o],k);
        addv[o]=sp(addv[o],k);
        revv[o]=(revv[o]+k)%3;
    }
    void add(int o,int l,int r,node k)
    {
        f[o]=f[o]+(k*(r-l+1));
        addv[o]=addv[o]+k;
    }
    void pushdown(int o,int l,int r)
    {
        insert(lson);mul(lson,mulv[o]);rev(lson,revv[o]);add(lson,l,mid,addv[o]);
        insert(rson);mul(rson,mulv[o]);rev(rson,revv[o]);add(rson,mid+1,r,addv[o]);
        mulv[o]=1;revv[o]=0;addv[o]=(node){0,0,0};
    }
    void optmul(int &o,int l,int r,int ql,int qr,int k)
    {
        insert(o);
        if(ql<=l&&r<=qr)return mul(o,k);
        pushdown(o,l,r);
        if(ql<=mid)optmul(lson,l,mid,ql,qr,k);
        if(qr>mid)optmul(rson,mid+1,r,ql,qr,k);
        pushup(o);
    }
    void optrev(int &o,int l,int r,int ql,int qr,int k)
    {
        insert(o);
        if(ql<=l&&r<=qr)return rev(o,k);
        pushdown(o,l,r);
        if(ql<=mid)optrev(lson,l,mid,ql,qr,k);
        if(qr>mid)optrev(rson,mid+1,r,ql,qr,k);
        pushup(o);
    }   
    void optadd(int &o,int l,int r,int ql,int qr,node k)
    {
        insert(o);
        if(ql<=l&&r<=qr)return add(o,l,r,k);
        pushdown(o,l,r);
        if(ql<=mid)optadd(lson,l,mid,ql,qr,k);
        if(qr>mid)optadd(rson,mid+1,r,ql,qr,k);
        pushup(o);
    }
    node query(int o,int l,int r,int ql,int qr)
    {
        if(!o)return (node){0,0,0};
        if(ql<=l&&r<=qr)return f[o];
        pushdown(o,l,r);
        node ans=(node){0,0,0};
        if(ql<=mid)ans=ans+query(lson,l,mid,ql,qr);
        if(qr>mid)ans=ans+query(rson,mid+1,r,ql,qr);
        return ans;
    }
}T;
int main()
{
    int n=read(),qnum=read(),rt=0;
    for(int i=1;i<=qnum;i++)
    {
        int flag=read(),l=read(),r=read();
        if(flag==1)
        {
            node k;
            k.x=read();k.y=read();k.z=read();
            T.optadd(rt,1,n,l,r,k);
        }
        if(flag==2)
        {
            int k;
            k=read();
            T.optmul(rt,1,n,l,r,k);
        }
        if(flag==3)
        {
            T.optrev(rt,1,n,l,r,1);
        }
        if(flag==4)
        {
            node ans=T.query(rt,1,n,l,r);
            int res=0;
            res=inc(res,1ll*ans.x*ans.x%mo);
            res=inc(res,1ll*ans.y*ans.y%mo);
            res=inc(res,1ll*ans.z*ans.z%mo);
            printf("%d\n",res);
        }
    }
    return 0;
}