gym 100548题解（2014年西安现场赛(回文树，01字典树，容斥)）

最新推荐文章于 2019-09-11 21:51:51 发布
最新推荐文章于 2019-09-11 21:51:51 发布
阅读量997 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Miracle_ma/article/details/52555911
版权

Problem A. Built with Qinghuai and Ari Factor

水题就是看是不是所有数字都是3的倍数

Problem F. Color

容斥题，m个颜色里选k个，然后给一个长度n的路涂色，每格一个颜色，相邻不能相同，求方案数
ans=C(m,k)×(k(k−1)n−1−C(k,1)(k−1)(k−2)n−1+…)
为什么呢，假设k个条件，第i个条件是使用第i种颜色
然后我们开始容斥，首先什么条件都不要，然后减去有一种颜色不使用，加上有两种颜色不使用，这样
C(m,k)怎么算，k范围是100W，所以可以直接暴力算，1−100W的逆元都可以提前预处理
1−100W的阶乘的逆元也可以直接预处理，不然会TLE

代码：

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")

using namespace std;
#define   MAX           1000005
#define   MAXN          1000005
#define   maxnode       15
#define   sigma_size    30
#define   lson          l,m,rt<<1
#define   rson          m+1,r,rt<<1|1
#define   lrt           rt<<1
#define   rrt           rt<<1|1
#define   middle        int m=(r+l)>>1
#define   LL            long long
#define   ull           unsigned long long
#define   mem(x,v)      memset(x,v,sizeof(x))
#define   lowbit(x)     (x&-x)
#define   pii           pair<int,int>
#define   bits(a)       __builtin_popcount(a)
#define   mk            make_pair
#define   limit         10000

//const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const LL     INFF  = 0x3f3f;
const double pi    = acos(-1.0);
const double inf   = 1e18;
const double eps   = 1e-8;
const int    mod   = 1e9+7;
const ull    mx    = 133333331;

/*****************************************************/
inline void RI(int &x) {
      char c;
      while((c=getchar())<'0' || c>'9');
      x=c-'0';
      while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
 }
/*****************************************************/

LL fact[MAX];
LL ppow[MAX];
LL pp[MAX];
LL qpow(LL a,LL n){
    LL ans=1;
    while(n){
        if(n&1) ans=ans*a%mod;
        a=a*a%mod;
        n>>=1;
    }
    return ans;
}

void init(){
    fact[0]=1;
    ppow[0]=qpow(fact[0],mod-2);
    for(int i=1;i<=1000000;i++){
        fact[i]=fact[i-1]*i%mod;
        ppow[i]=qpow(fact[i],mod-2);
        pp[i]=qpow(i,mod-2);
    }
}

LL C(int n,int m){
    return (fact[n]*ppow[m]%mod)*ppow[n-m]%mod;
}
int main(){
    //freopen("in.out","r",stdin);
    int t,kase=0;
    cin>>t;
    init();
    while(t--){
        kase++;
        LL n,m,k;
        cin>>n>>m>>k;
        if(n==1&&k==1){
            printf("Case #%d: ",kase);
            cout<<m<<endl;
            continue;
        }
        LL tmp=1;
        for(int i=1;i<=k;i++){
            tmp=(tmp*(m+1-i)%mod)*pp[i]%mod;
        }
        int flag=1;
        LL ans=0;
        for(int i=k;i>1;i--){
            ans=ans+flag*(C(k,k-i)*i%mod)*qpow(i-1,n-1)%mod;
            if(ans<0) ans+=mod;
            if(ans>=mod) ans-=mod;
            flag*=-1;
        }
        printf("Case #%d: ",kase);
        cout<<ans*tmp%mod<<endl;
    }
    return 0;
}

Problem G. The Problem to Slow Down You

给你A,B两个字符串，然后问你有多少对四元组(a,b,c,d),Aa...b=Bc...d，并且Aa...b是回文
不懂字符串的其他算法，直接回文树上就行了
O(n)的处理A,B两个串，然后从0,1两个节点开始往下dfs，因为0,1两个节点是奇数偶数的起点
然后对于一个两个串里本质相同的节点，他们往下走相同字符得到的节点肯定也是本质相同
所以数量直接相乘即可
开头添加字符之后别忘记count，因为count之后，才是每个节点本质相同的个数都算完

代码：

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")

using namespace std;
#define   MAX           200005
#define   MAXN          1000005
#define   maxnode       15
#define   sigma_size    30
#define   lson          l,m,rt<<1
#define   rson          m+1,r,rt<<1|1
#define   lrt           rt<<1
#define   rrt           rt<<1|1
#define   middle        int m=(r+l)>>1
#define   LL            long long
#define   ull           unsigned long long
#define   mem(x,v)      memset(x,v,sizeof(x))
#define   lowbit(x)     (x&-x)
#define   pii           pair<int,int>
#define   bits(a)       __builtin_popcount(a)
#define   mk            make_pair
#define   limit         10000

//const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const LL     INFF  = 0x3f3f;
const double pi    = acos(-1.0);
const double inf   = 1e18;
const double eps   = 1e-8;
const int    mod   = 1e9+7;
const ull    mx    = 133333331;

/*****************************************************/
inline void RI(int &x) {
      char c;
      while((c=getchar())<'0' || c>'9');
      x=c-'0';
      while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
 }
/*****************************************************/

struct Palindromic_Tree {  
    int next[MAX][sigma_size] ;//next指针，next指针和字典树类似，指向的串为当前串两端加上同一个字符构成  
    int fail[MAX] ;//fail指针，指向这个节点表示的回文串的最长后缀回文串的开头位置
    int cnt[MAX] ;//这个节点上本质相同的回文串的个数（不完整，最后count之后才是每个节点上本质相同的回文串个数）
    int num[MAX] ; //节点i表示的回文串的后缀回文串的个数
    int len[MAX] ;//len[i]表示节点i表示的回文串的长度  
    int S[MAX] ;//存放添加的字符  
    int last ;//指向上一个字符所在的节点，方便下一次add  
    int n ;//字符数组指针  
    int p ;//节点指针  

    int newnode ( int l ) {//新建节点  
        for ( int i = 0 ; i < sigma_size ; ++ i ) next[p][i] = 0 ;  
        cnt[p] = 0 ;  
        num[p] = 0 ;  
        len[p] = l ;  
        return p ++ ;  
    }  

    void init () {//初始化  
        p = 0 ;  
        newnode (  0 ) ;  
        newnode ( -1 ) ;  
        last = 0 ;  
        n = 0 ;  
        S[n] = -1 ;//开头放一个字符集中没有的字符，减少特判  
        fail[0] = 1 ;  
    }  

    int get_fail ( int x ) {//和KMP一样，失配后找一个尽量最长的  
        while ( S[n - len[x] - 1] != S[n] ) x = fail[x] ;  
        return x ;  
    }  

    void add ( char c ) {  
        c -= 'a' ;  
        S[++ n] = c ;  
        int cur = get_fail ( last ) ;//通过上一个回文串找这个回文串的匹配位置  
        if ( !next[cur][c] ) {//如果这个回文串没有出现过，说明出现了一个新的本质不同的回文串  
            int now = newnode ( len[cur] + 2 ) ;//新建节点  
            fail[now] = next[get_fail ( fail[cur] )][c] ;//和AC自动机一样建立fail指针，以便失配后跳转  
            next[cur][c] = now ;  
            num[now] = num[fail[now]] + 1 ;  
        }  
        last = next[cur][c] ;  
        cnt[last] ++ ;  
    }  

    void count () {  
        for ( int i = p - 1 ; i >= 0 ; -- i ) cnt[fail[i]] += cnt[i] ;  
        //父亲累加儿子的cnt，因为如果fail[v]=u，则u一定是v的子回文串！  
    }  
}a,b;  
char A[MAX],B[MAX];

LL dfs(int numa,int numb){
    LL ans=0;
    for(int i=0;i<26;i++){
        if(a.next[numa][i]&&b.next[numb][i]){
            ans+=(LL)a.cnt[a.next[numa][i]]*b.cnt[b.next[numb][i]]+dfs(a.next[numa][i],b.next[numb][i]);
        }
    }
    return ans;
}
int main(){
    //freopen("in.out","r",stdin);
    int t,kase=0;
    cin>>t;
    while(t--){
        kase++;
        printf("Case #%d:\n",kase);
        a.init();
        b.init();
        scanf("%s%s",A,B);
        int lena=strlen(A);
        int lenb=strlen(B);
        for(int i=0;i<lena;i++) a.add(A[i]);
        for(int i=0;i<lenb;i++) b.add(B[i]);
        a.count();b.count();
        cout<<dfs(0,0)+dfs(1,1)<<endl;
    }
    return 0;
}

Problem I. International Collegiate Routing Contest

题目哔哔了半天，其实就是给你一堆IP地址，然后问你求一些其他的IP地址
并起来和原来给的不想交并且互补
IP地址放成32位，然后根据子网掩码的长度，放进字典树L位
然后去字典树里dfs，如果碰到这个节点有，就往下dfs，如果空节点，就放进ans里
如果是终止节点，那么就return
最后化成十进制即可

代码：

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")

using namespace std;
#define   MAX           30005
#define   MAXN          1000005
#define   maxnode       15
#define   sigma_size    30
#define   lson          l,m,rt<<1
#define   rson          m+1,r,rt<<1|1
#define   lrt           rt<<1
#define   rrt           rt<<1|1
#define   middle        int m=(r+l)>>1
#define   LL            long long
#define   ull           unsigned long long
#define   mem(x,v)      memset(x,v,sizeof(x))
#define   lowbit(x)     (x&-x)
#define   pii           pair<int,int>
#define   bits(a)       __builtin_popcount(a)
#define   mk            make_pair
#define   limit         10000

//const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const LL     INFF  = 0x3f3f;
const double pi    = acos(-1.0);
const double inf   = 1e18;
const double eps   = 1e-8;
const int    mod   = 1e9+7;
const ull    mx    = 133333331;

/*****************************************************/
inline void RI(int &x) {
      char c;
      while((c=getchar())<'0' || c>'9');
      x=c-'0';
      while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
 }
/*****************************************************/

int ch[33*MAX][2];
int val[33*MAX];
int sz;

void init(){
    mem(ch[0],0);
    sz=1;
}

void inser(string a){
    int u=0;
    for(int i=0;i<a.size();i++){
        int c=a[i]-'0';
        if(!ch[u][c]){
            mem(ch[sz],0);
            val[sz]=0;
            ch[u][c]=sz++;
        }
        u=ch[u][c];
    }
    val[u]=1;
}
vector<string> ans;
void query(int u,string s){
    if(ch[u][0]&&!val[ch[u][0]]) query(ch[u][0],s+'0');
    if(ch[u][1]&&!val[ch[u][1]]) query(ch[u][1],s+'1');
    if(!ch[u][0]) ans.push_back(s+'0');
    if(!ch[u][1]) ans.push_back(s+'1');
}

int main(){
    //freopen("in.out","r",stdin);
    int t,kase=0;
    cin>>t;
    while(t--){
        kase++;
        printf("Case #%d:\n",kase);
        int n;
        cin>>n;
        ans.clear();
        if(n==0){
            printf("1\n");
            printf("0.0.0.0/0\n");
            continue;
        }
        init();
        int a[5];
        int flag=0;
        for(int i=0;i<n;i++){
            int l;
            scanf("%d.%d.%d.%d/%d",&a[0],&a[1],&a[2],&a[3],&l);
            if(l==0){
                flag=1;
                continue;
            }
            if(flag) continue;
            string s="";
            for(int j=0;j<4;j++){
                string x="";
                for(int k=0;k<8;k++){
                    char c=a[j]%2+'0';
                    x=c+x;
                    a[j]/=2;
                }
                s=s+x;
            }
            string tmp="";
            for(int i=0;i<l;i++) tmp=tmp+s[i];
                //cout<<tmp<<endl;
            inser(tmp);
        }
        if(flag){
            printf("0\n");
            continue;
        }
        query(0,"");
        printf("%d\n",(int)ans.size());
        for(int i=0;i<ans.size();i++){
            //cout<<ans[i]<<endl;
            int l=ans[i].size();
            for(int j=ans[i].size();j<32;j++) ans[i]=ans[i]+'0';
            int tmp=0;
            for(int j=0;j<8;j++){
                tmp=tmp*2+(ans[i][j]-'0');
            }
            printf("%d.",tmp);
            tmp=0;
            for(int j=8;j<16;j++){
                tmp=tmp*2+(ans[i][j]-'0');
            }
            printf("%d.",tmp);
            tmp=0;
            for(int j=16;j<24;j++){
                tmp=tmp*2+(ans[i][j]-'0');
            }
            printf("%d.",tmp);
            tmp=0;
            for(int j=24;j<32;j++){
                tmp=tmp*2+(ans[i][j]-'0');
            }
            printf("%d/%d\n",tmp,l);
        }
    }
    return 0;
}

Problem K. Last Defence

S0=A
S1=B
Si=|Si−1−Si−2|fori≥2
开头没仔细考虑这题，以为很简单，其实仔细看，对于A,B两个数字，先会出现A,B辗转相除过程中出现的那些数字
然后是min(A,B)和辗转相除到最后的那个数字进行辗转相除
模拟一下辗转相除的过程即可

代码：

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")

using namespace std;
#define   MAX           1000005
#define   MAXN          1000005
#define   maxnode       15
#define   sigma_size    30
#define   lson          l,m,rt<<1
#define   rson          m+1,r,rt<<1|1
#define   lrt           rt<<1
#define   rrt           rt<<1|1
#define   middle        int m=(r+l)>>1
#define   LL            long long
#define   ull           unsigned long long
#define   mem(x,v)      memset(x,v,sizeof(x))
#define   lowbit(x)     (x&-x)
#define   pii           pair<int,int>
#define   bits(a)       __builtin_popcount(a)
#define   mk            make_pair
#define   limit         10000

//const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const LL     INFF  = 0x3f3f;
const double pi    = acos(-1.0);
const double inf   = 1e18;
const double eps   = 1e-8;
const int    mod   = 1e9+7;
const ull    mx    = 133333331;

/*****************************************************/
inline void RI(int &x) {
      char c;
      while((c=getchar())<'0' || c>'9');
      x=c-'0';
      while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
 }
/*****************************************************/

LL gcd(LL a,LL b){
    if(!b) return a;
    return gcd(b,a%b);
}
int main(){
    //freopen("in.out","r",stdin);
    int t,kase=0;
    cin>>t;
    while(t--){
        LL a,b;
        cin>>a>>b;
        kase++;
        printf("Case #%d: ",kase);
        if(a==b){
            if(a==0) cout<<1<<endl;
            else cout<<2<<endl;
            continue;
        }
        if(a<b) swap(a,b);
        if(b==0){
            cout<<2<<endl;
            continue;
        }
        LL ans=2;
        while(b!=0){
            ans+=(a-b-1)/b;
            a%=b;
            swap(a,b);
            ans++;
        }
        cout<<ans<<endl;
    }
    return 0;
}
Miracle_ma
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CF GYM 100548 International Collegiate Routing Contest（2014ACM西安现场赛Problem I）
wujy的专栏
01-24 3027
解题思路： 每个IP地址由32位二进制组成。整个地址空间可以表现为一棵二叉树（简化的Trie树），如下图所示： 图中表示的是以下4个子网的覆盖情况： 0.0.0.0/1 （二进制前1位是0） 32.0.0.0/3（二进制前3位是001） 128.0.0.0/2 （二进制前2位是10） 224.0.0.0/3 （二进制前3位是111） 图中的红色节点代表网络覆盖的终结点，这一网络号覆盖红色节点下的完整一支；黄色节点也是包含在这个网络中的， 题目要求的就是树上没有被输入集合覆盖的分支。不能与
Codeforces GYM 100548 F - Color （2014年西安站F题）
long long ago
04-14 1459
题目地址 题意：NN朵花，有MM种颜色可用，要求给他们涂色，相邻的话颜色不同。要求正好使用KK种颜色。 题解：选KK种颜色是CkmC^k_m，记F(i)F(i)为选了KK种颜色后，使用不超过ii种颜色的方案。第一朵花有KK种选择，后面N−1N-1朵的花的颜色除了前一朵花的颜色之外都可以选，总的就是F(i)=Cik(k−1)n−1F(i)=C^i_k(k-1)^{n-1} 答案就是Ckm(F
Gym100548H
MatouKariya的专栏
04-08 472
2014西安赛区的H，是一道有向图上的博弈问题 首先我们要确定一下结束状态，一种是两点重合，还有一种是没法移动棋子 接下来我们把结束状态放在队列的队首，倒退之前的状态 我用1表示Alice必胜，2表示Bob必胜，3表示平局，分了4种情况 1、轮到Bob,状态为1，dp[x][y][1]=1,那么之前能到达y的点dp[x][v][0]=1 2、轮到Alice,状态为2，dp[x][y][0]
[2014 ACM 西安区域赛]PalindromicTree 回文树
Jazengm的博客
12-20 397
[2014 ACM 西安区域赛]PalindromicTree 回文树 Table of Contents 1. WTF is PT 1.1. 作用1.2. 性质1.3. 实现 1.3.1. 定义1.3.2. 过程 2. 题意3. 思路4. 代码 1 WTF is PT 1.1 作用 一个匹配模式串回文子串的自动机
2014西安区域赛
Qianyri的博客
10-17 309
2014西安区域赛 K.Last Defences 参考题解 给定两个数A，B（&lt;1e18）S0=A，S1=B，Si=| Si-1- Si-2 |，求Si不同值的个数 假设A=11，B=3，简单计算可得序列S：11，3，8，5，3，2，1，1，0，1，0~ 仔细观察可以看出：8=11-1*3，5=11-2*3，2=11-3*3，3出现的次数为11%3-1，产生的新数字个数为A/B ...
2014年西安区域赛的几道水题（A. F. K）
weixin_30763455的博客
08-23 89
A . 问一组数能否全部被3整除 K. S1 = A, S2 = B, Si = |Si-1 - Si-2|; 一直循环问， 出现了多少不同的数； 多模拟几组数， 可以发现和辗转相除法有很大关系 #include<bits/stdc++.h> using namespace std; #define ll long long ll gcd(ll a...
2014西安邀请赛部分题解
Tongqi
08-11 756
HDU 4848 Wow! Such Conquering! 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4848 题意及思路：有n个星球，现在你从1开始需要访问其他所有的星球。给你Txy表示从x到y的时间，再给n-1个Deadline表示第一次到星球2~n的最迟时间不能超过所给的Deadline。现在问你是否能在要求内访问所有的星球，如果可...
codeforces gym 100548G
Occult
04-15 492
求两个字符串的公共回文子串个数，搞两个回文树，dfs一遍即可。 #pragma comment(linker, "/STACK:102400000,102400000") #include #include #include #include #include #include #include #include #include #include #include using namespac
2014ACM/ICPC亚洲区西安站 F题 color (组合数学，容斥原理)
追梦赤子心
06-11 2072
2014ACM/ICPC亚洲区西安站 F题 color (组合数学，容斥原理)
Codeforces Gym 100548H - The Problem to Make You Happy 2014 ACM-ICPC 西安站
J. Cole
10-16 273
Problem H. The Problem to Make You Happy Input file: standard input Output file: standard output Time limit: 1 seconds Memory limit: 256 mebibytes Problem Description Alice and Bob are good friends, a...
uvalive7040/cf gym 100548 Color(2014西安区域赛F题)
weixin_30248399的博客
08-08 128
Source CF GYM 100548 UVALIVE 7040 题意 n个格子排成一行，有m种颜色，问用恰好k种颜色进行染色，使得相邻格子颜色不同的方案数。 \(k\leq10^6\quad n, m\leq10^9\) 分析 在网上看到的几篇解题报告好像没讲清楚为什么是容斥（反正我没看懂。。），所以我也写一篇。 首先，我们可以从m个颜色中取出k个，即\(C^k_m\)。 接着容易想...
Codeforces Gym 100548F Color (组合数＋容斥)
Tc的专栏
09-12 1383
Codeforces Gym 100548F Color (组合数＋容斥)
Gym - 100548C The Problem Needs 3D Arrays （最大密度子图）
LP_Cong
11-16 1061
  题意：求一个子序列，使得这个子序列的  逆序数/长度 最大   解题思路：如果知道什么是最大密度子图，那么这道题就是裸题了。这里保存一下模板~！ 感谢大佬的模板 https://www.cnblogs.com/xiuwenli/p/9748771.html 这个模板可以求 带点权带边权某些点必须用的最大密度子图   #include&lt;bits/stdc++.h&gt...
Gym - 100548G 回文树
bjfu170203101的博客
09-11 194
想到了建2棵回文树，但想的是利用hash，但会爆内存。 其实直接建出2棵回文树后对跑dfs就行了。 每棵树同时先跑奇偶结点即可。 比如 A树 0结点空 B树 0结点空 他们都指向aa，所以可以往下dfs 即有相同回文串。 然后发现aa又都指向baab 所以b这里即i=1可以往下dfs 每次算是匹配的回文串贡献即可。 //KX #include <bits/std...
Gym - 100548G (回文树,公共前缀的对数）
WayJasy的博客
07-30 180
传送门 题意：给你两个字符串s1,s2s1,s2s1,s2，求它们的公共前缀有多少对 题解：对s1s1s1建一棵回文树，然后部分初始化，再在s1s1s1的基础上对s2s2s2建回文树。　然后对cntcntcnt乘积求和 为什么可以这样？ 因为第一次建树的时候求出了s1s1s1在每个节点不同的回文子串个数，s2s2s2插入进来的时候，如果当前节点已经存在了回文子串，那么s2s2s2在当前节点的回文子...
2014 ACM/ICPC 西安赛区网络赛解题报告汇总
描绘自己的王国……
09-28 1458
首页 算法竞赛» 信息聚合 ONLINE JUDGE 书刊杂志 BLOG» 技术文章 解题报告 故事杂谈 新闻故事» 招聘信息» 投稿须知 2014 ACM/ICPC 西安赛区网络赛解题报告汇总 九月 17th, 2014 | Posted by huangkun in ICPC | ICPC 2014
2014ACM-ICPC亚洲区域西安赛区 G题 / GYM 100548 G
tanmlh的专栏
08-31 1040
思路： 利用回文树处理出两个串的每个回文串在该串中出现的次数，然后对回文树中的每个节点，用该节点所对应的回文串在第一个串中的出现次数乘上在第二个串中的出现次数，求和即可。 处理出每个串中的每个回文串在该串中出现次数的方法是：考虑到回文树中的每个节点对应一个回文字串，先用第一个串构造出回文树，插入两个不同的没有出现的字符（使得两个串不相干），再插入第二个串，过程中分别记录每个节点在第一个串和第二
2014 ACM-ICPC 西安站总结
A Cube Master
10-30 1170
ji'tian
第十届蓝桥杯省赛原题及参考答案
热门推荐
qq_39507723的博客
03-25 4万+
思路：这一题没有看懂是要挑选出成绩峰值最大的5个人，还是根据平均值选出5个人求其峰值和； 第一种情况答案是490 第二种情况没算 我考试时没有看清题意，以为是求出这几组数据的最大值，成功避开了题意，所以第一题就很随意的凉凉了~~ 思路： 截取所有可能的字符串放入hashmap中， hashmap的特点就是：如果有重复的字符串会覆盖之前的字符串， 最后利用map....
宇树 a1 isaacgym安装
最新发布
09-30
宇树a1的IsaacGym的安装可以按照以下步骤进行： 1. 首先，访问Isaac Gym的官方网站，可以在https://leggedrobotics.github.io/legged_gym/找到相关信息。 2. 在网站上找到论文地址，该论文名为《Learning to Walk ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值