选择的回溯值 我有一个C++程序，它计算数组的最大值，而不需要数组的两个连续元素。 例如： 7 3 4 6的结果是13。这里我们选择7和6作为最佳最大值。 这是我的递归程序 #include <iostream> using namespace std; int n; int findMax(int x,int ar[]) { if(x < n) return max( ar[x]+findMax(x+2,ar), findMax(x+1,ar)); return 0; } int main(){ int ar[]={1,7,4,4,9,5,12}; n = sizeof(ar)/sizeof(ar[0]); cout<<findMax(0,ar); return 0; } #包括 使用名称空间std； int n； int findMax（int x，int ar[] { if（x=n）{ if（resStore.first STD：：矢量< /代码>）。。我可以使用性能更友好的std:：vector:：insert（），而不是std:：vector:：push_back（）。（最终生成的向量可以反转。）是的，我可以在代码片段中使用备忘录，但为了简单起见，我没有：） indices(a, R): result = new empty vector i = n while i > 0 if (i == 1 and a[0] > 0) or R[i] == a[i-1] + R[i-2] result.push_back(i-1) i -= 2 else i -= 1

这肯定不是最有效的解决方案，但可能是实施工作最少的解决方案：

#include <iostream>
#include <vector>

using namespace std;

int n;

pair<int, vector<int> > findMax(int x, int ar[])
{
  if (x < n) {
    pair<int, vector<int> > max1 = findMax(x + 2, ar);
    const pair<int, vector<int> > max2 = findMax(x + 1, ar);
    max1.first += ar[x];
    max1.second.insert(max1.second.begin(), x);
    return max1.first >= max2.first ? max1 : max2;
  }
  return make_pair(0, vector<int>());
}

ostream& operator<<(ostream &out, const vector<int> &vec)
{
  const char *sep = "";
  for (int value : vec) {
    out << sep << value; sep = ", ";
  }
  return out;
}

int main()
{
  int ar[]={1,7,4,4,9,5,12};
  n = sizeof ar / sizeof *ar;
  const pair<int, vector<int> > maxAr = findMax(0, ar);
  cout << maxAr.first << '\n'
    << maxAr.second << '\n';
  return 0;
}

因此，返回值被扩展为一个

std:：vector

，它保存当前和旁边使用的索引

---

std:：max（）

如果我能提供一个合适的（重载的）

操作符，就可以使用

#include<bits/stdc++.h>
using namespace std;
int n;
void findMax(int arr[], int in, pair< int, vector<int> > tempStore, 
pair< int, vector<int> > &resStore) {
    if(in >=n) {
       if(resStore.first < tempStore.first) {
            resStore.first = tempStore.first;
            resStore.second = tempStore.second;
       }
       return;
    }
    findMax(arr, in+1, tempStore, resStore);
    tempStore.first += arr[in];
    tempStore.second.push_back(in);
    findMax(arr, in+2, tempStore, resStore);
}
int main() {
    int ar[]={1,7,4,4,9,5,12};
    n = sizeof(ar)/sizeof(ar[0]);
    pair< int, vector<int> > resStore, tempStore;
    findMax(ar, 0,tempStore,resStore);
    cout<<"Result Value: "<<resStore.first;
    cout<<"\nResult Index:\n";
    for(int i=0; i<resStore.second.size(); i++) {
        cout<<resStore.second[i]<<" ";
    }
    return 0;
}

#包括
使用名称空间std；
int n；
void findMax（int arr[]，int in，pairtempStore，
配对&resStore）{
如果（in>=n）{
if（resStore.firstresStore，tempStore；
findMax（ar、0、tempStore、resStore）；
cout数组前k个元素（无相邻项）的最大和的递推关系R（k）为：

这与您在代码中使用的递归几乎相同，但在代码中，您的函数返回元素k和之后的最大和

无论如何，您可以使用动态规划在线性时间内构建这些值的表。在伪代码中：

R = new array of length n+1
R[0] = 0
R[1] = max(0, a[0])
for i = 2 .. n
   R[i] = max(a[i-1] + R[i-2], R[i-1])

如果只需要最大和，可以返回R[n]。但也可以轻松重建索引。在伪代码中：

indices(a, R):
    result = new empty vector
    i = n
    while i > 0
        if (i == 1 and a[0] > 0) or R[i] == a[i-1] + R[i-2]
            result.push_back(i-1)
            i -= 2
        else
            i -= 1

您必须反转
结果
，才能按递增顺序获得索引。
我没有得到的：有多少个元素可以构成最大值？从您的第一个示例中，我认为有两个（不是连续的）元素。在您的第二个示例中，您想选择三个索引。您能澄清一下吗？我相信我明白了：最大值是一个前置元素和后继元素较低的元素（第一个和最后一个元素有特殊的例外）。您能确认这一点吗？您的代码以O（斐波那契（n））运行时间，这对于较大的n来说太慢了。有一个线性时间动态程序解决方案，它也会使返回索引更容易。@Scheff我认为这个例子是一个错误——代码在计算子序列时没有使其和最大化的连续元素。我添加了一个描述算法的答案，包括hoW重构索引。这是一个相当典型的动态编程解决方案，所以它是值得知道的技术。这是一个好主意，但是时间复杂度会是指数。@ UsSero0实际上，时间复杂性没有比你原来的算法（如果你不考虑插入到代码> STD：：矢量< /代码>）。。我可以使用性能更友好的
std:：vector:：insert（）
，而不是
std:：vector:：push_back（）
。（最终生成的向量可以反转。）是的，我可以在代码片段中使用备忘录，但为了简单起见，我没有：）
indices(a, R):
    result = new empty vector
    i = n
    while i > 0
        if (i == 1 and a[0] > 0) or R[i] == a[i-1] + R[i-2]
            result.push_back(i-1)
            i -= 2
        else
            i -= 1