10月20日 训练记录 GYM 101889

最新推荐文章于 2022-05-28 11:31:46 发布
最新推荐文章于 2022-05-28 11:31:46 发布
阅读量229 收藏
点赞数
分类专栏： 套题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Game_Acm/article/details/83240473
版权

训练题目集

B题：

题意：给一段字符串，它是由挨个添加字符生成，生成时当添加元音时会使得整个字符串翻转，给目标字符串求生成方案数

思路：计算整个字符串的元音数并找到不翻转原串的首个元音所在位置，若元音数为奇数答案为首个元音向后到下个元音或结尾的长度，若元音数为偶数答案则为向前到上个元音或开头的长度

代码：

#include<bits/stdc++.h>
using  namespace std;
const int maxn = 100010;
char s[maxn];
bool ok( char ch )
{
    if ( ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u' ) return true;
    else return false;
}
int main()
{
    scanf ( "%s" , s );
    int len = strlen(s),cnt = 0;
    for ( int i=0 ; i<len ; i++ )
    {
        if ( ok(s[i]) )
        {
            cnt++;
            if ( !ok(s[0]) )
            {
                cnt = -1;
                break;
            }
        }
    }
    if ( cnt==-1 )
        printf ( "0\n" );
    else if ( cnt== 0 )
        printf ( "1\n" );
    else
    {
        int tmp,ans = 0;
        if ( cnt%2==1 ) tmp = (cnt+1)/2;
        else tmp = cnt/2+1;
        for ( int i=0 ; i<len ; i++ )
        {
            if ( ok(s[i]) ) tmp--;
            if ( tmp==0   )
            {
                if ( cnt%2==1 )
                {
                    ans++;
                    while ( i+ans<len&&!ok(s[i+ans]) )
                        ans++;
                }
                else
                {
                    ans++;
                    while ( i-ans>=0&&!ok(s[i-ans]) )
                        ans++;
                }
                break;
            }
        }
        printf ( "%d\n" , ans );
    }
    return 0;
}

C题：

题意：一个长为n的数组，只含1-K，问进行以下一种操作是否可以使得整个数组中1-K的数目相同，若无解输出*

操作一：删除数组中的一个数 -X

操作二：添加一个数到数组中 +X

操作三：删除数组中的一个数并添加一个数 -X +Y

思路：模拟处理

#include<bits/stdc++.h>
using  namespace  std;
const int inf = 0x3f3f3f3f;
int Max( int a , int b ){ return a>b?a:b; }
int Min( int a , int b ){ return a<b?a:b; }
int k,n,a[1010];
int main()
{
    scanf( "%d%d" , &k , &n );
    for  ( int i=1 ; i<=k ; i++ ) a[i] = 0;
    for  ( int i=1 ; i<=n ; i++ )
    {
        int x; scanf( "%d" , &x );  a[x]++;
    }
    int maxx = -inf,cnta = 0,idxa;
    int minx = +inf,cntb = 0,idxb;
    for  ( int i=1 ; i<=k ; i++ )
    {
        if ( a[i]>maxx )
        {
            maxx = a[i]; cnta = 1; idxa = i;
        }
        else if ( a[i]==maxx )
        {
            cnta++;
        }
        if ( a[i]<minx )
        {
            minx = a[i]; cntb = 1; idxb = i;
        }
        else if ( a[i]==minx )
        {
            cntb++;
        }
    }
    if ( maxx-minx==1 )
    {
        if ( cnta==1&&cntb==k-1 )
        {
            printf( "-%d\n" , idxa );
        }
        else if ( cntb==1&&cnta==k-1 )
        {
            printf( "+%d\n" , idxb );
        }
        else
        {
            printf( "*\n" );
        }
    }
    else if ( maxx-minx==2 )
    {
        if ( cnta==1&&cntb==1 )
        {
            printf( "-%d +%d\n" , idxa , idxb );
        }
        else
        {
            printf( "*\n" );
        }
    }
    else
    {
        printf( "*\n" );
    }
    return 0;
}

E题：

题意：给一个字符串S和一个整数N，字符串中的？可以用任意数字代替，求是否存在一种代替方式，使得整数S整除N

思路：长度1000，N<=1000可以用1000*1000的数组记录状态，dfs搜索

代码：

#include<bits/stdc++.h>
using  namespace  std;
const int inf = 0x3f3f3f3f;
int Max( int a , int b ){ return a>b?a:b; }
int Min( int a , int b ){ return a<b?a:b; }
char s[1010],ans[1010]; int n,len; bool vis[1010][1010],ok;
void dfs( int dep , int sum )
{
    if ( ok ) return;
    if ( vis[dep][sum] ) return;
    vis[dep][sum] = true;
    if ( dep==len )
    {
        if ( sum==0 ) ok = true;
        return;
    }
    if ( s[dep]!='?' )
    {
        ans[dep] = s[dep]; dfs( dep+1 , (sum*10+s[dep]-'0')%n );
        if ( ok ) return;
    }
    else
    {
        int down = dep==0?1:0;
        for ( int i=down ; i<=9 ; i++ )
        {
            ans[dep] = i+'0',dfs( dep+1 , (sum*10+i)%n );
            if ( ok ) return;
        }
    }
}
int main()
{
    scanf ( "%s%d" , s , &n );
    memset( vis , false , sizeof(vis) );
    len = strlen(s);
    ok = false;
    dfs( 0 , 0 );
    ans[len] = '\0';
    if ( ok ) printf( "%s\n" , ans );
    else printf( "*\n" );
    return 0;
}

F题：

题意：n个人，每个人有三个属性a,b,val，从选取任意多人使得没有任何两个人的两个属性都是严格大于的，选取的人可以得到价值val，a，b相同也是允许的，求最大val和

思路：对a升序b降序进行排序，对b离散化后用线段树维护对应b值的最大价值

代码：

#include<bits/stdc++.h>
using  namespace std;
#define lson rt<<1
#define rson rt<<1|1
typedef long long LL;
const int maxn = 100010;
const int inf  = 0x3f3f3f3f;
LL Max( LL a , LL b ){ return a>b?a:b; }
LL Min( LL a , LL b ){ return a<b?a:b; }
struct node
{
    int a,b; LL val;
    friend bool operator<( const node&a , const node&b )
    {
        if ( a.a==b.a ) return a.b>b.b;
        else return a.a<b.a;
    }
}a[maxn];
int  n,m,b[maxn];
LL maxx[maxn<<2];
void push_up( int rt )
{
    maxx[rt] = Max( maxx[lson] , maxx[rson] );
}
void build( int l , int r , int rt )
{
    if ( l==r )
    {
        maxx[rt] = 0;
        return;
    }
    int mid = (l+r)>>1;
    build( l , mid , lson );
    build( mid+1 , r , rson );
    push_up( rt );
}
void update( int p , LL v , int l , int r , int rt )
{
    if ( l==r )
    {
        maxx[rt] = Max( maxx[rt] , v );
        return;
    }
    int mid = (l+r)>>1;
    if ( p<=mid ) update( p , v , l , mid , lson );
    else update( p , v , mid+1 , r , rson );
    push_up( rt );
}
LL query( int L , int R , int l , int r , int rt )
{
    if ( R<L ) return 0;
    if ( L<=l&&R>=r ) return maxx[rt];
    int mid = (l+r)>>1; LL res = 0;
    if ( L<=mid ) res = Max( res , query( L , R , l , mid , lson ) );
    if ( R> mid ) res = Max( res , query( L , R , mid+1 , r , rson ) );
    return res;
}
int main()
{
    int n; scanf( "%d" , &n );
    for ( int i=1 ; i<=n ; i++ )
    {
        scanf( "%d%d%I64d" , &a[i].a , &a[i].b , &a[i].val );
        b[i] = a[i].b;
    }
    LL ans = 0;
    sort ( a+1 , a+n+1 );
    sort ( b+1 , b+n+1 );
    m = unique( b+1 , b+n+1 )-b-1;
    build( 1 , m , 1 );
    for  ( int i=1 ; i<=n ; i++ )
    {
        int l=i,r=i; LL tmp = a[i].val;
        while ( r+1<=n&&a[r+1].a==a[l].a&&a[r+1].b==a[l].b )
        {
            r++;
            tmp += a[r].val;
        }
        //printf ( "%d %d\n" , l , r );
        //printf ( "%d %d\n" , a[i].a , a[i].b );
        int t = lower_bound( b+1 , b+m+1 , a[l].b )-b;
        LL res = query( 1 , t-1 , 1 , m , 1 );
        ans = Max( ans , res+tmp );
        update( t , tmp+res , 1 , m , 1 );
        i = r;
    }
    printf( "%lld\n" , ans );
    return 0;
}

H题：

题意：水题，求Max( 0 , d-a )+Max( 0 , e-b )+Max( 0 , f-c )

思路：水题

代码：

#include<bits/stdc++.h>
using  namespace  std;
int Max( int a , int b ){ return a>b?a:b; }
int main()
{
    int a,b,c; scanf( "%d%d%d" , &a , &b , &c );
    int d,e,f; scanf( "%d%d%d" , &d , &e , &f );
    printf( "%d\n" , Max( 0 , d-a )+Max( 0 , e-b )+Max( 0 , f-c ) );
    return 0;
}

I题：

题意：N个点R条边Q次询问，每次询问给定一条边为必选边，其余边任选，求使得整个图连通的最小花费

思路：先做出最小生成树，若询问边为最小树中的边则答案为最小树花费，若不是则是选定边花费+最小树花费-最小树上u到v的最长边

代码：

#include<bits/stdc++.h>
using  namespace  std;
const int inf = 0x3f3f3f3f;
int Max( int a , int b ){ return a>b?a:b; }
int Min( int a , int b ){ return a<b?a:b; }
const int maxn = 100010;
const int maxm = 200010;
int tol,head[maxn];
struct edge
{
    int to,next,cost;
}es[maxm];
void addedge( int u , int v , int w )
{
    es[tol].to = v;
    es[tol].next = head[u];
    es[tol].cost = w;
    head[u] = tol++;
}
struct node
{
    int u,v,w; bool used;
}a[maxm];
bool cmp1( node a , node b )
{
    return a.w<b.w;
}
bool cmp2( node a , node b )
{
    if ( a.u!=b.u ) return a.u<b.u;
    else return a.v<b.v;
}
int pre[maxn],val;
int Find( int x )
{
    if ( x!=pre[x] ) pre[x] = Find( pre[x] );
    return pre[x];
}
void kruskal( int m )
{
    val = 0; tol = 0; memset( head , -1 , sizeof(head) );
    for ( int i=1 ; i<=m ; i++ )
    {
        int fx = Find( a[i].u );
        int fy = Find( a[i].v );
        if ( fx!=fy )
        {
            pre[fy] = fx;
            addedge( a[i].u , a[i].v , a[i].w );
            addedge( a[i].v , a[i].u , a[i].w );
            val += a[i].w;
            a[i].used = true;
        }
    }
}
int fa[maxn][20],maxx[maxn][20],dep[maxn];
void dfs( int u , int f , int d  )
{
    for ( int i=head[u] ; i!=-1 ; i=es[i].next )
    {
        int v = es[i].to; if ( v==f ) continue;
        int w = es[i].cost;
        fa[v][0] = u;
        maxx[v][0] = w;
        dep[v] = d+1;
        dfs( v , u , d+1 );
    }
}
int lca( int u , int v )
{
    if( dep[u]<dep[v] ) swap( u , v );
    //printf ( "%d %d\n" , dep[u] , dep[v] );
    int d = dep[u]-dep[v],res = 0;
    for ( int i=19 ; i>=0 ; i-- )
    {
        if ( d&(1<<i) )
        {
            res = Max( res , maxx[u][i] );
            u = fa[u][i];
        }
    }
    if  ( u==v ) return res;
    for ( int i=19 ; i>=0 ; i-- )
    {
        if ( fa[u][i]!=fa[v][i] )
        {
            res = Max( res , maxx[u][i] );
            res = Max( res , maxx[v][i] );
            u = fa[u][i];
            v = fa[v][i];
        }
    }
    res = Max( res , maxx[u][0] );
    res = Max( res , maxx[v][0] );
    return res;
}
int main()
{
    int n,m; scanf( "%d%d" , &n , &m );
    for ( int i=1 ; i<=m ; i++ )
    {
        scanf( "%d%d%d" , &a[i].u , &a[i].v , &a[i].w );
        a[i].used = false;
    }
    sort( a+1 , a+m+1 , cmp1 );
    for ( int i=1 ; i<=n ; i++ )
    {
        pre[i] = i;
    }
    kruskal( m );
    //printf ( "%d\n" , val );
    sort( a+1 , a+m+1 , cmp2 );
    fa[1][0] = 0; maxx[1][0] = 0; dep[1] = 1;
    dfs ( 1 , 0 , 1 );
    for( int j=1 ; j<20 ; j++ )
    {
        for( int i=1 ; i<=n ; i++ )
        {
            maxx[i][j] = Max( maxx[i][j-1] , maxx[fa[i][j-1]][j-1] );
            fa[i][j] = fa[fa[i][j-1]][j-1];
        }
    }
    int q; scanf( "%d" , &q );
    for ( int i=1 ; i<=q ; i++ )
    {
        int u,v; scanf( "%d%d" , &u , &v );
        int l=1,r=m;
        while ( l<=r )
        {
            int mid = (l+r)>>1;
            if ( a[mid].u>u||(a[mid].u==u&&a[mid].v>=v) ) r = mid-1;
            else l = mid+1;
        }
        if ( a[l].used )
        {
            printf ( "%d\n" , val );
            continue;
        }
        int tmp = a[l].w;
        //printf( "%d %d %d\n" , val , lca( u , v ) , tmp );
        printf( "%d\n" , val-lca( u , v )+tmp );
    }
    return  0;
}

J题：

题意：一个环形数列，有石头’R‘有水潭‘P’，求步长范围[1,N-1]中有多少步长，是可以有从起点跳到起点的

思路：当步长为K时需要跳N/GCD(K,N)个石头，只要有余数相同且这些位置上都是石头则说明当前步长可行

代码：

#include<bits/stdc++.h>
using  namespace std;
const int maxn = 100010;
int Max( int a , int b ){ return a>b?a:b; }
int Gcd( int a , int b ){ return b==0?a:Gcd( b , a%b ); }
char s[maxn]; bool a[maxn],b[maxn],ok[maxn];
int main()
{
    scanf  ( "%s" , s );
    int len = strlen(s),ans=0;
    for ( int i=0 ; i<=len ; i++ )
    {
        ok[i] = false;
    }
    for ( int i=1 ; i*i<=len ; i++ )
    {
        if ( len%i==0 )
        {
            int  cnta = i,cntb = len/i;
            for ( int j=0 ; j<cnta ; j++ )
            {
                a[j] = false;
            }
            for ( int j=0 ; j<cntb ; j++ )
            {
                b[j] = false;
            }
            for ( int j=0 ; j<len  ; j++ )
            {
                if ( s[j]=='P' )
                {
                    int ta = j%(i);
                    int tb = j%(len/i);
                    if ( a[ta]==false )
                    {
                        a[ta] = true;
                        cnta--;
                    }
                    if ( b[tb]==false )
                    {
                        b[tb] = true;
                        cntb--;
                    }
                }
            }
            if ( cnta>0 ) ok[i] = true;
            if ( cntb>0 ) ok[len/i] = true;
        }
    }
    for ( int i=1 ; i<len ; i++ )
        ans += (ok[Gcd( i , len )]==true);
    printf( "%d\n" , ans );
    return 0;
}

 

maze_illusion
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rl-gym-maze:OpenAI体育馆中用于强化学习解决方案的迷宫环境
03-25
rl迷宫 OpenAI体育馆中用于强化学习解决方案的迷宫环境
强化学习的几种环境介绍
m0_62459326的博客
03-22 3362
强化学习的几种环境介绍
莫烦强化学习视频笔记：第四节 4.3 OpenAI Gym 环境库
sophicchen的专栏
11-09 646
1. 要点 手动编环境是一件很耗时间的事情, 所以如果有能力使用别人已经编好的环境, 可以节约我们很多时间. OpenAI gym 就是这样一个模块, 他提供了我们很多优秀的模拟环境. 我们的各种 RL 算法都能使用这些环境. 不过 OpenAI gym 暂时只支持 MacOS 和 Linux 系统. Windows 已经支持, 但是听说还没有全面支持, 大家时不时查看下官网, 可能就有惊喜. 实在等不及Windows更新了, 用 tkinter 来手动编写一下环境也行. 这里有我制作的很好的tkin..
10月21日 训练记录 GYM 101908
maze_illusion的博客
10-21 462
B题： 题意：博弈，二维平面上n个点，每次可以下移，左移或对角线移动任意步，将任意点移到原点即胜利 思路：SG函数，初始有在对角线上的点则先手必胜。有三个禁区x轴，y轴和对角线，一旦移动到这些地方对手就赢了。所以相应得（1，2）和（2，1）就成为必败点了，这两个点无论如何移动都会进入到禁区。任意点最终都会移到（1，2）和（2，1），所以以（1，2）和（2，1）为起点并躲避禁区SG博弈就出结果了...
ma-gym:基于OpenAI Gym的多代理环境集合
05-14
基于OpenAI Gym的多代理环境的集合。 安装 使用PyPI： pip install ma-gym 直接从来源： git clone https://github.com/koulanurag/ma-gym.git cd ma-gym pip install -e . 参考： 如果您想引用它，请使用此bibtex...
gym-minigrid:OpenAI Gym的简约gridworld软件包
04-29
简约的Gridworld环境（MiniGrid） 那里还有其他的gridworld Gym环境，但是该环境被设计为特别简单，轻巧和快速。 该代码几乎没有依赖项，因此不太可能破坏或无法安装。 它不加载外部精灵/纹理，并且可以在Core i7...
banana-gym:用于训练RL代理的简单随机OpenAI环境
04-30
import gym import gym_banana env = gym.make('Banana-v0') 有关某些示例，请参见 。 环境 想象一下你在卖香蕉。 一次一个。 香蕉很快变坏。 假设3天之内。 我卖香蕉的概率由下式给出： $$ p（x）=（1 + e）/（1。...
gym
03-06
状态：维护（预计错误修复和次要更新）OpenAI Gym是用于开发和比较强化学习算法的工具包。 这是gym开放源代码库，可让您访问一组标准化的环境。 gym不对代理的结构进行任何假设，并且与任何数字计算库（例如...
pybullet-gym:用于OpenAI Gym强化学习研究平台的OpenAI Gym MuJoCo环境的开源实现
05-02
PyBullet体育馆 PyBullet Gymperium是OpenAI Gym MuJoCo环境的开源实现，可与OpenAI Gym强化学习研究平台一起使用，以支持开放研究。... 为了简化实施环境的研究，每个环境都配备了经过预训练的代理，这些代理可以
Python库 | gym_maze_trustycoder83-0.0.2-py2.py3-none-any.whl
04-22
资源分类：Python库 所属语言：Python 使用前提：需要解压 资源全名：gym_maze_trustycoder83-0.0.2-py2.py3-none-any.whl 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
习题：基于gym环境构建迷宫世界
lxs3213196的博客
11-26 2496
迷宫世界效果演示环境测试代码测试代码的调用环境构建代码 效果演示 迷宫世界的最终演示效果如图。 黑色为墙不可通行，白色为道路可通行，黄色为出口。 环境测试代码 # 环境测试 import gym import random import time env=gym.make('MazeWorld-v0') env.reset() reward=0 while True: action = env.actions[int(random.random()*len(env.actions))]
自定义并注册gym环境
qq_43589538的博客
05-28 574
目录需要遵循的架构setup.pygym_maze/\__init__.pygym_maze/envs/\__init__.pygym_maze/envs/maze_env.py安装使用参考 需要遵循的架构 gym_maze/ setup.py gym_maze/ _init_ .py envs/ _init_ .py maze_env.py 下面介绍各部分需要写的内容. setup.py from setuptools import setup setup(name='gym_ma
Maze环境以及DQN的实现
天才男孩的博客
04-03 4072
环境 5*5的迷宫，其中(4,3)位置是出口，障碍物的位置分别为(1,1)、(1,2)、(1,3)、(1,4)、(3,2)、(3,3)、(4,2) 动作空间当然4个，上下左右 直接上代码~ import gym import tensorflow as tf import numpy as np import time import sys if sys.version_info.major ...
强化学习基础第一个环境（Maze）
qq446293528的博客
11-27 5012
本篇文章主要介绍在gym环境下env环境编写（未待完续，空闲更新） 经典的迷宫宝藏例子 import numpy as np import time import tkinter as tk # 窗口界面库 UNIT = 40 # 像素 MAZE_H = 5 # 高宽格子数 MAZE_W = 3 class Maze(tk.Tk): # 新类继承父类tkinter.Tk d...
10月19日训练记录 CF GYM 101911
maze_illusion的博客
10-19 833
A题 题意：喝n杯咖啡，但两杯咖啡的间隔时间要大于d，问最少需要几天才能喝上n杯咖啡 思路：贪心喝咖啡，每一杯都选时间符合要求的，如果找不到时间符合要求的就加一天 代码：数据结构减智力，可以用set简单维护。。。 #include&lt;bits/stdc++.h&gt; using namespace std; #define lson rt&lt;&lt;1 #define rso...
CodeForces Gym101158H Animal Companion in Maze
Tooc0ld
11-28 454
给一张图，图上的边有单向边也有双向边。双向边有一项限制是，当使用一条双向边从A->B时，不可以立刻使用这条边回去。如果图中有环，输出INF，否则输出最长路径长度。
[暴力 树形DP] Codeforces Gym 100553H NEERC14 H. Hidden Maze
雯舞
03-06 461
#include<cstdio> #include<cstdlib> #include<algorithm> using namespace std; typedef long long ll;inline char nc(){ static char buf[100000],*p1=buf,*p2=buf; return p1==p2&&(p2=(p1=buf)+fread(buf,1,1
codeforces gym 101889J – Jumping Frog ( 数学+ 思维 好题 )
yjt9299的博客
10-03 476
链接：http://codeforces.com/gym/101889/attachments 思路 ：青蛙每次跳长度为len  的距离，如果想要回到原点，那么青蛙跳的点数一定是固定的，把跳过的点标记成红色，那么相邻的两个红点之间的距离也一定是字符串长度n 的因子。那么就问题就可以转化成每次跳长度为两个红点的距离，能否满足题意。那么我就可以直接暴力处理长度n 的所有因子是否可以。因为n的因子不会...
gym 查看模型训练结果 多智能体强化学习
最新发布
09-19
此外，还可以使用Gym的监视器工具来记录和可视化智能体在不同环境中的行为。这些结果可以帮助我们评估和比较不同算法的性能，并为进一步改进模型提供指导。 总之，通过使用Gym进行模型训练和结果查看，我们可以方便...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值