CSP2019复赛游记

目录

  • Day -1
  • Day 0
  • Day 1
    • 考前
    • 考中
    • 考后
    • 做法&程序（考场做法，不能AC）
      • 格雷码
      • 括号树
      • 树上的数
  • Day 2
    • 考前
    • 考中
    • 考后
    • 做法&程序（考场做法，不能AC）
      • Emiya 家今天的饭
      • 划分
      • 树的重心
  • Day 3+（后记&提醒）

date: 2019-11-15

前言：想直接进入正题请跳转到Day 1。

Day -1

明天我就去南京了，感到非常的紧张，毕竟CSP和NOIP没有关系，没有真题可以刷（逃。

注：对于内心中难度的比较，是对于NOIP提高组的题目比较的。

Day 0

坐了一趟一个小时却感觉像是一天的火车，终于到了南京。到了南京就去南航去报到，报到完了就去三食堂的二楼吃饭，比学校的饭菜要好吃（SAN值++）。晚上和同学家长吃饭，互相鼓（mo）励（bai）一番以排解压力。回来之后写写线段树（对的，我喜欢写线段树），只需要一点点时间就可以让自己变得开心起来（大雾）。

总的来说，在没有被Day1血虐之前，我今天还是比较开心的。

Day 1

考前

进入考场没有什么大问题。试机前半段时间脑抽，bits之类的板子和提醒自己的东西都好久才想起来打，后半段花了大半段时间在搞懂怎么提交（话说我好像曾经来打过一次比赛来着怎么忘了），导致自己没有听清试题电子档的位置，心态瞬间跌入谷底。考前的提醒是放的NOIP2018的，很好笑，考场的人都笑了，稍稍缓解了气氛，如果没有的话心态肯定会受到影响（然后翻车）。所以说，考前一定要有一个开心的心情，心态不能乱。

考中

开局先开T1，感觉难度还没有什么问题，花了40分钟仔仔细细地做了，后来又花了30分钟检查，才意识到即使开了ull也需要特判\(n=64\)的情况，并且把它加入了程序。

此时考试过去了1小时10分钟，还剩2小时20分钟，心态尚且正常，并未受到影响，T1 100分。

打开T2，T2很难，我想了大约30分钟，想出了对于每一个结点都要维护从根节点到它的括号串中以它作为结束的子串的合法括号串个数，然后就不会做了。心想我先把T3的暴力分骗到了再来想T2的正解，于是我就开了T3，略微扫了一眼，幸好我比较菜（真的我没有假），一看就不会做，然后花了30分钟左右写好了10分的暴力。

此时考试过去了2小时10分钟，还剩1小时20分钟，心态已经受到影响，T1 100分，T3 10分。

接下来的时间我都在做T2，由于题目难度激增，知道最后我都没有把T2的正解写出来，只能使用了一个简单的优化策略，就是找一段最小的以它为结束的合法括号子串，之后把它开头的父亲结点的答案加1作为它的答案。这个优化即可骗到80分，虽然没有写出正解是个失误，但是由于暴力写得够快常数够小，并没有造成太大影响。

考试结束，T1 100分，T2 当时估计70分，T3 10分

考后

出了考场，我先和同班同学交流了一下，发现他的预估分数是大约200分左右，当时心态就崩了，虽然现在发现他T1不仅没有特判还写错了被卡成70分，T3爆零，但是对于当时的我来说，还是一个很大的冲击，感觉自己铁定与1=无缘了。

下午，令人惊讶的是，JS的程序很快就发了出来，同时信奥题库上也可以自测了，自测出来是190分（惊奇的和最终分数一样），比同学自测的还略高一点，重拾信心。

Day1结束后，我个人当时的心情应该还是OK的，没有彻底灰心，不过经历了一些大波动，脑海中还是会时不时的掠过诸如即将打铁之类的想法，对于Day2还是有一定影响吧。。。（可能）

做法&程序（考场做法，不能AC）

格雷码

题意

构造题，给出\(n\)和\(k\)，要求构造出\(n\)位格雷码中的第\(k\)个。构造方法如下：（抄的题目啦）

  • \(1\)位格雷码由两个\(1\)位二进制串组成，顺序为：\(0\)，\(1\)。
  • \(n+1\)位格雷码的前\(2^n\)个二进制串，可以由依此算法生成的\(n\)位格雷码（总共\(2^n\)个\(n\)位二进制串）按顺序排列，再在每个串前加一个前缀\(0\)构成。
  • \(n+1\)位格雷码的前\(2^n\)个二进制串，可以由依此算法生成的\(n\)位格雷码（总共\(2^n\)个\(n\)位二进制串）按逆序排列，再在每个串前加一个前缀\(1\)构成。

做法

直接模拟即可，对于正在求的\(n\)位第\(k\)个字符串，叫做\(f(n,k)\)，按照题目中的方式判断：（从一开始标号）

\[
f(n,k)='0'+f(n-1,k)(2k\leq n)\f(n,k)='1'+f(n-1,2^n-k)(2k\gt n)
\]

程序

记得特判一下\(n=64\)时的情况，此时会爆ull，但是由于要减一，所以可以赋值为\(-1\)来解决。

#include<bits/stdc++.h>
using namespace std;

typedef unsigned long long ull;

string ans;

void dfs(ull n,ull k){
    if(n==0)return;
    if(((ull(1))<<(n-1))>k){
        ans+='0';
        dfs(n-1,k);
    }else{
        ans+='1';
        if(n==64){
            ull tmp=-1;
            tmp-=k;
            dfs(n-1,tmp);
        }else{
            dfs(n-1,((ull(1))<<n)-k-1);
        }
    }
}

ull n,k;

int main(){

    freopen("code.in","r",stdin);
    freopen("code.out","w",stdout);

    cin>>n>>k;
    dfs(n,k);
    cout<<ans<<endl;

    return 0;

}

括号树

题意

给你一棵\(1\)为根的树，每个节点上面有一个括号，可能是(或者)。 定义\(s_i\)为：将根结点到\(i\)号结点的简单路径上的括号，按结点经过顺序依次排列组成的字符串。 要求出每一个结点的\(s\)中合法括号子串的个数，合法括号串定义见题目。

做法（理论50分，实际80分）

定义\(pre_i\)为以\(i\)作为结尾的\(s_i\)的合法括号子串的个数。

找到\(s_i\)后缀中最短的合法括号串，定义它的起始为\(l\)，结束为\(i\)。然后\(k_i\)就是\(k_{f(l)}+1\)（此处\(f(l)\)指的是\(l\)的父亲）。意义为后缀的最短合法串和之前的合法串连接后的也一定时合法的，也只有它们（和后缀最短合法串本身）是合法的。这个优化比朴素的查找所有的子串在随机数据下要快得多，甚至会因为没有开long long而WA而不是TLE。所以一定要记得开long long，即使它只是一个暴力。

程序

#include<bits/stdc++.h>
using namespace std;

struct NODE{
    NODE *nxt;
    int val;
    NODE(){
        nxt=NULL;
        val=0;
    }
};

struct LIST{
    NODE *head,*tail;
    LIST(){
        head=new NODE;
        tail=head;
    }
    void push(int val){
        tail->val=val;
        tail->nxt=new NODE;
        tail=tail->nxt;
    }
};

//后期注释：自己实现链表以减小常数

typedef long long ll;

int n;
bool br[500005];
int f[500005];
LIST g[500005];
int ansk[500005];

//a grave for some code
//后期注释：这个是我没想出来的正解的纪念，代表我写过

void brute(int x){
    //后期注释：计算pre
    int brc=0,cur=x,cnt=0;
    while(brc>=0&&cur){
        brc+=(br[cur]?-1:1);
        if(brc==0){
            //后期注释：优化
            ansk[x]=ansk[f[cur]]+1;
            break;
        }
        cur=f[cur];
    }
    for(NODE *it=g[x].head;it!=g[x].tail;it=it->nxt){
        brute(it->val);
    }
}

void calc(int x){
    //后期注释：简单的把做法中的pre计算为k
    ansk[x]+=ansk[f[x]];
    for(NODE *it=g[x].head;it!=g[x].tail;it=it->nxt){
        calc(it->val);
    }
}

int main(){

    freopen("brackets.in","r",stdin);
    freopen("brackets.out","w",stdout);

    scanf("%d\n",&n);
    for(int i=1;i<=n;i++){
        char c;
        scanf("%c",&c);//cerr<<c<<' ';
        br[i]=(c=='(');
    }
    f[1]=0;
    for(int i=2;i<=n;i++){
        scanf("%d",&f[i]);//cerr<<f[i]<<' ';
        g[f[i]].push(i);
    }
    bool brt=false;
    for(int i=2;i<=n;i++){
        if(f[i]!=i-1)brt=true;
    }
    brute(1);
    calc(1);
    ll ans=0;
    for(int i=1;i<=n;i++){
        ans^=((ll)i)*ansk[i];
        //cerr<<i<<": "<<ansk[i]<<endl;
    }
    printf("%lld",ans);

    return 0;

}

树上的数

题意

仅仅只需要注意一件事，这个是输入输出都是以数字排列的结点编号！

要好好看题目！不然很可能浪费做题时间！

做法（10分）

next_permutation()你值得拥有。它用于计算当前排列的下一个排列。

程序

#include<bits/stdc++.h>
using namespace std;

int T,n;
int eu[15],ev[15];
int a[15];
int o[15];
int v[15];
int r[15];
int tmp[15];

void solve(){
    memcpy(v,o,sizeof(o));
    for(int j=1;j<n;j++){
        swap(v[eu[a[j]]],v[ev[a[j]]]);
    }
    //后期注释：以边的排列交换边
    for(int i=1;i<=n;i++){
        tmp[v[i]]=i;
    }
    //后期注释：改换为以数字排列的结点编号
    for(int i=1;i<=n;i++){
        if(tmp[i]<r[i]){
            memcpy(r,tmp,sizeof(tmp));
            break;
        }
        if(tmp[i]>r[i])break;
    }
    //后期注释：更改最小字典序的排列
}

int main(){

    freopen("tree.in","r",stdin);
    freopen("tree.out","w",stdout);

    cin>>T;
    while(T--){
        cin>>n;
        for(int i=1;i<=n;i++){
            cin>>tmp[i];
            o[tmp[i]]=i;
        }
        //后期注释：读入排列并更改为以结点编号排列的数字
        memset(r,0x3f,sizeof(r));
        for(int i=1;i<n;i++){
            a[i]=i;
            cin>>eu[i]>>ev[i];
        }
        //后期注释：读入边同时初始化边的排列
        do{
            //后期注释：全排列需要交换的边的顺序
            solve();
        }while(next_permutation(a+1,a+n));
        for(int i=1;i<=n;i++)cout<<r[i]<<' ';
        cout<<endl;
    }

    return 0;

}

Day 2

考前

由于众所周知的原因，我今天一开始就没有想要做出任何一道题目的正解。换句话说，我今天就是冲着拿暴力分去的。这是一个看似怂实则更怂的方法，但是他很有用的，有的人死磕T1最后还没搞出来。我还准备了一些糖果用于在昏昏沉沉的时候提神，事实证明这是有用的。

考中

这是我失策的一次，我全程T1T2T3换来换去，导致做题时间被分割成了大约半个小时的一段一段的，没有集中精神思考，全部都只有基本暴力分，最后20分钟还在改自己的程序，局部变量没有初始化这种错误都会犯，幸好NOI LINUX的编译器很好，把我的错误避免了，果然还是太紧张了，考试一定不能太紧张。由于时间分隔太多，对于每道题目的时间分配将在做法中写出。

考后

考完了，心态什么样都没有关系了。滚回去刷题。

做法&程序（考场做法，不能AC）

Emiya 家今天的饭

做法（36分）

没有想法，暴力搜索一波走，36分到手了。由于每一种烹饪方法的菜只有一种，所以就把这个当作是深度，每次选出一道就好了。程序好写方便检查。

程序

#include<bits/stdc++.h>
//后期注释：无用头文件删去
using namespace std;

/*
REMEMBER to use long long and unsigned long long
REMEMBER to check array size
REMEMBER to make brute-force program and use it
*/

typedef long long ll;
const int mod=998244353;

int n,m,k;
int a[105][2005];
int dfscnt[2005];
ll ans;

void dfs(int row,ll cur,int alr){
   //后期注释：row是递归到第几种烹饪方法，cur是目前方法数，alr是选了的菜的数量
   if(alr==k){
       ans=(ans+cur)%mod;
       return;
   }
   //后期注释：判断是否制作了可行的组合，加入到答案里
   if(n-row+1+alr<k){
       return;
   }
   //后期注释：可行性剪枝，然而并不能多骗一点分数。。。
   for(int i=1;i<=m;i++){
       if(dfscnt[i]<(k>>1)&&a[row][i]){
           dfscnt[i]++;
           dfs(row+1,cur*a[row][i]%mod,alr+1);
           dfscnt[i]--;
           //后期注释：由于每一种食材、方法的菜都有很多种，所以直接乘上去它的数量可以多骗点分
       }
   }
   dfs(row+1,cur,alr);
   //后期注释：判断不选菜是否可行
}

int main(){

   ios::sync_with_stdio(false);
   cin.tie(0);
   cout.tie(0);

   freopen("meal.in","r",stdin);
   freopen("meal.out","w",stdout);

   cin>>n>>m;
   for(int i=1;i<=n;i++){
       for(int j=1;j<=m;j++){
           cin>>a[i][j];
       }
   }
   for(k=2;k<=n;k++){
       //后期注释：k是预备选的菜品的总数
       dfs(1,1,0);
   }
   cout<<ans<<endl;

}

划分

做法（64分）

首先，可以证明，确定了某一前缀区间的分配情况后，最后一个子任务尽量小答案才会好。不会证但是感性认识很简单，考场时可以很快想到，我大约想了45分钟想出这个结论。之后就是枚举子任务的大小DP就可以了，只需要写20分钟不到。局部变量千万记得要初始化，我差点爆零。

程序

#include<bits/stdc++.h>
//后期注释：无用头文件删去
using namespace std;

//后期注释：同上考前提醒，删去

typedef long long ll;
const ll LLINF=0x3f3f3f3f3f3f3f3f;

struct LIST{
    //后期注释：无用的链表，没用上，完全错误的想法
};

int n,type;
int a[40000005];
ll dpf[5005];
ll dp[5005];
int dpprv[5005];
LIST tsk;

void specgen(){
    //write no code, run nowhere
}

void normread(){
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
}

void dp5000(){
    ll ans;
    //后期注释：千万记得要初始化，差点爆零
    dp[0]=0;
    //后期注释：dp[i]表示直到i的前缀序列都计算好后最后一个子任务的长度最小是什么
    for(int i=1;i<=n;i++){
        dpf[i]=dpf[i-1]+a[i];
        //后期注释：前缀和计算
        dp[i]=LLINF;
        for(int j=0;j<i;j++){
            if(dp[j]<=dpf[i]-dpf[j]&&dpf[i]-dpf[j]<dp[i]){
                //后期注释：枚举上一个前缀序列，发现更好的情况在转移过去，记录父亲以便计算最后的答案（因为要算平方）
                dp[i]=dpf[i]-dpf[j];
                dpprv[i]=j;
            }
        }
    }
    int cur=n;
    while(cur){
        ans+=(dpf[cur]-dpf[dpprv[cur]])*(dpf[cur]-dpf[dpprv[cur]]);
        cur=dpprv[cur];
        //后期注释：从最后一个结点n开始向着0更新
    }
    cout<<ans<<endl;
}

void greedy(){
    //ohhhhhhhh f***
    //i don't have time to complete it
    //yet another grave here
    //后期注释：当时认为是贪心，后来发现是单调队列，代码没写
}

int main(){

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    freopen("partition.in","r",stdin);
    freopen("partition.out","w",stdout);

    cin>>n>>type;
    if(type){
        specgen();
    }else{
        normread();
    }
    dp5000();

    return 0;
}

树的重心

想法（40分）

虽然好像做过原题，可是我忘了qaq。那么我就用朴素的方法，枚举树的重心之后计算好了，就是程序写起来很烦的样子。其实还可以多骗一条链的15分的，就是我数组开小了qaq。一定要检查数组啊。

程序

#include<bits/stdc++.h>
//后期注释：无用头文件
using namespace std;

//后期注释：同上提醒

typedef long long ll;

int RP,n,sz[2005],ban,f[2005];
vector<pair<int,int> > g[2005];
ll ans;

int find(int x){
    if(f[x]==x)return x;
    else return f[x]=find(f[x]);
}

void unite(int x,int y){
    x=find(x);
    y=find(y);
    f[x]=y;
}

void dfs(int x,int p){
    sz[x]=1;
    for(int i=0;i<g[x].size();i++){
        int y=g[x][i].first,z=g[x][i].second;
        if(y!=p&&z!=ban){
            dfs(y,x);
            sz[x]+=sz[y];
        }
    }
    //后期注释：计算有根时它的子树大小
}

void mkc(int x,int p){
    bool isc=sz[find(x)]-sz[x]<=(sz[find(x)]>>1);
    for(int i=0;i<g[x].size();i++){
        int y=g[x][i].first,z=g[x][i].second;
        if(y!=p&&z!=ban){
            mkc(y,x);
            isc&=sz[y]<=(sz[find(x)]>>1);
        }
    }
    if(isc)ans+=x;
    //后期注释：查看是否是重心并加入答案
}

int main(){

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    freopen("centroid.in","r",stdin);
    freopen("centroid.out","w",stdout);

    cin>>RP;
    while(RP--){//后期注释：RP--啦（不是）
        cin>>n;
        for(int i=1;i<=n;i++){
            g[i].clear();
        }
        ans=0;
        for(int i=1;i<n;i++){
            int a,b;
            cin>>a>>b;
            g[a].push_back(make_pair(b,i));
            g[b].push_back(make_pair(a,i));
        }
        if(n%10==1){//后期注释：特判链，可惜数组开小了
            for(int i=1;i<n;i++){
                if(((1+i+1)>>1)==((1+i)>>1)){
                    ans+=(1+i)>>1;
                }else{
                    ans+=(1+i);
                }
                if(((n+i+1+1)>>1)==((n+i+1)>>1)){
                    ans+=(n+i+1)>>1;
                }else{
                    ans+=(n+i+1);
                }
            }
            cout<<ans<<endl;
            ans=0;
            continue;
        }
        for(int bn=1;bn<n;bn++){//后期注释：枚举删除的边
            int rt1=-1,rt2=-1;
            ban=bn;
            for(int i=1;i<=n;i++)f[i]=i;
            for(int i=1;i<=n;i++){
                for(int j=0;j<g[i].size();j++){
                    int k=g[i][j].first,l=g[i][j].second;
                    if(l!=ban)unite(i,k);
                }
            }
            for(int i=1;i<=n;i++){
                if(rt1==-1){
                    rt1=find(i);
                }else{
                    if(rt1!=find(i)){
                        rt2=find(i);
                        break;
                    }
                }
            }//后期注释：用并查集制作连通并找到两个根
            dfs(rt1,-1);
            dfs(rt2,-1);
            mkc(rt1,-1);
            mkc(rt2,-1);
        }
        cout<<ans<<endl;
    }

}

Day 3+（后记&提醒）

注意事项：

  • 局部变量初始化
  • 不要因为紧张而把时间分成一小段一小段
  • 不要害怕难，大家都难（除非你像我一样做题时不时脑抽）
  • 数组检查一下，不能只检查直接使用它的子任务，如果有数组复用还要检查复用了它的子任务是否会爆。

好像成绩还行的样子，326分1=，可以试着报各类WC诶（虽然去了也只是充人数）。

原文地址：https://www.cnblogs.com/BlahDuckling747/p/11979412.html

时间： 2024-10-08 16:40:36

CSP2019复赛游记的相关文章

[随笔]NOIP2017提高组复赛 游记

前言 真正意义上的第一篇游记,经历了第一次正式大考,希望自己能在这条道路上走得足够远... 当然最主要的梦想还是THU喔! Day -2 今天就是NOIP考前在机房呆的最后一天,上午打完了最后一场模拟赛,是NOIP模拟赛50,难以置信集训期间考了这么多场QAQ 应该这场就是信心赛了,因为好像上午要和我们联考的学校放了OD鸽子了2333(喜闻乐见) 然后蒟蒻的我信心赛只打了210分rank12 T-T,只能说RP++ 下午没有考试,于是机房内的气氛从原来的高级算法乱飞,变成了都在码最基础的模板 临

第36届全国物理竞赛复赛游记

2019年9月20日下午,到达成都. 很晚才吃午饭,然后去看考场,不让进……无所无所事事的我们去去看了看天府新区的一个湖,挺漂亮的,环境很好…… 晚上复习(话说我还没预习呢T_T) 9月21日,早上七点起床,去吃早饭(这个是我最想吐槽的,等会再说),然后去考场,考试时间9:00-12:00. 说说早饭的问题吧.大家说吃那个贵州羊肉米粉,我以为跟广元的差不多,结果竟然是那种比面条还粗的米粉,我暑假在长沙吃了一个月,已经快吐了,现在又吃……我夹了几口,实在吃不下,再吃真吐了. 然后早上什么也没吃,又

[个人][AFO] OI回忆录 The End

前言 微微颤抖的双手敲击键盘,身处从长沙飞驰的高铁,返回家乡. 我知道终将离别,但我不知道离别到来的如此之快.内心有些怅惘,微微的失落,却是又无可奈何. 没有后悔,没有怨念,有的只是一丝丝不舍,舍不得的却是太多. 是时候做一个完结了,结束,也就意味着一个新的开始. 初识OI 是的,两年前初识OI,我还是一个不谙世事的少年,带着对未来的憧憬,带着对高中的期待,踏入这所全国著名的中学. 缘起,卓越之旅理科夏令营. 我还记得营服背后那句话 "给理想一点时间" 当时并不知道什么叫做竞赛,以为只

OI回忆录——梦开始的地方

前言 谨以此文,纪念和整理我在OI之路上的奔波历程. 或许,等到或早或晚都要来临的退役真正来临时,再写回忆录,就晚了,那么,趁现在,自信还在,青春犹存,整理一下我慢慢的OI路吧. 我真正开始接触OI是初一下的暑假,一次无意间翻淘宝时,看到了一篇写 Scratch的这种图形化编程的书,突发奇想求妈妈把它买了下来,一到手,我就对它爱不释手,感觉这是信息学是一门十分深奥的学问,现在想想,Scratch只不过是一种非常简单的编程语言,一本面向低龄儿童的超入门级书籍.但是正是它领着我走进了OI的殿堂,随着

CSP2019游记

——by Nelson 前前夜 秋日降临. 对于我各位亲爱的高中同学们来讲,秋天,意味着井冈山,意味着期中考,意味着这繁忙的高二又过去了四分之一.而我虽然不在什么天边,却也在另一个校园里仰望同一片天空,踌躇着,准备奔向另一个战场. 夜风渐凉,再度穿上薄外套,企图用衣物掩盖内心的慌乱,还能再学到一点吗?后天能否遇上熟悉的知识点,恰好是现在眼前所及的?——或许也是徒劳吧.要不,让时间过的再快一点,现在就可以打开电脑,迎接最终的试炼?——那样的话,万一遇上本可以今天回顾的知识点,可就追悔莫及了. 明天

从“水下八关”的传说说起（人民邮电报专栏《乐游记》之17）

越不容易开启的隐藏关卡,越容易成为剧情的特殊分支,直接影响到游戏的结局,而这激发了玩家高亢的游戏热情,同时让游戏经久不衰. 文/张书乐 二周目.隐藏角色.隐藏关卡等等探宝式的游戏玩法,让游戏具有了更强的续航力.任何事物都有一个起源,而在我看来,这一切都源于与<魂斗罗>有关的"水下八关"传说,这个传说和中国游戏玩家关系很大. 在没有社交网络的时代,<魂斗罗>游戏非常流行.而在游戏第六关有一个bug(程序漏洞),会使敌兵的图形显示不正常,变成类似青蛙嘴的模样.在中国

hdu 4542 数论 + 约数个数相关 腾讯编程马拉松复赛

题目:http://acm.hdu.edu.cn/showproblem.php?pid=4542 小明系列故事--未知剩余系 Time Limit: 500/200 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Total Submission(s): 889    Accepted Submission(s): 207 Problem Description "今有物不知其数,三三数之有二,五五数之有三,七七数之有

海康威视复赛题 ---- 碰撞避免方案（1）

题目详情:http://www.cnblogs.com/wlzy/p/7096182.html 复赛题要求机器人之间不允许发生碰撞和相遇,拿到题目后,大体有以下几个解题思路: 1.基于侧边停车的碰撞避免算法 侧边停车是属于一种局部路径规划,只要保证每辆车时时刻刻拥有独立的侧停车位,那么即使发生相遇冲突,也可以及时侧停避让,算法大体描述如下: 定义机器人占据点属性: 机器人可获取侧停车位的最小路径点集. 预测点属性: 从占据点下个点到路径终点的点集. 开始: 1.初始化地图map 2.计算每个机器

陕西省第九次大学生高等数学竞赛复赛试题

参考解答见 家里蹲大学数学杂志第6卷第430期_陕西省第九次大学生高等数学竞赛复赛试题参考解答