ccf刷题记04

最新推荐文章于 2024-06-24 21:09:13 发布
最新推荐文章于 2024-06-24 21:09:13 发布
阅读量436 收藏
点赞数 1
分类专栏： 模拟 字符串 stl 文章标签： acm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Owen_Q/article/details/78237560
版权

不知不觉，近两年的ccf前两题都刷完了呢

大概总结一下，第一题就是个简单水题，热身签到

第二题是个简单模拟，多数是对数据或自创数据结构排序的考察，细心分析内部关系就好了

第三题就是个大模拟了，一般条件考虑还比较多，细心才能成大事

这次就来三道大模拟吧

三道题都是个字符串处理题，string，用getline读取，那么先关一下cin同步吧

ios::sync_with_stdio(false);


201703-3 Markdown

思路：字符串处理，根据每行首元素判断标题、段落和无序列表，然后分别按要求处理

对于下划线和链接，需要单独写个函数特判，下划线是个全局变量，因为其嵌套性很强，而链接中很可能还要套链接，于是写成递归吧

这题细节点很多，6次尝试后终于拿了满分

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
#include <map>
#include <cmath>
#include <string>
#include <queue>
#include <stack>

using namespace std;

bool down;

string dealstring(string s)
{
    int len = s.size();
    string re = "";
    for(int pos=0;pos<len;pos++)
    {
        if(s[pos] == '_')
        {
            if(down)
            {
                down = false;
                re += "</em>";
            }
            else
            {
                down = true;
                re += "<em>";
            }
            continue;
        }
        if(s[pos] == '[')
        {
            pos++;
            int st = pos;
            int slen = 1;
            while(s[pos]!= ']')
            {
                slen++;
                pos++;
            }
            string text = dealstring(s.substr(st,slen-1));
            pos++;
            pos++;
            st = pos;
            slen = 1;
            while(s[pos]!= ')')
            {
                slen++;
                pos++;
            }
            string link = dealstring(s.substr(st,slen-1));
            re += "<a href=\"" + link + "\">" + text + "</a>";
            continue;
        }
        re += s[pos];
    }
    return re;
}

int main()
{
    string line;
    bool star = false;
    bool paragraph = false;
    //freopen("in3.txt","r",stdin);
    down = false;
    while(getline(cin,line))
    {
        int len = line.size();
        if(len==0)
        {
            if(star)
            {
                star = false;
                cout << "</ul>" << endl;
            }
            if(paragraph)
            {
                paragraph = false;
                cout << "</p>" << endl;
            }
            continue;
        }
        if(line[0]=='#')
        {
            if(star)
            {
                star = false;
                cout << "</ul>" << endl;
            }
            if(paragraph)
            {
                paragraph = false;
                cout << "</p>" << endl;
            }
            int num = 1;
            int pos = 1;
            while(pos <= len)
            {
                if(line[pos]=='#')
                {
                    num++;
                }
                else if(line[pos]!=' ')
                {
                    break;
                }
                pos++;
            }
            cout << "<h" << num << ">";
            cout << dealstring(line.substr(pos,len-pos));
            cout << "</h" << num << ">" << endl;
        }
        else if(line[0]=='*')
        {
            if(paragraph)
            {
                paragraph = false;
                cout << "</p>" << endl;
            }
            if(!star)
            {
                star = true;
                cout << "<ul>" << endl;
            }
            cout << "<li>";
            int pos = 1;
            while(pos <= len)
            {
                if(line[pos]!=' ')
                {
                    break;
                }
                pos++;
            }
            cout <<dealstring(line.substr(pos,len-pos));
            cout << "</li>" << endl;
        }
        else
        {
            if(star)
            {
                star = false;
                cout << "</ul>" << endl;
            }
            if(!paragraph)
            {
                paragraph = true;
                cout << "<p>";
            }
            else
            {
                cout << endl;
            }
            int pos = 0;
            while(pos <= len)
            {
                if(line[pos]!=' ')
                {
                    break;
                }
                pos++;
            }
            cout << dealstring(line.substr(pos,len-pos));
        }
    }
    if(star)
    {
        star = false;
        cout << "</ul>" << endl;
    }
    if(paragraph)
    {
        paragraph = false;
        cout << "</p>" << endl;
    }
    return 0;
}

/*
#  Heading
##  Sub-heading

Paragraphs are seperated
by a blank line.


Text attributes _italic_.

Bullet list:


* apples
* oranges
* pears

A [link](http://example.com).
*/


201612-3 权限查询

思路：这题主要就是stl的嵌套，map套map，还是思路问题，大脑一定要清晰

对于第一个特权，既然后面限定特权合法，那么完全没用啊，直接读进来就好了，getline读缓冲区，时时输出检查，这题还挺顺利，差点一发ac，就是没注释freopen有点坑了

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
#include <map>
#include <cmath>
#include <string>
#include <queue>
#include <stack>

using namespace std;

const int maxn = 1e5+10;

map<string,map<string,int> > privilege;

int main()
{
    //cout << privilege["5"] << "*"<<endl;
    //freopen("in.txt","r",stdin);
    ios::sync_with_stdio(false);
    privilege.clear();
    int p;
    cin >> p;
    for(int i=0;i<=p;i++)
    {
        string temp;
        getline(cin,temp);
    }
    int r;
    cin >> r;
    for(int i=0;i<=r;i++)
    {
        string temp;
        getline(cin,temp);
        int len = temp.size();
        if(len == 0)
        {
            continue;
        }
        //cout << temp << "*&^" << endl;
        int pos;
        string role;
        temp += " ";
        len++;
        for(pos=0;pos<len;pos++)
        {
            if(temp[pos] == ' ')
            {
                break;
            }
        }
        role = temp.substr(0,pos);
        pos += 3;
        string pri;
        while(pos<len)
        {
            //cout << pos << "$$$" << endl;
            bool nex = false;
            int posstop;
            for(posstop=pos;posstop<len;posstop++)
            {
                if(temp[posstop] == ':')
                {
                    break;
                }
                else if(temp[posstop] == ' ')
                {
                    nex = true;
                    break;
                }
            }
            pri = temp.substr(pos,posstop-pos);
            //cout << pri << "%^&&^%" << endl;
            int ran = -1;
            if(nex)
            {
                nex = false;
            }
            else
            {
                posstop++;
                ran = temp[posstop]-'0';
                posstop++;
            }
            //cout << pri << "%^&&^%" << ran << endl;
            if((privilege.find(role)!=privilege.end())&&(privilege[role].find(pri)!=privilege[role].end()))
            {
                if(privilege[role][pri]<ran)
                {
                    privilege[role][pri] = ran;
                }
            }
            else
            {
                privilege[role][pri] = ran;
            }
            pos = posstop+1;
        }
    }
    /*map<string,map<string,int> > :: iterator it = privilege.begin();
    map<string,int> :: iterator itt;
    for(;it!=privilege.end();it++)
    {
        cout << (it->first) <<"*"<< endl;
        for(itt=(it->second).begin();itt!=(it->second).end();itt++)
        {
            cout << (itt->first) << "#" << (itt->second) << endl;
        }
    }*/
    int u;
    cin >> u;
    for(int i=0;i<=u;i++)
    {
        string temp;
        getline(cin,temp);
        int len = temp.size();
        if(len == 0)
        {
            continue;
        }
        string person;
        int pos;
        temp += " ";
        len++;
        for(pos=0;pos<len;pos++)
        {
            if(temp[pos] == ' ')
            {
                break;
            }
        }
        person = temp.substr(0,pos);
        pos += 3;
        string rr;
        while(pos<len)
        {
            int posstop;
            for(posstop=pos;posstop<len;posstop++)
            {
                if(temp[posstop] == ' ')
                {
                    break;
                }
            }
            rr = temp.substr(pos,posstop-pos);
            //cout << pri << "%^&&^%" << endl;
            map<string,int> :: iterator pit = privilege[rr].begin();
            for(;pit!=privilege[rr].end();pit++)
            {
                if((privilege.find(person)!=privilege.end())&&(privilege[person].find(pit->first)!=privilege[person].end()))
                {
                    if(privilege[person][pit->first]<(pit->second))
                    {
                        privilege[person][pit->first]=(pit->second);
                    }
                }
                else
                {
                    privilege[person][pit->first]=(pit->second);
                }
            }
            pos = posstop+1;
        }
    }
    /*map<string,map<string,int> > :: iterator it = privilege.begin();
    map<string,int> :: iterator itt;
    for(;it!=privilege.end();it++)
    {
        cout << (it->first) <<"*"<< endl;
        for(itt=(it->second).begin();itt!=(it->second).end();itt++)
        {
            cout << (itt->first) << "#" << (itt->second) << endl;
        }
    }*/
    int q;
    cin >> q;
    for(int i=0;i<=q;i++)
    {
        string temp;
        getline(cin,temp);
        int len = temp.size();
        if(len == 0)
        {
            continue;
        }
        int pos;
        temp += " ";
        len++;
        string sperson;
        for(pos=0;pos<len;pos++)
        {
            if(temp[pos] == ' ')
            {
                break;
            }
        }
        sperson = temp.substr(0,pos);
        pos ++;
        string pri;
        bool nex = false;
        int posstop;
        for(posstop=pos;posstop<len;posstop++)
        {
            if(temp[posstop] == ':')
            {
                break;
            }
            else if(temp[posstop] == ' ')
            {
                nex = true;
                break;
            }
        }
        pri = temp.substr(pos,posstop-pos);
        int ran = -1;
        if(!nex)
        {
            posstop++;
            ran = temp[posstop]-'0';
        }
        if(privilege.find(sperson) != privilege.end())
        {
            if(privilege[sperson].find(pri)!=privilege[sperson].end())
            {
                    if(ran==-1)
                    {
                        if(privilege[sperson][pri] == ran)
                        {
                            cout << "true" << endl;
                        }
                        else
                        {
                            cout << privilege[sperson][pri] << endl;
                        }
                    }
                    else
                    {
                        if(privilege[sperson][pri]>=ran)
                        {
                            cout << "true" << endl;
                        }
                        else
                        {
                            cout << "false" << endl;
                        }
                    }
            }
            else
            {
                cout << "false" << endl;
            }
        }
        else
        {
            cout << "false" << endl;
        }
    }
    //cout << p << r << u << q << endl;
    return 0;
}

201604-3 路径解析

思路：这题也是满满的坑点啊

首先，对于合法路径，一定是由‘/’和名称组成，且名称中不含‘/’，那么利用压栈的思想，直接记录路径，最后自己生成标准格式，这样就免去了矫正格式中的大量细节

这题主要两个坑点就是‘.’，这个不起眼的点号，不仅仅可以表示当前路径，上一路径，也可以作为文件名，这个确实很意外，比较难考虑到，因为题目中只说了名称不为‘.’和‘..’，没说不能作为文件名的一部分

其他还有就是并不一定以‘.’开头才是相对路径，一切不以‘/’开头的路径均为相对路径，其实这个题目中说的很清楚，但很容易相当然就忽略误解了

最后就是空行了，这个一不小心就容易被忽略了，一不小心也就容易被改动，还是细心问题

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
#include <map>
#include <cmath>
#include <string>
#include <queue>
#include <stack>

using namespace std;

const int maxn = 1010;

vector <string> contem;
int clen;

void correctaddress(string s)
{
    stack <string> address;
    while(!address.empty())
    {
        address.pop();
    }
    stack <string> prin;
    while(!prin.empty())
    {
        prin.pop();
    }
    int len = s.size();
    if(s[0]!='/'||s.empty())
    {
        for(int i=0;i<clen;i++)
        {
            address.push(contem[i]);
        }
    }
    if(!s.empty())
    {
        s += '/';
    }
    string addr;
    addr.clear();
    //bool name = false;
    for(int pos=0;pos<len;pos++)
    {
        if(s[pos]=='/')
        {
            if(!addr.empty())
            {
                if(addr == "..")
                {
                    if(!address.empty())
                    {
                        address.pop();
                    }
                }
                else if(addr != ".")
                {
                    address.push(addr);
                }
                addr.clear();
            }
            //name = false;
        }
        /*else if(s[pos]=='.'&&(!name))
        {
            if(s[pos+1]=='/')
            {
                continue;
            }
            if(s[pos+1]=='.'&&s[pos+2]=='/')
            {
                if(!address.empty())
                {
                    address.pop();
                }
            }
            else
            {
                addr += s[pos];
                //name = true;
            }
        }*/
        else
        {
            addr += s[pos];
            //name = true;
        }
    }
    if(!addr.empty())
    {
        if(addr == "..")
        {
            if(!address.empty())
            {
                address.pop();
            }
        }
        else if(addr != ".")
        {
            address.push(addr);
        }
        addr.clear();
    }
    while(!address.empty())
    {
        string str = address.top();
        prin.push(str);
        address.pop();
    }
    if(prin.empty())
    {
        cout << "/" << endl;
    }
    else
    {
        while(!prin.empty())
        {
            string str = prin.top();
            cout << "/" << str;
            prin.pop();
        }
        cout << endl;
    }
    return ;
}

int main()
{
    //freopen("in.txt","r",stdin);
    ios::sync_with_stdio(false);
    int p;
    cin >> p;
    string ori;
    getline(cin,ori);
    getline(cin,ori);
    contem.clear();
    int len = ori.size();
    string addr;
    addr.clear();
    for(int pos=0;pos<len;pos++)
    {
        if(ori[pos]=='/')
        {
            if(!addr.empty())
            {
                contem.push_back(addr);
                clen++;
                addr.clear();
            }
        }
        else
        {
            addr += ori[pos];
        }
    }
    if(!addr.empty())
    {
        contem.push_back(addr);
        clen++;
        addr.clear();
    }
    /*for(int i=0;i<(int)(contem.size());i++)
    {
        cout << contem[i] <<"*" << clen<< endl;
    }*/
    while(p--)
    {
        string now;
        getline(cin,now);
        correctaddress(now);
    }
    return 0;
}

就此，近两年的第三道大模拟也全部刷完了，这周离出发还有7天，加油！
文章地址：http://blog.youkuaiyun.com/owen_q/article/details/78237560


【CCF 2018-09】买菜与卖菜问题
有星星的桦树林
03-11 632
一.卖菜问题 问题描述 　　在一条街上有n个卖菜的商店，按1至n的顺序排成一排，这些商店都卖一种蔬菜。 　　第一天，每个商店都自己定了一个价格。店主们希望自己的菜价和其他商店的一致，第二天，每一家商店都会根据他自己和相邻商店的价格调整自己的价格。具体的，每家商店都会将第二天的菜价设置为自己和相邻商店第一天菜价的平均值（用去尾法取整）。 　　注意，编号为1的商店只有一个...
CCF 刷题目录
baidu_34884208的博客
03-15 2536
CCF计算机职业资格认证 Computing Accreditation for Professionals (CAP) CCF是计算机领域内一个权威的学术组织，具有高端定位、崇高的价值追求、先进的治理架构和制度规范，拥有众多资深的学者和企业家为骨干会员。CCF开展的该认证工作，具有客观公正及很强的专业性，将解决企业及高校界普遍关心的软件开发人才评价问题，便于有关单位了解求职或求学者的实际开发能力...
历年CSP，CCF考试题目（前两题）
09-16
历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）历年CSP，CCF考试题目（前两题）
CCF认证201403前两题：相反数、窗口
学习，不哔哔
08-02 362
201403-1 相反数：package exam201403;import java.util.Scanner;public class Task1 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int n = sc.nextInt();
第一次CCF软件能力认证（前两题）
就是氧气的博客
03-29 337
第一次CCF题目解析（前两题）
CCF计算机软件能力认证202006前两题java满分解
zyc534927618的博客
03-27 382
第二题（使用了hashmap）
基于Java语言的CCF-CSP刷题记录与源码分享
最新发布
10-03
本项目是基于Java语言开发的CCF-CSP刷题记录工具，它为参加计算机能力培养计划的竞赛选手提供了一个便捷的练习与回顾平台。项目中包含了375个文件，这些文件涵盖了多种类型，以便于用户能够有效地进行算法训练和知识...
ccf csp认证刷题笔记202212
qq_55931897的博客
02-24 542
此处用以记录一下自己在刷题时候的思路和使用的方法。本人算法小垃圾，所以基本上使用最原始的方法来完成这些题目。
PTA 刷题记录 1002 写出这个数（20分）
m0_46238469的博客
10-21 187
题目 读入一个正整数 n，计算其各位数字之和，用汉语拼音写出和的每一位数字。 输入格式 每个测试输入包含 1 个测试用例，即给出自然数 n 的值。这里保证 n 小于 10^100. 输出格式 在一行内输出 n 的各位数字之和的每一位，拼音数字间有 1 空格，但一行中最后一个拼音数字后没有空格。 输入样例 1234567890987654321123456789 输出样例 yi san wu 思路 将每一个数字对应的拼音保存在一个数组当中 将给定的数字保存在数组中并计算总和 分解得到的多项式每一位将其保存在一
【NSSCTF】刷题记录——[SWPUCTF 2024 新生赛]系列（REVERSE篇(1)
2401_84437604的博客
06-24 2173
import base64,urllib.parse key = “HereIsFlagggg” flag = “xxxxxxxxxxxxxxxxxxx”s_box = list(range(256)) j = 0 for i in range(256): j = (j + s_box[i] + ord(key[i % len(key)])) % 256 s_box[i], s_box[j] = s_box[j], s_box[i] res = [] i = j = 0 for s in flag: i =
ccf历年试题百分题解(第二题合集)
09-04
这是到目前为止的ccf考试的历年测试题，压缩包内只有历年的第二题的答案（百分通过），没有其他答案，也没有题目！
CCF CSP历届真题前两题---持续更新(山无陵，天地合，乃敢与君绝)更新至2021.04
あなたの可愛い41
07-26 1925
CCF2019年12月201912-1 报数201912-2 回收站选址2019年9月2019年3月2018年12月2018年9月2018年3月 2019年12月 201912-1 报数 看到题目首先想到的是约瑟夫环问题，是个沙雕题，直接缪杀。 #include<iostream> #include<cstring> #include<algorithm> #define mm(a,b) memset(a,b,sizeof(a)) using namespace std
首届CCF软件能力认证试题第二题详解（窗口）
brucexiajun的博客
01-17 698
分享一下首届CCF第二题的思路，供大家交流学习
xdoj系统_XDOJ目录操作
weixin_39548805的博客
12-22 1940
目录操作类别字符串处理时间限制1S内存限制256Kb问题描述在操作系统中，文件系统一般采用层次化的组织形式，由目录(或者文件夹)和文件构成，形成一棵树的形状。有一个特殊的目录被称为根目录，是整个文件系统形成的这棵树的根节点，在类Linux系统中用一个单独的 “/”符号表示。因此一个目录的绝对路径可以表示为“/d2/d3”这样的形式。当前目录表示用户目前正在工作的目录。为了切换到文件系统中的某个目录...
XDOJ.T84_目录操作
既然来了，请让我无耻地求一波赞QAQ
12-21 2665
这题同样是我在XDOJ中长时间以来没有做出来的三道题目之一。只能说是我想得太简单了。题目的样例我觉得用这句话来形容再合适不过了：只有你想不到，没有他做不到。 先贴题目 标题 目录操作 类别 字符串处理 时间限制 1S 内存限制 256Kb 问题描述 在操作系统中，文件系统一般采用层次化的组织形式，由目录（或者文件夹）和文件构成，形成一棵树的形状。 有一个特殊的目录被称为根目录，是整个文件系统形成的...
ccf--2019/3/16--第二题
_caorui_blog
03-21 1042
100分代码： （暴力解决。。大佬别嫌） /* 2 */ #include <iostream> #include <cstring> using namespace std; const int N = 10; char s[N]; int main(void){ int n; scanf("%d",&n); for(int...
ACM ICPC 2017 Warmup Contest 7（CTU Open Contest 2016）
Owen_Q的博客
10-14 875
乘坐气球 状压 枚举遍历 特殊位置 分类讨论 搜索 水质监测 set插入、排序、删除，earse的坑点
2019年3月CCF考试前两题题解
Armstrong的博客
04-13 2411
201903-1 小中大 1、题目大意 题目链接 给出有序的整数序列，输出中位数。 2、解题思路 序列已经有序，如果数字个数为偶数，则中位数为中间两个数的平均值；如果为奇数，则中位数为中间的那个整数。 注意输出。如果中位数为小数，则只可能为 x.5 的形式，保留一位小数输出即可；如果为整数，直接输出整数即可。 最大值和最小值直接读入判断输出即可。 3、参考代码 #include&l...
蓝桥杯竞赛项目源码分析与实战记录
蓝桥杯是中国计算机学会（China Computer Federation, CCF）主办的一项面向全国大学生的计算机类竞赛活动，旨在提升学生的计算机程序设计能力，强化算法和软件设计的基本功。该竞赛通常包含多个级别和组别，如软件类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值