2

我是 OO 编程的新手，在设计我的程序以使用这些概念时遇到了一些麻烦。我已经完成了教程，但仍然有问题。

我有一个递归，它接受一个项目的值（在这个例子中可以是任何东西，股票）并计算出需要多少个项目才能等于一个特定的值（在这个代码中是 100）。这部分有效，但我想知道股票的权重是否超过阈值。最初，我使用一种执行 for 循环并计算整个值列表的方法来解决这个问题，但这非常低效，因为它在递归的每个循环上都执行此操作。我认为这将是尝试学习类的好时机，因为我可以使用类来维护状态信息并在每个循环上增加值，它会让我知道何时达到阈值。

我想我有代码，但我不完全理解如何用类设计这个问题。到目前为止，它在递归的每一步都运行循环，因为我最初是那里的班级。有没有更好的方法来设计这个？我的最终目标是在超过权重时收到通知（我已经可以做到），但我想以使用最少资源的方式进行（避免低效/不必要的循环）

代码（这是我用来学习的全部代码，但问题在于 Counter 类及其在 findVariables 方法中的位置）：

import java.util.Arrays;


public class LearningClassCounting {

    public static int[] stock_price = new int[]{ 20,5,20};
    public static int target = 100;

    public static void main(String[] args) {
        // takes items from the first list
        findVariables(stock_price, 100, new int[] {0,0,0}, 0, 0);
    }

    public static void findVariables(int[] constants, int sum, 
            int[] variables, int n, int result) {
        Counter Checker = new Counter(stock_price, variables);
        if (n == constants.length) { 
            if (result == sum) {
                System.out.println(Arrays.toString(variables));
            }
        } else if (result <= sum){ //keep going
            for (int i = 0; i <= 100; i++) {
                variables[n] = i;
                Checker.check_total_percent(n, i);
                findVariables(constants, sum, variables, n+1, result+constants[n]*i);
            }
        }
    }

}

class Counter {
    private int[] stock_price;
    private int[] variables;
    private int value_so_far;
    public Counter(int[] stock_price, int[] variables) {
        this.stock_price = stock_price;
        this.variables = variables; 
        for (int location = 0; location < variables.length; location++) {
            //System.out.println(variables[location]  + " * " + stock_price[location] + " = " + (variables[location] * stock_price[location]) );
            value_so_far = value_so_far + (variables[location] * stock_price[location]);
        }
        //System.out.println("Total value so far is " + value_so_far);
        //System.out.println("************");
    } 

    public  void check_total_percent(int current_location, int percent) {
        // Check to see if weight exceeds threshold
        //System.out.println("we are at " + current_location + " and " + percent + " and " + Arrays.toString(variables));
        //System.out.println("value is " + stock_price[current_location] * percent);
        //formula I think I need to use is:
        if (percent == 0) {
            return;
        }
        int current_value = (stock_price[current_location] * percent);
        int overall_percent = current_value/(value_so_far + current_value);
        if (overall_percent > 50 ) {
            System.out.println("item " + current_location + " is over 50%" );
        }
    }
}
4

1 回答 1

0

你所描述的听起来像是著名的背包问题的变体。有许多方法可以解决这些问题，这些方法本质上是难以计算的。

本质上，可能需要检查“所有组合”。所谓的优化来自于当某个选择子集已经太大时的回溯（例如，如果给定的10只股票超过我的总和，则无需探索其他组合）。此外，可以缓存某些子集（例如，如果我知道 XY 和 Z 等于某个值 V，我可以重用该值）。你会看到很多关于如何解决这类问题以及如何设计解决方案的讨论。

话虽如此，我的观点是，虽然这类算法问题对于学习如何编程和构建代码和数据结构可能很重要，但对于学习面向对象的设计和建模来说，它们通常是一个非常糟糕的选择。

于 2012-04-25T16:00:36.543 回答