题404.csp-2206 P1归一化处理&P2寻宝！大冒险！&P3角色授权&P4光线追踪

已于 2023-01-10 22:39:06 修改
阅读量241 收藏
点赞数
分类专栏： # csp 文章标签： 算法 c++
于 2023-01-05 17:52:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51352378/article/details/128567247
版权

文章目录

题404.csp-2206 P1归一化处理&P2寻宝！大冒险！&P3角色授权&P4光线追踪

一、P1归一化处理

1.题目：

在这里插入图片描述
在这里插入图片描述

2.题解：

本题套个公式做计算，注意参与计算的数的数据类型定义为double即可。
代码如下：

#include <bits/stdc++.h>

#define rep(i,a,n) for(int i=a;i<n;i++)
#define per(i,a,n) for(int i=n-1;i>=a;i--)
#define pb push_back
#define x first
#define y second

using namespace std;

typedef long long ll;
typedef pair<int,int> pii;
const int Inf=0x3f3f3f3f;
const int maxn=1100;

int n;
double a[maxn];

int main()
{
    cin>>n;
    double sum=0;
    for(int i=1;i<=n;i++)
    {
        scanf("%lf",&a[i]);
        sum+=a[i];
    }
    double tmp=0;
    for(int i=1;i<=n;i++) tmp+=(a[i]-sum/n)*(a[i]-sum/n);
    for(int i=1;i<=n;i++)
    {
        double d=a[i]-sum/n;
        printf("%f\n",d/sqrt(tmp/n));
    }
}

二、P2寻宝！大冒险！

1.题目：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.题解：

本题就是要你统计出有几个合法原点，即宝藏埋藏地（必在树下）。我们会想着直接去暴力枚举每个树点作为原点，然后看藏宝图的其他点是否完全能够对应到绿化图上（条件1：不越界；条件2：树情况一致）。树点采用集合set来存储，方便后期判断树点情况。
代码如下：

#include <bits/stdc++.h>

#define x first
#define y second

using namespace std;

typedef pair<int,int> pii;

const int maxs=55;

int n,L,S;
set<pii> s;
int g[maxs][maxs];

int main()
{
    cin>>n>>L>>S;
    for(int i=0;i<n;i++)
    {
        int x,y;
        cin>>x>>y;
        s.insert({x,y});
    }
    for(int i=S;i>=0;i--)
    {
        for(int j=0;j<=S;j++) cin>>g[i][j];
    }
    int cnt=0;
    for(auto p:s)//枚举原点
    {
        int x=p.x,y=p.y;
        int flag=1;//合法标记
        for(int i=0;i<=S;i++)
        {
            for(int j=0;j<=S;j++)
            {
                int xx=x+i,yy=y+j;
                if(xx>L||yy>L)//越界判断
                {
                    flag=0;//越界非法
                    break;
                }
                //树情况判断
                if(g[i][j])//藏宝图(i,j)有树
                {
                    if(!s.count({xx,yy}))//则到绿化图上对应位置看是否有树，如果没有则非法
                    {
                        flag=0;
                        break;
                    }
                }
                else//藏宝图(i,j)无树
                {
                    if(s.count({xx,yy}))//则到绿化图上对应位置看是否有树，如果有则非法
                    {
                        flag=0;
                        break;
                    }
                }
            }
            if(!flag) break;
        }
        if(flag) cnt++;//合法则可行原点数++
    }
    cout<<cnt;
}

三、P3角色授权

1.题目：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.题解：

这题就读懂题意之后直接模拟，然后没优化前想的是角色信息里头操作、资源类型、资源名用unordered_set存然后查授权的时候用us.count()去查，结果交上去超时了70分。
代码如下：

//70分代码，运行超时
#include <bits/stdc++.h>

using namespace std;

struct RoleInfo
{
    string name;
    unordered_set<string> ops;
    unordered_set<string> stypes;
    unordered_set<string> snames;
};

int n,m,q;
unordered_map<string,RoleInfo> roles;
unordered_map<string,unordered_set<string>> rels;

void initRoleinfo()
{
    for(int i=0;i<n;i++)
    {
        string name;
        cin>>name;
        RoleInfo ri;
        ri.name=name;
        int nv;
        cin>>nv;
        for(int j=0;j<nv;j++)
        {
            string op;
            cin>>op;
            roles[name].ops.insert(op);
        }
        int no;
        cin>>no;
        for(int j=0;j<no;j++)
        {
            string stype;
            cin>>stype;
            roles[name].stypes.insert(stype);
        }
        int nn;
        cin>>nn;
        for(int j=0;j<nn;j++)
        {
            string sname;
            cin>>sname;
            roles[name].snames.insert(sname);
        }
    }
}

void initRoleRel()
{
    for(int i=0;i<m;i++)
    {
        string name;
        cin>>name;
        int ns;
        cin>>ns;
        for(int j=0;j<ns;j++)
        {
            string type,ug;
            cin>>type>>ug;
            rels[ug].insert(name);
        }
    }
}

bool checkRole(string name,string op,string stype,string sname)
{
    auto ri=roles[name];
    if(ri.ops.size()&&!ri.ops.count(op)&&!ri.ops.count("*")) return false;
    if(ri.stypes.size()&&!ri.stypes.count(stype)&&!ri.stypes.count("*")) return false;
    if(ri.snames.size()&&!ri.snames.count(sname)&&!ri.snames.count("*")) return false;
    return true;
}

void check()
{
    for(int i=0;i<q;i++)
    {
        int flag=0;
        string uname;
        cin>>uname;
        int ng;
        cin>>ng;
        vector<string> gs;
        for(int j=0;j<ng;j++)
        {
            string gname;
            cin>>gname;
            gs.push_back(gname);
        }
        string op,stype,sname;
        cin>>op>>stype>>sname;

        //查用户名本身
        if(rels.find(uname)!=rels.end())
        {
            for(auto role:rels[uname])
            {
                if(checkRole(role,op,stype,sname))
                {
                    flag=1;
                    break;
                }

            }
        }

        //查用户组
        for(auto gname:gs)
        {
            for(auto role:rels[gname])
            {
                if(checkRole(role,op,stype,sname))
                {
                    flag=1;
                    break;
                }
            }
        }
        if(flag) cout<<1<<endl;
        else cout<<0<<endl;
    }
}

int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin>>n>>m>>q;
    initRoleinfo();
    initRoleRel();
    check();
}

tip：unordered_set中的元素没有按照任何特定的顺序排序，而是根据它们的散列值组织成桶，从而允许通过它们的值直接快速访问单个元素(平均时间复杂度为常数)。

之后就想着优化，然后就想着把作为string的那堆名字化成int的id，关系存成邻接矩阵，查关系直接查就好，结果一交满分了。。。
代码如下：

//满分代码，string名int后用邻接矩阵直接判关系优化
#include <bits/stdc++.h>

using namespace std;

const int maxn=550,maxm=234650;//卡了波内存极限

int n,m,q;
int G[maxn][maxm],cnt[maxn];
unordered_map<string,unordered_set<string>> rels;//记得用unordered_map
unordered_map<string,int> rid,oid;//将角色名、操作名、资源类型名、资源名化成id，用于后续直接用邻接矩阵判断角色和后三者是否有关系
int rcnt=0,ocnt=550;

void initRoleinfo()
{
    for(int i=0;i<n;i++)
    {
        int u,v;
        string name;
        cin>>name;
        u=rid[name]=++rcnt;
        int nv;
        cin>>nv;
        for(int j=0;j<nv;j++)
        {
            string op;
            cin>>op;
            if(oid.count(op)) v=oid[op];
            else v=oid[op]=++ocnt;
            G[u][v]=1;
        }
        int no;
        cin>>no;
        for(int j=0;j<no;j++)
        {
            string stype;
            cin>>stype;
            if(stype=="*")
            {
                stype="**";
            }
            if(oid.count(stype)) v=oid[stype];
            else v=oid[stype]=++ocnt;
            G[u][v]=1;
        }
        int nn;
        cin>>nn;
        for(int j=0;j<nn;j++)
        {
            string sname;
            cin>>sname;
            if(oid.count(sname)) v=oid[sname];
            else v=oid[sname]=++ocnt;
            G[u][v]=1;
            cnt[u]++;
        }
    }
}

void initRoleRel()
{
    for(int i=0;i<m;i++)
    {
        string name;
        cin>>name;
        int ns;
        cin>>ns;
        for(int j=0;j<ns;j++)
        {
            string type,ug;
            cin>>type>>ug;
            rels[ug].insert(name);
        }
    }
}

bool checkRole(string name,string op,string stype,string sname)
{
    int u=rid[name];
    int v,v0;
    v=oid[op],v0=oid["*"];
    if(!G[u][v]&&!G[u][v0]) return false;
    v=oid[stype],v0=oid["**"];
    if(!G[u][v]&&!G[u][v0]) return false;
    v=oid[sname];
    if(cnt[u]&&!G[u][v]) return false;
    return true;
}

void check()
{
    for(int i=0;i<q;i++)
    {
        int flag=0;
        string uname;
        cin>>uname;
        int ng;
        cin>>ng;
        vector<string> gs;
        for(int j=0;j<ng;j++)
        {
            string gname;
            cin>>gname;
            gs.push_back(gname);
        }
        string op,stype,sname;
        cin>>op>>stype>>sname;

        //查用户名本身
        if(rels.find(uname)!=rels.end())
        {
            for(auto role:rels[uname])
            {
                if(checkRole(role,op,stype,sname))
                {
                    flag=1;
                    break;
                }

            }
        }

        //查用户组
        for(auto gname:gs)
        {
            for(auto role:rels[gname])
            {
                if(checkRole(role,op,stype,sname))
                {
                    flag=1;
                    break;
                }
            }
        }
        if(flag) cout<<1<<endl;
        else cout<<0<<endl;
    }
}

int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);//开始的时候没加这个，因为我没想到csp的题可以加这个能快多少的，没想到一加就不超时了
    cin>>n>>m>>q;
    initRoleinfo();
    initRoleRel();
    check();
}

四、P4光线追踪

1.题目：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.题解：

这题也是读懂题意之后直接模拟，对于3操作步骤可分为三步：联立光线方程与反射镜方程求最近反射点、修改反射之后光线方向、得到新光线方程，循环这个过程，直到I<1ort不够用了结束，最后码完一交，成功超时了。
代码如下：

//35分代码，运行超时
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const ll Inf=LONG_LONG_MAX;

struct Mirror
{
    double k;//斜率
    int type;//直线类型，增or减
    ll x1,y1,x2,y2;//两点
    double a;//系数
};

int m;
unordered_map<int,Mirror> mirrors;

void check(ll x0,ll y0,int d,double I,ll t)
{
    while(1)
    {
        ll nx,ny,mind=Inf;
        double a;
        int type;
        if(d==0||d==2)//x方向，光直线方程为y=y0;
        {
            //联立直线方程求最近交点
            for(auto mirror:mirrors)
            {
                auto info=mirror.second;
                ll x=info.k*(y0-info.y1)+info.x1;
                ll y=y0;
                if(x==x0) continue;
                if(d==0&&x<x0||d==2&&x>x0) continue;
                if(x<=min(info.x1,info.x2)||x>=max(info.x1,info.x2)||y<=min(info.y1,info.y2)||y>=max(info.y1,info.y2)) continue;
                ll dd=abs(x-x0);
                if(dd<mind)
                {
                    mind=dd;
                    nx=x,ny=y;
                    type=info.type;
                    a=info.a;
                }
            }
            //判断t内是否能走到反射镜
            if(mind<=t)
            {
                if(type==-1&&d==0||type==1&&d==2) d=3;
                else if(type==-1&&d==2||type==1&&d==0) d=1;
                x0=nx,y0=ny;
                I=a*I;
                if(I<1)
                {
                    cout<<"0 0 0"<<endl;
                    break;
                }
                t-=mind;
            }
            else
            {
                I=floor(I);
                if(I==0) cout<<"0 0 0"<<endl;
                else
                {
                    if(d==0) x0=x0+t,y0=y0;
                    else x0=x0-t,y0=y0;
                    cout<<x0<<" "<<y0<<" "<<(int)I<<endl;
                }
                break;
            }
        }
        else//y方向，光直线方程为x=x0
        {
            for(auto mirror:mirrors)
            {
                auto info=mirror.second;
                ll x=x0;
                ll y=(1/info.k)*(x0-info.x1)+info.y1;
                if(y==y0) continue;
                if(d==1&&y<y0||d==3&&y>y0) continue;
                if(x<=min(info.x1,info.x2)||x>=max(info.x1,info.x2)||y<=min(info.y1,info.y2)||y>=max(info.y1,info.y2)) continue;
                ll dd=abs(y-y0);
                if(dd<mind)
                {
                    mind=dd;
                    nx=x,ny=y;
                    type=info.type;
                    a=info.a;
                }
            }

            //判断t内是否能走到反射镜
            if(mind<=t)
            {
                if(type==-1&&d==1||type==1&&d==3) d=2;
                else if(type==-1&&d==3||type==1&&d==1) d=0;
                x0=nx,y0=ny;
                I=a*I;
                if(I<1)
                {
                    cout<<"0 0 0"<<endl;
                    break;
                }
                t-=mind;
            }
            else
            {
                I=floor(I);
                if(I==0) cout<<"0 0 0"<<endl;
                else
                {
                    if(d==1) x0=x0,y0=y0+t;
                    else x0=x0,y0=y0-t;
                    cout<<x0<<" "<<y0<<" "<<(int)I<<endl;
                }
                break;
            }
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    cin>>m;
    for(int i=1;i<=m;i++)
    {
        int op;
        cin>>op;
        if(op==1)
        {
            ll x1,y1,x2,y2;
            double a;
            cin>>x1>>y1>>x2>>y2>>a;
            Mirror mirror;
            mirror.k=(y2-y1)/(x2-x1);
            if(mirror.k>0) mirror.type=1;
            else mirror.type=-1;
            mirror.x1=x1,mirror.y1=y1,mirror.x2=x2,mirror.y2=y2;
            mirror.a=a;
            mirrors[i]=mirror;
        }
        else if(op==2)
        {
            int k;
            cin>>k;
            mirrors.erase(k);
        }
        else
        {
            ll x,y,t;
            double I;
            int d;
            cin>>x>>y>>d>>I>>t;
            check(x,y,d,I,t);
        }
    }
}
Adongua
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2021csp-j初赛试题及答案.docx
11-09
2021csp-j初赛试题及答案 全新整理
CSP-J CSP-S 初赛模拟题_(C)-2021.09.01(H)--18页.pdf
09-01
CSP-J CSP-S 初赛模拟题汇总 本资源汇总了CSP-J和CSP-S的初赛模拟题，涵盖了2019年和2020年的初赛试题，以及相关的评级分数线和模拟试题分析。这些资源对于参加CSP-J和CSP-S比赛的学生和教师具有重要的参考价值。 ...
CCF CSP 202206-4 光线追踪（误）
qq_54056938的博客
09-09 940
CCF202206-4 训练
CCF CSP——202206-4 光线追踪
qq_40477864的博客
09-23 1382
CCF CSP20220604 光线追踪85分题解，摆烂
csp 202206-4光线追踪 满分代码
MTS_ZX的博客
03-18 236
【代码】csp 202206-4光线追踪 满分代码。
CCF CSP认证2022年6月 归一化处理、寻宝！大冒险！、光线追踪
qq_23096319的博客
11-26 6894
这是我第一次参加了这次CSP考试，300分，写了124三题，模拟题到现在都没看过题面没看，笑，t4写成模拟加数据结构，200+行，因为一个小错误调了1h，错失了大好机会。考试环境的VSC配置的字体太小，甚至连空格都看不清有还是没有，当时没想到可以重新配置，这可能也是我t4调了1h的原因。距离下一次CSP考试考试还有20天左右，特此回顾。代码均为考试时提交的代码，补充思路。
CCFCSP认证202206-04光线追踪解析
weixin_66586476的博客
09-01 204
CCFCSP认证202206-4光线追踪100分答案，需要使用c++stl的set，不需要其他算法
2023 CSP-J2 CSP-S2 复赛 第2轮 真题讲解.pdf
10-24
2023 CSP-J2 CSP-S2 复赛 第2轮 真题讲解
CSP-J CSP-S 初赛模拟题_(C)-2021.09.01(G)--23页.pdf
09-01
CSP-J CSP-S 初赛模拟题资源库 该资源库收录了多份CSP-J和CSP-S初赛模拟题，涵盖了2019年和2020年的试题，涉及到信息学奥林匹克联赛的初赛试题和相关评级分数线统计。这些试题来自于不同的来源，包括浙江省的评级...
2021 CSP-J1 junior-C++ 初赛　第1轮　真题　.pdf
09-20
CSP-J1 初赛真题解析 本文档是对 2021 CSP-J1 junior-C++ 初赛第 1 轮真题的详细解析，以帮助读者更好地理解题目内容和解题思路。 一、单项选择题 1. 不属于面向对象程序设计语言的是（ ）。 答案：D. C。面向...
CSP 202206 题解:归一化处理,寻宝大冒险,角色授权,光线追踪,PS无限版
fmy_xfk的博客
09-01 3739
CSP 专业组 202206题解 归一化处理 寻宝！大冒险！ 角色授权 光线追踪 PS无限版(部分解)
csp-202206
m0_58642116的博客
09-04 520
csp的简单题题解
CCF-CSP历年真题大全附题解(202312已更)
热门推荐
weixin_53919192的博客
05-22 13万+
各位朋友，历年的题目你们要是有不同的解法想和大家进行分享的，可以私聊我发我题目编号和代码，我也可以更新到文章中，给需要的朋友多点参考~~ CCF-CSP真题拿来练手，如果对自己没有拿高分的期望的话，可以就琢磨着写一二三题就好，三题可以就拿最基础的情况，再慢慢添东西更新代码，持续更新，博主的算力有限，努力提升进步中，写一道发一道，目前先从简单慢慢做，有想法的可以一起讨论呀~~
计算机图形学入门（十三）-光线追踪（基本原理）
weixin_45314475的博客
12-12 1082
本部分主要介绍了光线追踪的基本原理，简述了光线追踪的实现过程，并对实现过程中第一步，求解射线与表面的交点的过程进行了全面的分析和解答。
计算机图形学GAMES101（十二）光线追踪（基本原理）
weixin_45712636的博客
02-23 1544
为什么要使用光线追踪？ 当对物体着色的时候，只考虑了像素点自己，没有考虑物体遮挡。所以着色不能解决阴影。那么怎么解决阴影问题呢？ 阴影映射（Shadow mapping） 可以使用阴影映射来渲染阴影。阴影映射的实质还是光栅化。 阴影映射的思想： 如果一个点不在阴影里，则我们可以看到这个点，而且相对于光源来说也可以看到这个点。如果一个点在阴影里，则我们可以看到这个点，但是相对于光源来说也看不到这个点。即一个点不在阴影里面则两者都可以看到。（这种阴影叫做硬阴影） 实现阴影映射的步骤： 1、从光源看向场景记录看到
算法009：长度最小的子数组
最新发布
m0_62319039的博客
06-20 307
算法009：长度最小的子数组
排序——希尔排序
2301_80662872的博客
06-16 585
当序列越有顺序时，插入排序的时间效率就越高。时间复杂度：O(N^2)（虽然时间复杂度是N^2，那是在逆序的序列情况下，在现实中这种情况一般不会出现）空间复杂度：O(1)gap＞1：预排序，目的是让序列变得更有序。时间复杂度：O(N^1.3)空间复杂度：O(1)
【康复学习--LeetCode每日一题】2748. 美丽下标对的数目
Puppet__的博客
06-20 220
如果下标对 i、j 满足 0 ≤ i < j < nums.length ，如果 nums[i] 的 第一个数字 和 nums[j] 的 最后一个数字 互质 ，则认为 nums[i] 和 nums[j] 是一组 美丽下标对。2 和 5 互质，因此 gcd(2,1) == 1。i = 1 和 j = 2 ：nums[1] 的第一个数字是 5 ，nums[2] 的最后一个数字是 1。i = 0 和 j = 1 ：nums[0] 的第一个数字是 1 ，nums[1] 的最后一个数字是 1。
力扣136. 只出现一次的数字
LNsupermali的博客
06-15 474
力扣136. 只出现一次的数字
ccfcsp归一化处理
08-30
归一化处理是数据预处理的一种常用方法，可将不同的数据值缩放到相同的范围，通常是0到1之间。这样做可以消除不同特征之间的量纲差异，有助于提高模型的性能和收敛速度。 对于数据集ccfcsp，归一化处理可以按照以下...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值