a

ROS/Scapter/tractor.md

@@ -0,0 +1,27 @@
+# 1.问题规划
+
+1. 上CNKI和谷歌学术找现成的包
+    1. Fork Lift Truck(**关键字**)
+    2. 铲运机路径规划
+    3. tractor trailor
+    4. forklift
+2. 找导航包
+
+
+
+# 2. 找到的可能的包
+
+1. https://github.com/aeksiri/forklift
+
+    ![alt text](https://github.com/OrebroUniversity/navigation_oru-release/raw/master/docs/figs/rviz_single_truck.png)
+
+2. https://github.com/youbot/youbot_forklift
+
+[视频链接](https://www.youtube.com/watch?v=K8QHs7iJGtY)
+
+![image-20230114112024877](https://obsidians-pics.oss-cn-beijing.aliyuncs.com/image-20230114112024877.png)
+
+3. https://github.com/ErikOrjehag/forklift-mpc/blob/master/README.md
+
+![image-20230114112611979](https://obsidians-pics.oss-cn-beijing.aliyuncs.com/image-20230114112611979.png)
+

cpp/Algorithm.md

@@ -1,3 +1,101 @@
+- [1.时间复杂度和空间复杂度](#1时间复杂度和空间复杂度)
+	- [1-1.概念](#1-1概念)
+	- [1-2.oj](#1-2oj)
+- [2.链表和顺序表](#2链表和顺序表)
+	- [2-1.数组](#2-1数组)
+		- [1.数组基本概念](#1数组基本概念)
+		- [2.oj](#2oj)
+			- [2-1.元素逆序问题](#2-1元素逆序问题)
+			- [2-2.双指针实现调换](#2-2双指针实现调换)
+			- [2-3.移除数组](#2-3移除数组)
+			- [2-3.删除有序数组中的重复项](#2-3删除有序数组中的重复项)
+			- [2-4.数组形式的整数加法](#2-4数组形式的整数加法)
+			- [2-5.合并2个有序数组](#2-5合并2个有序数组)
+			- [2-6.旋转数组](#2-6旋转数组)
+			- [2-7.左移数组](#2-7左移数组)
+	- [2-2.单链表](#2-2单链表)
+		- [1.链表的特点](#1链表的特点)
+		- [2.链表的增删改查](#2链表的增删改查)
+		- [3.链表Oj](#3链表oj)
+	- [2-3.单向循环链表](#2-3单向循环链表)
+		- [1.定义](#1定义)
+		- [2.约瑟夫环](#2约瑟夫环)
+	- [2-3.双向链表](#2-3双向链表)
+	- [2-4.双向循环链表](#2-4双向循环链表)
+	- [2-5.栈](#2-5栈)
+		- [1.栈的相关概念](#1栈的相关概念)
+		- [2.栈OJ](#2栈oj)
+			- [2-1.括号匹配](#2-1括号匹配)
+			- [2-2.逆波兰表达式](#2-2逆波兰表达式)
+			- [2-3.中缀表达式转换为后缀表达式](#2-3中缀表达式转换为后缀表达式)
+	- [2-6.队列](#2-6队列)
+		- [1.连续队列](#1连续队列)
+		- [2.链式队列](#2链式队列)
+		- [3.队列oj](#3队列oj)
+- [3.搜索算法](#3搜索算法)
+	- [3-1.二分搜索算法](#3-1二分搜索算法)
+		- [3-1-1.实例](#3-1-1实例)
+		- [3-1-2.二分搜索的时间复杂度](#3-1-2二分搜索的时间复杂度)
+		- [3-1-3.二分搜索算法的递归实现](#3-1-3二分搜索算法的递归实现)
+	- [3-2.排序算法](#3-2排序算法)
+		- [3-2-1.冒泡排序](#3-2-1冒泡排序)
+		- [3-2-2.选择排序](#3-2-2选择排序)
+		- [3-2-3.插入排序](#3-2-3插入排序)
+		- [3-2-4.希尔排序](#3-2-4希尔排序)
+		- [3-2-5.各类排序算法的时间比较](#3-2-5各类排序算法的时间比较)
+		- [3-2-6.快速排序](#3-2-6快速排序)
+		- [3-2-7.归并排序](#3-2-7归并排序)
+		- [3-2-8.堆排序](#3-2-8堆排序)
+			- [1.基于堆的优先级队列调整](#1基于堆的优先级队列调整)
+			- [2.堆排序原理调整](#2堆排序原理调整)
+		- [3-2-9.基数排序](#3-2-9基数排序)
+		- [3-2-10.四大排序算法比较](#3-2-10四大排序算法比较)
+		- [3-2-11.排序算法的常见问题](#3-2-11排序算法的常见问题)
+- [4.哈希表](#4哈希表)
+	- [4-1.线性探测哈希表](#4-1线性探测哈希表)
+	- [4-2.链式哈希表](#4-2链式哈希表)
+- [5.大数据查重](#5大数据查重)
+	- [5-1.哈希表的应用](#5-1哈希表的应用)
+	- [5-2.位图法](#5-2位图法)
+	- [5-3.布隆过滤器](#5-3布隆过滤器)
+- [6.TopK问题](#6topk问题)
+- [7.一致性哈希算法](#7一致性哈希算法)
+	- [7-1.一致性哈希算法](#7-1一致性哈希算法)
+- [8.BST树](#8bst树)
+	- [8-1.总体操作](#8-1总体操作)
+	- [8-2.递归操作](#8-2递归操作)
+		- [8-2-1.递归遍历操作](#8-2-1递归遍历操作)
+		- [8-2-2.递归插入操作](#8-2-2递归插入操作)
+		- [8-2-3.递归删除操作](#8-2-3递归删除操作)
+	- [8-3.常见笔试题](#8-3常见笔试题)
+		- [8-3-1.区间元素搜索方法](#8-3-1区间元素搜索方法)
+		- [8-3-2.判断二叉树](#8-3-2判断二叉树)
+		- [8-3-3.判断子树](#8-3-3判断子树)
+		- [8-3-4.求LCA的最近公共祖先节点](#8-3-4求lca的最近公共祖先节点)
+		- [8-3-5.镜像翻转](#8-3-5镜像翻转)
+		- [8-3-6.镜像对称](#8-3-6镜像对称)
+		- [8-3-7.二叉树前序中序重构](#8-3-7二叉树前序中序重构)
+		- [8-3-8.二叉树的平衡判断](#8-3-8二叉树的平衡判断)
+		- [8-3-9.求中序倒数第k个节点](#8-3-9求中序倒数第k个节点)
+- [9.AVL树](#9avl树)
+	- [9-1.节点的旋转](#9-1节点的旋转)
+	- [9-2.节点的插入](#9-2节点的插入)
+	- [9-3.节点的删除](#9-3节点的删除)
+- [10.红黑树](#10红黑树)
+	- [10-1.红黑树特点](#10-1红黑树特点)
+	- [10-2.红黑树的代码](#10-2红黑树的代码)
+- [12.五大经典算法](#12五大经典算法)
+	- [12-1.回溯算法](#12-1回溯算法)
+		- [12-1-1.回溯算法思想](#12-1-1回溯算法思想)
+		- [12-1-2.整数选择问题](#12-1-2整数选择问题)
+		- [12-1-3.2N整数选择问题](#12-1-32n整数选择问题)
+		- [12-1-4.挑数字问题](#12-1-4挑数字问题)
+		- [12-1-5.排列组合问题](#12-1-5排列组合问题)
+		- [12-1-6.组合求和问题](#12-1-6组合求和问题)
+		- [12-7.电话号码的字母组合](#12-7电话号码的字母组合)
+		- [12-8.组合问题](#12-8组合问题)
+		- [12-9.分割回文串](#12-9分割回文串)
+
 # 1.时间复杂度和空间复杂度
 ## 1-1.概念
 1. 定义:算法中**基本操作的执行次数**为时间复杂度
@@ -9437,3 +9535,73 @@ int main()
  */
 ```
 
+### 12-9.分割回文串
+
+![04a0148f1d299c99be869f53ac88a23](https://obsidians-pics.oss-cn-beijing.aliyuncs.com/04a0148f1d299c99be869f53ac88a23.jpg)
+
+```cpp
+#include<iostream>
+#include<vector>
+using namespace std;
+string s = "aab";
+vector<vector<string>> result;
+vector<string> path;
+bool isPalindrome(string s, int start, int end)
+{
+	for (int i = start, j = end; i < j; i++, j--)
+	{
+		if (s[i] != s[j])
+		{
+			return false;
+		}
+	}
+	return true;//相等直接跳出来
+}
+void backTracking(string& s, int startIndex)
+{
+	if (startIndex >= s.size())
+	{
+		result.push_back(path);
+		return;
+	}
+	for (int i = startIndex; i < s.size(); i++)
+	{
+		if (isPalindrome(s, startIndex, i))
+		{
+			string str = s.substr(startIndex, i - startIndex + 1);
+			path.push_back(str);
+		}
+		else
+		{
+			continue;
+		}
+		backTracking(s, i + 1);
+		path.pop_back();
+	}
+}
+
+vector<vector<string>> combine()
+{
+	backTracking(s, 0);
+	return result;
+}
+
+int main()
+{
+	vector<vector<string>> res = combine();
+	for (int i = 0; i < res.size(); i++)
+	{
+		for (int j = 0; j < res[i].size(); j++)
+		{
+			cout << res[i][j] << " ";
+		}
+		cout << endl;
+	}
+}
+/**
+result = 
+[a a b 
+aa b]
+/
+```
+

cpp/Leetcode.md

@@ -9,10 +9,13 @@ public:
         for (int i = 0; i < n - 1; i++) {
             if (nums[i] == nums[i + 1]) {
                 return true;
-            }
+            }p
         }
         return false;
     }
 };
 ```
 
+
+
+