C++ 如何使用堆栈将字符串输入拉伸k次

通过重复每个字符生成输入字符串的一段 最多可订购k次（至少一次）。对于输入字符串“abc”和 k=2，输出列表应该有：abc、aabc、abbc、abcc、aabbc、， aabcc，abbcc，aabbcc

我花了这么长时间试图弄明白这一点，我无法理解其中的逻辑。这就是我目前所拥有的。这是一个非常粗糙的尝试，因为我只想重复每个字符最多2次，以尝试让一些工作：/

class Ana
{
    public:
        string in_str;
        int len;
        int counter;
}; 

List stretch(string input, int k) {
List final_output; // generate empty list
    stack<class Ana> recurStack; // empty stack that performs the recursion
    Ana init, stacktop, orig; // create a pair to push, to start the stack
    orig.in_str = input; // put the initial string
    orig.len = 0; // this is the fixed string, initially empty
    init.in_str = input; // put the initial string
    init.counter = 0;
    init.len = -1; 
    recurStack.push(init); // push this pair onto the top

    while(!recurStack.empty()) // while the stack is non-empty
    {    
        stacktop = recurStack.top();// get the top pair in stack 
        recurStack.pop(); // remove the top element of stack
        if (stacktop.counter == (input.length() - 1)) 
        {
            final_output.insert(stacktop.in_str); // insert the fixed string onto list
            continue; // pop the next element of stack
        }
        char to_ignore;
        if(stacktop.counter == 1) {
                to_ignore = orig.in_str[stacktop.len];
        }



        for(int i = 0; i < stacktop.in_str.length(); i++) {
            if(to_ignore == stacktop.in_str[i])
                continue;
            char to_insert = stacktop.in_str[i];
            Ana temp;
            temp.in_str = stacktop.in_str;
            temp.len = stacktop.len;
            temp.counter = stacktop.counter;
            temp.in_str.insert(i, 1, to_insert);
            (temp.len) = i;
            (temp.counter)++;
            recurStack.push(temp);
        }       
    }
    return final_output;
}

Ana类
{
公众：
_str中的字符串；
内伦；
整数计数器；
}; 
列表拉伸（字符串输入，int k）{
列出最终输出；//生成空列表
stack recurStack；//执行递归的空堆栈
Ana init，stacktop，orig；//创建一对来推动，以启动堆栈
orig.in_str=input；//放入初始字符串
orig.len=0；//这是固定字符串，最初为空
init.in_str=input；//放入初始字符串
初始计数器=0；
init.len=-1；
recurStack.push（init）；//将这对推到顶部
while（！recurStack.empty（））//堆栈非空时
{    
stacktop=recurStack.top（）；//获取堆栈中的顶层对
recurStack.pop（）；//删除堆栈的顶部元素
if（stacktop.counter==（input.length（）-1））
{
final_output.insert（stacktop.in_str）；//将固定字符串插入列表
continue；//弹出堆栈的下一个元素
}
要忽略的字符；
if（stacktop.counter==1）{
to_ignore=orig.in_str[stacktop.len]；
}
对于（int i=0；i

也许我不完全理解这个问题。无论如何，我将向您展示一个非常简单的解决方案，但不使用堆栈。如果您需要使用堆栈、递归调用或任何东西，请发表评论，我将开发一个新的答案

但让我们先看看算法。你需要的是所有字母的某种“子集组合”。正确的方法是使用所谓的and来计算所有需要的子集。使用子集总数的二进制表示法非常简单。对于幂集的所有子集，如果设置了位，我们将拉伸相应的字母

在此上下文中，拉伸意味着简单地重复k次

警告。因为我们使用

无符号long

作为powerset ID，所以我们可以处理最大长度为64的字符串。但是相信我。这将导致许多子集，所以您的计算机无法处理它

因此，生成的代码相当简单，但需要3个嵌套循环

请参阅：

#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <algorithm>
#include <iterator>

// Make typing easier
using ULL = unsigned long long;

std::list<std::string> stretch(std::string input, size_t k)
{
    // Resulting list. Initialize with given string
    std::list<std::string> result{ input };

    // Go through all requested depths
    for (size_t depth = 0U; depth < k-1; ++depth) {

        // Go through all possible power-set sub-sets for selecting 1 or more letters
        for (ULL subSetID = 1ULL ; subSetID < (1ULL << static_cast<ULL>(input.size())); ++subSetID) {

            // Bit mask, for checking, if a bit in the sub-set is set
            ULL bitMask{ 1ULL };

            // In here, we build the string from a letter or stretched letter
            std::string temp{};

            // Go through all letters of the input string
            for (const char letter : input) {

                // Check, if the bit mask for this powerset element is set, then stretch, else. take letter as is
                temp += std::string(1, letter) + (((subSetID & bitMask) == bitMask) ? std::string(depth + 1, letter) : "");

                // Check next bit
                bitMask <<= 1;
            }
            // Store the new found string in the resulting list
            result.push_back(temp);     
        }
    }
    return result;
}

int main() {
    // Test for string abc with depth 2
    std::list<std::string> l{ stretch("abc",2) };

    // Show result on screen
    std::copy(l.begin(), l.end(), std::ostream_iterator<std::string>(std::cout, "\n"));

    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
//使打字更容易
使用ULL=无符号长；
标准：：列表拉伸（标准：：字符串输入，大小\u t k）
{
//结果列表。使用给定字符串初始化
std：：列出结果{input}；
//检查所有要求的深度
用于（尺寸\u t深度=0U；深度对于（ULL subSetID=1ULL；subSetID<（1ULL和您迄今为止尝试过的内容？请展示您尝试过的内容，并解释失败的地方。