Algorithm on DoubleCat's Blog

T-ST闭环循迹算法

Mon, 23 Jan 2023 21:31:02 +0800

前导

众所周知，大部分的巡线算法都需要编码器来构成闭环系统

那要是没有编码器了？难不成巡线就只能靠暴力巡线了？~~那岂不一个参数没对直接寄了？~~

此时唯一的传感参数就是光电传感器的光电值

能利用的数据有：

变速后的速度
一侧光电识别到黑和另一侧光电识别到黑的时间差

那么要么是利用时间t，要么利用时间t * 速度v

但是用t * v这不还是到了暴力巡线那步，甚至不好估算误差~~也有可能是我太菜没想到对应算法~~

那么只能利用时间t来构成一个闭环系统了

原理

对于一个高斯函数

$$Tc=ae^{\frac{-(Ti-b)^2}{2c^2}}$$

在这里，我们定义一侧识别到黑线后向另一边转动Ti(ms)后直行，从直行到下一次识别到黑线的时间差为Tc(ms)，若在Ti以内识别到黑线则定义此时Tc为1ms

算法思路

定义Ti每次的增量DeltaTi

采集两次初始{Ti,Tc}，判断Tc值

如果Tc两次都为1

如果两次都是同侧且和黑线同侧，则下一次Ti取两次Ti的最大值 + DeltaTi
如果两次都是同侧且和黑线异侧，则下一次Ti取两次Ti的最小值 - DeltaTi
如果两次是异侧，则下一次Ti取这两次Ti的中值，同时DeltaTi = 两次Ti差值的n分

如果Tc三次都为1

参考二分查找，记得减小DeltaTi

反正就是一个循环+递归来进行查找Tc峰值的过程

只要Tc不为1了，那就用这里的Ti对两个相近的Ti进行二分查找

如果查不到Tc(即Tc = 1)，那么用新的两个Ti与找到的Tc不为1的Ti同样二分查找，直到找到一个Tc也不为1的Ti

~~妈的一个二分查找被我叨叨这么久~~

只要找到了三个Tc不为1的Ti，就可以愉快地…继续二分查找了…

理论上来说最后可以逼近峰值

(可以找个长点的直线，然后用串口通信测量这些数据，这样得到的Ti和DeltaTi就可以直接作为以后的初始数据让今后的巡线更加迅速)

源代码

还有许许多多的部分还没有写完，hmmmm，希望不会烂尾

点我进入Gayhub仓库

高斯函数拟合

Mon, 23 Jan 2023 14:27:40 +0800

高斯函数

高斯函数以大数学家约翰·卡尔·弗里德里希·高斯的名字命名。高斯函数应用范围很广，在自然科学、社会科学、数学以及工程学等领域都能看到它的身影

对于这次要写的算法，高斯函数可以对数据进行拟合和表征，从而预测值

高斯函数可写为：

$$y=ae^{\frac{-(x-b)^2}{2c^2}}$$

其中 a 为波峰 y~~max~~ ， b 为波峰对应的 x 值 x~~max~~ ， c 为 y=x~~max~~ 与 x=0.607y~~max~~ 的交点到两边的距离

数据生成

数据生成程序由C++编写

#include <math.h>
#include <time.h>
#include <iostream>
#include <random>
using namespace std;
// #pragma GCC optimize(2)
// #pragma G++ optimize(2)
void gaosi(double x, double a, double b, double c) {
  double y, flag = -(x - b) * (x - b) / (2 * c * c);
  y = a * exp(flag);
  cout << x << " " << y << "\n";
}
int main() {
  default_random_engine e(time(0));
  uniform_real_distribution<double> u(0.1, 20.1);
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  double a, b, c;
  cin >> a >> b >> c;
  double mod = c * 5, index = b - 2.5 * c;
  for (int i = 0; i < 20; i++) {
    double swap = u(e);
    while (swap > mod) {
      swap -= mod;
    }
    swap += index;
    gaosi(swap, a, b, c);
  }
  return 0;
}

高斯拟合

拟合的算法我参考了CSDN上的这篇文章

但是似乎总是有哪里不对，但是又分析不上来

计协第九周算法赛A组所有+B组前俩题题解

Mon, 12 Dec 2022 17:51:20 +0800

A组题解

A.饮料换购

打卡题，注意下细节即可

#include<bits/stdc++.h>
using namespace std;
// #pragma GCC optimize(2)
// #pragma G++ optimize(2)
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
    int n;
    cin>>n;
    int ans=n;
    while(n>=3){
        ans+=n/3;
        n=n/3+n%3;
    }
    cout<<ans;
    return 0;
}

B.Display The Number

模拟题，用有限的段输出能显示的最大数字

如输入2时显示1, 3时显示7, 1和7两个数字是性价比最高的

只需要判断这个数字是奇数还是偶数, 是偶数就全输出1, 奇数输出1个7, 随后的都输出1即可

#include<bits/stdc++.h>
using namespace std;
// #pragma GCC optimize(2)
// #pragma G++ optimize(2)
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int t;
	cin>>t;
	while(t--){
		int n;
		cin>>n;
		if(n%2==1){
			cout<<"7";
			n-=3; 
		}
		for(int i=0;i<n/2;i++){
			cout<<"1";
		}
		cout<<"\n";
	}
	return 0;
}

C.外卖店优先级

原文链接

首先来介绍几个数组的作用: order 数组用来存储 pair 信息:时刻编号和外卖店编号; st[i] 是判断编号为 i 的外卖店是否在有限缓存中, score[i] 用来存储编号为 i 的外卖店的当前优先级, last[i] 表示编号为 i 的外卖店的上一次订单的时间。

首先对 order 数组按照时间进行排序,然后依次去枚举每个订单,我们只需要去考虑有订单的时间点，比如编号为 3 的店的订单是在 5 时刻,然后下一次 3 号点的订单是在 8 时刻,那么对于 3 号店铺而言,我们不需要去考虑 5 ~ 7 这些时刻的情况,因为肯定是没有订单的,我们只需要在处理 8 时刻之前,去让店铺的优先级减去这些没有订单的时刻即可

1
2

int j=i;
while(j<m&&order[j]==order[i]) j++;

因为此时的 order 数组已经有序,上述代码的结果即 i~j-1 的范围内的值都是相同的,即对于同一家外卖店在同一时刻有多个订单,即一共订单量为:cnt=j-3,这家点的编号为:id=order[i].y;,时刻为:tm=order[i].x;,即当前的时刻是tm,现在我们要计算tm时刻之前(从last[id]到tm-1)的信息

1
2
3

score[id] -= tm - last[id] - 1;
score[id] = max(0, score[id]);
if (score[id] <= 3) st[id] = false;

最后,我们要计算在每个店铺获得了最后一个订单的时刻到最终的 t 时刻,需要让优先级减去多少,并计算是否让这些店铺退出优先缓存

for (int i=1;i<=n;i++){
    if (last[i]<t){
        score[i]-=t-last[i];
        if (score[i]<=3) st[i]=false;
    }
}

#include <cstdio>
#include <cstring>
#include <algorithm>

#define x first
#define y second

using namespace std;

const int N = 100010;

typedef pair<int, int> PII;

PII order[N];

int last[N];         // 上一次的订单时间
int score[N];        // 店铺的优先级
bool st[N];

int main()
{
    int n, m, t;
    scanf("%d%d%d", &n, &m, &t);
    for (int i = 0; i < m; i ++ ) scanf("%d%d", &order[i].x, &order[i].y);
    
    sort(order, order + m);
    
    for (int i = 0; i < m;)
    {
        int j = i;
        while (j < m && order[j] == order[i]) j ++;
        int cnt = j - i, id = order[i].y, tm = order[i].x;
        
        // 当前的时刻是tm,现在我们要计算tm时刻之前(从last[id]到tm-1)的信息
        score[id] -= tm - last[id] - 1;
        score[id] = max(0, score[id]);
        if (score[id] <= 3) st[id] = false;
        
        // 现在处理t时刻的信息
        score[id] += cnt * 2;
        if (score[id] > 5) st[id] = true;
        last[id] = tm;
        
        i = j;
    }
    
    for (int i = 1; i <= n; i ++ ) 
        if (last[i] < t)
        {
            score[i] -= t - last[i];
            if (score[i] <= 3) st[i] = false;
        }
    
    int res = 0;
    for (int i = 1; i <= n; i ++ )
        if (st[i]) res ++;
        
    printf("%d\n", res);
    
    return 0;
}

D.BAN BAN

二分BAN序列，将N全部丢左边，B全部丢右边即可

#include<bits/stdc++.h>
using namespace std;
// #pragma GCC optimize(2)
// #pragma G++ optimize(2)
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int t;
	cin>>t;
	while(t--){
		int n,count;
		cin>>n;
		count=n/2+n%2;
		cout<<count<<"\n";
		for(int i=0;i<count;i++){
			cout<<i*3+1<<" "<<n*3-i*3<<"\n";
		}
	}
	return 0;
}

E.路径之谜

这道题考察搜索

我的思路是有一个 res[n][n] 存储已走路径, top[n] 存储每列已运行步数, left[n] 存储每行已运行步数,每次搜索向4个方向进行搜索，如果遇上边界、移动方向步数已达阈值、路径已走，中断此次搜索(也就是剪枝)

因为周日开会+写B组去了，索性帖个别人AC的，思路应该差不多

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

int n;
int path[25][25], vis[25][25];
int north[25], west[25];
int north_tru[25], west_tru[25];
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
vector<int> vv;
bool flag = false;

bool judge() {
	for (int i = 1; i <= n; i++) {
		if (north[i] != north_tru[i] || west[i] != west_tru[i])
			return false;
	}
	return true;
}

void dfs(int x, int y) {
	if (flag) return ;   // 剪枝，找到答案后就提前结束，不要再去遍历所有情况了
	// 因为题目保证了路径唯一
	if (x == n && y == n) {
		if (judge()) {
			// 输出路径
			for (int i = 0; i < vv.size(); i++) {
				cout << vv[i] << " ";
			}
			flag = true;
		}
		return ;
	}
	for (int i = 0; i < 4; i++) {
		int tx = x + dx[i];
		int ty = y + dy[i];
		if (tx <= 0 || tx > n || ty <= 0 || ty > n) continue;
		if (!vis[tx][ty]) {
			if (west[tx] >= west_tru[tx] || north[ty] >= north_tru[ty]) continue;  // 最关键的一个剪枝，不加上的话，会超时
			vis[tx][ty] = 1;
			west[tx]++, north[ty]++;  // 向正北方和正西方各射一箭
			vv.push_back(path[tx][ty]); // 记录路径

			dfs(tx, ty);

			vis[tx][ty] = 0;
			west[tx]--, north[ty]--;
			vv.pop_back();
		}
	}
}

int main() {
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> north_tru[i];
	}
	for (int i = 1; i <= n; i++) {
		cin >> west_tru[i];
	}

	int k = 0;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			path[i][j] = k;
			k++;
		}
	}

	vis[1][1] = 1;
	west[1]++, north[1]++;
	vv.push_back(path[1][1]);
	dfs(1,1);

	return 0;
}

F.Xenia and Ringroad

水题 ~~(虽然它有1000分)~~ ,有 n 个点围成的圆,每个点编号 1~~n ,移动一个点花费为1,要求第 i 个点的任务必须在 a~~i~ 点完成,并且必须按照顺序去完成任务,计算完成所有任务需要花费的最小时间

#include<bits/stdc++.h>
using namespace std;
// #pragma GCC optimize(2)
// #pragma G++ optimize(2)
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n, m;
	cin>>n>>m;
	int flag = 1;
	long long ans=0;
	for(int i=0; i<m; i++) {
		int now;
		cin>>now;
		if(now >= flag)
			ans += now - flag;
		else
			ans += n - (flag - now);
		flag = now;
	}
	cout << ans << "\n";
	return 0;
}

G.Portal

此题摘自DMOI Round 1,难死人

因为本次周赛是IOI 赛制，所以想着有人用dfs暴力一下，~~万一有神犇学了剪枝能A呢(虽然自己做后看题解才知道要用01bfs才能A(悲))~~

由于我用的dfs+剪枝不能A，只有一半多的分，这里就不班门弄斧了，官方题解已经很详细了

官方题解点我

H.灵能传输

前缀和+贪心

我做的时候Full-WA了，所以还是看看别人的题解吧(悲)

点我~~嘲笑DoubleCat~~看题解

B组

A.Yes-Yes?

打卡题

#include<bits/stdc++.h>
using namespace std;
// #pragma GCC optimize(2)
// #pragma G++ optimize(2)
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int t;
	cin>>t;
	while(t--){
		string s1,s2="";
		cin>>s1;
		for(int i=0;i<20;i++){
			s2+="Yes";
		}
		if(s2.find(s1,0)==string::npos){
			cout<<"NO\n";
		}else{
			cout<<"YES\n";
		}
	}
	return 0;
}

B.Stripes

水题，看是否有一行全是R

#include<bits/stdc++.h>
using namespace std;
// #pragma GCC optimize(2)
// #pragma G++ optimize(2)
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int t;
	cin>>t;
	while(t--){
		char res[9][9];
		int red=0,flag=0;
		for(int i=1;i<=8;i++){
			for(int j=1;j<=8;j++){
				cin>>res[i][j];
			}
		}
		for(int i=1;i<=8;i++){
			flag=0;
			for(int j=1;j<=8;j++){
				if(res[i][j]=='R'){
					flag++;
				}
			}
			if(flag==8){
				red=1;
			}
		}
		if(red){
			cout<<"R\n";
		}else{
			cout<<"B\n";
		}
	}
	return 0;
}

计协第一周算法赛大一组题解

Sat, 15 Oct 2022 23:22:39 +0800

A - A+B Problem

这道题，啊，洛谷经典题，你翻开那B题解啥解法都有

签到题嘛随便写 ~~(珍爱时间，拒绝int c=a+b;)~~

#include <iostream>
using namespace std;
int main() {
    int a,b;
    cin>>a>>b;
    cout<<a+b;
    return 0;
}

B - 成绩

这道题最精髓的点在于下面的Hint

数据说明
对于 30% 的数据，A=B=0。
对于另外 30% 的数据，A=B=100。
对于 100% 的数据，0≤A,B,C≤100 且 A,B,C都是 10 的整数倍。

如果不分类的话，那大可以

1
2

cin>>a>>b>>c;
cout<<a*0.2+b*0.3+c*0.5;

但是如果分类的话，代码是

cin>>a>>b>>c;
if (a==b){
	if (a==0){
		cout<<c*0.5;
	}else{
		cout<<50+c*0.5;
	}
}else{
	cout<<a*0.2+b*0.3+c*0.5;
}

那么说，

对于30%的数据，直接计算c的成绩，就可以省下两次乘法和两次加法

对于30%的数据，计算c的成绩+50，就可以省下两次乘法和一次加法

这不爽省一波时间？

C - 闰年判断

先判断是否100倍数，如果否再看能否被4整除，如果是就看能否被400整除

#include<iostream>
using namespace std;
int main(){
	int a;
	cin>>a;
	if(a%100!=0){
		if(a%4==0){
			cout<<"1";
		}else{
			cout<<"0";
		}
	}else{
		if(a%400==0){
			cout<<"1";
		}else{
			cout<<"0";
		}
	}
	return 0;
}

D - 陶陶摘苹果

算法优化重点在于，是否先把身高和凳子高度相加

#include<iostream>
using namespace std;
int main(){
	int a[10],num,count=0;
	for(int k=0;k<10;k++){
		cin>>a[k];
	}
	cin>>num;
	num+=30;
	for(int k=0;k<10;k++){
		if(a[k]<=num){
			count+=1;
		}
	}
	cout<<count;
	return 0;
}

如果没有预先加上凳子高度，只在第二个for中比较的时候使用if(a[k]<=num+30)的话，那么num+30会被多计算9次 ~~⑨次啊⑨次~~

E - 月落乌啼算钱（斐波那契数列）

** ~~遇事不决，打表万岁！~~ **

因为数据实在太小，为了时间索性打表

（实际比赛当中一定要结合题意和限制权衡算法，当然时间复杂度优先）

打表部分代码(用于生成表 ~~(也是生成斐波那契数列的)~~ )

#include<iostream>
using namespace std;
int main(){
	long num[49]={0,1,1,2};
	for(int i=4;i<49;i++){
		num[i]=num[i-1]+num[i-2];
	}
	for(int i=0;i<48;i++){
		cout<<num[i]<<",";
	}
	cout<<num[48];
	return 0;
}

然后把表倒腾进去，写查表

#include<iostream>
using namespace std;
int main(){
	long a[49]={0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102334155,165580141,267914296,433494437,701408733,1134903170,1836311903,2971215073,4807526976};
	int k=0;
	cin>>k;
	printf("%.2f",double(a[k]));
    //或者cout<<a[k]<<".00";
	return 0;
}

F - 金币

没啥好说的，看注释吧

#include<iostream>
using namespace std;
int main(){
	long long n=0; //总得到金币数，和下面的a一样要初始化
	int k,a=0; //k储存天数，a储存已经给的天数，a必须初始化
	cin>>k;
	for(int i=1;;i++){
		if(k>=a+i){ //如果这一轮给完还有剩余或刚好给完
			for(int j=0;j<i;j++){
				n+=i;
				a++;
			}
		}else{ //这一轮中就给完
			for(int j=0;j<k-a;j++){ //上一轮刚好给完而进入这个else代码块的话，由于k-a=0，for跟没有一样
				n+=i;
			}
			break; //跳出
		}
	}
	cout<<n;
}

G - 杨辉三角

** ~~遇事不决，打表万岁！~~ **

这道题其实可以搞字符串打表，即这样：

string s1="1";
string s2="1 1";
string s3="1 2 1";
…………

嗯，打表是很好，但是我已经懒得写打表程序了

所以还是老老实实写程序吧

#include<iostream>
using namespace std;
int main(){
	int n,a[21][21]={}; //老老实实初始化嗷
    cin>>n;
    a[1][1]=1; //预存一个
    for(int i=2;i<=n;i++){
        for(int j=1;j<=i;j++){
            a[i][j]=a[i-1][j-1]+a[i-1][j]; //把上一行的数和上一行左边的数加在一起，两边因为边界的关系计算永远是0+1(所以初始化很重要，不然万一加到114514了呢(划掉) )
        }
    }
    for(int i=1;i<=n;i++){ //打表输出
        for(int j=1;j<=i;j++){
        	cout<<a[i][j]<<" ";
		}
        cout<<endl;
    }
    return 0;
}

H - 选数

** 递归是个好东西，~~地瓜也是~~ **

求是否是素数就一暴力取%，真想拿分还得线性筛(欧拉筛)

int get_num(int m){
	for(int i=2;i<m;i++){
		if(m%i==0) return 0; //如果被整除就返回0
	}
	return 1; //没有被整除过才会到这，返回1
}

然后就是核心递归部分，上注释！

（反正流程就跟十个人握手求多少组合那个9+8+7+balabala那玩意差不多，不过这变成k个人一起牵手手）

void chooe_num(int x,int y){ //x表示还要取多少个数字，y表示数组上一次取值的下标
	if(x==0){ //如果剩下没有可加的了，那就判断和是否为素数
		ans+=get_num(sum_add); //如果是素数，返回值为1，ans++；如果不是素数，返回值为0
	}
	else{
		y++; //下标右移一位，此时a[y]为可取数字的第一个
	    for(int i=y;i<=n;i++){ //循环取数
	    	sum_add+=a[i]; //将数字加入和
	    	x--; //已经选了一个所以剩余可选的数字-1；
	    	choose_num(x,i); //选下一个(如果没得选的话x=0，就是上面那种直接去判断了)
	    	sum_add-=a[i]; //判断完毕，减去当前数字，恢复没选这个值的时候的sum_add
	    	x++; //可选数字+1(上一个已经放回去了)
		}
	}
}

整体代码就是

#include<bits/stdc++.h>
using namespace std;
int n,k,sum_add,ans,a[21];
int get_num(int m){
	for(int i=2;i<m;i++){
		if(m%i==0)
		return 0;
	}
	return 1;
}
void choose_num(int x,int y){
	if(x==0){
		ans+=get_num(sum_add);
	}
	else{
		y++;
	    for(int i=y;i<=n;i++){
	    	sum_add+=a[i];
	    	x--;
	    	choose_num(x,i);
	    	sum_add-=a[i];
	    	x++;
		}
	}
}
int main(){
	cin>>n>>k;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	choose_num(k,0);
	cout<<ans;
	return 0;
 }

后记

我要看🐟总的B组题解！（超大声）