暑期整理板子。

最新推荐文章于 2024-07-10 11:31:17 发布
最新推荐文章于 2024-07-10 11:31:17 发布
阅读量226 收藏 1
点赞数
分类专栏： 板子区
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44767279/article/details/108724838
版权

常用数据结构

单调队列

​ 求出连续区间内的最大值或最小值 ，维护一个单调的队列。

`
/*
ans数组维护第k个区间最大最小值。a数组存储数据，q数组模拟队列，m是区间长度，h维护队头指针
*/
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
h=1;t=0;
for(int i=1;i<=n;i++){//以i为结尾 
    while(h<=t && a[q[t]]<=a[i])t--;//删去队尾的无用元素 ，修改这里改变最大最小
    q[++t]=i;//进队
    while(i-q[h]>=m)h++;//队头删去在所需区间外的元素 
    if(i>=m)ans[i-m+1]= a[q[h]];//这么写省了先入m个元素的问题，便捷
}
`

单调栈

​ 很方便地求出某个数的左边或者右边第一个比它大或者小的元素，而且总时间复杂度O(N)。

//求出右边第一个比他大的元素下标
//a存数据，q存栈中下标，t维护栈顶。ans维护每个点右边第一个比他大的元素的下标，整体为单调递减栈
int t = 0;
for(int i = n; i>=1; i -- )//待修改
{
	while(t && a[q[t - 1]] <= a[i]) t --;//待修改
	if(t) ans[i] = q[t - 1];
	q[t ++ ] = i;
}

跳跃表

字符串

KMP

定义：有一个文本串S，和一个模式串P，现在要查找P在S中的位置

方法：①建立next数组(即最大公共前缀后缀)，使得模式串可以更方便的进行回溯，不用从头在开始匹配。

​ ② 通过while循环获取到第一个位置。

​ ③ 周期性循环节长度为 ： len-next【len】

#include<bits/stdc++.h>
using namespace std ;
string s,p;
const int maxn=1e5;
int nxtpos0[maxn];//nxtpos0为未优化版nxtpos数组
void getnxt()//获取next数组
{
    nxtpos0[0]=-1;
    int len = p.size();
    int j=0,k=-1;
    while(j <= len - 1)
    {
        if(k==-1||p[j]==p[k])
        {
            j++;
            k++;
            nxtpos0[j]=k;
        }
        else
        {
            k = nxtpos0[k];
        }
    }
}
void kmp()//对模式串和文本串进行匹配
{
    int i=0,j=0;
    int slen=s.size();
    int plen=p.size();
    while(i < slen)
    {
        if(j == -1||p[j] == s[i])
        {
            i++;
            j++;
        }
        else
        {
            j=nxtpos0[j];
        }
        if(j==plen)
        {
            cout<<i-j+1<<"\n";//输出匹配的到的模式串位置。
            i=i-j+1;
            j=0;
        }
    }
}
int main()
{
    cin>>s>>p;
    getnxt();
    kmp();
    return 0;
}

exKMP

定义母串S，和字串T，extend[i]表示T与S[i,n-1]的最长公共前缀。

https://blog.youkuaiyun.com/yiqzq/article/details/98663132?utm_medium=distribute.pc_relevant_download.none-task-blog-baidujs-1.nonecase&depth_1-utm_source=distribute.pc_relevant_download.none-task-blog-baidujs-1.nonecase

Manacher算法

字典树

也可解决区间亦或最值问题

//指针型字典树
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct trie//trie型结构体，建立树
{
    int cnt;//用作标记查找
    trie *next[26];//连接树与节点的指针
    bool flag;///单词结尾节点标记
};
trie *root=new trie;//建立根节点

void insert(char ch[])
{
    trie *p=root,*newnode;
    for(int i=0; ch[i]!='\0'; i++)
    {
        if(p->next[ch[i]-'a']==0)//这里以所有的字符全部为小写字母为例
        {
            newnode=new trie;///创建新节点
            newnode->flag=false;///初始化新节点结尾标记
            for(int j=0; j!=26; j++)
            {
                newnode->next[j]=NULL;///初始化所有孩子
            }
            newnode->cnt=1;///新节点次数初始化
            p->next[ch[i]-'a']=newnode;
            p=newnode;
        }
        else
        {
            p=p->next[ch[i]-'a'];
            p->cnt++;///对走过的节点次数进行计数
        }
    }
    p->flag=true;///标记结尾
}

int find(char ch[])///查询
{
    trie *p=root;
    for(int i=0; ch[i]!='\0'; i++)
    {
        if(p->next[ch[i]-'a']!=NULL)
            p=p->next[ch[i]-'a'];
        else
            return 0;
    }
    return p->cnt;
}

int deal(trie* T)//递归将字典树清空
{
    int i;
    if(T==NULL)
        return 0;
    for(i=0;i<10;i++)
    {
        if(T->next[i]!=NULL)
            deal(T->next[i]);
    }
    free(T);
    return 0;
}

int main()
{
    char ch[20];
    for(int i=0; i!=26; i++)
    {
        root->next[i]=NULL;
    }
    root->cnt=0;
    while(gets(ch))
    {
        if(!strcmp(ch,""))
            break;
        insert(ch);
    }
    while(scanf("%s",ch)!=EOF)
    {
        printf("%d\n",find(ch));
    }
    deal(root);
    return 0;
}

//数组型字典树
//
#include <stdio.h>
#include <string.h>
const int maxn=10000;//提前估计好可能会开的节点的个数

int tot;            //节点编号，模拟申请新节点，静态申请
int trie[10000][26]; //假设每个节点的分支有26个
bool isw[10000];     //判断该节点是不是单词结尾

void insert(char *s,int rt)//投入的参数是一个字符串和节点数,建立字典树
{
    for(int i=0; s[i]; i++)
    {
        int x=s[i]-'a';//假设单词都是小写字母组成
        if(trie[rt][x]==0) //没有，申请新节点
        {
            trie[rt][x]=++tot;//每个字符的编号
        }
        rt=trie[rt][x];
    }
    isw[rt]=true;//整个字符串读完后，在isw数组中记录第rt层为单词结尾
}

bool find(char *s,int rt)
{
    for(int i=0; s[i]; i++)
    {
        int x=s[i]-'a';//假设单词都是小写字母组成
        if(trie[rt][x]==0)
        {
            return false;
        }
        rt=trie[rt][x];
    }
    return isw[rt];
}

char s[22];//单词读入

int main()
{
    tot=0;//一开始没有节点

    int rt=++tot;//申请一个根节点
    memset(trie[rt],0,sizeof(trie[rt]));//初始化根节点
    memset(isw,false,sizeof(isw));

    while(scanf("%s",s),s[0]!='#') //新建字典，以一个'#'结束
    {
        insert(s,rt);
    }
    while(scanf("%s",s),s[0]!='#') //查单词，以一个'#'结束
    {
        if(find(s,rt))//从字典中查找单词
            printf("%s 在字典中\n",s);
        else
            printf("%s 不在字典中\n",s);
    }
    return 0;
}

AC自动机

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Node
{
	int cnt;//是否为该单词的最后一个结点 
	Node *fail;//失败指针 
	Node *next[26];//Trie中每个结点的各个节点 
}*queue[500005];//队列，方便用BFS构造失败指针 
char s[1000005];//主字符串 
char keyword[55];//需要查找的单词 
Node *root;//头结点 
void Init(Node *root)//每个结点的初始化 
{
	root->cnt=0;
	root->fail=NULL;
	for(int i=0;i<26;i++)
		root->next[i]=NULL;
}
void Build_trie(char *keyword)//构建Trie树 
{
	Node *p,*q;
	int i,v;
	int len=strlen(keyword);
	for(i=0,p=root;i<len;i++)
	{
		v=keyword[i]-'a';
		if(p->next[v]==NULL)
		{
			q=(struct Node *)malloc(sizeof(Node));
			Init(q);
			p->next[v]=q;//结点链接 
		}
		p=p->next[v];//指针移动到下一个结点 
	}
	p->cnt++;//单词最后一个结点cnt++，代表一个单词 
}
void Build_AC_automation(Node *root)
{
	int head=0,tail=0;//队列头、尾指针 
	queue[head++]=root;//先将root入队 
	while(head!=tail)
	{
		Node *p=NULL;
		Node *temp=queue[tail++];//弹出队头结点 
		for(int i=0;i<26;i++)
		{
			if(temp->next[i]!=NULL)//找到实际存在的字符结点 
			{ //temp->next[i] 为该结点，temp为其父结点 
				if(temp==root)//若是第一层中的字符结点，则把该结点的失败指针指向root 
					temp->next[i]->fail=root;
				else
				{
					//依次回溯该节点的父节点的失败指针直到某节点的next[i]与该节点相同，
                	//则把该节点的失败指针指向该next[i]节点； 
                	//若回溯到 root 都没有找到，则该节点的失败指针指向 root
					p=temp->fail;//将该结点的父结点的失败指针给p 
					while(p!=NULL)
					{
						if(p->next[i]!=NULL)
						{
							temp->next[i]->fail=p->next[i];
							break;
						}
						p=p->fail;
					}
					//让该结点的失败指针也指向root 
					if(p==NULL)
						temp->next[i]->fail=root;
				}
				queue[head++]=temp->next[i];//每处理一个结点，都让该结点的所有孩子依次入队 
			}
		}
	}
}
int query(Node *root)
{ //i为主串指针，p为模式串指针 
	int i,v,count=0;
	Node *p=root;
	int len=strlen(s);
	for(i=0;i<len;i++)
	{
		v=s[i]-'a';
		//由失败指针回溯查找，判断s[i]是否存在于Trie树中 
		while(p->next[v]==NULL && p!=root)
			p=p->fail;
		p=p->next[v];//找到后p指针指向该结点 
		if(p==NULL)//若指针返回为空，则没有找到与之匹配的字符 
			p=root;
		Node *temp=p;//匹配该结点后，沿其失败指针回溯，判断其它结点是否匹配 
		while(temp!=root)//匹配结束控制 
		{
			if(temp->cnt>=0)//判断该结点是否被访问 
			{
				count+=temp->cnt;//由于cnt初始化为 0，所以只有cnt>0时才统计了单词的个数 
				temp->cnt=-1;//标记已访问过 
			}
			else//结点已访问，退出循环 
				break;
			temp=temp->fail;//回溯 失败指针 继续寻找下一个满足条件的结点 
		}
	}
	return count;
}
int main()
{
	int T,n;
	scanf("%d",&T);
	while(T--)
	{
		root=(struct Node *)malloc(sizeof(Node));
		Init(root);
		scanf("%d",&n);
		for(int i=0;i<n;i++)
		{
			scanf("\n%s",keyword);
			Build_trie(keyword);
		}
		Build_AC_automation(root);
		scanf("\n%s",s);
		printf("%d\n",query(root));
	}
	return 0;
}

字符串hash

字符串hash就是通过不同的进制，将字符串变成数字来做hash，通过前缀的方式，可以O（1）快速查询某个子串是否出现过，同时可以水过数据范围小的一些字符串问题。

//核心思想：将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低
//小技巧：取模的数用2^64，这样直接用unsigned long long存储，溢出的结果就是取模的结果
#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ULL;
const int N=1e6+5;
ULL h[N], power[N]; // h[k]存储字符串前k个字母的哈希值, power[k]存储 P^k mod 2^64
char str[N];
int len,P;
// 初始化
void calHash()
{
	P=131;
    power[0] = 1;
    for (int i = 1; i <= len; i ++ )
    {
        h[i] = h[i - 1] * P + (str[i]-'a'+1);
        power[i] = power[i - 1] * P;
    }
}
 
 
// 计算子串 str[l ~ r] 的哈希值
ULL get(int l, int r)
{
    return h[r] - h[l - 1] * power[r - l + 1];
}
//该题是判断一个字符串两个区间的字符串是否相同
int main()
{
	scanf("%s",str+1);
	len=strlen(str+1);
	calHash();
	int m;
	scanf("%d",&m);
	while(m--)
	{
	  int l1,r1,l2,r2;
	  scanf("%d%d%d%d",&l1,&r1,&l2,&r2);
	  if(get(l1,r1)==get(l2,r2))
	  {
	  	printf("Yes\n");
	  }
	  else
	  {
	  	printf("No\n");
	  }
	}
	return 0;
}

图论

最小生成树

Prim算法（适用点少)

Kruskal算法(适用边少)

最优比率生成树

最小k度限制生成树

Tarjan算法（缩点，算环）

矩阵快速幂（可求点到点的经历k条可重边的方案）

struct Mat{
    long long mat[111][111];
    Mat(){
        memset(mat,0,sizeof(mat));
    }
};

Mat operator*(const Mat &m1,const Mat &m2){
    Mat m;
    for(int i=0; i<=tn; ++i){
        for(int j=0; j<=tn; ++j){
            for(int k=0; k<=tn; ++k){
                m.mat[i][j]+=m1.mat[i][k]*m2.mat[k][j];
                m.mat[i][j]%=100000;
            }
        }
    }
    return m;
}

		Mat e,x;
        for(int i=0; i<=tn; ++i) e.mat[i][i]=1;
        for(int i=0; i<=tn; ++i){//对矩阵进行标记。
            if(flag[i]) continue;
            for(int j=0; j<4; ++j){
                if(flag[ch[i][j]]) continue;
                ++x.mat[i][ch[i][j]];
            }
        }
        while(n){
            if(n&1) e=e*x;
            x=x*x;
            n>>=1;
        }

DFS

​ 发现数据范围过大时，考虑双向dfs，即可将2的n此方复杂度变成2的n/2次方

BFS

​ 在做bfs时，应保证队列中的元素具有单调性，即应为一层一层向外扩展。

​ 如果出现单层bfs或dfs过不去的情况，考虑双向bfs，即从起点和终点向中间扩展，时间为指数级缩小，

搜索

迭代加深：

A*:

IDA*:

拓扑排序（判断图是否为DAG图）

​ 判断一个图是否是 有向无环图(DAG) 。 拓扑排序原理： 对 DAG 的顶点进行排序，使得对每一条有向边 (u, v)，均有 u（在排序记录中）比 v 先出现。亦可理解为对某点 v 而言，只有当 v 的所有源点均出现了，v 才能出现。

​ BFS法进行论证：

​ 算法流程：
​ 1.首先计算出所有节点的入度表。设nums为节点的数量和

​ 2.使用队列进行广度优先搜索，将所有入度为0的点入队，然后一边出队，一边判断哪些点的入度变为0了，同时将他们入队，不断迭代。

​ 3.每次执行出队操作时，将nums–，若存在如1-0,0-1的自环，则nums永不会为0，此时证明有环存在。

数论

叉乘，判断从同一个点出发的两直线相对顺时针or逆时针位置

double ans=(mx1-mid_x)*(my2-mid_y)-(mx2-mid_x)*(my1-mid_y);
ans>0||ans<0||ans=0;

矩阵快速幂

约数个数和欧拉函数

1.约数个数，存在N=p1的l1次方乘p2的l2次方*…乘Pk的lk次方

​ 约数个数即为（l1+1）乘（l2+1)乘(l3+1)

2.1到N中，从i=1加到i=n f(i) = nlog(n);

3.int范围内，最多的因字数有1600个。

阶乘分解：例如将5！分解为2的3次方乘3乘5；

分解方式：

图片

for(long long i=2;i<=n;i++)
        if (!vis[i])
        {
            long long ans=0;
            cout<<i<<" ";
            for(long long k=1;power(i,k)<=n;k++)//统计p出现的次数
                ans=ans+n/power(i,k);
            cout<<ans<<endl;
        }

杂论

ST表（区间最大最小值）

预：nlogn，查询为O（1）

//查询范围0-n-1
int a[1010];//原始输入数组
int st[1010][20];//st表

void init(int n)
{
    for (int i = 0; i < n; i++)
        st[i][0] = a[i];
	for (int i = 1; (1 << i) <= n; i++){
   		for (int j = 0; j + (1 << i) - 1 < n; j++)
        	st[j][i] = min(st[j][i - 1],st[j + (1 << (i - 1))][i - 1]);
	}
}
int search(int l, int r)
{
    int k = (int)(log((double)(r - l + 1)) / log(2.0));
    return min(st[l][k],st[r - (1 << k) + 1][k]);
}

博弈论

巴什博弈

即为一堆物品两个人轮流去，一次取一个或至多m个，问后手胜利前提下每次至多取多少个。

简称为：给你一个k，求最小的L使得k%（1+L）=0；

L为可以使第二个玩家获胜每次取纽扣的最大数量。

简单为：寻找k的大于等于2的因子，若能找到，则可确定第二个玩家必胜下每次最多选取的数量。

k倍动态减法有序（红书481页）：

例如，也是一堆物品，轮流取，后一个人至多取前一个人的k倍，问谁赢

威佐夫博弈

即为两堆物品两个人轮流取，一次在一堆取k个或者两堆各取k个，问后手胜利前提下每次至多取多少个。

面对非奇异局势，先拿者必胜，反之，后拿者必胜。

通过floor（（b-a）*（（1.0+sqrt（5.0）/2.0）==a判断奇异局势。

尼姆博奕

简要解法：所有数取亦或判断是否为0，再或者取余再取亦或，再或者奇数堆取亦或或偶数堆取亦或。

n堆物品，轮流取

判断方式：将所有数亦或起来，判断最后的数是否为0，来判断先后手胜。

若询问第一步可创造出多少种必败态：

则先算出最后亦或结果t，判断有多少个数t^a[i]<a[i];

每堆至多取m个，此时将所有堆对m取余，在进行亦或运算判断0的情况

动态规划

待补：BZOJ5424

取数问题

​ 例如：给定一个矩阵，从左上角向右下角取数，取两轮，第一轮被取过得数会变成0，问两轮后取得最大值。

​ 解法：建立二维数组f【k】【i1】【i2】，k表示当前一共走了多少步，i1为目前第一轮的位置，i2为第二轮的位置，所以k-i1和k-i2确定具体坐标，代码如下：

for(int k = 2; k <= 2*n; k++) {
    for(int i1 = 1; i1 <= k-1; i1++) {
        for(int i2 = 1; i2 <= k-1; i2++) {
           	    int j1 = k-i1, j2 = k-i2;
                int &x = f[k][i1][i2];
                int t = w[i1][j1];
                if(i1!=i2) t += w[i2][j2];
                //不重合则需要加两个权重.
                x = max(x, f[k-1][i1-1][i2-1]+t);
                x = max(x, f[k-1][i1-1][i2]+t);
                x = max(x, f[k-1][i1][i2-1]+t);
                x = max(x, f[k-1][i1][i2]+t);
                //保留最大属性
        }
    }
}

cout << f[n*2][n][n] << endl;//输出时注意后两个属性应相同，为行数。
return 0；

01背包

STL用法

unordered_map(哈希表)

//unordered_map内存占用率较高
unordered_map<int, string> myMap={{ 5, "张大" },{ 6, "李五" }};//使用{}赋值
myMap[2] = "李四";  //使用[ ]进行单个插入，若已存在键值2，则赋值修改，若无则插入。
myMap.insert(pair<int, string>(3, "陈二"));//使用insert和pair插入,直接赋值也可以

优先队列

//升序队列，小顶堆
priority_queue <int,vector<int>,greater<int> > q;
//降序队列，大顶堆
priority_queue <int,vector<int>,less<int> >q;

//greater和less是std实现的两个仿函数（就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了）

运算符重载

struct node //运算符重载<
{
    int x;
    friend bool operator< (node n1, node n2)
    {
        return n1.x < n2.x;
    }
};

问题总结：

图论算边权时

1.图论算顶点到叶子节点的路径值的和时，如果有除以2的操作，一定注意是仅针对某一条边，还是整条路径。尤其是向下取整时，构造奇数边权的样例防止错误。

「3D视觉技术交流群」精华帖与关键问题
3D视觉工坊
07-27 3655
原文首发于微信公众号3D视觉工坊： 「3D视觉技术交流群」精华帖与关键问题 本文主要总结了「3D视觉技术交流群」自建立以来，星球内共发布与交流过的技术帖及关键问题，以便大家回顾温习。 一 星球主题，主要包括： 1.1　２Ｄ视觉 １）相机标定； ２）图像处理基础； ３）相机与镜头 1.2　手眼标定 1.3　３Ｄ视觉 1.4　编程技巧 1.5　VSLAＭ，包括：ubuntu系统；VSLAM技术； 1...
Android-嵌入式蓝牙 多年蓝牙产品开发学习心路历程分享-A2DP音频流的建立、A2DP播放暂停音乐命令交互、HFP、AVRCP、RFCOMM、OPP、AVDTP
手机-手表蓝牙开发工程师的博客
05-08 8116
序言 当你点进来看到这段话的时候，是不是感觉自己被骗了，哈哈哈，本来想搜索蓝牙某个协议，却成了一大段废话文，但此时，别退出去，如果你是一个牛逼的蓝牙开发者，只是想了解蓝牙某个协议或者知识点，那么直接点击进入我的主页，查看蓝牙相关文章，绝对能满足你的需要。但是，如果你是一个蓝牙新人、才开始学习蓝牙开发，那么请用几分钟看完这篇文章，一定会激励你的蓝牙学习和给你提供一个正确的学习途径，废话少说，直入正题。 PS:本文章将持续更新，内容很长，请及时收藏。 一、自我介绍 1、工作............
NOIP2018 - 暑期博客整理
weixin_30410999的博客
10-22 251
暑假写的一些博客复习一遍。顺便再写一遍或者以现在的角度补充一点东西。 盛暑七月 初涉基环外向树dp&&bzoj1040: [ZJOI2008]骑士 比较经典的基环外向树dp。可以借鉴的技巧在于将每一个环拆出一条边，使剩下部分成为树。再然后就是max(f[u][0],f[v][0])思考中可能会出现的纰漏。 44 for (i=1; i<=n; i+...
常系数齐次线性递推(知识总结+板子整理)
小衣同学的博客
07-25 797
心得 其实挑战上提了一句这个，只滚系数是O(k²logn)的，但是一直不会实现 今天终于把代码啃下来了，以后带着板子抄就可以了…… 适用于dp递推式，O(k³logn)矩阵快速幂超时的场合， 可O(k²)的BM求线性递推式或O(k²logn)的系数矩阵快速幂 思路来源 https://ac.nowcoder.com/acm/contest/view-submission?submiss...
图论专题整理［主攻洛谷
qq_43337366的博客
01-09 691
洛谷例题【p2661 信息传递 大佬思路：并查集 附上题解【来自洛谷用户 【bie淖_kkk&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;anyway】 并查集求最小环 把每个同学看成一个点，信息的传递就是在他们之间连有向边，游戏轮数就是求最小环。 图论求最小环，我在里面看到了并查集。 假如说信息由A传递给B，那么就连一条由A指向B的边，同时更新A的父节点，A到它的父节点的路径长也就是B到它的父节点
2021.8.24 比赛题整理
531 の 流 水 线
03-23 234
UPDATE 21/08/26 更改题面、转移链接等。 2021.8.24 新初一暑假测试七 链接集合 4 / 18，300 / 400。 总结 谁会想到分数第一和第二分别都三个同分的。。我的第二。。。 状态不错，好好做了推了的都 AC 了 （虽然这次比赛题都是板子）。 题目概述 T1：贪心 + 模拟； T2：快速幂 + 逆元 + 进制模拟（除 T4 外最难的题）； T3：KMP 的 nxt 数组应用； T4：树形 DP（全军覆没）。 赛时情况 （按提交顺序阐明。） T1 & T3：一遍 AC；
暑假多校总结
Oinng的博客
08-25 147
收获还是有的，暑假前打蓝名表现分还不是很稳定，暑假尾期的几场都打出了1800多的表现分，算是在大一稳蓝名水平了吧。五、没有自己去整理板子，遇到一些需要板子的还要去百度筛选适合的写法风格。二、最初的几场签到题老是没去考虑特判，白白浪费罚时，好在后期改进了。三、每场都会有的博弈论，不会sg函数，只能硬想，靠猜。四、一些知识点的欠缺，预计搭配刷题和代码源补充知识库。一、读题有时候想当然，没有看全题面（看了后来忘记）。打的好快，一下子就打了20场多校了。开学开始刷cf，希望在大二上上紫名。
acm暑假训练总结
u013345179的博客
09-03 305
暑假的训练即将结束，一个月的时间过去的也很快，就要开学放松了(但还有好多任务要完成啊喂，不能放松的啊)感觉势必比训练以前收获的更多学到了很多的新知识，提高了自己做水题的能力，思维方面也感觉有所提高，但还是感觉有好多的知识要去学习同时也发现了自己还有很多的不足，学海无涯啊。其实我觉得”码农”这个词有点可以形容我这个阶段原理懂的不太多但是知道板子套板子就可以A题了，然而这种感觉并不好受只是单纯枯燥的码...
2018暑期在校培训总结
Ajwallet
08-25 1267
持续被虐
暑期实习工程师的一天
brian_chen2011的博客
07-10 145
我学会了如何建一个倾斜的立体模型，原本计划建立一个倾斜的基准面，然后发现倾斜是相对而言的，可以在xy平面建一个歪的草图，然后以xz平面拉长生成3D模型，那么对xz平面来说就可以组成一个三角的结构。学习了拼接机械臂和车子的原零件，然后在拼接过程中发现车子的底座没有为电路板安装固定的位置，起初考虑用胶水粘上去，然后改了主意，打算用3D打印在底座的基础上做一个嵌套，不仅固定住了电路板还易替换。所以还有可能是断路了，也可能器械坏了，所以用万用表检测并打开了蜂鸣器，发现器械里的电路没问题。然后又尝试了无线遥控。
2019纪中暑假游记+总结
QuantAsk
07-06 509
travels总篇\texttt{travels总篇}travels总篇 7/5\texttt{7/5}7/5 下午才去纪中，早上就一大早和同学出去玩，看了蜘蛛侠然后到3点多才出发。 因为走南沙大桥所以很快就到了(具体有多快忘了，反正路上一点都不塞车)。就愉快的去整理宿舍+洗个早。很快搞定去电脑室，发现没有座位，就辗转了几趟从303到401又到402。算是愉快的安定下来，听老师吹会水开始无目的做...
繁凡的 ACM 退役记（一名普通算法竞赛选手与博主的竞赛生涯回忆录）凡是过往，皆为序章
热门推荐
繁凡さん的博客
01-01 2万+
你好呀，我是繁凡！这里是一名双非 ACM 弱校的零基础菜鸡算法竞赛选手与博主的竞赛生涯回忆录。
Linux入门之入手开发板与开发环境的搭建 2016.5.7
康张琦的专栏
05-07 1万+
这是我的关于Linux的第一篇文章，这个Linux系统编程系列的博客用于定期整理我学习Linux过程的一些知识，主要目的是记录自己的学习过程，利用写博客的过程来梳理自己的知识。 一、学习Linux的初衷 大二下学期时，因为一个叫电脑鼠（MicroMouse）的竞赛开始接触32位的单片机。电脑鼠是一个轮式机器人，主要就是用单片机读取很多传感器的信息，然后利用这些信息通过单片机去控制两个电机运转，
如何成为一名很酷的机器人工程师
MuscleMonk的博客
09-19 2247
观文有感 之 如何成为一名很酷的机器人工程师 闲来垂钓碧溪上。今天来钓一波职业规划，记录一下笔记（特别注意：本文中大部分内容是复制粘贴的，只有少数位置的删改和整理，目的是分享一下大佬的讲解）： 文章目录观文有感 之 如何成为一名很酷的机器人工程师1.前言2.大一3.大二4.大三5.大四6.原文作者的话 1.前言 （1）机器人学的公认难题是：在物理世界中实现类人的活动能力 （2）机器人学的核心问题是：做好与物理世界的交互，在主流的机器人学分支中分为三类：传感器和处理算法（激光雷达、多目视觉、融合算法），多刚体
cmd-bat-批处理-脚本-系统-System info.zip
05-22
cmd-bat-批处理-脚本-系统-System info.zip
基于Matlab 2018的新能源电机控制器FOC仿真模型及MTPAMTPV弱磁控制实现 - 查表法 手册
最新发布
05-22
内容概要：本文介绍了基于Matlab 2018的新能源电机控制器仿真模型，重点在于FOC（场矢量控制）的仿真及MTPA（最大转矩每安培）、MTPV（最大转矩每伏特）弱磁控制的实现。模型由FOC矢量控制、SVPWM调制算法、转矩/电压/转速查表模块、电感查表及前馈解耦控制模块、转速环和电流环控制五个部分构成。通过这些模块，模型能够模拟电机控制器的运行，确保电机在不同速度和负载下高效稳定地工作。 适用人群：从事新能源汽车电机控制系统研究与开发的技术人员、高校相关专业师生。 使用场景及目标：适用于新能源汽车电机控制器的研发测试阶段，旨在验证和优化电机控制策略，特别是在FOC控制和弱磁控制方面，提升电机效率和性能。 其他说明：该模型不仅有助于深入理解电机控制原理，还为实际工程应用提供了宝贵的理论支持和技术手段。
Docker Intel chip MAC
05-22
Docker Intel chip MAC
图书管理系统软件完整版
05-22
以下是重新表述后的内容： 使用 Java 连接 Oracle 数据库，借助 Swing 包开发图书管理系统，实现以下功能： 登录界面：用户输入账号和密码，系统通过查询数据库验证用户身份。若账号或密码错误，会弹出提示“用户名或密码错误” 。 超级用户权限：系统内置“admin”超级用户，账号为“admin”，密码为“123”。登录后进入主界面，具备以下功能： 展示所有书籍：登录成功后，主界面首先展示所有书籍的详细信息 。 搜索功能：提供多种搜索方式，用户可根据不同条件进行模糊查询 。 新增图书：可添加新图书信息，新增完成后需刷新页面，点击搜索按钮即可完成刷新 。 删除图书：用户可选择指定行的图书进行删除操作，系统会自动刷新页面 。 借书记录管理：点击“借书记录”按钮，可查看所有用户的借书记录 。 记录搜索：支持按条件对借书记录进行模糊查询，按日期搜索时需注意格式 。
遥感图像处理-深度学习框架-AIE-SDK-遥感样本集管理-模型训练与部署-地物分类-变化检测-目标提取-建筑物变化检测-半监督学习-云端联动-本地开发-算法定制-遥感模型库-地球.zip
05-22
fpga中国创新中心遥感图像处理_深度学习框架_AIE_SDK_遥感样本集管理_模型训练与部署_地物分类_变化检测_目标提取_建筑物变化检测_半监督学习_云端联动_本地开发_算法定制_遥感模型库_地球.zip
2022二年级暑假数学思维训练题集整理
资源摘要信息:"二年级2022年暑假数学思维题.pdf_文档整理可打印.zip" 在本次分享的资源中，标题与描述指出了资源的性质——这是一份针对二年级学生的暑假数学思维题集。资源的形式是一个可打印的PDF文件，这表明...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值