提交后提示运行超时，帮忙看看

自测能跑过，但提交后提示运行超时，推测可能是计算路线时陷入死循环了，帮忙看看（没有任何算法基础，纯靠想，所以代码有点长）：

#include <iostream>
using namespace std;

int n, m, s, t;
int** haveSearched, hSNum = 0;
int** paths;
bool exist = false;
int totalLen = 10000000;

int append(int** &arr, int* addArr) //添加数组
{
    int num = sizeof(arr) / sizeof(arr[0]); //获取现有长度

    int** newArr = new int* [num + 1];
    for (int j = 0; j < num; j++) //拷贝前面的元素
    {
        newArr[j] = arr[j];
    }
    newArr[num] = addArr; //新增数组
    arr = newArr; //替代之前的元素

    return num + 1; //放回新数组的长度
}

int searchPath(int num, int x, int len) //从某一点开始，寻找连接这一点的所有路
{
    int* okPath = new int[m];
    int* nextPoint = new int[m];
    int okNum = 0;

    //寻找
    for (int i = 0; i < m; i++)
    {
        bool bl = true;
        for (int j = 0; j < hSNum; j++) //不走重复的路
        {
            if (i == haveSearched[x][j])
            {
                bl = false;
            }
        }

        if (bl)
        {
            if (paths[i][0] == num) //找到路
            {
                exist = true; //存在路
                haveSearched[x][hSNum] = i; //记录这段路
                hSNum++;
                okPath[okNum] = i;
                nextPoint[okNum] = paths[i][1];
                okNum++;
            }
            else if (paths[i][1] == num) //类似
            {
                exist = true; //存在路
                haveSearched[x][hSNum] = i; //记录这段路
                hSNum++;
                okPath[okNum] = i;
                nextPoint[okNum] = paths[i][0];
                okNum++;
            }
        }
    }

    //全部找完
    if (okNum >= 1) //至少有一条路
    {
        int i = okPath[0]; //第一条路
        if (nextPoint[0] == t) //到达终点
        {
            totalLen = totalLen < (len + paths[i][2]) ? totalLen : (len + paths[i][2]); //取最小值
        }
        else { //没到达
            searchPath(nextPoint[0], x, len + paths[i][2]); //增加路程并继续搜索
        }

        if (okNum >= 2) //还有其它路
        {
            for (int j = 1; j < okNum; j++)
            {
                i = okPath[j];
                if (nextPoint[j] == t) //到达终点
                {
                    totalLen = totalLen < (len + paths[i][2]) ? totalLen : (len + paths[i][2]); //取最小值
                }
                else { //没到达
                    int arrLen = append(haveSearched, new int[m]); //加一个数组
                    for (int k = 0; k < m; k++)
                    {
                        haveSearched[arrLen - 1][k] = haveSearched[x][k]; //复制前面走过的路
                    }
                    searchPath(nextPoint[j], arrLen - 1, len + paths[i][2]); //换另一个数组，增加路程并继续搜索
                }
            }
        }
    }


    return 0;
}

int main()
{
    cin >> n >> m >> s >> t; //输入
    paths = new int* [m]; //创建一个指针数组（即类型为整型指针的数组）
    for (int i = 0; i < m; i++)
    {
        paths[i] = new int[3]; //指针数组中的每个指针都分配一个数组，形成二维数组
    }

    for (int i = 0; i < m; i++) //初始化每一条道路
    {
        int a, b, v;
        cin >> a >> b >> v;
        paths[i][0] = a;
        paths[i][1] = b;
        paths[i][2] = v;
    }

    //从s点开始, 寻找连接s点的每一条路
    exist = false;
    haveSearched = new int* [1];
    haveSearched[0] = new int[m];
    searchPath(s, 0, 0);

    if (totalLen == 10000000) //没找到一个合适的路径，或者是原地tp
    {
        totalLen = 0;
    }

    if (exist == false) //没找到过
    {
        cout << -1 << endl; //输出-1
    }
    else //有找到
    {
        cout << totalLen << endl; //输出最短路径
    }

    return 0;
}