我不知道你的代码是如何工作的，所以我决定用一种对我来说既清楚又相当有效的方式重写。如果答案是m从长度为n的列表中增加长度为k的序列，我的算法将是O(n^2 + m*k)。
注意m可以随着向量的大小呈指数增长。最坏的情况是一个结构为[2, 1, 4, 3, 6, 5, 8, 7, ..., n, n-1]的向量，那么将有2^(n/2)最大递增序列。递增序列的数量几乎可以肯定是你的代码太慢的原因。这就是为什么我边走边打印的原因。前两行给出了它有多糟糕的想法。
这是一个演示程序。

#include <iostream>
#include <vector>
using namespace std;

// Make it easy to print a vector.
template <typename S>
ostream& operator<<(ostream& os, const vector<S>& vector)
{
    // Printing all the elements
    // using <<
    for (auto element : vector) {
        os << element << " ";
    }
    return os;
}

void printAllIS(const std::vector<int>& seq) {
    size_t n = seq.size();
    int maxSize = 0;
    std::vector<int> listSize;
    std::vector<int> countLists;
    std::vector<std::vector<int>> nextIndexes;

    // initialize empty data.
    for (int i = 0; i < n; i++) {
        listSize.push_back(0);
        countLists.push_back(0);
        std::vector<int> next;
        nextIndexes.push_back(next);
    }

    // Go from the end of the sequence backwards.
    for (int i = n-1; 0 <= i; i--) {
        int size = 1;
        int count = 1;
        std::vector<int> next;

        for (int j = i+1; j < n; j++) {
            if (seq[i] < seq[j]) {
                if (size < listSize[j] + 1) {
                    // Reinitialize to only count lists of this size.
                    size = listSize[j] + 1;
                    count = 0;
                    next.clear();
                    if (maxSize < size) {
                        maxSize = size;
                    }
                }
                if (size == listSize[j] + 1) {
                    // This is a next index, record it.
                    count += countLists[j];
                    next.push_back(j);
                }
            }
        }
        // Now that we have the answer, save it.
        listSize[i] = size;
        countLists[i] = count;
        nextIndexes[i] = next;
    }

    int count = 0;
    vector<int> next;
    for (int i = 0; i < n; i++) {
        if (listSize[i] == maxSize) {
            count += countLists[i];
            next.push_back(i);
        }
    }

    // Indicate how big the answer will be.
    cout << "Size of sequences: " << maxSize << endl;
    cout << "Number of sequences: " << count << endl;

    // Indicate how big the answer will be.
    cout << "Size of sequences: " << maxSize << endl;
    cout << "Number of sequences: " << count << endl;

    /*
        The data structure for printing is 3 vectors of the same size.
        Think of it as a vector of frames with:

        - value = seq[i]
        - indexIter = iterator through nextIndexes[i]
        - indexIterEnd = nextIndexes[i].end()

        Each time we come back to a frame we discard the value. If
        iteration is done at this level, we throw away the rest of
        the frame. Otherwise we stack up frames until we are ready
        to print again.
    */
    vector<int> values;
    vector<vector<int>::iterator> indexIters;
    vector<vector<int>::iterator> indexIterEnds;

    // initialize. Note, we'll discard the value immediately.
    values.push_back(0);
    indexIters.push_back(next.begin());
    indexIterEnds.push_back(next.end());
    while (0 < indexIters.size()) {
        // Done with this value.
        values.pop_back();
        auto indexIter = indexIters.back();
        auto indexIterEnd = indexIterEnds.back();
        if (indexIter == indexIterEnd) {
            // Throw away the rest of the frame.
            indexIters.pop_back();
            indexIterEnds.pop_back();
        }
        else {
            while (true) {
                // Start stacking frames.
                int i = *indexIter;
                // Add a value - they are now equal.
                values.push_back(i);
                indexIters.back() = ++indexIter;
                indexIter = nextIndexes[i].begin();
                indexIterEnd = nextIndexes[i].end();
                if (indexIter == indexIterEnd) {
                    // Ready to print!
                    cout << values << endl;
                    // All done the printing loop.
                    break;
                }
                else {
                    // Add the rest of the next frame.
                    // The value will be added at
                    // the start of the next loop.
                    indexIters.push_back(indexIter);
                    indexIterEnds.push_back(indexIterEnd);
                }
            }
        }
    }
}

int main() {
    vector<int> vect{2, 1, 4, 3, 6, 5, 8, 7, 10, 9};
    printAllIS(vect);
}

字符串