C++ 追溯递归调用的最简单方法？

我写了一个问题的递归DP解决方案。解决方案在某些测试用例中失败了（仅仅一个回合就计算过多或计算不足）。我怎样才能回溯或只打印那些导致我最终答案的状态

递归函数是这样的。它接受4个输入。如果某个特定状态之前已被评估过，它将从

std:：map

返回解决方案，否则将对其进行评估。该解决方案递归返回每个状态的

min

值

这是一种解决问题的尝试

int-hd、ad、hk、ak、b、d；
int inf=1e9+1；
mapdp；
整数计数（整数hld、整数hlk、整数atd、整数atk）{
if（dp[生成组（hld、hlk、atd、atk）]）{
返回dp[make_tuple（hld、hlk、atd、atk）]；
}
否则{
如果（hlk一个简单的方法是将父元组与计算值一起保留在映射中，即如果T是您使用的元组，那么您可以使用
std:：map
，我认为有一个解决方案可以满足您的愿望，但它一点也不简单，实现它您可以在代码中引入比现在更多的问题或错误（我建议他们出席，因为你没有得到正确的答案）。其思想是使用唯一id和全局存储的数据标记任何新函数调用。调用该函数时，它应该具有有关其父id的信息，并创建自己的id以传递给它将要调用的所有分支。完成后，它会将其id写入父id数据单元格并显示结果。函数中只有一个位置ns用于分支-当您计算两个计数的最小值时。因此，您需要将两个调用结果与id放入父id数据单元格中，以便在将来的分析中进行比较。因此，您创建了一个调用结构，它本身并没有提供任何信息。主要的是向父id添加一些附加信息-选择了哪个分支（我的意思是，你有15个返回语句和其中的2个选项变体-我想你想知道选择了什么）。对于任何选择的分支，你和to id field Selected标志。通过该标志，当你的计算完成时，你将从id到id显示你的数据，并在屏幕上只写“Selected”的调用数据。祝你好运

int hd,ad,hk,ak,b,d;
int inf=1e9+1;
map< tuple<int,int,int,int>, int > dp;

int count(int hld, int hlk, int atd, int atk){
  if(dp[make_tuple(hld,hlk,atd,atk)]){
    return dp[make_tuple(hld,hlk,atd,atk)];
  }
  else{
    if(hlk<=0){
      return 0;
    }
    if(hld<=0){
      return inf;
    }
    if(hlk-atd<=0){
      return 1;
    }
    if(hld==hd-atk){
      if(b==0||d==0){
        if(b==0&&d!=0){
          return dp[make_tuple(hld,hlk,atd,atk)] = 1 + min(
                                                           count(hld-atk,hlk-atd,atd,atk),
                                                           count(hld-atk+d,hlk,atd,(atk-d)<0?0:(atk-d))
                                                           );
        }
        if(b!=0&&d==0){
          return dp[make_tuple(hld,hlk,atd,atk)] = 1 + min(
                                                           count(hld-atk,hlk-atd,atd,atk),
                                                           count(hld-atk,hlk,atd+b,atk)
                                                           );
        }
        return dp[make_tuple(hld,hlk,atd,atk)] = 1 + count(hld-atk,hlk-atd,atd,atk);
      }
      return dp[make_tuple(hld,hlk,atd,atk)] = 1 + min(
                                                       count(hld-atk,hlk-atd,atd,atk),
                                                       min(
                                                           count(hld-atk,hlk,atd+b,atk),
                                                           count(hld-atk+d,hlk,atd,(atk-d)<0?0:(atk-d))
                                                           )
                                                       );
    }
    if(b==0||d==0){
      if(b==0&&d!=0){
        if(atk<=0){
          return dp[make_tuple(hld,hlk,atd,atk)] = 1 + count(hld-atk,hlk-atd,atd,atk);
        }
        return dp[make_tuple(hld,hlk,atd,atk)] = 1 + min(
                                                         count(hld-atk,hlk-atd,atd,atk),
                                                         min(
                                                             count(hd-atk,hlk,atd,atk),
                                                             count(hld-atk+d,hlk,atd,(atk-d)<0?0:(atk-d))
                                                             )
                                                         );
      }
      if(b!=0&&d==0){
        return dp[make_tuple(hld,hlk,atd,atk)] = 1 + min(
                                                         count(hld-atk,hlk-atd,atd,atk),
                                                         min(
                                                             count(hld-atk,hlk,atd+b,atk),
                                                             count(hd-atk,hlk,atd,atk)
                                                             )
                                                         );
      }
      if(atk<=0){
        return dp[make_tuple(hld,hlk,atd,atk)] = 1 + count(hld-atk,hlk-atd,atd,atk);
      }
      return dp[make_tuple(hld,hlk,atd,atk)] = 1 + min(
                                                       count(hld-atk,hlk-atd,atd,atk),
                                                       count(hd-atk,hlk,atd,atk)
                                                       );
    }

    if(atk<=0){
      return dp[make_tuple(hld,hlk,atd,atk)] = 1 + min(
                                                       count(hld-atk,hlk-atd,atd,atk),
                                                       count(hld-atk,hlk,atd+b,atk)
                                                       );
    }
    return dp[make_tuple(hld,hlk,atd,atk)] = 1 + min(
                                                     count(hld-atk,hlk-atd,atd,atk),
                                                     min(
                                                         count(hld-atk,hlk,atd+b,atk),
                                                         min(
                                                           count(hd-atk,hlk,atd,atk),
                                                           count(hld-(atk-d)<0?0:(atk-d),hlk,atd,(atk-d)<0?0:(atk-d))
                                                         )
                                                         )
                                                     );
  }
}