精华内容
下载资源
问答
  • 2020csp第三题

    2020-11-17 19:40:17
    作者对你说:“虽然今年csp没有进复赛,但还是想尽办法找来了题目,因为我想帮助未知的你们,希望你们在看到我的文章后,可以有显著的进步." 题意:这道大体就是给你一个组合电路,有输入信号和电器元件,他给你...

    作者对你说:“虽然今年csp没有进复赛,但还是想尽办法找来了题目,因为我想帮助未知的你们,希望你们在看到我的文章后,可以有显著的进步."

    题意:这道题大体就是给你一个组合电路,有输入信号和电器元件,他给你一些值然后让你输出询问的电器元件计算的值。

    首先是输入:
    第一行是q代表查询的次数,然后是m,n,分别是输入信号的数目和电器元件的数目。之后n行是电器元件作用(像AND,XOR等),然后是输入的信号的数目,后面是电器元件的符号(Ox)或者输入信号的符号(Ix)。然后是s代表运行的次数,之后是s行代表每次运行所有的输入信号的值(只有0和1两种)。之后s行每行第一个是要输出的电器元件的数目,之后是电器元件的序号(数字)。

    然后是输出:
    输出就是对最后s行每行查询的电器元件,输出他计算的值。(当然你还要判断是否有环路)

    解题思路:
    其实仔细一想这就是个拓扑排序。首先如果没有某个电器元件的输入量全是输入信号的,那么就一定存在环路,直接输出loop就行了。如果有的话,就可以设置电器元件的输入的其他电器元件的数目,存放在in数组里面(全是输入信号的话值为0,这个就是拓扑排序的起始点)。然后用队列直接实现拓扑排序就行了。
    而在这里我用的结构体记录的电器元件和输入信号的信息。

    #include<iostream>
    #include<algorithm>
    #include<cstring>
    #include<cstdlib>
    #include<queue>
    #include<vector>
    #include<cstdio>
    #include<cmath>
    #define ll long long
    using namespace std;
    int in[100000]={0},q1,m,n,s;
    vector<int> h[50005],g[50005];//这个是每次运行的所有信号量的值和你要输出的电器元件的信号
    int in1[100000]={0},out1[100000]={0};//in1代表每次运行的(in代表的东西上面说了),out1就是我记录每个电器元件的计算的值
    int flag;//flag=0代表有环路
    struct node{
     string zt;
     int num;
     vector<int> u,v;
    }e[100000];//结构体,zt是状态(如AND),num是计算的值,u是该电器元件的输入的信号或元件的序号,v是该元件是,,,的输入信号
    int sol(string tt){//这个函数是将Ix和Ox转化成序号
     if(tt[0]=='I'){
      int tot=0;
      for(i/nt i=1;i<tt.size();i++){
       tot*=10;
       tot+=int(tt[i]-'0');
      }
      return tot;
     }else if(tt[0]=='O'){
      int tot=0;
      for(int i=1;i<tt.size();i++){
       tot*=10;
       tot+=int(tt[i]-'0');
      }
      tot+=m;
      return tot;
     }
    }//在这里前m个是输入信号量,电器元件序号加m
    void solve(int u){//这个是根据状态求计算的值
     if(e[u].zt=="NOT"){
      e[u].num=(!e[e[u].u[0]].num);
     }
     if(e[u].zt=="AND"){
      e[u].num=1;
      for(int i=0;i<e[u].u.size();i++)
      {
       e[u].num=(e[u].num&e[e[u].u[i]].num);
      }
     }
     if(e[u].zt=="OR"){
      e[u].num=0;
      for(int i=0;i<e[u].u.size();i++)
      {
       e[u].num=(e[u].num|e[e[u].u[i]].num);
      }
     }
     if(e[u].zt=="XOR"){
      e[u].num=0;
      for(int i=0;i<e[u].u.size();i++)
      {
       e[u].num=(e[u].num^e[e[u].u[i]].num);
      }
     }
     if(e[u].zt=="NAND"){
      e[u].num=1;
      for(int i=0;i<e[u].u.size();i++)
      {
       e[u].num=(e[u].num&e[e[u].u[i]].num);
      }
      e[u].num=(!e[u].num);
     }
     if(e[u].zt=="NOR"){
      e[u].num=0;
      for(int i=0;i<e[u].u.size();i++)
      {
       e[u].num=(e[u].num|e[e[u].u[i]].num);
      }
      e[u].num=(!e[u].num);
     }
    }
    void dfs(){//拓扑排序
     queue<int> q;
     for(int i=1;i<=m+n;i++){
      in1[i]=in[i];
     }
     for(int i=m+1;i<=m+n;i++){//这个是我上面说的判断环路
      if(in1[i]==0){
       q.push(i);
       flag=1;
      }
     }
     if(!flag)return;
     int hh=n;
     while(!q.empty()){
      int u=q.front();
      q.pop();
      solve(u);
      out1[u-m]=e[u].num;
      hh--;
      for(int i=0;i<e[u].v.size();i++){
       int cnt=e[u].v[i];
       in1[cnt]--;
       if(in1[cnt]==0){
        q.push(e[u].v[i]);
       }
      }
     }
     if(hh!=0){//如果依然存在电器元件没有更新,说明存在环路
      flag=0;
     }
    }
    int main()
    {
     cin>>q1;
     while(q1--){
      flag=0;
      cin>>m>>n;
      for(int i=0;i<10000;i++){//这个是初始化
       h[i].clear();
       g[i].clear();
      }
      for(int i=1;i<=m+n;i++){
       in[i]=0;
      }
      for(int i=1;i<=m;i++){
       e[i].zt="0";
       e[i].num=-1;
       e[i].u.clear();
       e[i].v.clear();
      }
      for(int i=m+1;i<=m+n;i++){//对于每个信号或元件进行结构体构建
       e[i].num=0;
       e[i].u.clear();
       e[i].v.clear();
       string p;
       cin>>p;
       e[i].zt=p;
       int a1;
       cin>>a1;
       for(int j=0;j<a1;j++){
        string tt;
        cin>>tt;
        int num=sol(tt);
        e[i].u.push_back(num);
        if(num>m){
         in[i]++;
         e[num].v.push_back(i);
        }
       }
      }
      cin>>s;
      int w;
      for(int i=0;i<s;i++){//存储每次运行信号的值
       for(int j=0;j<m;j++){
        cin>>w;
        h[i].push_back(w);
       }
      }
      for(int i=0;i<s;i++){//要查询的信号
       int ww;
       cin>>ww;
       for(int j=0;j<ww;j++){
        cin>>w;
        g[i].push_back(w);
       }
      }
      for(int i=0;i<s;i++){
       memset(out1,0,sizeof(out1));
       memset(in1,0,sizeof(in1));
       for(int j=1;j<=m;j++){
        e[j].num=h[i][j-1];
       }
       dfs();
       if(!flag){//判断是否有环
        cout<<"LOOP"<<endl;
        break;
       }
       for(int j=0;j<g[i].size();j++){
        cout<<out1[g[i][j]]<<" ";//输出
       }
       cout<<endl;
      }
     }
    }
    
    展开全文
  • 2019年12月CSP第三题化学方程式的Java代码,已在官网上验证,100分通过。主要思想来自编译原理。
  • 已经很多次做这几道0分了 自己试了一些样例输出都是对的 只是求过前两个简单样例拿到20分再继续完善 无奈连20分都拿不到 感觉每次刷题毫无长进 大神们能说说0分可能是什么原因么?能给点刷题建议么&#...
  • Python\C++| CCFCSP 第三题

    千次阅读 2018-07-24 11:35:06
     在横轴上放了n个相邻的矩形,每个矩形的宽度是1,而i(1 ≤ i ≤ n)个矩形的高度是hi。这n个矩形构成了一个直方图。例如,下图中六个矩形的高度就分别是3, 1, 6, 5, 2, 3。  请找...
    试题编号: 201312-3
    试题名称: 最大的矩形
    时间限制: 1.0s
    内存限制: 256.0MB
    问题描述:

    问题描述

      在横轴上放了n个相邻的矩形,每个矩形的宽度是1,而第i(1 ≤ i ≤ n)个矩形的高度是hi。这n个矩形构成了一个直方图。例如,下图中六个矩形的高度就分别是3, 1, 6, 5, 2, 3。



      请找出能放在给定直方图里面积最大的矩形,它的边要与坐标轴平行。对于上面给出的例子,最大矩形如下图所示的阴影部分,面积是10。

    输入格式

      第一行包含一个整数n,即矩形的数量(1 ≤ n ≤ 1000)。
      第二行包含n 个整数h1, h2, … , hn,相邻的数之间由空格分隔。(1 ≤ hi ≤ 10000)。hi是第i个矩形的高度。

    输出格式

      输出一行,包含一个整数,即给定直方图内的最大矩形的面积。

    样例输入

    6
    3 1 6 5 2 3

    样例输出

    10

    #include <iostream>
    #include <cstring>
    #include <algorithm>
    #include <algorithm>
    using namespace std;
    int  tt[1005];
    bool cmp(int a,int b)
    {
        return a>b;
    }
    int main()
    {
        int n,l,t;
        while(cin>>n)
        {
            int ans=0;
            int maxn=0;
            for(int i=0; i<n; i++)
            {
                cin>>tt[i];
                maxn=max(maxn,tt[i]);
            }
            for(int i=1;i<n;i++)
            {
                if(tt[i]==0)
                    break;
                else
                {
                    int cnt=0;
                    for(int j=0;j<n;j++)
                    {
                        if(tt[j]-tt[i]<0)
                            cnt=0;
                        else
                            cnt++;
                        maxn=max(maxn,cnt*tt[i]);
                    }
                }
            }
            cout<<maxn<<endl;
        }
    }
    
    试题编号: 201403-3
    试题名称: 命令行选项
    时间限制: 1.0s
    内存限制: 256.0MB
    问题描述:

    问题描述

      请你写一个命令行分析程序,用以分析给定的命令行里包含哪些选项。每个命令行由若干个字符串组成,它们之间恰好由一个空格分隔。这些字符串中的第一个为该命令行工具的名字,由小写字母组成,你的程序不用对它进行处理。在工具名字之后可能会包含若干选项,然后可能会包含一 些不是选项的参数。
      选项有两类:带参数的选项和不带参数的选项。一个合法的无参数选项的形式是一个减号后面跟单个小写字母,如"-a" 或"-b"。而带参数选项则由两个由空格分隔的字符串构成,前者的格式要求与无参数选项相同,后者则是该选项的参数,是由小写字母,数字和减号组成的非空字符串。
      该命令行工具的作者提供给你一个格式字符串以指定他的命令行工具需要接受哪些选项。这个字符串由若干小写字母和冒号组成,其中的每个小写字母表示一个该程序接受的选项。如果该小写字母后面紧跟了一个冒号,它就表示一个带参数的选项,否则则为不带参数的选项。例如, "ab:m:" 表示该程序接受三种选项,即"-a"(不带参数),"-b"(带参数), 以及"-m"(带参数)。
      命令行工具的作者准备了若干条命令行用以测试你的程序。对于每个命令行,你的工具应当一直向后分析。当你的工具遇到某个字符串既不是合法的选项,又不是某个合法选项的参数时,分析就停止。命令行剩余的未分析部分不构成该命令的选项,因此你的程序应当忽略它们。

    输入格式

      输入的第一行是一个格式字符串,它至少包含一个字符,且长度不超过 52。格式字符串只包含小写字母和冒号,保证每个小写字母至多出现一次,不会有两个相邻的冒号,也不会以冒号开头。
      输入的第二行是一个正整数 N(1 ≤ N ≤ 20),表示你需要处理的命令行的个数。
      接下来有 N 行,每行是一个待处理的命令行,它包括不超过 256 个字符。该命令行一定是若干个由单个空格分隔的字符串构成,每个字符串里只包含小写字母,数字和减号。

    输出格式

      输出有 N 行。其中第 i 行以"Case i:" 开始,然后应当有恰好一个空格,然后应当按照字母升序输出该命令行中用到的所有选项的名称,对于带参数的选项,在输出它的名称之后还要输出它的参数。如果一个选项在命令行中出现了多次,只输出一次。如果一个带参数的选项在命令行中出 现了多次,只输出最后一次出现时所带的参数。

    样例输入

    albw:x
    4
    ls -a -l -a documents -b
    ls
    ls -w 10 -x -w 15
    ls -a -b -c -d -e -l

    样例输出

    Case 1: -a -l
    Case 2:
    Case 3: -w 15 -x
    Case 4: -a -b

    Python 实现

    import sys
    a=sys.stdin.readline()
    a=a.strip()
    b=sys.stdin.readline()
    b=b.strip()
    cnt=int(b)
    for case in range(0,cnt):
        cmd = sys.stdin.readline()
        cmd=cmd.strip()
        cmd=cmd.replace('\n','')
        cmd=cmd.split(" ")
        ans = {}
        l=len(cmd)
        f=len(a)
        i=1
        while(i<=l-1):
            if(cmd[i][0]=='-' and len(cmd[i])==2):
                index=a.find(cmd[i][1])
                if(index==-1):
                    break
                if(index + 1 == f):
                    ans[cmd[i]] = '0'
                elif(a[index+1]==':'):
                    if(i+1==l):
                        break
                    else:
                        ans[cmd[i]]=cmd[i+1]
                        i+=1
                else:
                    ans[cmd[i]] = '0'
            else:
                break
            i+=1
        slove=sorted(ans.items(), key=lambda d: d[0])
        s="Case "+str(case+1)+": "
        for h in slove:
            key,value=h
            if(value=='0'):
                s+=(key+" ")
            else :
                s+=(key+" "+value+" ")
        s+='\n'
        sys.stdout.write(s)
    试题编号: 201409-3
    试题名称: 字符串匹配
    时间限制: 1.0s
    内存限制: 256.0MB
    问题描述:

    问题描述

      给出一个字符串和多行文字,在这些文字中找到字符串出现的那些行。你的程序还需支持大小写敏感选项:当选项打开时,表示同一个字母的大写和小写看作不同的字符;当选项关闭时,表示同一个字母的大写和小写看作相同的字符。

    输入格式

      输入的第一行包含一个字符串S,由大小写英文字母组成。
      第二行包含一个数字,表示大小写敏感的选项,当数字为0时表示大小写不敏感,当数字为1时表示大小写敏感。
      第三行包含一个整数n,表示给出的文字的行数。
      接下来n行,每行包含一个字符串,字符串由大小写英文字母组成,不含空格和其他字符。

    输出格式

      输出多行,每行包含一个字符串,按出现的顺序依次给出那些包含了字符串S的行。

    样例输入

    Hello
    1
    5
    HelloWorld
    HiHiHelloHiHi
    GrepIsAGreatTool
    HELLO
    HELLOisNOTHello

    样例输出

    HelloWorld
    HiHiHelloHiHi
    HELLOisNOTHello

    样例说明

      在上面的样例中,第四个字符串虽然也是Hello,但是大小写不正确。如果将输入的第二行改为0,则第四个字符串应该输出。

    评测用例规模与约定

      1<=n<=100,每个字符串的长度不超过100。

    import sys
    a=sys.stdin.readline()
    a=a.strip()
    c=sys.stdin.readline()
    c=c.strip()
    b=sys.stdin.readline()
    b=b.strip()
    cnt=int(b)
    test=[]
    for case in range(0,cnt):
        d=sys.stdin.readline()
        d=d.strip()
        test.append(d)
    if(c=='0'):
        a=a.lower()
    for tt in test :
        cc=tt
        if (c == '0'):
            cc=cc.lower()
        if(a in cc):
            sys.stdout.write(tt+'\n')
    
    试题编号: 201412-3
    试题名称: 集合竞价
    时间限制: 1.0s
    内存限制: 256.0MB
    问题描述:

    问题描述

      某股票交易所请你编写一个程序,根据开盘前客户提交的订单来确定某特定股票的开盘价和开盘成交量。
      该程序的输入由很多行构成,每一行为一条记录,记录可能有以下几种:
      1. buy p s 表示一个购买股票的买单,每手出价为p,购买股数为s。
      2. sell p s 表示一个出售股票的卖单,每手出价为p,出售股数为s。
      3. cancel i表示撤销第i行的记录。
      如果开盘价为p0,则系统可以将所有出价至少为p0的买单和所有出价至多为p0的卖单进行匹配。因此,此时的开盘成交量为出价至少为p0的买单的总股数和所有出价至多为p0的卖单的总股数之间的较小值。
      你的程序需要确定一个开盘价,使得开盘成交量尽可能地大。如果有多个符合条件的开盘价,你的程序应当输出最高的那一个。

    输入格式

      输入数据有任意多行,每一行是一条记录。保证输入合法。股数为不超过108的正整数,出价为精确到恰好小数点后两位的正实数,且不超过10000.00。

    输出格式

      你需要输出一行,包含两个数,以一个空格分隔。第一个数是开盘价,第二个是此开盘价下的成交量。开盘价需要精确到小数点后恰好两位。

    样例输入

    buy 9.25 100
    buy 8.88 175
    sell 9.00 1000
    buy 9.00 400
    sell 8.92 400
    cancel 1
    buy 100.00 50

    样例输出

    9.00 450

    评测用例规模与约定

      对于100%的数据,输入的行数不超过5000。

    不知道该怎么优化了 70分代码

    import sys
    tt={}
    i=1
    while True:
        line=sys.stdin.readline().strip()
        if not line:
            break
        if(line[0]=='c'):
            x,y=line.split(" ")
            tt[i]='0'
            tt[int(y)]='0'
        else:
            value=line.split(" ")
            tt[i]=(value[0],float(value[1]),int(value[2]))
        i+=1
    
    sum=0
    all=0
    ansp=0.0
    i=0
    for i in range(1,len(tt)+1):
        buy=0
        sell=0
        if(tt[i]=='0'):
            continue
        for j in range(1,len(tt)+1):
            if (tt[j] == '0'):
                continue
            if(tt[j][0][0]=='b'and tt[j][1]>=tt[i][1]):
                buy+=tt[j][2]
            if (tt[j][0][0] == 's' and tt[j][1] <= tt[i][1]):
                sell += tt[j][2]
        sum=min(sell,buy)
        if sum>all:
            all=sum
            ansp=tt[i][1]
        if sum == all:
            ansp=max(ansp,tt[i][1])
    ansp='%.2f'%ansp
    sys.stdout.write(ansp+" "+str(all)+'\n')
    试题编号: 201503-3
    试题名称: 节日
    时间限制: 1.0s
    内存限制: 256.0MB
    问题描述:

    问题描述

      有一类节日的日期并不是固定的,而是以“a月的第b个星期c”的形式定下来的,比如说母亲节就定为每年的五月的第二个星期日。
      现在,给你abcy1, y2(1850 ≤ y1, y2 ≤ 2050),希望你输出从公元y1年到公元y2年间的每年的a月的第b个星期c的日期。
      提示:关于闰年的规则:年份是400的整数倍时是闰年,否则年份是4的倍数并且不是100的倍数时是闰年,其他年份都不是闰年。例如1900年就不是闰年,而2000年是闰年。
      为了方便你推算,已知1850年1月1日是星期二。

    输入格式

      输入包含恰好一行,有五个整数abcy1, y2。其中c=1, 2, ……, 6, 7分别表示星期一、二、……、六、日。

    输出格式

      对于y1和y2之间的每一个年份,包括y1和y2,按照年份从小到大的顺序输出一行。
      如果该年的a月第b个星期c确实存在,则以"yyyy/mm/dd"的格式输出,即输出四位数的年份,两位数的月份,两位数的日期,中间用斜杠“/”分隔,位数不足时前补零。
      如果该年的a月第b个星期c并不存在,则输出"none"(不包含双引号)。

    样例输入

    5 2 7 2014 2015

    样例输出

    2014/05/11
    2015/05/10

    评测用例规模与约定

      所有评测用例都满足:1 ≤ a ≤ 12,1 ≤ b ≤ 5,1 ≤ c ≤ 7,1850 ≤ y1, y2 ≤ 2050。

    import sys
    
    day = [29, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    month = list(range(1, 13))
    year = list(range(1850, 2051))
    data = {}
    week = 2
    i = 0
    for y in year:
        if ((y % 4 == 0 and y % 100 != 0) or y % 400 == 0):
            day[2] = day[0]
        for m in month:
            da = day[m]
            for d in range(1, da + 1):
                # print(str(y)+' '+str(m)+' '+str(d)+' '+str(week))
                data[i] = tuple((y, m, d, week))
                week += 1
                week %= 7
                i += 1
        day[2] = 28
    line = sys.stdin.readline().strip()
    line = line.split(" ")
    line = [int(v) for v in line]
    line[2] %= 7
    a = False
    i = 0
    nowy = line[3]
    k = 0
    while (k < len(data)):
        if (data[k][1] == line[0] and data[k][0] >= line[3] and data[k][0] <= line[4] and data[k][3] == line[2]):
            i += 1
            if (i == line[1]):
                a = True
                sys.stdout.write(str(data[k][0]) + '/' + str('%0.2d' % data[k][1]) + '/' + str('%0.2d' % data[k][2]) + '\n')
        if (data[k][1]==12 and data[k][2]==31 and data[k][0] >= line[3] and data[k][0] <= line[4]):
            if(a==False):
                sys.stdout.write('none' + '\n')
            i = 0
            a=False
        k += 1
    
    试题编号: 201509-3
    试题名称: 模板生成系统
    时间限制: 1.0s
    内存限制: 256.0MB
    问题描述:

    问题描述

      成成最近在搭建一个网站,其中一些页面的部分内容来自数据库中不同的数据记录,但是页面的基本结构是相同的。例如,对于展示用户信息的页面,当用户为 Tom 时,网页的源代码是


      而当用户为 Jerry 时,网页的源代码是


      这样的例子在包含动态内容的网站中还有很多。为了简化生成网页的工作,成成觉得他需要引入一套模板生成系统。
      模板是包含特殊标记的文本。成成用到的模板只包含一种特殊标记,格式为 {{ VAR }},其中 VAR 是一个变量。该标记在模板生成时会被变量 VAR 的值所替代。例如,如果变量 name = "Tom",则 {{ name }} 会生成 Tom。具体的规则如下:
      ·变量名由大小写字母、数字和下划线 (_) 构成,且第一个字符不是数字,长度不超过 16 个字符。
      ·变量名是大小写敏感的,Name 和 name 是两个不同的变量。
      ·变量的值是字符串。
      ·如果标记中的变量没有定义,则生成空串,相当于把标记从模板中删除。
      ·模板不递归生成。也就是说,如果变量的值中包含形如 {{ VAR }} 的内容,不再做进一步的替换。

    输入格式

      输入的第一行包含两个整数 mn,分别表示模板的行数和模板生成时给出的变量个数。
      接下来 m 行,每行是一个字符串,表示模板。
      接下来 n 行,每行表示一个变量和它的值,中间用一个空格分隔。值是字符串,用双引号 (") 括起来,内容可包含除双引号以外的任意可打印 ASCII 字符(ASCII 码范围 32, 33, 35-126)。

    输出格式

      输出包含若干行,表示模板生成的结果。

    样例输入

    11 2
    <!DOCTYPE html>
    <html>
    <head>
    <title>User {{ name }}</title>
    </head>
    <body>
    <h1>{{ name }}</h1>
    <p>Email: <a href="mailto:{{ email }}">{{ email }}</a></p>
    <p>Address: {{ address }}</p>
    </body>
    </html>
    name "David Beckham"
    email "david@beckham.com"

    样例输出

    <!DOCTYPE html>
    <html>
    <head>
    <title>User David Beckham</title>
    </head>
    <body>
    <h1>David Beckham</h1>
    <p>Email: <a href="mailto:david@beckham.com">david@beckham.com</a></p>
    <p>Address: </p>
    </body>
    </html>

    评测用例规模与约定

      0 ≤ m ≤ 100
      0 ≤ n ≤ 100
      输入的模板每行长度不超过 80 个字符(不包含换行符)。
      输入保证模板中所有以 {{ 开始的子串都是合法的标记,开始是两个左大括号和一个空格,然后是变量名,结尾是一个空格和两个右大括号。
      输入中所有变量的值字符串长度不超过 100 个字符(不包括双引号)。
      保证输入的所有变量的名字各不相同。

    import sys
    import re
    line = sys.stdin.readline().strip()
    line = line.split(" ")
    line = [int(v) for v in line]
    i=0
    kk={}
    ht={}
    for _ in range(0,line[0]):
        html = sys.stdin.readline().strip()
    
        g=re.findall(r"{{ (.+?) }}",html)
        #print(g)
        for x in g:
            s='{{ '
            s+=x
            s+=' }}'
            kk[s]=''
        ht[i] = html
        i += 1
    for _ in range(0,line[1]):
        pat = sys.stdin.readline().strip()
        a,b=pat.split(" ",1)
        b=b.strip('"')
        s = '{{ '
        s += a
        s += ' }}'
        if(s in kk):
            kk[s]=b
    ll=0
    for ll in range(0,len(ht)):
        for a,b in kk.items():
            if(a in ht[ll]):
             ht[ll]=ht[ll].replace(a,b)
        print(ht[ll])
    试题编号: 201512-3
    试题名称: 画图
    时间限制: 1.0s
    内存限制: 256.0MB
    问题描述:

    问题描述

      用 ASCII 字符来画图是一件有趣的事情,并形成了一门被称为 ASCII Art 的艺术。例如,下图是用 ASCII 字符画出来的 CSPRO 字样。
      ..____.____..____..____...___..
      ./.___/.___||.._.\|.._.\./._.\.
      |.|...\___.\|.|_).|.|_).|.|.|.|
      |.|___.___).|..__/|.._.<|.|_|.|
      .\____|____/|_|...|_|.\_\\___/.
      本题要求编程实现一个用 ASCII 字符来画图的程序,支持以下两种操作:
       画线:给出两个端点的坐标,画一条连接这两个端点的线段。简便起见题目保证要画的每条线段都是水平或者竖直的。水平线段用字符 - 来画,竖直线段用字符 | 来画。如果一条水平线段和一条竖直线段在某个位置相交,则相交位置用字符 + 代替。
       填充:给出填充的起始位置坐标和需要填充的字符,从起始位置开始,用该字符填充相邻位置,直到遇到画布边缘或已经画好的线段。注意这里的相邻位置只需要考虑上下左右 4 个方向,如下图所示,字符 @ 只和 4 个字符 * 相邻。
      .*.
      *@*
      .*.

    输入格式

      第1行有三个整数mnqmn分别表示画布的宽度和高度,以字符为单位。q表示画图操作的个数。
      第2行至第q + 1行,每行是以下两种形式之一:
       0 xyxy2:表示画线段的操作,(x1, y1)和(x2, y2)分别是线段的两端,满足要么x1 = x2 且y1 ≠ y2,要么 y1 = y2 且 x1 ≠ x2。
       1 x y c:表示填充操作,(xy)是起始位置,保证不会落在任何已有的线段上;c 为填充字符,是大小写字母。
      画布的左下角是坐标为 (0, 0) 的位置,向右为x坐标增大的方向,向上为y坐标增大的方向。这q个操作按照数据给出的顺序依次执行。画布最初时所有位置都是字符 .(小数点)。

    输出格式

      输出有n行,每行m个字符,表示依次执行这q个操作后得到的画图结果。

    样例输入

    4 2 3
    1 0 0 B
    0 1 0 2 0
    1 0 0 A

    样例输出

    AAAA
    A--A

    样例输入

    16 13 9
    0 3 1 12 1
    0 12 1 12 3
    0 12 3 6 3
    0 6 3 6 9
    0 6 9 12 9
    0 12 9 12 11
    0 12 11 3 11
    0 3 11 3 1
    1 4 2 C

    样例输出

    ................
    ...+--------+...
    ...|CCCCCCCC|...
    ...|CC+-----+...
    ...|CC|.........
    ...|CC|.........
    ...|CC|.........
    ...|CC|.........
    ...|CC|.........
    ...|CC+-----+...
    ...|CCCCCCCC|...
    ...+--------+...
    ................

    评测用例规模与约定

      所有的评测用例满足:2 ≤ mn ≤ 100,0 ≤ q ≤ 100,0 ≤ x < mx表示输入数据中所有位置的x坐标),0 ≤ y < ny表示输入数据中所有位置的y坐标)。

    又是运行错误  90分代码

    import sys
    line = sys.stdin.readline().strip()
    line = line.split()
    line[0]=int(line[0])
    line[1]=int(line[1])
    line[2]=int(line[2])
    #line = [int(v) for v in line]
    ans = [(['.'] * line[0]) for _ in range(line[1])]
    vis= [([0] * line[0]) for _ in range(line[1])]
    che = ['-', '|', '+']
    dir=[[1,0],[-1,0],[0,-1],[0,1]]
    def check(xx,yy):
        if(xx>=0 and yy>=0 and xx<line[1] and yy<line[0] ):
            if(ans[xx][yy] not in che and vis[xx][yy]==0):
                return True
            else:
                return False
        else:
            return False
    def solve(xx,yy,pad):
        if (check(xx,yy)):
            vis[xx][yy] = 1
            ans[xx][yy] = pad
            for dire in dir:
                ccx = xx + dire[0]
                ccy = yy + dire[1]
                if (check(ccx, ccy)):
                    solve(ccx, ccy, pad)
    for _ in range(0, line[2]):
        cmd = sys.stdin.readline().strip()
        cmd = cmd.split()
        if (cmd[0] == '0'):
            cmd[1]=int(cmd[1])
            cmd[2]=int(cmd[2])
            cmd[3]=int(cmd[3])
            cmd[4]=int(cmd[4])
            if (cmd[1] == cmd[3]):
                for c in range(min(cmd[2], cmd[4]), max(cmd[2], cmd[4]) + 1):
                    if (ans[c][cmd[1]] == '-' or ans[c][cmd[1]] == '+'):
                        ans[c][cmd[1]] = '+'
                    else:
                        ans[c][cmd[1]] = '|'
            else:
                for c in range(min(cmd[1], cmd[3]), max(cmd[1], cmd[3])+1):
                    # print(str(cmd[2]) + " " + str(c))
                    if (ans[cmd[2]][c] == '|' or ans[cmd[2]][c] == '+'):
                        ans[cmd[2]][c] = '+'
                    else:
                        ans[cmd[2]][c] = '-'
        else:
            sty = int(cmd[1])
            stx = int(cmd[2])
            if(check(stx,sty)):
                vis = [([0] * line[0]) for _ in range(line[1])]
                solve(stx,sty,cmd[3])
    for pp in range(len(ans) - 1, -1, -1):
        for q in ans[pp]:
            sys.stdout.write(q)
        sys.stdout.write('\n')
    
    
    试题编号: 201604-3
    试题名称: 路径解析
    时间限制: 1.0s
    内存限制: 256.0MB
    问题描述:

    问题描述

      在操作系统中,数据通常以文件的形式存储在文件系统中。文件系统一般采用层次化的组织形式,由目录(或者文件夹)和文件构成,形成一棵树的形状。文件有内容,用于存储数据。目录是容器,可包含文件或其他目录。同一个目录下的所有文件和目录的名字各不相同,不同目录下可以有名字相同的文件或目录。
      为了指定文件系统中的某个文件,需要用路径来定位。在类 Unix 系统(Linux、Max OS X、FreeBSD等)中,路径由若干部分构成,每个部分是一个目录或者文件的名字,相邻两个部分之间用 / 符号分隔。
      有一个特殊的目录被称为根目录,是整个文件系统形成的这棵树的根节点,用一个单独的 / 符号表示。在操作系统中,有当前目录的概念,表示用户目前正在工作的目录。根据出发点可以把路径分为两类:
       绝对路径:以 / 符号开头,表示从根目录开始构建的路径。
       相对路径:不以 / 符号开头,表示从当前目录开始构建的路径。

      例如,有一个文件系统的结构如下图所示。在这个文件系统中,有根目录 / 和其他普通目录 d1、d2、d3、d4,以及文件 f1、f2、f3、f1、f4。其中,两个 f1 是同名文件,但在不同的目录下。

      对于 d4 目录下的 f1 文件,可以用绝对路径 /d2/d4/f1 来指定。如果当前目录是 /d2/d3,这个文件也可以用相对路径 ../d4/f1 来指定,这里 .. 表示上一级目录(注意,根目录的上一级目录是它本身)。还有 . 表示本目录,例如 /d1/./f1 指定的就是 /d1/f1。注意,如果有多个连续的 / 出现,其效果等同于一个 /,例如 /d1///f1 指定的也是 /d1/f1。
      本题会给出一些路径,要求对于每个路径,给出正规化以后的形式。一个路径经过正规化操作后,其指定的文件不变,但是会变成一个不包含 . 和 .. 的绝对路径,且不包含连续多个 / 符号。如果一个路径以 / 结尾,那么它代表的一定是一个目录,正规化操作要去掉结尾的 /。若这个路径代表根目录,则正规化操作的结果是 /。若路径为空字符串,则正规化操作的结果是当前目录。

    输入格式

      第一行包含一个整数 P,表示需要进行正规化操作的路径个数。
      第二行包含一个字符串,表示当前目录。
      以下 P 行,每行包含一个字符串,表示需要进行正规化操作的路径。

    输出格式

      共 P 行,每行一个字符串,表示经过正规化操作后的路径,顺序与输入对应。

    样例输入

    7
    /d2/d3
    /d2/d4/f1
    ../d4/f1
    /d1/./f1
    /d1///f1
    /d1/
    ///
    /d1/../../d2

    样例输出

    /d2/d4/f1
    /d2/d4/f1
    /d1/f1
    /d1/f1
    /d1
    /
    /d2

    评测用例规模与约定

      1 ≤ P ≤ 10。
      文件和目录的名字只包含大小写字母、数字和小数点 .、减号 - 以及下划线 _。
      不会有文件或目录的名字是 . 或 .. ,它们具有题目描述中给出的特殊含义。
      输入的所有路径每个长度不超过 1000 个字符。
      输入的当前目录保证是一个经过正规化操作后的路径。
      对于前 30% 的测试用例,需要正规化的路径的组成部分不包含 . 和 .. 。
      对于前 60% 的测试用例,需要正规化的路径都是绝对路径。

    用的大佬的思路  是真没看懂题啊

    import sys
    line = sys.stdin.readline().strip()
    n=int(line)
    now=sys.stdin.readline().strip()
    for _ in range(0, n):
        dir = sys.stdin.readline().strip()
        if(dir==""):
            sys.stdout.write(now+'\n')
            continue
        if(dir[0]!='/'):
            dir=now+'/'+dir
        dir=dir.replace('/',' ')
        dir=dir.split()
        #print(dir)
        ans=[]
        for x in dir:
            if (x=='.'):
                continue
            elif(x=='..'):
                if(len(ans)!=0):
                    ans.pop()
            else:
                ans.append(x)
        sys.stdout.write('/')
        for i in range(0,len(ans)):
            if(i!=0):
                sys.stdout.write('/')
            sys.stdout.write(ans[i])
        sys.stdout.write('\n')
    
    
    
    
    
    
    
    
    
    试题编号: 201609-3
    试题名称: 炉石传说
    时间限制: 1.0s
    内存限制: 256.0MB
    问题描述:

    问题描述

      《炉石传说:魔兽英雄传》(Hearthstone: Heroes of Warcraft,简称炉石传说)是暴雪娱乐开发的一款集换式卡牌游戏(如下图所示)。游戏在一个战斗棋盘上进行,由两名玩家轮流进行操作,本题所使用的炉石传说游戏的简化规则如下:

      * 玩家会控制一些角色,每个角色有自己的生命值攻击力。当生命值小于等于 0 时,该角色死亡。角色分为英雄随从
      * 玩家各控制一个英雄,游戏开始时,英雄的生命值为 30,攻击力为 0。当英雄死亡时,游戏结束,英雄未死亡的一方获胜。
      * 玩家可在游戏过程中召唤随从。棋盘上每方都有 7 个可用于放置随从的空位,从左到右一字排开,被称为战场。当随从死亡时,它将被从战场上移除。
      * 游戏开始后,两位玩家轮流进行操作,每个玩家的连续一组操作称为一个回合
      * 每个回合中,当前玩家可进行零个或者多个以下操作:
      1) 召唤随从:玩家召唤一个随从进入战场,随从具有指定的生命值和攻击力。
      2) 随从攻击:玩家控制自己的某个随从攻击对手的英雄或者某个随从。
      3) 结束回合:玩家声明自己的当前回合结束,游戏将进入对手的回合。该操作一定是一个回合的最后一个操作。
      * 当随从攻击时,攻击方和被攻击方会同时对彼此造成等同于自己攻击力的伤害。受到伤害的角色的生命值将会减少,数值等同于受到的伤害。例如,随从 X 的生命值为 HX、攻击力为 AX,随从 Y 的生命值为 HY、攻击力为 AY,如果随从 X 攻击随从 Y,则攻击发生后随从 X 的生命值变为 HX - AY,随从 Y 的生命值变为 HY - AX。攻击发生后,角色的生命值可以为负数。
      本题将给出一个游戏的过程,要求编写程序模拟该游戏过程并输出最后的局面。

    输入格式

      输入第一行是一个整数 n,表示操作的个数。接下来 n 行,每行描述一个操作,格式如下:
      <action> <arg1> <arg2> ...
      其中<action>表示操作类型,是一个字符串,共有 3 种:summon表示召唤随从,attack表示随从攻击,end表示结束回合。这 3 种操作的具体格式如下:
      * summon <position> <attack> <health>:当前玩家在位置<position>召唤一个生命值为<health>、攻击力为<attack>的随从。其中<position>是一个 1 到 7 的整数,表示召唤的随从出现在战场上的位置,原来该位置及右边的随从都将顺次向右移动一位。
      * attack <attacker> <defender>:当前玩家的角色<attacker>攻击对方的角色 <defender>。<attacker>是 1 到 7 的整数,表示发起攻击的本方随从编号,<defender>是 0 到 7 的整数,表示被攻击的对方角色,0 表示攻击对方英雄,1 到 7 表示攻击对方随从的编号。
      * end:当前玩家结束本回合。
      注意:随从的编号会随着游戏的进程发生变化,当召唤一个随从时,玩家指定召唤该随从放入战场的位置,此时,原来该位置及右边的所有随从编号都会增加 1。而当一个随从死亡时,它右边的所有随从编号都会减少 1。任意时刻,战场上的随从总是从1开始连续编号。

    输出格式

      输出共 5 行。
      第 1 行包含一个整数,表示这 n 次操作后(以下称为 T 时刻)游戏的胜负结果,1 表示先手玩家获胜,-1 表示后手玩家获胜,0 表示游戏尚未结束,还没有人获胜。
      第 2 行包含一个整数,表示 T 时刻先手玩家的英雄的生命值。
      第 3 行包含若干个整数,第一个整数 p 表示 T 时刻先手玩家在战场上存活的随从个数,之后 p 个整数,分别表示这些随从在 T 时刻的生命值(按照从左往右的顺序)。
      第 4 行和第 5 行与第 2 行和第 3 行类似,只是将玩家从先手玩家换为后手玩家。

    样例输入

    8
    summon 1 3 6
    summon 2 4 2
    end
    summon 1 4 5
    summon 1 2 1
    attack 1 2
    end
    attack 1 1

    样例输出

    0
    30
    1 2
    30
    1 2

    样例说明

      按照样例输入从第 2 行开始逐行的解释如下:
      1. 先手玩家在位置 1 召唤一个生命值为 6、攻击力为 3 的随从 A,是本方战场上唯一的随从。
      2. 先手玩家在位置 2 召唤一个生命值为 2、攻击力为 4 的随从 B,出现在随从 A 的右边。
      3. 先手玩家回合结束。
      4. 后手玩家在位置 1 召唤一个生命值为 5、攻击力为 4 的随从 C,是本方战场上唯一的随从。
      5. 后手玩家在位置 1 召唤一个生命值为 1、攻击力为 2 的随从 D,出现在随从 C 的左边。
      6. 随从 D 攻击随从 B,双方均死亡。
      7. 后手玩家回合结束。
      8. 随从 A 攻击随从 C,双方的生命值都降低至 2。

    评测用例规模与约定

      * 操作的个数0 ≤ n ≤ 1000。
      * 随从的初始生命值为 1 到 100 的整数,攻击力为 0 到 100 的整数。
      * 保证所有操作均合法,包括但不限于:
      1) 召唤随从的位置一定是合法的,即如果当前本方战场上有 m 个随从,则召唤随从的位置一定在 1 到 m + 1 之间,其中 1 表示战场最左边的位置,m + 1 表示战场最右边的位置。
      2) 当本方战场有 7 个随从时,不会再召唤新的随从。
      3) 发起攻击和被攻击的角色一定存在,发起攻击的角色攻击力大于 0。
      4) 一方英雄如果死亡,就不再会有后续操作。
      * 数据约定:
      前 20% 的评测用例召唤随从的位置都是战场的最右边。
      前 40% 的评测用例没有 attack 操作。
      前 60% 的评测用例不会出现随从死亡的情况。

    import sys
    
    line = sys.stdin.readline().strip()
    n = int(line)
    p1 = [[0, 30]]
    p2 = [[0, 30]]
    now = 1
    for _ in range(0, n):
        x = sys.stdin.readline().strip()
        if (x[0] == 's'):
            x = x.split()
            p = int(x[1])
            a = int(x[2])
            h = int(x[3])
            if (now == 1):
                p1.insert(p, [a, h])
            else:
                p2.insert(p, [a, h])
        if (x[0] == 'a'):
            x = x.split()
            a = int(x[1])
            d = int(x[2])
            if (now == 1):
                p2[d][1] -= p1[a][0]
                p1[a][1] -= p2[d][0]
                if (p1[a][1] <= 0 and a!=0):
                    p1.remove(p1[a])
                if (p2[d][1] <= 0 and d!=0):
                    p2.remove(p2[d])
            else:
                p1[d][1] -= p2[a][0]
                p2[a][1] -= p1[d][0]
                if (p2[a][1] <= 0 and a!=0):
                    p2.remove(p2[a])
                if (p1[d][1] <= 0 and d!=0):
                    p1.remove(p1[d])
    
        if (x[0] == 'e'):
            if (now == 1):
                now = 2
            else:
                now = 1
        #print(p1)
        #print(p2)
    if (p1[0][1] > 0 and p2[0][1] > 0):
        sys.stdout.write('0' + '\n')
    elif (p1[0][1] <= 0 and p2[0][1] > 0):
        sys.stdout.write('-1' + '\n')
    elif (p1[0][1] > 0 and p2[0][1] <= 0):
        sys.stdout.write('1' + '\n')
    sys.stdout.write(str(p1[0][1]) + '\n')
    sys.stdout.write(str(str(len(p1)-1) + ' '))
    for i in range(1, len(p1)):
        sys.stdout.write(str(p1[i][1]) + ' ')
    sys.stdout.write('\n')
    sys.stdout.write(str(p2[0][1]) + '\n')
    sys.stdout.write(str(str(len(p2)-1) + ' '))
    for i in range(1, len(p2)):
        sys.stdout.write(str(p2[i][1]) + ' ')
    sys.stdout.write('\n')
    试题编号: 201612-3
    试题名称: 权限查询
    时间限制: 1.0s
    内存限制: 256.0MB
    问题描述:

    问题描述

      授权 (authorization) 是各类业务系统不可缺少的组成部分,系统用户通过授权机制获得系统中各个模块的操作权限。
      本题中的授权机制是这样设计的:每位用户具有若干角色,每种角色具有若干权限。例如,用户 david 具有 manager 角色,manager 角色有 crm:2 权限,则用户 david 具有 crm:2 权限,也就是 crm 类权限的第 2 等级的权限。
      具体地,用户名和角色名称都是由小写字母组成的字符串,长度不超过 32。权限分为分等级权限和不分等级权限两大类。分等级权限由权限类名和权限等级构成,中间用冒号“:”分隔。其中权限类名也是由小写字母组成的字符串,长度不超过 32。权限等级是一位数字,从 0 到 9,数字越大表示权限等级越高。系统规定如果用户具有某类某一等级的权限,那么他也将自动具有该类更低等级的权限。例如在上面的例子中,除 crm:2 外,用户 david 也具有 crm:1 和 crm:0 权限。不分等级权限在描述权限时只有权限类名,没有权限等级(也没有用于分隔的冒号)。
      给出系统中用户、角色和权限的描述信息,你的程序需要回答多个关于用户和权限的查询。查询可分为以下几类:
      * 不分等级权限的查询:如果权限本身是不分等级的,则查询时不指定等级,返回是否具有该权限;
      * 分等级权限的带等级查询:如果权限本身分等级,查询也带等级,则返回是否具有该类的该等级权限;
      * 分等级权限的不带等级查询:如果权限本身分等级,查询不带等级,则返回具有该类权限的等级;如果不具有该类的任何等级权限,则返回“否”。

    输入格式

      输入第一行是一个正整数 p,表示不同的权限类别的数量。紧接着的 p 行被称为 P 段,每行一个字符串,描述各个权限。对于分等级权限,格式为 <category>:<level>,其中 <category> 是权限类名,<level> 是该类权限的最高等级。对于不分等级权限,字符串只包含权限类名。
      接下来一行是一个正整数 r,表示不同的角色数量。紧接着的 r 行被称为 R 段,每行描述一种角色,格式为
      <role> <s> <privilege 1> <privilege 2> ... <privilege s>
      其中 <role> 是角色名称,<s> 表示该角色具有多少种权限。后面 <s> 个字符串描述该角色具有的权限,格式同 P 段。
      接下来一行是一个正整数 u,表示用户数量。紧接着的 u 行被称为 U 段,每行描述一个用户,格式为
      <user> <t> <role 1> <role 2> ... <role t>
      其中 <user> 是用户名,<t> 表示该用户具有多少种角色。后面 <t> 个字符串描述该用户具有的角色。
      接下来一行是一个正整数 q,表示权限查询的数量。紧接着的 q 行被称为 Q 段,每行描述一个授权查询,格式为 <user> <privilege>,表示查询用户 <user> 是否具有 <privilege> 权限。如果查询的权限是分等级权限,则查询中的 <privilege> 可指定等级,表示查询该用户是否具有该等级的权限;也可以不指定等级,表示查询该用户具有该权限的等级。对于不分等级权限,只能查询该用户是否具有该权限,查询中不能指定等级。

    输出格式

      输出共 q 行,每行为 false、true,或者一个数字。false 表示相应的用户不具有相应的权限,true 表示相应的用户具有相应的权限。对于分等级权限的不带等级查询,如果具有权限,则结果是一个数字,表示该用户具有该权限的(最高)等级。如果用户不存在,或者查询的权限没有定义,则应该返回 false。

    样例输入

    3
    crm:2
    git:3
    game
    4
    hr 1 crm:2
    it 3 crm:1 git:1 game
    dev 2 git:3 game
    qa 1 git:2
    3
    alice 1 hr
    bob 2 it qa
    charlie 1 dev
    9
    alice game
    alice crm:2
    alice git:0
    bob git
    bob poweroff
    charlie game
    charlie crm
    charlie git:3
    malice game

    样例输出

    false
    true
    false
    2
    false
    true
    false
    true
    false

    样例说明

      样例输入描述的场景中,各个用户实际的权限如下:
      * 用户 alice 具有 crm:2 权限
      * 用户 bob 具有 crm:1、git:2 和 game 权限
      * 用户 charlie 具有 git:3 和 game 权限
      * 用户 malice 未描述,因此不具有任何权限

    评测用例规模与约定

      评测用例规模:
      * 1 ≤ pru ≤ 100
      * 1 ≤ q ≤ 10 000
      * 每个用户具有的角色数不超过 10,每种角色具有的权限种类不超过 10
      约定:
      * 输入保证合法性,包括:
      1) 角色对应的权限列表(R 段)中的权限都是之前(P 段)出现过的,权限可以重复出现,如果带等级的权限重复出现,以等级最高的为准
      2) 用户对应的角色列表(U 段)中的角色都是之前(R 段)出现过的,如果多个角色都具有某一分等级权限,以等级最高的为准
      3) 查询(Q 段)中的用户名和权限类名不保证在之前(U 段和 P 段)出现过
      * 前 20% 的评测用例只有一种角色
      * 前 50% 的评测用例权限都是不分等级的,查询也都不带等级

    import sys
    
    line = sys.stdin.readline().strip()
    n = int(line)
    au=[]
    for i in range(0,n):
        tt=sys.stdin.readline().strip()
        au.append(au)
    line = sys.stdin.readline().strip()
    n = int(line)
    xx={}
    for i in range(0,n):
        tt=sys.stdin.readline().strip()
        tt=tt.split(' ')
        tt.remove(tt[1])
        bas=[]
        for ii in tt[1:]:
            if(':' in ii):
                ii=ii.split(':')
                gg=int(ii[1])
                if(ii[0] not in bas):
                    bas.append(ii[0])
                for j in range(gg,-1,-1):
                    add=ii[0]+':'+str(j)
                    if(add not in bas):
                        bas.append(add)
            else:
                 bas.append(ii)
        xx[tt[0]]=bas
    #print(str(xx))
    line = sys.stdin.readline().strip()
    n = int(line)
    user={}
    for i in range(0,n):
        tt=sys.stdin.readline().strip()
        tt=tt.split(' ')
        tt.remove(tt[1])
        basic=[]
        for lit in tt[1:]:
            basic.append(xx[lit])
        user[tt[0]]=basic
    #print(str(user))
    line = sys.stdin.readline().strip()
    n = int(line)
    for i in range(0,n):
        cc = sys.stdin.readline().strip()
        cc=cc.split(' ')
        if(cc[0] in user):
            o=0
            flag=False
            zz=0
            if(':' in cc[0]):
                for auth in user[cc[0]]:
                    if(cc[1] in auth):
                        o+=1
                        if(o>=1):
                            break
            else :
                kk = cc[1] + ':' + str(zz)
                for auth in user[cc[0]]:
                    if (kk in auth):
                        flag = True
                        while (kk in auth):
                            kk = cc[1] + ':' + str(zz)
                            zz += 1
                    else:
                        if (cc[1] in auth):
                            o += 1
            if(flag):
                sys.stdout.write(str(zz-2)+'\n')
            elif(o>=1):
                sys.stdout.write('true'+'\n')
            else:
                sys.stdout.write('false'+'\n')
        else:
            sys.stdout.write('false'+'\n')
    '''
    6
    crm:2
    crm:7
    hhhh
    jj
    ll
    git:5
    3
    rr 3 crm:5 hhhh jj
    cc 5 hhhh git:0 ll jj crm:0
    qq crm:4 ll
    4
    a 1 rr 
    b 2 cc qq
    c 3 qq rr
    d 1 cc
    '''

     

    展开全文
  • 前言 暂1 202009-3点亮数字人生 前两个测试点(Q=1):最后print的有错误 def cal_one(func, num_lst): if func == "NOT": flag = not num_lst[0] elif func == "AND": flag = not 0 in num_lst ...

    前言

    暂1

    202009-3点亮数字人生

    前两个测试点(Q=1):最后print的有错误

    def cal_one(func, num_lst):
        if func == "NOT":
            flag = not num_lst[0]
        elif func == "AND":
            flag = not 0 in num_lst
        elif func == "OR":
            flag = 1 in num_lst
        elif func == "XOR":
            flag = num_lst[0]
            for num in num_lst[1:]:
                flag = 1 if flag != num else 0
        elif func == "NAND":
            flag = 0 in num_lst
        else:
            flag = not 1 in num_lst
        if type(flag) == int:
            return flag
        return 1 if flag == True else 0
    
    def cal_all(I_lst, cell_lst):
        tmp_O_lst = []
        for cell in cell_lst:
            func = cell[0]
            num_lst = [I_lst[int(i[1:])-1] if i[0] == "I" else tmp_O_lst[int(i[1:])-1] for i in cell[2:]]
            tmp_O_lst.append(cal_one(func, num_lst))
        return tmp_O_lst
    
    
    Q = int(input())
    for q in range(Q):
        M,N = list(map(int, input().split()))
        cell_lst = []
        O_lst = []
        for n in range(N):
            cell_lst.append(input().split())
        S = int(input())
        for s in range(S):
            I_lst = list(map(int, input().split()))
            O_lst.append(cal_all(I_lst, cell_lst))
        for s in range(S):
            input_lst = list(map(int,input().split()))
            cell_num = input_lst[0]
            for idx,cell_idx in enumerate(input_lst[1:]):
                if idx!= cell_num -1:
                    print(O_lst[s][cell_idx-1], end=" ")
                else:
                	# 这里写错了
                    if s != S-1:
                        print(O_lst[s][cell_idx-1])
                    else:
                        print(O_lst[s][cell_idx-1], end="")
    

    在这里插入图片描述
    前5个测试点:没有考虑环

    def cal_one(func, num_lst):
        if func == "NOT":
            flag = not num_lst[0]
        elif func == "AND":
            flag = not 0 in num_lst
        elif func == "OR":
            flag = 1 in num_lst
        elif func == "XOR":
            flag = num_lst[0]
            for num in num_lst[1:]:
                flag = 1 if flag != num else 0
        elif func == "NAND":
            flag = 0 in num_lst
        else:
            flag = not 1 in num_lst
        if type(flag) == int:
            return flag
        return 1 if flag == True else 0
    
    def cal_all(I_lst, cell_lst):
        tmp_O_lst = []
        for cell in cell_lst:
            func = cell[0]
            num_lst = [I_lst[int(i[1:])-1] if i[0] == "I" else tmp_O_lst[int(i[1:])-1] for i in cell[2:]]
            tmp_O_lst.append(cal_one(func, num_lst))
        return tmp_O_lst
    
    
    Q = int(input())
    for q in range(Q):
        M,N = list(map(int, input().split()))
        cell_lst = []
        O_lst = []
        for n in range(N):
            cell_lst.append(input().split())
        S = int(input())
        for s in range(S):
            I_lst = list(map(int, input().split()))
            O_lst.append(cal_all(I_lst, cell_lst))
        for s in range(S):
            input_lst = list(map(int,input().split()))
            cell_num = input_lst[0]
            for idx,cell_idx in enumerate(input_lst[1:]):
                if idx!= cell_num -1:
                    print(O_lst[s][cell_idx-1], end=" ")
                else:
                    print(O_lst[s][cell_idx-1])
    

    在这里插入图片描述
    全部测试点

    def cal_one(func, num_lst):
        if func == "NOT":
            flag = not num_lst[0]
        elif func == "AND":
            flag = not 0 in num_lst
        elif func == "OR":
            flag = 1 in num_lst
        elif func == "XOR":
            flag = num_lst[0]
            for num in num_lst[1:]:
                flag = 1 if flag != num else 0
        elif func == "NAND":
            flag = 0 in num_lst
        else:
            flag = not 1 in num_lst
        if type(flag) == int:
            return flag
        return 1 if flag == True else 0
    
    def cal_all(I_lst, cell_lst):
        tmp_O_lst = []
        for cell in cell_lst:
            func = cell[0]
            num_lst = []
            for i in cell[2:]:
                if i[0] == "I":
                    num_lst.append(I_lst[int(i[1:])-1])
                else:
                    # circle
                    if int(i[1:]) > len(tmp_O_lst):
                        return False
                    else:
                        num_lst.append(tmp_O_lst[int(i[1:])-1])
                    int(i[1:]) - 1
            # num_lst = [I_lst[int(i[1:])-1] if i[0] == "I" else tmp_O_lst[int(i[1:])-1] for i in cell[2:]]
            tmp_O_lst.append(cal_one(func, num_lst))
        return tmp_O_lst
    
    
    Q = int(input())
    for q in range(Q):
        M,N = list(map(int, input().split()))
        cell_lst = []
        O_lst = []
        for n in range(N):
            cell_lst.append(input().split())
        S = int(input())
        for s in range(S):
            I_lst = list(map(int, input().split()))
            result = cal_all(I_lst, cell_lst)
            O_lst.append(cal_all(I_lst, cell_lst))
        for s in range(S):
            input_lst = list(map(int,input().split()))
            if O_lst[s] != False:
                cell_num = input_lst[0]
                for idx,cell_idx in enumerate(input_lst[1:]):
                    if idx!= cell_num -1:
                        print(O_lst[s][cell_idx-1], end=" ")
                    else:
                        print(O_lst[s][cell_idx-1])
                else:
                    continue
        # print LOOP
        if O_lst[0] == False:
            print("LOOP")
    

    在这里插入图片描述

    展开全文
  • cnt1[i]--i个字符串的项数,isp--待查询的字符串末尾是否为‘/’,sp[i]--i个字符串末尾是否为‘/’ 12 string str[maxn],str1[maxn],str2; // str[i]--i个字符串的配置信息,str1[i]--i个映射规则,...

    URL映射

    1. 规则的相邻两项之间用‘/’分开,所以我们先把所有项分开,然后依次把两个字符串的对应项匹配即可。
    2. 分离字符串这里用字符串流(stringstream)处理,先把所有的‘/’变为空格,然后一个一个把各项分开。
    3. 在把‘/’变为空格的时候,要注意行末的‘/’,比如:
      /okokokok  与  /okokokok/是无法匹配成功的。同样的:/<str>/ 与/okokok也无法匹配成功。
    4. 模拟,注意细节和边界即可。
     1 #include<iostream>
     2 #include<sstream>
     3 #include<cstring>
     4 #include<string>
     5 #include<cstdio>
     6 #include<vector>
     7 #include<algorithm>
     8 #define LL unsigned long long
     9 using namespace std;
    10 const int maxn=101;
    11 int cnt1[maxn],isp,sp[maxn]; //cnt1[i]--第i个字符串的项数,isp--待查询的字符串末尾是否为‘/’,sp[i]--第i个字符串末尾是否为‘/’
    12 string str[maxn],str1[maxn],str2; //str[i]--第i个字符串的配置信息,str1[i]--第i个映射规则,str2--当前需要被查询的字符串
    13 string sp1[maxn][maxn],sp2[maxn]; //sp1[i]--保存第i个字符串的所有项,sp2--保存当前被查询字符串的所有项。
    14 string is_num(string s){  //判断某一项是否为整数:是--去掉前导0并返回整数;不是--返回“-”
    15     int ok=0;
    16     string ss="";
    17     int len=s.length();
    18     for(int i=0;i<len;i++){
    19         if(s[i]<'0'||s[i]>'9')return "-";
    20         if(ok||s[i]!='0')ss+=s[i],ok=1;
    21     }
    22     if(ss=="")ss="0";
    23     return ss;
    24 }
    25 void getinfo(string s,string s1[],int &f,int &t){ //分离并保存一个字符串的所有项,标记末尾是否为‘/’
    26     f=t=0;
    27     int len=s.length();
    28     if(s[len-1]=='/')f=1;
    29     for(int p=0;p<len;p++){
    30         if(s[p]=='/')s[p]=' ';
    31     }
    32     string ss;
    33     stringstream in(s);
    34     while(in>>ss)s1[t++]=ss;
    35 }
    36 bool match(int t,int j,string &s){ //判断被查询字符串与第j个规则是否能匹配
    37     s="";
    38     int p1=0,p2=0;
    39     while(p1<t&&p2<cnt1[j]){
    40         if(sp2[p1]==sp1[j][p2]);
    41         else if(sp1[j][p2]=="<int>"){
    42             string f=is_num(sp2[p1]);
    43             if(f=="-"){return 0;}
    44             s+=" "+f;
    45         }
    46         else if(sp1[j][p2]=="<str>"){s+=" "+sp2[p1];}
    47         else if(sp1[j][p2]=="<path>"){                 //<path>直接全部加上
    48             s+=" "+sp2[p1++];
    49             while(p1<t)s+="/"+sp2[p1++];
    50             if(isp)s+='/';
    51             return 1;
    52         }
    53         else return 0;
    54         p1++;p2++;
    55     }
    56     if(isp^sp[j])return 0; //末尾判断--同时有‘/’或同时无‘/’才能匹配
    57     if(p1!=t||p2!=cnt1[j])return 0; //完全匹配
    58     return 1;
    59 }
    60 int main(){                                          
    61     freopen("in.txt","r",stdin);
    62     int n,m;
    63     cin>>n>>m;
    64     for(int i=0;i<n;i++){
    65         cin>>str1[i]>>str[i];
    66         getinfo(str1[i],sp1[i],sp[i],cnt1[i]);  //string, split, 末尾是否'/', 字符串数量
    67     }
    68     for(int i=0;i<m;i++){
    69         string ans;
    70         int cnt=0;isp=0;
    71         cin>>str2;
    72         getinfo(str2,sp2,isp,cnt);
    73         bool ok=0;
    74         for(int j=0;j<n;j++){
    75             if(match(cnt,j,ans)){
    76                 cout<<str[j]<<ans<<endl;;
    77                 ok=1;break;
    78             }
    79         }
    80         if(!ok)cout<<404<<endl;
    81     }
    82     return 0;
    83 }

    路径解析

    以及末尾有/

     1 #include<iostream>
     2 #include <string>
     3 #include <vector>
     4 using namespace std;
     5 int main()
     6 {
     7     int num,pos,pos1;
     8     string curDir,line;
     9     cin >> num >> curDir;
    10     getchar(); // 使用getline要注意处理回车符
    11     while (num--)
    12     {
    13         getline(cin, line); // 读空字符串
    14 
    15         if (line.empty())line = curDir; //
    16         else if (line[0] != '/')line = curDir + "/" + line; //  1.首位不为'/'的情况,将相对路径转化为绝对路径
    17 
    18         while ((pos = line.find("//")) != -1) line.erase(pos, 1);//   2.出现///
    19 
    20         while ((pos = line.find("/../")) != -1) //  3.出现/../
    21         {
    22             if (!pos)line.erase(0, 3);
    23             else{
    24                 pos1 = line.rfind("/", pos - 1);
    25                 line.erase(pos1, pos - pos1 + 3);
    26             }
    27         }
    28         while ((pos = line.find("/./")) != -1)line.erase(pos, 2);//  4.出现/./
    29 
    30         if (line.size()>1 && line[line.size() - 1] == '/')line.erase(line.size() - 1, 1);//   5.末尾有/
    31 
    32         cout << line << endl;
    33     }
    34     return 0;
    35 }、

    ——如果用cin>>line的方式输入string类型的line,会导致不能判断为空的输入,所以采用getline。在while循环之前还需要添加getchar(),吸收换行。否则90分;

    ——c++中单双引号的区别:

    ""是字符串,C风格字符串后面有一个'\0';''是一个字符,一共就一字节。

    单引号表示是字符变量值,字母的本质也是数字。双引号表示字符串变量值,给字符串赋值时系统会自动给字符串变量后面加上一个\0来表示字符串结尾。

    string::rfind(string, pos) 是从头开始找,到pos为止,最后一次出现string的位置。

    权限查询

    map的灵活运行,给出集合A和集合B,集合B和集合C的关系,计算集合C和集合A的关系,因为会出现重叠的元素,所以要遍历所有的A集合中的元素,取最大。

    用到知识点:

    map<string, map<string, int>>

    map::count() 返回0,1

    map<string, int>::iterator it--it->first, it->second

    string::substr(start, len)--s.substr(0,3)

    string::find(string)返回找到的pos,-1

    #include <iostream>
    #include <vector>
    #include <string>
    #include <map>
    using namespace std;
    
    map<string,int> cate;
    map<string,map<string, int> > rol;
    map<string,map<string,int> > usr;
    
    void find(string u, string role, int level){
        if(usr.count(u)>0&&usr[u].count(role)>0)
        {
            int lev = usr[u][role];
            if(level==-1)
            {
                if(lev>-1)cout<<lev<<endl;
                else cout<<"true"<<endl;
            }
            else
            {
                if(lev<level)cout<< "false"<<endl;
                else cout<<"true"<<endl;
            }
        }
        else cout<<"false"<<endl;
    }
    
    int to_int(string s,int pos)
    {
        int ans=0;
        for(int i=pos;i<s.size();i++)
        {
            ans = ans*10 + s[i]-'0';
        }
        return ans;
    }
    
    int main()
    {
        int p,r,u,q;
        cin>>p;
        string s;
        int level;
        size_t pos;
        for(int i=0;i<p;i++) {
            cin >> s;
            if ((pos = s.find(":")) != -1)
            {
                level = to_int(s,pos+1);
                s = s.substr(0,pos);
                cate[s]=max(cate[s],level);
            }
            else cate[s]=-1;
        }
    
        cin>>r;
        int cnt;
        string role;
        for(int i=0;i<r;i++)
        {
            cin>>role>>cnt;
            for(int j=0;j<cnt;j++)
            {
                cin>>s;
                if ((pos = s.find(":")) != -1)
                {
                    level = to_int(s,pos+1);
                    s = s.substr(0,pos);
                    rol[role][s]=max(rol[role][s],level);
                }
                else rol[role][s]=-1;
            }
        }
        cin>>u;
        for(int i =0;i<u;i++) // 直接和cate通过role关联
        {
            string name;
            cin>>name>>cnt;
            for(int j=0;j<cnt;j++)
            {
                cin>>s;
                map<string,int>::iterator it = rol[s].begin();
                while(it!=rol[s].end())
                {
                    if(usr[name].count(it->first)>0)// 这里必须要区分是否存在,否则默认的0会覆盖-1
                    {
                        usr[name][it->first]=max(usr[name][it->first],it->second);
                    }
                    else
                        usr[name][it->first] = it->second;
                    it++;
                }
            }
        }
        cin>>q;
        while(q--)
        {
            string x;
            cin>>s>>x;
            size_t pos=x.find(":");
            if(pos==string::npos) find(s,x,-1);
            else find(s,x.substr(0,pos),x[pos+1]-'0');//string_to_int的另一种写法
        }
        return 0;
    }

     JSON查询

    解法转自meelo

    json是一个递归数据结构,因此可以使用函数的递归调用来进行解析。

    每一类数据对应一个解析函数,代码中parseString实现解析字符串的功能,parseObject实现解析对象的功能。

    解析函数的主体功能就是依次遍历每一个字符,根据字符判断是否是字符串的开始、对象的开始……并进行相应的处理。

    json是一个键值对的结构,因此可以用map存储。map的键可以用查询的格式,用小数点.来分隔多层的键。

      1 #include <iostream>
      2 #include <cassert>
      3 #include <map>
      4 using namespace std;
      5 
      6 string parseString(string &str, int &i) { 
      7     string tmp;
      8     if(str[i] == '"') i++;
      9     else assert(0);
     10 
     11     while(i < str.size()) {
     12         if(str[i] == '\\') {
     13             i++;
     14             tmp += str[i];
     15             i++;
     16         }
     17         else if(str[i] == '"') {
     18             break;
     19         }
     20         else {
     21             tmp += str[i];
     22             i++;
     23         }
     24     }
     25 
     26     if(str[i] == '"') i++;
     27     else assert(0);
     28 
     29     return tmp;
     30 }
     31 
     32 void parseObject(string &str, string prefix, map<string, string> &dict, int &i) {
     33     if(str[i] == '{') i++;
     34     else assert(0);
     35 
     36     string key, value;
     37     bool strType = false; // 标志 false:key, true:value
     38     while(i < str.size()) {
     39         if(str[i] == '"') {
     40             string tmp = parseString(str, i);
     41             if(strType) { // value
     42                 value = tmp;
     43                 dict[key] = value;
     44             }
     45             else { // key
     46                 key = prefix + (prefix==""?"":".") + tmp;
     47             }
     48         }
     49         else if(str[i] == ':') {
     50             strType = true;
     51             i++;
     52         }
     53         else if(str[i] == ',') {
     54             strType = false;
     55             i++;
     56         }
     57         else if(str[i] == '{') {
     58             dict[key] = "";
     59             parseObject(str, key, dict, i);
     60         }
     61         else if(str[i] == '}') {
     62             i++;
     63             break;
     64         }
     65         else {
     66             i++;
     67         }
     68     }
     69 }
     70 
     71 int main() {
     72     int N, M;
     73     cin >> N >> M;
     74     string json;
     75     if(cin.peek()=='\n') cin.ignore();
     76     for(int n=0; n<N; n++) { // 输入用getline(保留空格,空)连成一个string
     77         string tmp;
     78         getline(cin, tmp);
     79         json += tmp;
     80     }
     81     map<string, string> dict; // 存储所有候选键值对
     82     int i = 0;
     83     parseObject(json, "", dict, i); // json是一个递归结构,递归解析
     84     string query;
     85     for(int m=0; m<M; m++) {
     86         getline(cin, query);
     87         if(dict.find(query) == dict.end()) {
     88             cout << "NOTEXIST\n";
     89         }
     90         else {
     91             if(dict[query] == "") {
     92                 cout << "OBJECT\n";
     93             }
     94             else {
     95                 cout << "STRING " << dict[query] << "\n";
     96             }
     97         }
     98     }
     99     return 0;
    100 }

     MarkDown

    解法转自:meelo 逻辑异常清晰,这老哥写的代码会说话2333

    Markdown分为区块结构和行内结构。
    区块结构的类型可以根据第一个符号进行辨别,区块结构结束的可以通过空行来辨别。
    行内结构与区块结构的处理不同,则需要分析每一行的内容。
    因此程序的两个主题部分: 分割区块、处理行内结构。处理区块结构的逻辑在main函数中,处理行内结构的逻辑在parseLine函数中。
    每一种语法对应于一个函数。
      1 #include <iostream>
      2 #include <vector>
      3 #include <string>
      4 #include <cassert>
      5 
      6 using namespace std;
      7 
      8 string to_string(int i) {
      9     char buffer[10];
     10     return string(itoa(i, buffer, 10));
     11 }
     12 
     13 string parseEmphasize(string text) {
     14     string result;
     15     result += "<em>";
     16     result += text;
     17     result += "</em>";
     18     return result;
     19 }
     20 
     21 string parseLink(string text, string link) {
     22     string result;
     23     result += "<a href=\"";
     24     result += link;
     25     result += "\">";
     26     result += text;
     27     result += "</a>";
     28     return result;
     29 }
     30 
     31 string parseLine(string line) { // 行内解析,包含递归调用
     32     string result;
     33     int i = 0;
     34     while(i<line.size()) {
     35         if(line[i]=='[') {
     36             string text, link;
     37             int j = i+1;
     38             while(line[j] != ']') j++;
     39             text = line.substr(i+1, j-i-1);
     40             i = j+1;
     41             assert(line[i]=='(');
     42             while(line[j]!=')') j++;
     43             link = line.substr(i+1, j-i-1);
     44             
     45             text = parseLine(text);
     46             link = parseLine(link);
     47             result += parseLink(text, link);
     48             i = j+1;
     49         }
     50         else if(line[i]=='_') {
     51             string text;
     52             int j = i+1;
     53             while(line[j]!='_') j++;
     54             text = line.substr(i+1, j-i-1);
     55             
     56             text = parseLine(text);
     57             result += parseEmphasize(text);
     58             i = j + 1;
     59         }
     60         else {
     61             result += line[i];
     62             i++;
     63         }
     64     }
     65     return result;
     66 }
     67 
     68 string parseHeading(vector<string> &contents) {
     69     assert(contents.size()==1);
     70     int level = 1;
     71     int i = 0;
     72     string heading = parseLine(contents[0]);
     73     
     74     while(heading[i] == '#') i++;
     75     level = i;
     76     while(heading[i] == ' ') i++;
     77     
     78     string result;
     79     result += "<h";
     80     result += to_string(level);
     81     result += '>';
     82     result += heading.substr(i,-1);
     83     result += "</h";
     84     result += to_string(level);
     85     result += ">\n";
     86     return result;
     87 }
     88 
     89 string parseParagraph(vector<string> &contents) {
     90     string result;
     91     result += "<p>";
     92     for(int i=0; i<contents.size(); i++) {
     93         result += parseLine(contents[i]);
     94         if(contents.size() != 0 && i != contents.size()-1) result += '\n';
     95     }
     96     result += "</p>\n";
     97     return result;
     98 }
     99 
    100 string parseUnorderedList(vector<string> &contents) {
    101     string result;
    102     result += "<ul>\n";
    103     int j;
    104     for(int i=0; i<contents.size(); i++) {
    105         result += "<li>";
    106         j = 1;
    107         while(contents[i][j] == ' ') j++;
    108         result += parseLine(contents[i].substr(j,-1));
    109         result += "</li>\n";
    110     }
    111     result += "</ul>\n";
    112     return result;
    113 }
    114 
    115 int main() {
    116     string line;
    117     vector<string> contents;
    118     int blockType; // 0:empty, 1:paragraph, 2:heading, 3:unordered list
    119     string result;
    120     while(getline(cin, line) || contents.size()>0) { // getline空行的时候注意
    121         if(line.empty()) {  // 结束的标志
    122             if(blockType != 0) {
    123                 switch(blockType) {
    124                     case 1: result += parseParagraph(contents); break;
    125                     case 2: result += parseHeading(contents); break;
    126                     case 3: result += parseUnorderedList(contents); break;
    127                 }
    128                 contents.resize(0);
    129                 blockType = 0;
    130             }
    131         }
    132         else if(line[0] == '#') {
    133             contents.push_back(line);
    134             blockType = 2;
    135         }
    136         else if(line[0] == '*') {
    137             contents.push_back(line);
    138             blockType = 3;
    139         }
    140         else {
    141             contents.push_back(line);
    142             blockType = 1;
    143         }
    144         line = "";
    145     }
    146     cout << result;
    147 }

     

    转载于:https://www.cnblogs.com/demian/p/9609223.html

    展开全文
  • #include &lt;iostream&gt; #include &lt;bits/stdc++.h&gt; using namespace std; int ans=0; int main() { int s; int t=0; int flag=0; int base=1; while(cin&......
  • 模拟 #include &lt;bits/stdc++.h&gt; using namespace std; int n,l,t; struct ball { int pos,v; void init(int p) { pos=p; v=1; } void run() { pos+=v; ...
  • CSP第线性分类器

    2021-03-24 09:41:48
    这个的难度不小,先理清题意:输入n个点,其中每个点都属于A类或者B类。再输入m组数据,是方程的参数,这组数据可以确定一条...现在解决二个问题,键入组数据,如何判断是不是将AB组数据分开了呢,只需判断将x
  • CSP第消除类游戏

    2021-03-24 10:03:07
    两番遍历数组,一次是横着遍历,为了使横排连着个相等的位置被记录,这个时候就使列++之后再使行++,还有就是要注意列数遍历到n-2个位置即可因为后面还要加的。 找连行相等也是同理,但是现在是使行先++完了再使...
  • csp杂记-历年第三题

    2021-04-10 01:04:03
    201403-3 命令行选项 #include <iostream> #include <string> #include <cstdio> #include <cmath> #include <algorithm> #include <vector> #include <...#i
  • 问题描述  授权 (authorization) 是各类业务系统不可缺少的组成部分,系统...例如,用户 david 具有 manager 角色,manager 角色有 crm:2 权限,则用户 david 具有 crm:2 权限,也就是 crm 类权限的 2 等级的权限。
  • 会给出一些路径,要求对于每个路径,给出正规化以后的形式。一个路径经过正规化操作后,其指定的文件不变,但是会变成一个不包含 . 和 … 的绝对路径,且不包含连续多个 / 符号。如果一个路径以 / 结尾,那么它...
  • Input 1行有个整数m, n和q。m和n分别表示画布的宽度和高度,以字符为单位。q表示画图操作的个数。 2行至q + 1行,每行是以下两种形式之一: ① 0 x1 y1 x2 y2:表示画线段的操作,(x1, y1)和(x2, y2)分别是...
  • CCF CSP真题刷题,做到2020年9月的真题,第三题:“点亮数字人生”的时候,遇到了奇怪的问题。 本人利用面向对象的方法实现了这道模拟题,自认为逻辑比较清晰了,不管使用什么网上的什么测试用例,代码均能通过。 ...
  • 箴言录: 知之者不如好知者,好知者不如乐之者。
  • CSP题库-2013年12月第三题(最大的矩形)问题问题描述输入格式输出格式样例输入样例输出Python代码知识点总结 问题 问题描述 在横轴上放了n个相邻的矩形,每个矩形的宽度是1,而第i(1 ≤ i ≤ n)个矩形的高度是hi...
  • 会给出一些路径,要求对于每个路径,给出正规化以后的形式。一个路径经过正规化操作后,其指定的文件不变,但是会变成一个不包含 . 和 … 的绝对路径,且不包含连续多个 / 符号。如果一个路径以 / 结尾,那么它...
  • csp 2020-9-13 第三题

    2020-09-16 08:58:27
    题意:这道大体就是给你一个组合电路,有输入信号和电器元件,他给你一些值然后让你输出询问的电器元件计算的值。 首先是输入: 一行是q代表查询的次数,然后是m,n,分别是输入信号的数目和电器元件的数目。之后...
  • 2019年CSP-J第二轮认证,第三题纪念品。 题目链接:http://47.110.135.197/problem.php?id=5078。 题面 小伟突然获得一种超能力,他知道未来 T 天 N 种纪念品每天的价格。某个纪念品的价格是指购买一个该纪念品所...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 290
精华内容 116
关键字:

csp第三题