CSP 202012

CSP202012-1

#include<iostream>
#include<cstdio>
using namespace std;
int main(){
    int n,ans=0,w,s;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d%d",&w,&s);
        ans+=w*s;
    }
    ans=max(ans,0);
    printf("%d\n",ans);
    return 0;
}

 

CSP202012-2

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define maxn 100010
using namespace std;
int n,sum1[maxn],sum0[maxn];//sum1是后缀1的个数，sum0是前缀0的个数
struct node{
    int x,y;
}a[maxn];
bool cmp(node u,node v){
    return u.x<v.x;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d%d",&a[i].x,&a[i].y);
    sort(a+1,a+n+1,cmp);
    for(int i=1;i<=n;i++){
        if(a[i].y==0)sum0[i]=sum0[i-1]+1;
        else sum0[i]=sum0[i-1];
    }
    for(int i=n;i>=1;i--){
        if(a[i].y==1)sum1[i]=sum1[i+1]+1;
        else sum1[i]=sum1[i+1];
    }
    int mx=0,ansnow,ans=a[1].x;
    for(int i=1;i<=n;i++){
        if(a[i].x==a[i-1].x && i!=1)continue;
        ansnow=sum1[i]+sum0[i-1];
        if(ansnow>=mx){
            mx=ansnow;
            ans=a[i].x;
        }
    }
    printf("%d\n",ans);
    system("pause");
    return 0;
}

 

CSP202012-3

#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
#include <vector>
#define maxn 4000010
#define INF (LLONG_MAX/3)
using namespace std;
struct node{
    map<string,int>son;
    int kind;//1文件，2目录
    long long ld,lr;//ld孩子大小上限，lr后代大小上限
    long long sld,slr;//sld孩子文件大小，slr后代文件大小
    long long fsize;//如果为文件，那么自身有一个大小
    int fa;//父亲节点
}g[maxn];
int clockIndex;

vector<pair<int,string> >reback;//存储创建过的路径

void REBACK(){
    for(int i=0;i<reback.size();i++){
        int a=reback[i].first;
        string b=reback[i].second;
        g[a].son.erase(g[a].son.find(b));
    }
}

string solveC(){//创建普通文件
    string path;cin>>path;
    long long fsize;scanf("%lld",&fsize);
    int p=1,id=0,Lpath=path.length(),last=-1;
    for(int i=Lpath-1;i>=0;i--){
        if(path[i]=='/'){
            last=i;
            break;
        }
    }
    int tclock=clockIndex;
    reback.clear();

    //寻找路径
    while(p<last){
        string t="";//t存储目录名
        while(p<last && path[p]!='/'){
            t=t+path[p];p++;
        }
        p++;
        //不存在这个目录，则新建这个目录
        if(g[id].son.find(t)==g[id].son.end()){
            g[id].son[t]=++clockIndex;
            g[clockIndex].fa=id;
            g[clockIndex].kind=2;
            g[clockIndex].ld=INF;
            g[clockIndex].lr=INF;
            reback.push_back(make_pair(id,t));
            id=clockIndex;
        }
        else {
            int sonid=g[id].son[t];
            if(g[sonid].kind==1){//存在这个文件，并且文件类型是普通文件
                clockIndex=tclock;
                REBACK();
                return "N";
            }
            id=sonid;
        }
    }

    //读出文件名
    string t="";
    for(int i=last+1;i<Lpath;i++)t=t+path[i];
    if(g[id].son.find(t)!=g[id].son.end()){
        int sonid=g[id].son[t];
        if(g[sonid].kind==2){
            clockIndex=tclock;
            REBACK();
            return "N";
        }
    }

    //向上追溯，检查是否符合ld和lr
    long long py=0;
    if(g[id].son.find(t)==g[id].son.end())
        py=fsize;
    else 
        py=-g[g[id].son[t]].fsize+fsize;
    if(g[id].sld+py>g[id].ld){
        clockIndex=tclock;
        REBACK();
        return "N";
    }
    int now=id;
    while(now!=-1){
        if(g[now].slr+py>g[now].lr){
            clockIndex=tclock;
            REBACK();
            return "N";
        }
        now=g[now].fa;
    }

    //加入文件
    if(g[id].son.find(t)==g[id].son.end()){//创建新文件
        g[++clockIndex].kind=1;g[clockIndex].fsize=fsize;
        g[clockIndex].fa=id;g[id].son[t]=clockIndex;
    }
    else g[g[id].son[t]].fsize=fsize;
    g[id].sld+=py;
    while(id!=-1){
        g[id].slr+=py;
        id=g[id].fa;
    }
    return "Y";
}

string solveR(){//移除文件
    string path;cin>>path;
    int p=1,id=0,Lpath=path.length(),last=-1;
    for(int i=Lpath-1;i>=0;i--){
        if(path[i]=='/'){last=i;break;}
    }
    while(p<last){
        string t="";
        while(p<last && path[p]!='/'){
            t=t+path[p];p++;
        }
        p++;
        if(g[id].son.find(t)==g[id].son.end()){
            return "Y";
        }
        else {
            int sonid=g[id].son[t];
            if(g[sonid].kind==1)return "Y";
            id=sonid;
        }
    }
    string t="";
    for(int i=last+1;i<Lpath;i++)t=t+path[i];
    if(g[id].son.find(t)==g[id].son.end())
        return "Y";
    int delNode=g[id].son[t];
    long long add=0;
    if(g[delNode].kind==1){//是文件
        g[id].sld-=g[delNode].fsize;
        add=g[delNode].fsize;
        g[id].son.erase(g[id].son.find(t));
    }
    if(g[delNode].kind==2){//是目录
        add=g[delNode].slr;
        g[id].son.erase(g[id].son.find(t));
    }
    while(id!=-1){
        g[id].slr-=add;
        id=g[id].fa;
    }
    return "Y";
}

string solveQ(){//设置配额值
    string path;cin>>path;
    long long LD,LR;
    scanf("%lld%lld",&LD,&LR);
    if(LD==0)LD=INF;
    if(LR==0)LR=INF;
    int p=1,id=0,Lpath=path.length(),last=-1;
    for(int i=Lpath-1;i>=0;i--){
        if(path[i]=='/'){last=i;break;}
    }
    while(p<last){
        string t="";
        while(p<last && path[p]!='/'){
            t=t+path[p];
            p++;
        }
        p++;
        if(g[id].son.find(t)==g[id].son.end()){
            return "N";
        }
        else {
            int sonid=g[id].son[t];
            if(g[sonid].kind==1)return "N";
            id=sonid;
        }
    }
    string t="";
    for(int i=last+1;i<Lpath;i++)t=t+path[i];
    int qNode;
    if(t==""){
        qNode=0;
    }
    else {
        if(g[id].son.find(t)==g[id].son.end())return "N";
        else qNode=g[id].son[t];
    }
    if(g[qNode].kind==1)return "N";
    if(LD<g[qNode].sld || LR<g[qNode].slr)
        return "N";
    g[qNode].ld=LD;g[qNode].lr=LR;
    return "Y";
}


int main(){
    //设置根目录
    g[0].kind=2;
    g[0].ld=INF;g[0].lr=INF;
    g[0].fa=-1;
    int q;scanf("%d",&q);
    char op;
    while(q--){
        cin>>op;
        if(op=='C'){//创建普通文件
            cout<<solveC()<<'\n';
        }
        if(op=='R'){//移除文件
            cout<<solveR()<<'\n';
        }
        if(op=='Q'){//设置配额值
            cout<<solveQ()<<'\n';
        }
    }
    return 0;
}