先贴个地址

https://github.com/adnanh/webhook

[Github 工具] Webhook

![image.png](http://van.beiklive.top/static/img/c0d76216710c381a390b89a574103dd0.image.png)



## 前言
由于typora收费，不得不去找markdown的替代编辑器，但是很多编辑器虽然基本语法都支持，但是对我这种经常粘贴图片的人来说，没有自动把图片本地化能力的编辑器是完全没法用的。

在日日夜夜的网络冲浪后，终于让我发现了[VNote](https://github.com/vnotex/vnote)

由国人编写，使用QT开发，功能完备，并且有完善的开发文档，可以作为QT的学习项目


## 使用
这是我的常用布局
![image.png](http://van.beiklive.top/static/img/906b1a42a5c8160735b56454e6b08b86.image.png)


### 快捷键
该有的都有

[MarkDown工具] VNote

![image.png](http://van.beiklive.top/static/img/eb7e9e96f93eb04aa984e0edefec115a.image.png)


## 什么是滑动窗口
滑动窗口算法是一种常用的算法，用于在线性数据结构（如数组或链表）中寻找特定模式的子串或子序列。它的基本思想是维护一个固定大小的窗口，并在每次移动窗口时更新窗口内的状态，以便有效地查找目标模式。

滑动窗口算法通常包含两个指针，一个指向窗口的起始位置，一个指向窗口的结束位置。初始时，这两个指针都指向数据结构的第一个元素。然后，我们将窗口向右移动，更新窗口内的状态，并检查是否已找到目标模式。如果找到了目标模式，我们记录结果，并继续向右移动窗口以查找其他可能的匹配。如果没有找到目标模式，则继续向右移动窗口，重复以上步骤。

滑动窗口算法通常用于解决字符串或数组相关的问题，如最小子串问题，最大子数组问题，子字符串排列问题等。它的时间复杂度通常为O(n)，其中n是数据结构中元素的数量。

## C++实现

```cpp
#include <iostream>
#include <vector>

using namespace std;

class SlidingWindow {
private:
    vector<int> arr;
    int k;
    int window_start;
    int window_sum;
public:
    SlidingWindow(vector<int> input, int k) {
        this->arr = input;
        this->k = k;
        this->window_start = 0;
        this->window_sum = 0;
        for (int i = 0; i < k; i++) {
            this->window_sum += arr[i];
        }
    }

    void move_window() {
        this->window_sum -= arr[window_start];
        this->window_start++;
        this->window_sum += arr[window_start + k - 1];
    }

    int get_max_sum() {
        int max_sum = window_sum;
        for (int i = window_start + k; i < arr.size(); i++) {
            move_window();
            max_sum = max(max_sum, window_sum);
        }
        return max_sum;
    }
};

int main() {
    vector<int> arr = {1, 3, -1, -3, 5, 3, 6, 7};
    int k = 3;
    SlidingWindow sliding_window(arr, k);
    int max_sum = sliding_window.get_max_sum();
    cout << "Max sum of each " << k << " sized subarray: " << max_sum << endl;
    return 0;
}

```

滑动窗口算法

<div align=center><img src="http://text.beiklive.top/static/img/056050da1103681cc4e47ca901dead2e.image.png" style="border-radius:20px; box-shadow:4px 4px 10px rgb(0,0,0); width:70%;height:220px;"></div>



## A*算法总结(Summary of the A* Method)
1. 把起点加入 open list 。
2. 重复如下过程：
a. 遍历 open list ，查找 F 值最小的节点，把它作为当前要处理的节点。
b. 把这个节点移到 close list 。
c. 对当前方格的 4 个相邻方格的每一个方格判断处理

        1. 如果它是不可抵达的或者它在 close list 中，忽略它。否则，做如下操作。
        2. 如果它不在 open list 中，把它加入 open list ，并且把当前方格设置为它的父亲，记录该方格的 F ， G 和 H 值。
        3.如果它已经在 open list 中，检查这条路径 ( 即经由当前方格到达它那里 ) 是否更好，用 G 值作参考。更小的 G 值表示这是更好的路径。如果是这样，把它的父亲设置为当前方格，并重新计算它的 G 和 F 值。如果你的 open list 是按 F 值排序的话，改变后你可能需要重新排序。

3. 停止
    1. 把终点加入到了 open list 中，此时路径已经找到了
    2. 查找终点失败，并且 open list 是空的，此时没有路径

3. 保存路径。从终点开始，每个方格沿着父节点移动直至起点，这就是你的路径。

## 效果图

![Animation2.gif](http://text.beiklive.top/static/img/55d41f3cf5b9adbfa91ec9e8ff67a9c5.Animation2.gif)

## 代码
❗ 代码目前仍有bug, 目前已知bug: 1. 最终显示的路线不是最短路线。 2. 出发后在第一格有概率直接退出
❗ 在Linux上运行
运行：
```bash
g++ main.cpp -o app
./app
```

```C++
#include <iostream>
#include <vector>
#include <time.h>
#include <stdlib.h>
#include <unistd.h>

int steps = 0;
namespace MapFunction
{
    using MapItem = std::string;
    using MapContainer = std::vector<std::vector<MapItem>>;

    const int MapSize = 20;
    int BlockCount = 110;
    const MapItem BlockItem = "\033[93m⊞\033[0m";
    const MapItem TargetItem = "\033[92m⊡\033[0m";
    const MapItem RoleItem = "\033[91m■\033[0m";
    const MapItem SpaceItem = " ";
    const MapItem PathItem = "\033[94m■\033[0m";
    const MapItem ProgressItem = "\033[97m■\033[0m";

    struct Point
    {
        int x;
        int y;
    };

    Point StartPoint;
    Point EndPoint;

    MapContainer MissionMap(MapSize);

    Point _m_RandomGen()
    {
        srand(time(NULL));
        int x = rand() % MapSize;
        int y = rand() % MapSize;
        while (MissionMap[y][x] != SpaceItem)
        {
            x = rand() % MapSize;
            y = rand() % MapSize;
        }
        Point temp;
        temp.x = x;
        temp.y = y;
        return temp;
    }

    void _m_MapItemSet(const Point &pos, const MapItem &item)
    {
        MissionMap[pos.y][pos.x] = item;
    }

    void _m_SetItemPos()
    {
        EndPoint = _m_RandomGen();
        _m_MapItemSet(EndPoint, TargetItem);

        StartPoint = _m_RandomGen();
        _m_MapItemSet(StartPoint, RoleItem);

        Point temp;
        if (BlockCount > (MapSize - 1) * (MapSize - 1))
            BlockCount = MapSize / 2;
        for (size_t i = 0; i < BlockCount; i++)
        {
            temp = _m_RandomGen();
            _m_MapItemSet(temp, BlockItem);
        }
    }
    void MapInit()
    {
        for (int i = 0; i < MapSize; i++)
        {
            MissionMap[i].resize(MapSize);
        }
        for (int i = 0; i < MapSize; i++)
        {
            for (int j = 0; j < MapSize; j++)
            {
                MissionMap[i][j] = SpaceItem;
            }
        }
        _m_SetItemPos();
    }

    void _m_FlushDelay()
    {
        usleep(100000);
    }

    void MapFlush(bool flag)
    {
        if(flag){
            std::cout << "\033c";
            MissionMap[EndPoint.y][EndPoint.x] = TargetItem;
            MissionMap[StartPoint.y][StartPoint.x] = RoleItem;
            for (int i = 0; i < MapSize; i++)
            {
                for (int j = 0; j < MapSize; j++)
                {
                    std::cout << MissionMap[i][j] << " ";
                }
                std::cout << "│\n";
            }

            for (int i = 0; i < MapSize; i++)
                std::cout << "──";
            std::cout << "┘\n";
            std::cout << steps++ << std::endl;

            _m_FlushDelay();
        }
    }

} // namespace MapFunction

namespace AStarFunction
{
    using namespace MapFunction;
    constexpr int PathCost = 10;
    class MyPoint
    {
    public:
        int F, G, H;
        int x, y;
        bool isWalked;

    public:
        bool operator==(const MyPoint &pos)
        {
            return (pos.x == x && pos.y == y);
        }
        void SetH(const MyPoint &cur, const MyPoint &end)
        {
            H = PathCost * (abs(cur.x - end.x) + abs(cur.y - end.y));
        }
        void SetG(int num) { G = num; }
        void SetF() { F = G + H; }
    };
    class TreeNode
    {
    public:
        // curren Point
        MyPoint pos;
        // container to store one or one more child point
        std::vector<TreeNode *> pChildNode;
        // parent Node;
        TreeNode *pParent;
        int TreeLength;

    public:
        TreeNode(const MyPoint &next)
        {
            pos = next;
            pParent = nullptr;
        }
    };

    enum Dir
    {
        cur_up,
        cur_down,
        cur_left,
        cur_right
    };
    // check border and block
    bool walkCheck(const MapContainer &box, const MyPoint &pos)
    {
        if (pos.y < 0 || pos.x < 0 || pos.y >= MapSize || pos.x >= MapSize)
        {
            return false;
        }

        if (box[pos.y][pos.x] == TargetItem)
        {
            return true;
        }

        // if (box[pos.y][pos.x] == BlockItem || box[pos.y][pos.x] == RoleItem)
        if (box[pos.y][pos.x] != SpaceItem)
        {
            return false;
        }
        return true;
    }

    void StartAStar()
    {
        MapFunction::MapInit();
        MyPoint StartPos;
        StartPos.x = StartPoint.x;
        StartPos.y = StartPoint.y;

        MyPoint EndPos;
        EndPos.x = EndPoint.x;
        EndPos.y = EndPoint.y;
        // root init
        TreeNode *pRoot = new TreeNode(StartPos);
        pRoot->pParent == nullptr;
        pRoot->TreeLength = 0;
        TreeNode *pCur = pRoot;
        TreeNode *pTemp = nullptr;

        std::vector<TreeNode *> buff;
        std::vector<TreeNode *> FinishList;
        std::vector<TreeNode *> OpenList;
        bool FindFlag = false;
        while (1)
        {
            if (pCur != nullptr)
            {
                // check all directions and sava the direction that can move to;
                for (size_t i = 0; i < 4; i++)
                {
                    pTemp = new TreeNode(pCur->pos);
                    switch (i)
                    {
                    case cur_up:
                        pTemp->pos.y--;
                        break;
                    case cur_down:
                        pTemp->pos.y++;
                        break;
                    case cur_left:
                        pTemp->pos.x--;
                        break;
                    case cur_right:
                        pTemp->pos.x++;
                        break;
                    default:
                        break;
                    }

                    if (walkCheck(MissionMap, pTemp->pos))
                    {
                        if (pTemp->pos == EndPos)
                        {
                            buff.clear();
                        }
                        pCur->pChildNode.push_back(pTemp);
                        pTemp->pParent = pCur;
                        pTemp->TreeLength = pCur->TreeLength + 1;
                        pTemp->pos.SetG(PathCost);
                        pTemp->pos.SetH(pTemp->pos, EndPos);
                        pTemp->pos.SetF();
                        buff.push_back(pTemp);

                        if (pTemp->pos == EndPos)
                        {
                            break;
                        }

                        // MissionMap[pTemp->pos.y][pTemp->pos.x] = ProgressItem;
                    }
                    else
                    {
                        delete pTemp;
                        pTemp = nullptr;
                    }
                }
            }
            // push qualified data into openlist and clean buffer list.
            for (auto it = buff.begin(); it != buff.end(); ++it)
            {
                OpenList.push_back(*it);
            }
            buff.clear();

            if (OpenList.size() > 0)
            {
                /* code */
                // find all minimum score
                auto minF = OpenList.begin();
                for (auto it = OpenList.begin(); it != OpenList.end(); ++it)
                {
                    minF = (*minF)->pos.F < (*it)->pos.F ? minF : it;
                }
                pCur = *minF;
                OpenList.erase(minF);
                MissionMap[pCur->pos.y][pCur->pos.x] = ProgressItem;

                if (pCur->pos == EndPos)
                {
                    FindFlag = true;
                    FinishList.push_back(pCur);
                    pCur = nullptr;
                    break;
                }

                MapFunction::MapFlush(true);
                if (OpenList.size() == 0)
                {
                    break;
                }
            }
        }
        if (FindFlag)
        {
            auto MinSize = FinishList.begin();
            for (auto it = FinishList.begin(); it != FinishList.end(); ++it)
            {
                MinSize = (*MinSize)->TreeLength < (*it)->TreeLength ? MinSize : it;
            }
                auto pTemp2 = *MinSize;
                while (pTemp2->pParent != nullptr)
                {
                    MissionMap[pTemp2->pos.y][pTemp2->pos.x] = PathItem;
                    pTemp2 = pTemp2->pParent;
                }

            MapFunction::MapFlush(true);
        }
    }

} // namespace A

int main(int argc, char **argv)
{
    AStarFunction::StartAStar();
    return 0;
}

```

A* 算法