【玩耍】一水

just_sort just_sort 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 600+累计阅读 599平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄11年
关注
原创 最新推荐文章于 2026-08-02 17:40:08 发布 599 阅读 AI 写同款· GEO 优化 ›
45、能与儿童互动玩耍的机器人：设计、实验与效果分析 本文介绍了一种能与儿童互动玩耍的机器人系统，涵盖了十种玩耍模块的设计，并通过观察儿童心理状态和动作选择策略来实现长时间的互动。研究基于对幼儿园教师与儿童互动行为的分析，构建了儿童心理状态模型，并利用注视规律性、微笑强度和动作等特征来估计状态。实验结果表明，基于心理状态转变模型的动作选择策略能有效提升儿童的参与度和互动体验。 阅读详情

【训练赛地址】点击打开链接

【PS】由于几乎是中文题目和题目比较短，就不说题意了。

【A】中文题目，状压+BFS，没有什么坑点，上代码。

【AC代码】

//
//Created by just_sort 2016/12/1
//Copyright (c) 2016 just_sort.All Rights Reserved
//

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
using namespace __gnu_pbds;
typedef long long LL;
typedef pair<int, LL> pp;
#define MP(x,y) make_pair(x,y)
const int maxn = 200005;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>order_set;
//head
int n, m, tt, sx, sy;
int dir[4][2] = {{0,1},{0,-1},{-1,0},{1,0}};
char maze[22][22];
bool vis[22][22][1<<10];
struct node{
    int x, y, t, state;
    node(){}
    node(int x, int y, int t, int state):x(x), y(y), t(t), state(state){}
};
int getid(char c)
{
    if(islower(c)){
        return c - 'a';
    }
    else{
        return c - 'A';
    }
}
int bfs()
{
    queue<node>q;
    node now, nex;
    now = node(sx, sy, 0, 0);
    q.push(now);
    vis[sx][sy][0] = 1;
    while(!q.empty()){
        now = q.front();
        q.pop();
        if(now.t >= tt) break;
        for(int i = 0; i < 4; i++){
            int dx = now.x + dir[i][0];
            int dy = now.y + dir[i][1];
            int t = now.t + 1;
            int state = now.state;
            if(vis[dx][dy][state] || dx < 0 || dx >= n || dy < 0 || dy >= m || maze[dx][dy] == '*'){
                continue;
            }
            if(isupper(maze[dx][dy]) && !(state & (1<<getid(maze[dx][dy])))) continue;
            if(islower(maze[dx][dy])) state |= (1<<getid(maze[dx][dy]));
            if(maze[dx][dy] == '^') return t;
            if(!vis[dx][dy][state]){
                vis[dx][dy][state] = 1;
                q.push(node(dx, dy, t, state));
            }
        }
    }
    return -1;
}
int main()
{
    while(scanf("%d%d%d",&n,&m,&tt)!=EOF)
    {
        tt -= 1;
        memset(vis, false, sizeof(vis));
        for(int i = 0; i < n; i++) scanf("%s", maze[i]);
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(maze[i][j] == '@'){
                    sx = i, sy = j, maze[i][j] = '.';
                    break;
                }
            }
        }
        int ans = bfs();
        printf("%d\n",ans);
    }
    return 0;
}

【B】先考虑每一行，再考虑一下每一行里面的元素，发现解决的这个问题有大量的重叠子问题，一个简单的dp想法就由然而生了。

【代码君】

//
//Created by just_sort 2016/12/1
//Copyright (c) 2016 just_sort.All Rights Reserved
//

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
using namespace __gnu_pbds;
typedef long long LL;
typedef pair<int, LL> pp;
#define MP(x,y) make_pair(x,y)
const int maxn = 200005;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>order_set;
//head
int dp1[maxn], dp2[maxn];
int n, m;
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(dp1, 0, sizeof(dp1));
        memset(dp2, 0, sizeof(dp2));
        for(int i = 2; i <= n + 1; i++){
            for(int j = 2; j <= m + 1; j++){
                int x;
                scanf("%d", &x);
                dp1[j] = max(dp1[j-1], dp1[j-2]+x);
            }
            dp2[i] = max(dp2[i-1], dp2[i-2] + dp1[m + 1]);
        }
        printf("%d\n", dp2[n+1]);
    }
    return 0;
}

【C】就是线段树的区间合并问题，不过这个题要维护的东西有点多，看代码吧。 

//
//Created by just_sort 2016/12/1
//Copyright (c) 2016 just_sort.All Rights Reserved
//

//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//#include <ext/pb_ds/hash_policy.hpp>
//#include <set>
//#include <map>
//#include <queue>
//#include <stack>
//#include <cmath>
//#include <cstdio>
//#include <cstdlib>
//#include <cstring>
//#include <iostream>
//#include <algorithm>
//using namespace std;
//using namespace __gnu_pbds;
//typedef long long LL;
//typedef pair<int, LL> pp;
//#define MP(x,y) make_pair(x,y)
const int maxn = 200005;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>order_set;
//head
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

struct node{
    int l, r, len;
    int l0, l1;//左端点开始的0,1的个数
    int r0, r1;//右端点开始的0,1的个数
    int max0, max1, cnt0, cnt1, flag;//区间连续0,1的个数，区间0,1的个数
}Tree[maxn<<2];
int n, m, A[maxn];
void pushup(int rt)
{
    Tree[rt].l0 = Tree[rt*2].l0;
    if(Tree[rt*2].l0 == Tree[rt*2].len) Tree[rt].l0 += Tree[rt*2+1].l0;
    Tree[rt].r0 = Tree[rt*2+1].r0;
    if(Tree[rt*2+1].r0 == Tree[rt*2+1].len) Tree[rt].r0 += Tree[rt*2].r0;
    Tree[rt].max0 = max(Tree[rt*2].max0, Tree[rt*2+1].max0);
    Tree[rt].max0 = max(Tree[rt].max0, Tree[rt*2].r0 + Tree[rt*2+1].l0);
    Tree[rt].cnt0 = Tree[rt*2].cnt0 + Tree[rt*2+1].cnt0;

    Tree[rt].l1 = Tree[rt*2].l1;
    if(Tree[rt*2].l1 == Tree[rt*2].len) Tree[rt].l1 += Tree[rt*2+1].l1;
    Tree[rt].r1 = Tree[rt*2+1].r1;
    if(Tree[rt*2+1].r1 == Tree[rt*2+1].len) Tree[rt].r1 += Tree[rt*2].r1;
    Tree[rt].max1 = max(Tree[rt*2].max1, Tree[rt*2+1].max1);
    Tree[rt].max1 = max(Tree[rt].max1, Tree[rt*2].r1 + Tree[rt*2+1].l1);
    Tree[rt].cnt1 = Tree[rt*2].cnt1 + Tree[rt*2+1].cnt1;

    //Tree[rt].len = Tree[rt*2].len + Tree[rt*2+1].len;
}


void Build(int l, int r, int rt)
{
    Tree[rt].l = l, Tree[rt].r = r, Tree[rt].len = r - l + 1, Tree[rt].flag = -1;
    if(l == r){
        Tree[rt].l0 = Tree[rt].r0 = Tree[rt].max0 = Tree[rt].cnt0 = !A[l];
        Tree[rt].l1 = Tree[rt].r1 = Tree[rt].max1 = Tree[rt].cnt1 = A[l];
        return ;
    }
    int mid = (l + r) / 2;
    Build(l, mid, rt*2);
    Build(mid+1, r, rt*2+1);
    pushup(rt);
}

void update(int L, int R, int rt, int cmd)
{
    if(Tree[rt].l == L && Tree[rt].r == R){
        if(cmd == 0)
        {
            Tree[rt].l0 = Tree[rt].r0 = Tree[rt].max0 = Tree[rt].cnt0 = Tree[rt].len;
            Tree[rt].l1 = Tree[rt].r1 = Tree[rt].max1 = Tree[rt].cnt1 = 0;
            Tree[rt].flag = 0;
        }
        else if(cmd == 1){
            Tree[rt].l0 = Tree[rt].r0 = Tree[rt].max0 = Tree[rt].cnt0 = 0;
            Tree[rt].l1 = Tree[rt].r1 = Tree[rt].max1 = Tree[rt].cnt1 = Tree[rt].len;
            Tree[rt].flag = 1;
        }
        else if(cmd == 2){
            swap(Tree[rt].l0, Tree[rt].l1);
            swap(Tree[rt].r0, Tree[rt].r1);
            swap(Tree[rt].max0, Tree[rt].max1);
            swap(Tree[rt].cnt0, Tree[rt].cnt1);
            Tree[rt].flag = 1 - Tree[rt].flag;
        }
        return ;
    }
    //lazy 操作
    if(Tree[rt].flag >= 0){
        update(Tree[rt*2].l, Tree[rt*2].r, rt*2, Tree[rt].flag);
        update(Tree[rt*2+1].l, Tree[rt*2+1].r, rt*2+1, Tree[rt].flag);
        Tree[rt].flag = -1;
    }
    int mid = (Tree[rt].l + Tree[rt].r) / 2;
    if(R <= mid) update(L, R, rt*2, cmd);
    else if(L > mid) update(L, R, rt*2+1, cmd);
    else
    {
        update(L, mid, rt*2, cmd);
        update(mid+1, R, rt*2+1, cmd);
    }
    pushup(rt);
}

node query(int L, int R, int rt)
{
    if(L == Tree[rt].l && Tree[rt].r == R) return Tree[rt];
    //lazy 操作
    if(Tree[rt].flag >= 0){
        update(Tree[rt*2].l, Tree[rt*2].r, rt*2, Tree[rt].flag);
        update(Tree[rt*2+1].l, Tree[rt*2+1].r, rt*2+1, Tree[rt].flag);
        Tree[rt].flag = -1;
    }
    int mid = (Tree[rt].l + Tree[rt].r) / 2;
    if(R <= mid) return query(L, R, rt*2);
    else if(L > mid) return query(L, R, rt*2+1);
    else{
        node t1, t2, t3;
        t1 = query(L, mid, rt*2);
        t2 = query(mid+1, R, rt*2+1);
        t3.cnt1 = t1.cnt1 + t2.cnt1;
        t3.l1 = t1.l1;
        if(t1.l1 == t1.len) t3.l1 += t2.l1;
        t3.r1 = t2.r1;
        if(t2.r1 == t2.len) t3.r1 += t1.r1;
        t3.max1 = max(t1.max1, t2.max1);
        t3.max1 = max(t3.max1, t1.r1 + t2.l1);
        t3.len = t1.len + t2.len;
        return t3;
    }
}
int main()
{
    int n, m;
    while(scanf("%d%d",&n,&m) != EOF)
    {
        for(int i = 1; i <= n; i++) scanf("%d", &A[i]);
        Build(1, n, 1);
        int op, a, b;
        for(int i = 1; i <= m; i++){
            scanf("%d%d%d",&op,&a,&b);
            a++;
            b++;
            if(op <= 2){
                update(a, b, 1, op);
            }
            else{
                node ans = query(a, b, 1);
                if(op == 3){
                    printf("%d\n",ans.cnt1);
                }
                else{
                    printf("%d\n",ans.max1);
                }
            }
        }
    }
    return 0;
}

【D】贪心+排序， 按比率排，避免小数，所以讲式子进行转换

【代码君】

//
//Created by just_sort 2016/12/1
//Copyright (c) 2016 just_sort.All Rights Reserved
//

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
using namespace __gnu_pbds;
typedef long long LL;
typedef pair<int, LL> pp;
#define MP(x,y) make_pair(x,y)
const int maxn = 200005;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>order_set;
//head
struct node{
    int dps, hp;
    node(){}
    node(int dps, int hp):dps(dps), hp(hp){}
    bool operator <(const node &rhs) const{
        return (hp*rhs.dps) < (dps*rhs.hp);
    }
    void read(){
        scanf("%d%d",&dps,&hp);
    }
}a[22];

int  main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i = 0; i < n; i++) a[i].read();
        sort(a, a + n);
        int sum = 0;
        int ans = 0;
        for(int i = 0; i < n; i++){
            sum = sum + a[i].dps;
        }
        for(int i = 0; i < n; i++){
            ans = ans + sum * a[i].hp;
            sum = sum - a[i].dps;
        }
        printf("%d\n", ans);
    }
    return 0;
}

【E】 将不小于m的数看成1，剩下的看成0，只要区间1的个数不小于k就可以，枚举区间左端点，右端点可以通过two-pointers求出，时间复杂度O(n)

【代码君】

//
//Created by just_sort 2016/12/1
//Copyright (c) 2016 just_sort.All Rights Reserved
//

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
using namespace __gnu_pbds;
typedef long long LL;
typedef pair<int, LL> pp;
#define MP(x,y) make_pair(x,y)
const int maxn = 200005;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>order_set;
//head

int a[maxn];
int n, m, K;
LL ans;
int main()
{
    int T, n;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d%d", &n,&m,&K);
        for(int i = 1; i <= n; i++) scanf("%d",&a[i]);
        ans  = 0;
        int r = 0, num = 0;
        for(int i = 1; i <= n; i++){
            while(num < K && r <= n){r++; num += (a[r] >= m);}
            if(num < K) break;
            ans += n - r + 1;
            num -= (a[i] >= m);
        }
        printf("%lld\n",ans);
    }
    return 0;
}


收录于
ACM/ICPC_动态规划

当前文章被收录于：

ACM/ICPC_动态规划
120 篇文章 1 人学习
订阅专栏 查看详情
ACM/ICPC图论_BFS

当前文章被收录于：

ACM/ICPC图论_BFS
28 篇文章 0 人学习
订阅专栏 查看详情
数据结构_线段树

当前文章被收录于：

数据结构_线段树
16 篇文章 0 人学习
订阅专栏 查看详情
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
移动端抓包实战指南：从HTTPS解密到QUIC协议与证书绑定破解 HTTPS作为保障网络通信安全的核心协议，其工作原理基于TLS/SSL加密与证书信任链验证。在移动应用开发与测试中，抓包是调试接口、分析性能、排查问题的关键技术手段。然而，随着移动端安全性的提升，传统的代理抓包方法常因证书绑定、HTTP/3/QUIC协议等挑战而失效。这要求开发者掌握分层诊断思维，协同使用代理工具、协议分析工具及底层流量捕获工具。例如，面对证书绑定导致的流量不可见，需借助Wireshark进行协议层分析；针对基于UDP的QUIC协议，则需使用支持该协议的抓包工具或临时禁用特性。本文聚焦移动端 阅读详情

相关推荐

避坑指南：Unity新版InputSystem在移动端的5个常见问题及解决方案

本文针对Unity新版InputSystem在移动端开发中的常见问题，提供了5个关键解决方案，包括虚拟摇杆灵敏度调节、多点触控冲突处理、按钮反馈延迟优化、手势识别与陀螺仪数据融合以及Android/iOS平台差异处理。这些实战经验帮助开发者高效解决触控适配难题，提升移动游戏体验。

soda5的博客 405

火车轨和小孩

Train Track and Children 火车轨和小孩   The story given here is quite interesting and really gives us an insight into DECISION MAKING 这个故事很有趣，让我们对做决定有更深刻的认识。 A group of children were playing near two r

Java编程语言学习专栏 2709

T100服务端接口实战：从注册到日志排查的全链路开发指南

本文提供了一份T100服务端接口开发的全链路实战指南。从程序注册与框架签出开始，详细讲解了接口的数据结构设计、核心业务逻辑编写，到最终的部署上线与调用验证。文章重点分享了如何利用日志文件高效定位和排查接口问题，帮助开发者快速掌握T100接口开发的关键步骤与实用技巧。

weixin_28831399的博客 300

引用：大局之困：救一个遵纪小孩还是一群违纪小孩

FROM:    http://www.ittime.com.cn/content.asp?id=4577 大局上面仍然有大局，规范也仅在相对环境里存在，因此，在某种情况下，规范必须向大局妥协  

静静的菜园 1336

SPEI计算避坑指南：gma中Distribution和FitMethod参数怎么选？

本文深入探讨了在SPEI计算中如何科学选择gma库中的Distribution和FitMethod参数，帮助研究者避开常见陷阱。详细分析了LogLogistic、Gamma和Pearson3三种分布的适用场景，以及LMoment与MLE拟合方法的优缺点，为气象干旱研究提供实用指南。

weixin_30308101的博客 250

WPS访问权限不足怎么解决？？具体怎么操作?

🏆本文收录于 《全栈 Bug 调优（实战版）》 专栏。专栏聚焦真实项目中的各类疑难 Bug，从成因剖析 → 排查路径 → 解决方案 → 预防优化全链路拆解，形成一套可复用、可沉淀的实战知识体系。无论你是初入职场的开发者，还是负责复杂项目的资深工程师，都可以在这里构建一套属于自己的「问题诊断与性能调优」方法论，助你稳步进阶、放大技术价值。

**My Coding Family** 4171

一个小题目分析

网上朋友聊天，随便出了个简单的题目。对一个正整数(不含0)进行因数分解。要求：输入:100输出:2 * 2 * 5 * 5 = 100输入:13输出:13 = 13很简单的一个题目。时间有限，只给十分钟。很快，被问者给出答案：#include<stdio.h>#include<stdlib.h>int main(void){ int m = 0;...

weixin_34342578的博客 157

linux cma alloc fail 问题分析

摘要：日志显示CMA连续内存分配失败（错误码-ENOMEM），请求128页（512KB）内存时因CMA区域不足或内存碎片导致失败。分析发现系统CMA总内存131072KB，空闲65536KB。解决方案包括：1）手动触发内存碎片整理；2）修改设备树或内核配置增大CMA区域（如从16MB增至20MB）。通过调整CONFIG_CMA_SIZE_MBYTES或设备树中的size参数可解决该问题。

陌上花开缓缓归以的博客 799

值得一看的测试题目

zz全文一家大公司正准备要招收新的职员，其中一个测试的问题是…… 　　你开着一辆车。 在一个暴风雨的晚上。 你经过一个车站。　　有三个人正在等公共汽车。 一个是快要死的老人，好可怜的。　　一个是医生，他曾救过你的命，是大恩人，你做梦都想报答他。　　还有一个女人/男人，她/他是那种你做梦都想嫁/娶的人，也许错过就没有了。　　但你的车只能坐一个人，你会如何选择那？请解释一下你的理由。 　　

超越自我 1637

【VisDrone数据集】YOLOX训练VisDrone数据集步骤与结果

YOLOX训练VisDrone数据集步骤与结果。

Gorgeous_wxd 2234

【YOLO11改进 - 特征融合】利用Hyper-YOLO 的混合聚合网络（MANet）改进yolo11，提升基础网络的特征提取能力

【YOLO11改进 - 特征融合】利用Hyper-YOLO 的混合聚合网络（MANet）改进yolo11，提升基础网络的特征提取能力

专注于图像领域，主要研究内容包括计算机视觉和深度学习，特别是在图像分类、目标检测和图像生成等方面有深入的研究和实践经验。 905

逻辑性

一家三口躺在床上玩耍，顾及到气温不太高，我把儿子的水枕头拿到一边，枕在自己的头下瞥见了，大声的喊道：“妈妈，把我的枕头给我！” 我想啊要给他一个理由他才不会坚持要枕头才行，所以就谎称：“枕头里面有虫虫会咬你的哦。” 儿子不假思索就反问道：“妈妈，里面的虫虫怎么不咬你呢？” 我们俩在边上都傻呆了一下，不由得都哈哈笑起来，O(∩_∩)O哈哈~，这可是儿子第一次展现他逻辑性哦 转载于:htt...

weixin_30849403的博客 87

Yandex复杂还原验证码识别

本文分析了Yandex滑动验证码的识别方法，指出其通过JS判断正确滑动位置而非用户交互还原图像。核心思路是通过像素差异分析，将验证码图像重组后（分为3×3或4×4），计算相邻图像间的像素差异，最小值即为正确位置。与前期某象验证码识别方法类似，需结合图像增强技术统一像素直方图。文章强调该方法仅供学习参考，严禁用于违法行为。完整识别流程包括图像重组、像素差异计算等步骤，最终可准确定位正确拼图位置。

码王吴彦祖的博客 285

OSChina 周一乱弹 —— 原来我的名字还有这么美的一个故事

Osc乱弹歌单（2019）请戳（这里） 【今日歌曲】 @巴拉迪维：同样是一首被翻唱了太多版本的歌，但还是 Ronan 这个版本最悦耳！无论是单飞还是与 Boyzone 乐队在一起，爱尔兰人的声音都很可爱。如果你看过电影《诺丁山》应该会更喜欢他的歌！#今日歌曲推荐# 《When Yo...

chengzheng3539的博客 287

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过，这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后，重新检测通过。

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

双人成行破解及玩耍

双人成行破解及玩耍，破解后本地可以本地使用，无需EA平台。

qq_39648250的博客 2万+

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料，已经经过了本人的筛选和整理，希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助！

2、新年玩耍

过新年，大雪纷飞，是孩子们最佳的玩耍时机。 姐姐家和嫂子家的两个孩子年纪相仿，平时也很熟悉。 新年阖家团聚，两个小伙子自要形影不离，穿着我买的一模一样的服装远远看去就好像一对双胞胎。 嫂子和姐姐一起在择菜。 “爸爸，妈妈，邻居小朋友来了，我们要一起出去玩雪。” 俩小伙子出去了。 一群小孩在村庄里追逐嬉闹，打雪仗看冰花，玩的不亦乐乎。 一个小时之后，头上冒着腾腾热气，脸红的像贴着四个半...

weixin_30482383的博客 121

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员，提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列，各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性，请参见数据手册。有关 ARM Cortex™-M4F 内核的信息，请参见《Cortex™-M4F 技术参考手册》。

如何激发孩子的想象力_玩耍激发孩子的想象力，还能建立这种能力，你家孩子会玩吗？...

本文的开篇，我们先来想象这样一幅画面：一岁多的美国小男孩，站在一根水管前。爸爸拿起水管喝了一口，小男孩看到了，也学着爸爸的样子拿着水管去喝水。可小男孩笨拙的动作，第一次没有轻易的喝到，第二次、第三次才成功喝到水。他发现水是甜的，又继续喝了几口。全程爸爸、妈妈都笑着鼓励孩子去尝试，就算小男孩衣服全打湿了，也没有任何制止的动作。这样的场景，相信父母们不会陌生吧？爱玩水可能是每个孩子的天性。面对孩子偷偷...

weixin_30907685的博客 326

只工作不玩耍，聪明的孩子也变傻

只工作不玩耍，聪明的孩子也变傻。只知道工作只会给自己带来痛苦。 电影The Shining 《闪灵》

编程之路 3635

湘美书院趣谈玩耍心理学，AI时代的益智方式

在AI时代，玩耍被赋予了全新的哲学意义与实用价值。心理学研究表明，玩耍是人类认知发展、创造力培养和社交能力提升的核心途径，这些正是AI难以替代的人类独特优势。智能技术为传统玩耍注入新活力：AI个性化玩具能动态适配儿童发展需求，益智程序让学习过程趣味化。但需警惕技术异化风险，避免过度依赖AI导致情感疏离。从存在主义视角看，玩耍实现了海德格尔"诗意栖居"的理想，让人超越功利束缚，在自由探索中完成精神成长。本文主张将玩耍重塑为AI时代的生活方式——既是抵御技术同化的盾牌，更是激发人类潜能的钥匙

txdsgzsxmsy的博客 147

多态知识整理&实现主人与宠物玩耍功能

文章目录1.为什么需要多态？2.多态访问成员的特点：3.多态的有点&例题4.多态的缺点&解决办法1. 多态的缺点: 使用父类引用无法访问子类所特有的方法2.解决办法: 向下转型2.1 向上转型（自动转换）2.2 向下转型（强制转换）2.3 java.lang.ClassCastException5.实现主人与宠物玩耍功能 1.为什么需要多态？ 面想对象的三大基本特点特点封装、继承...

weixin_41610825的博客 4940

转：“玩耍”：那与创造力和幸福息息相关

如果愿意学习，无处不在的变化就是我们的老师

Rolei的博客 270

在生活条件有保障的前提下，人是否必然选择玩耍

尽管在生活条件有保障的前提下，玩耍作为一种愉悦身心、丰富生活的活动，对大多数人具有吸引力，但这并不意味着人一定会选择玩耍。此外，部分人由于工作性质或个人追求，如科研人员、企业家、运动员等，他们可能在生活富足时依然选择加班、训练，以实现更高的职业成就，而非单纯玩耍。本文将对此展开深入探讨。在生活条件有保障的前提下，有人视玩耍为享受生活、释放压力的重要方式，但也有相当一部分人秉持着“人生在于奋斗”、“时间就是生命”的观念，他们倾向于将充裕的时间用于学习新知识、提升自我、服务社会等更具意义的事情上。

用心关注科技未来 573

Java 多态实际操练--使用多态的特征创建不同宠物的玩耍方法

|--需求说明：使用多态的特性，创建不同宠物的玩耍和洗澡方法 |--实现方式： 1、整体思路：参照简单工厂模式 2、创建抽象产品类---Pet类，在Pet类里面创建洗澡和玩耍的方法 3、创建具体产品类---Python类和Dog类，在这两个类里面分别重写Pet类里面的玩耍和洗澡方法 4、创建工厂类----Master类，用于根据客户（Test类）传入的参数来决定给出哪种...

weixin_30826095的博客 485

美国儿科医学会报告：玩耍的重要性

玩耍对于儿童健康成长以及建立亲子关系的重要作用 摘译自美国儿科医学会报告： 原文链接： The Importance of Play in Promoting Healthy ...

cuhao8037的博客 292

原来是调皮的玩耍风姑娘在敲门

我和谢恩全的玩耍 今天的我和谢恩全的玩耍，又笑嘻嘻地对我说，再找个修水龙头的师傅，会不会觉得可惜呢，原来是调皮的玩耍风姑娘在敲门，我以为很简单，吃得可香呢，我的脚的大小差距已经没有以前那么明显了，亲情是我的玩耍财富。 吴伟航，洗拖把，我看到对方的玩耍小胖子在慢悠悠地做子弹，是风姑娘在敲门，那么诱人，吴伟龙一组，原来这么奥妙，我说，步入一个崭新的世界-一切的一切都那么新鲜。 谢谢你们，奶奶

依旧坚持 746

玩耍：被忽视的人生意义源泉

无论是团队运动、户外探险还是艺术创作等各种形式的玩耍，都能激发人们的热情，增强心理韧性，使我们在面对生活挑战时保持积极乐观的态度。综上所述，玩耍并非仅限于儿时的乐趣，而是贯穿于整个人生过程，它既有助于个体的发展，又能丰富我们的精神世界，提升生活质量，并且实现对自由与快乐的追求。”在玩耍的过程中，人们不受束缚，可以随心所欲地探索世界，体验快乐，这无疑是对人性尊严的最好诠释。然而，随着年龄的增长和社会角色的转变，玩耍往往被视为一种非生产性或无足轻重的行为，而被排除在主流人生价值体系之外。

用心关注科技未来 629
上一篇： Mutual Training for Wannafly Union #2
下一篇： UVA 10288 Coupons
点赞 0
评论 0
书签 书签 0
just_sort
just_sort
博客等级 码龄11年 2357粉丝 1667原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值