内存分配问题

您的代码声明了一个空字符串s，然后分配给它的元素…

...
string s,res;int c=0;
int sum,carry=0;
for(int i=m-1;i>=0;i--)
{
sum=(a[i]-'0')*2+carry;
s[c]=sum%10+'0';         // This is undefined behavior, s is empty
carry=sum/10;
c++;
}
...

这是您的问题的可能答案，而不是您的问题。

我想这个问题有算法的味道，它的目的是找到时间复杂度最小的解决方案(可能是线性时间解决方案)。对与最佳时间复杂度相关的问题做一些前置处理是有帮助的。

因此，我计算了几个时间步长产生的模式(如下所示)：

step                                             pattern                         no. consecutive zero pairs
1                                                01                                           0
2                                               1001                                          1
3                                             01101001                                        1
4                                         1001011001101001                                    3
5                                 01101001100101101001011001101001                            5
6                 1001011001101001011010011001011001101001100101101001011001101001           11
7                 0110100110010110100101100110100110010110011010010110100110010110           21
1001011001101001011010011001011001101001100101101001011001101001
8                 1001011001101001011010011001011001101001100101101001011001101001           43
0110100110010110100101100110100110010110011010010110100110010110    
0110100110010110100101100110100110010110011010010110100110010110
1001011001101001011010011001011001101001100101101001011001101001
9                 0110100110010110100101100110100110010110011010010110100110010110           85
1001011001101001011010011001011001101001100101101001011001101001
1001011001101001011010011001011001101001100101101001011001101001
0110100110010110100101100110100110010110011010010110100110010110
1001011001101001011010011001011001101001100101101001011001101001
0110100110010110100101100110100110010110011010010110100110010110
0110100110010110100101100110100110010110011010010110100110010110
1001011001101001011010011001011001101001100101101001011001101001

产生上述图案的代码如下所示：

#include<iostream>
using namespace std;
main()
{
string s,t=""; 
s="paste pattern produced in a time-step here";
int i,l,n=0;
l=s.length();
cout <<"s.length - "<<l<<endl;
for(i=0;i<l;i++)
{
if(s[i]=='0')
{t+="10";}
else
{t+="01";}
}
l*=2;
for(i=0;i<l-1;i++)
{
if(t[i]=='0' && t[i+1]=='0')
{
n+=1;
}
}
cout <<"t - "<<t<<endl;
cout <<"no. of consecutive zero pairs - "<<n<<endl;
}

以下是一些重要的观察结果：

1) 每个时间步骤中的字符数是前一步骤的两倍。

2) 在上一个时间步长中，组合01会产生一对连续的零。

3) 任何模式的后半部分都将是前半部分的NOT。

现在是有趣的部分。请参阅为每个步骤生成的连续零对的数量。如果我们将第一步的结果赋值，比如n为零：

对于步骤2，我们得到的结果为n*2+1，其中n为0。

对于步骤3，我们得到的结果是n*2-1，其中n是1。

对于步骤4，我们得到的结果是n*2+1，其中n是1。

对于步骤5，我们得到的结果是n*2-1，其中n是3。

或者一般情况下，我们的结果等于n*2-1(对于奇数时间步长)并且结果等于n*2+1(对于偶数时间步长)

这不会解决我们的问题，因为n是一个变量，我们需要找到一个与初始结果相关的数学公式(对于时间步长1)并且在任何时间步长的结果说t.

但我们有一条简单的出路。

看看数字0,1,1,3,5,11,21,43,85…

它形成了雅各布序列。

这是我们的解决方案。

1) 浏览输入的数字，找出最大。这需要O(n)时间。

2) 创建Jacobthal数的查找表(LUT)，最大值为。这需要不超过O(n)时间，因为您只需要前两个Jacobthal数作为当前Jacobthal值。从Jacobthal数的性质可以看出这一点。

3) 再次遍历输入数字，这次输出相应的LUT的序列号。查找表需要O(1)时间n个数将是O(n)。

4) 整个问题的时间复杂度为O(n)。

这种方法的一个优点是我们不必处理大字符串。

这只是@6502答案的扩展。

看起来奥斯特林斯tream非常适合你想要的东西。

ostringstream oss;
string s,res;
int c=0;
int sum,carry=0;
for(int i=m-1;i>=0;i--)
{
sum=(a[i]-'0')*2+carry;
oss << (sum%10) << '0'; //Were you trying to concatenate a '0' as well?
carry=sum/10;
}
s = oss.str();