Question

我只想打印子集和中的最大和。我真正想要的是比较函数中所有子集的和值，然后仅返回主函数中的最大和。

我试图做的是将子集和值保存在一个新数组中。然后比较其中的值。但是我无法做到这一点，因为它什么也没有返回。我想假设输入array的大小为n = 5，要求和的元素数为r = 3，数组为：

{1,2,3,4,5}

则最大和应为3 + 4 + 5 = 12。但是我的代码返回了所有的和。

我想将和值保存在newArray中

newArray[] = sum;

然后从newArray中找到最大值。

这是我的code：

#include <stdio.h>
#include <iostream>
using namespace std;

void combinationRecursion(int start, int end, int index, int r, int *arr, int *data, int sum){

if(r == index){
    for(int i=0; i<r; i++){
        int val = data[i];
        cout<<val<<' ';
        sum = sum + data[i];

    }
    printf("sum %d\n",sum);
    printf("\n");

}
for(int i=start; i<end; i++){
    data[index] = arr[i];
    combinationRecursion(i+1, end, index+1, r, arr, data, sum);
   }
 }

 int main() {
     int arr[100], n, data[100], r;
     scanf("%d%d",&n,&r);

for(int i=0; i<n; i++) {
    scanf("%d",&arr[i]);
}
combinationRecursion(0, n, 0, r, arr, data, 0);
}

Answer 1

如果您对基数为k的大小为n的子集感兴趣，则无需执行任何组合生成工作。您可以按照降序的顺序对数组进行排序，然后选择顶部的k元素，因为它们按降序排序，它们将给出大小为k的子集的最大和。

Answer 2

最后，我已经能够通过全局设置max来解决此问题。这是修改后的版本

swagger-codegen-maven-plugin

Answer 3

让我们看看是否可以使用std :: algorithms（未经测试的代码）做到这一点。

import tensorflow as tf
import numpy as np
from sklearn.model_selection import train_test_split

x_data = np.random.randint(1000, 8000, 10000)
y_true = x_data + 250


feat_cols = tf.feature_column.numeric_column('x')
optimizer = tf.train.AdamOptimizer(1e-3)

estimator = tf.estimator.LinearRegressor(feature_columns=[feat_cols],optimizer=optimizer)

x_train, x_eval, y_train, y_eval = train_test_split(x_data, y_true, test_size=0.3, random_state=101)


train_input_func = tf.estimator.inputs.numpy_input_fn({'x': x_train}, y_train, batch_size=1, num_epochs=None,
                                                      shuffle=True)

eval_input_func = tf.estimator.inputs.numpy_input_fn({'x': x_eval}, y_eval, batch_size=1, num_epochs=None,
                                                     shuffle=True)

estimator.train(input_fn=train_input_func, steps=1005555)

train_metrics = estimator.evaluate(input_fn=train_input_func, steps=10000)
eval_metrics = estimator.evaluate(input_fn=eval_input_func, steps=10000)

print(train_metrics)
print(eval_metrics)

brand_new_data = np.array([1000, 2000, 7000])
input_fn_predict = tf.estimator.inputs.numpy_input_fn({'x': brand_new_data}, num_epochs=1,shuffle=False)

prediction_result = estimator.predict(input_fn=input_fn_predict)

for prediction in prediction_result:
    print(prediction['predictions'])

但是这里没有递归...

使用递归从子集总和中找到最大总和

3 个答案: