佬，这里的点的个数为什么直接就当作1处理了呀？

/*
SPFA找环+手写栈优化

队列换成栈效率会更高
因为在队列中，一个点会把它更新的节点依次入队，当有环的时候，它需要遍历完队列中所有的节点才会发现。
但是栈不一样了,如果这个环只有三个节点，它很快就会找到了
*/
#include <bits/stdc++.h>

using namespace std;
const double eps = 1e-4;
// N是点数， M是边数。
const int N = 700, M = 100010;

int m;

double dist[N];
int q[N], cnt[N];
bool st[N];

//链式前向星
int e[M], h[N], idx, w[M], ne[M];
void add(int a, int b, int c) {
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}

bool check(double mid) {
    memset(st, 0, sizeof st);
    memset(cnt, 0, sizeof cnt);

    int hh = 0, tt = -1;
    for (int i = 0; i < 676; i++) {
        q[tt++] = i;
        st[i] = true;
    }

    int count = 0;
    while (hh <= tt) {
        int t = q[--tt]; //注意这里是栈
        st[t] = false;
        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (dist[j] < dist[t] + w[i] - mid) {
                dist[j] = dist[t] + w[i] - mid;
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= N) return true; // 走过的点超过了26*26，就存在环
                if (!st[j]) {
                    q[tt++] = j;
                    st[j] = true;
                }
            }
        }
    }
    return false;
}

int main() {
    string s;
    while (cin >> m, m) {
        //多组测试数据,清空邻接表
        memset(h, -1, sizeof h);
        idx = 0;
        //读入每条边
        while (m--) {
            cin >> s;
            if (s.size() < 2) continue; //不够长，没用,就是这样的小边界才是出问题的关键位置，千万要小心处理

            //模拟节点号
            int a = (s[0] - 'a') * 26 + s[1] - 'a';
            int b = (s[s.size() - 2] - 'a') * 26 + s[s.size() - 1] - 'a';

            //建图，有向图
            add(a, b, s.size());
        }
        //连0都不可以的话，当边权更大时就更不可能了
        if (!check(0))
            puts("No solution");
        else {
            // 01分数规划+二分
            double l = 0, r = 1000;
            while (r - l > eps) {
                double mid = (l + r) / 2;
                if (check(mid))
                    l = mid;
                else
                    r = mid;
            }
            printf("%.2lf\n", l);
        }
    }
    return 0;
}

请问有代码吗？我把AC的code里的queue直接换成了stack，但是只过了第一个数据，然后TLE了，还请大佬指教。

#include <bits/stdc++.h>

using namespace std;

const int N = 26 * 26 + 10;
const int M = 1e5 + 10;

int e[N], ne[M], nb[M], w[M], tot;

bool vis[N];
int cnt[N];
double d[N];

int m, n;

void add(int a, int b, int c) {
    nb[++tot] = b;
    w[tot] = c;
    ne[tot] = e[a];
    e[a] = tot;
}

bool spfa(double mid) {
    stack<int> st;
    memset(vis, true, sizeof vis);
    memset(cnt, 0, sizeof cnt);
    memset(d, 0, sizeof d);
    for (int i = 0; i <= 25 * 26 + 25; i++) {
        st.push(i);
    }

    int iter = 0;
    while (st.size()) {
        int a = st.top();
        st.pop();
        vis[a] = false;
        for (int i = e[a]; i; i = ne[i]) {
            int b = nb[i];
            double ww = w[i] - mid;
            if (d[a] + ww > d[b]) {
                d[b] = d[a] + ww;
                cnt[b] = cnt[a] + 1;
                if (cnt[b] > N) return true;
                if (!vis[b]) {
                    st.push(b);
                    vis[b] = true;
                    iter++;
                    // if (iter > 2 * m) return true;
                }
            }
        }
    }
    return false;
}

int main() {
    n = N;

    while (cin >> m) {
        memset(e, 0, sizeof e);
        memset(ne, 0, sizeof e);
        memset(nb, 0, sizeof nb);
        memset(w, 0, sizeof w);
        for (int i = 0; i < m; i++) {
            string s;
            cin >> s;
            int len = s.size();
            if (s.size() < 2) continue;
            int a = (s[0] - 'a') * 26 + s[1] - 'a';
            int b = (s[len - 2] - 'a') * 26 + s[len - 1] - 'a';
            add(a, b, len);
        }

        double l = 0;
        double r = 1000;
        if (!spfa(0)) {
            cout << "No solution" << endl;
            continue;
        }

        while (r - l > 1e-4) {
            double mid = (l + r) / 2;
            if (spfa(mid)) {
                l = mid;
            } else {
                r = mid;
            }
        }

        cout << l << endl;
    }
    return 0;
}

Y总之后一节课有用stack写，但是是array模拟stack，我的过不了应该是stl的效率不够高。

同问。但是我调了调玄学优化，发现是入栈次数变得多了，并不是效率不够高。

个人理解换stack其实是大概率有环的情况下才会去换，也就是queue被卡的时候可以考虑，但是多数情况下queue的效率是要比stack好的，因为对于stack来说只有在有环的时候它的的性质（队尾出）才有优势。