java - JTree,优化算法,Java
问题描述
我的合作伙伴和我,我们正在努力优化频率过程......
我们希望尽可能简化我们的问题JTree
。
如您所见,每个节点/叶子都涉及node
或涉及leaf
一个。numResampleOperations
L -> Increment or multiplication
M -> Decrement or division
我们如何计算这些值?
Target = Source*L/M
numResampleOperations = filterSize * Source * Integer.max(L, M);
我们希望在 JTextField 中显示的每个频率只获得一个值,删除不需要的分支。
对于这个例子,我们只使用了 5 个有序Target
频率(只允许整数值),但可以增长到 50 个频率值。
JTree 必须为每个包含 Target
的频率至少保留一个 150Hz、至少 160Hz、..、210Hz 之一。
最高优先级是涉及的最小金额为numResampleOperations
如何删除不需要的分支(those whose sum is very high
)、节点或叶子,保证至少有一个(JTextField 要求的频率),但所有的总和numResampleOperations
是最小的?
你对我们有什么建议?
我们从生成列表与列表子集的组合开始,Java 但由于尺寸的原因,该解决方案不可行。
编辑 1
我的课
public class NodeResample {
private int incrementL;
private int decrementM;
private int sampleRateSource;
private int sampleRateTarget;
private double maxPassFreq;
private Integer filterSize;
private Integer numResampleOperations;
public NodeResample(int incrementL, int decrementM, int sampleRateSource, int sampleRateTarget, double maxPassFreq, Integer filterSize, Integer numResampleOperations) {
this.incrementL = incrementL;
this.decrementM = decrementM;
this.sampleRateSource = sampleRateSource;
this.sampleRateTarget = sampleRateTarget;
this.maxPassFreq = maxPassFreq;
this.filterSize = filterSize;
this.numResampleOperations = numResampleOperations;
}
public int getIncrementL() {
return incrementL;
}
public void setIncrementL(int incrementL) {
this.incrementL = incrementL;
}
public int getDecrementM() {
return decrementM;
}
public void setDecrementM(int decrementM) {
this.decrementM = decrementM;
}
public int getSampleRateSource() {
return sampleRateSource;
}
public void setSampleRateSource(int sampleRateSource) {
this.sampleRateSource = sampleRateSource;
}
public int getSampleRateTarget() {
return sampleRateTarget;
}
public void setSampleRateTarget(int sampleRateTarget) {
this.sampleRateTarget = sampleRateTarget;
}
public double getMaxPassFreq() {
return maxPassFreq;
}
public void setMaxPassFreq(double maxPassFreq) {
this.maxPassFreq = maxPassFreq;
}
public Integer getFilterSize() {
return filterSize;
}
public void setFilterSize(Integer filterSize) {
this.filterSize = filterSize;
}
public Integer getNumResampleOperations() {
return numResampleOperations;
}
public void setNumResampleOperations(Integer numResampleOperations) {
this.numResampleOperations = numResampleOperations;
}
@Override
public String toString() {
return "NodeResample{" + "L=" + incrementL + ", M=" + decrementM
+ ", Source=" + sampleRateSource + ", Target=" + sampleRateTarget
+ ", filterSize=" + filterSize + ", numResampleOperations=" + numResampleOperations + "} ";
}
}
现在,我注意到某些分支是必不可少的,例如First (Top)
包含 的分支210
,因为树的其他分支不包含它。
首先,我需要一个代码来找到包含该值(200)
“或最便宜”的分支。将找到的分支添加到另一个目标 JTree。
这部分的一些代码?
我还注意到其他分支仍然具有 的值200
,但是,添加另一个分支的成本大于继续使用第一个“基本”分支的成本,因为这是only adding two nodes
,其总和小于添加另一个分支。
其次,我需要知道这些的值two nodes numResampleOperations -> (267960 + 1091720)
,以及另一个分支的值,以进行比较并将最佳选项添加到另一个目标 JTree。 这部分的一些代码?
解决方案
我解决了我的问题...
我想改进我所有的方法,尤其是searchNodeResamplePerValue和getOptimizedTree。
我创建了一个填充方法... https://pastebin.com/LvCefdc4
您可以复制粘贴并执行。
public class OptimizationResample {
public static void main(String[] args) {
final JTree tree = new JTree();
tree.setRootVisible(false);
removeAllTreeNodes(tree);
fillTreeNestedListNodeResample(tree, filler());
expandAllNodes(tree);
List<Integer> listSampleRateFinal = Arrays.asList(210, 200, 180, 160, 150);
JTree treeOut = getOptimizedTree(tree, listSampleRateFinal);
expandAllNodes(treeOut);
final JTextField textField = new JTextField(listSampleRateFinal.toString());//listSampleRateFinal .collect(Collectors.joining(","));
JSplitPane splitPane = new JSplitPane();
splitPane.setOrientation(JSplitPane.VERTICAL_SPLIT);
splitPane.setTopComponent(new JScrollPane(tree));
splitPane.setBottomComponent(new JScrollPane(treeOut));
splitPane.setDividerLocation(350);
JPanel panel = new JPanel();
panel.setLayout(new BoxLayout(panel, BoxLayout.PAGE_AXIS));
panel.add(textField);
panel.add(splitPane);
JFrame frame = new JFrame("Optimization NodeResample");
frame.setContentPane(panel);
frame.pack();
frame.setSize(new Dimension(600, 700));
frame.setVisible(true);
}
private static JTree getOptimizedTree(JTree tree, List<Integer> listSampleRateFinal) {
JTree treeOut = new JTree();
treeOut.setRootVisible(false);
removeAllTreeNodes(treeOut);
listSampleRateFinal.forEach(target -> {
List<List<NodeResample>> nestedListPerValue = searchNodeResamplePerValue(tree, target);
Long lastMinimum = Long.MAX_VALUE;
List<NodeResample> minimumlistPerValue = null;
for (List<NodeResample> listPerValue : nestedListPerValue) {
// I can't easily copy all nodes from treeOut to tempTree (I had problem with new JTree(treeOut.getModel());)
List<List<NodeResample>> nestedListNodeResample2 = getNestedListNodeResampleFromTree(treeOut);
JTree tempTree = new JTree();
tempTree.setRootVisible(false);
removeAllTreeNodes(tempTree);
fillTreeNestedListNodeResample(tempTree, nestedListNodeResample2);
addNodeResampleToTree(tempTree, listPerValue);
List<DefaultMutableTreeNode> listNodes = getListNodesFromTree(tempTree);
Long accumulator = listNodes.stream()
.filter(leaf -> leaf.getUserObject() instanceof NodeResample)
.map(leaf -> (NodeResample) leaf.getUserObject())
.map(nodeResample -> (long) nodeResample.getNumResampleOperations())
.mapToLong(Long::longValue).sum();
if (accumulator < lastMinimum) {
lastMinimum = accumulator;
minimumlistPerValue = listPerValue;
}
}
if (minimumlistPerValue != null) {
System.out.println("\nminimumlistPerValue:" + Arrays.toString(minimumlistPerValue.toArray()) + "\n");
} else {
System.out.println("\nminimumlistPerValue:" + null + "\n");
}
addNodeResampleToTree(treeOut, minimumlistPerValue);
});
return treeOut;
}
private static List<List<NodeResample>> searchNodeResamplePerValue(JTree tree, int value) {
List<DefaultMutableTreeNode> listNodes = getListNodesFromTree(tree);
List<DefaultMutableTreeNode> listNodesWithValue = listNodes.stream()
.filter(node -> node.getUserObject() instanceof NodeResample)
.filter(node -> value == ((NodeResample) node.getUserObject()).getSampleRateTarget())
.collect(Collectors.toList());
List<List<NodeResample>> out = new ArrayList<>();
Long lastSumNumResampleOperations = Long.MAX_VALUE;
for (DefaultMutableTreeNode leaf : listNodesWithValue) {
List<NodeResample> listNodeResample = new ArrayList<>();
listNodeResample.add((NodeResample) leaf.getUserObject());
TreeNode treeNode = leaf.getParent();
while (treeNode != null) {
DefaultMutableTreeNode parent = (DefaultMutableTreeNode) treeNode;
if ((parent).getUserObject() instanceof NodeResample) {
listNodeResample.add(0, (NodeResample) parent.getUserObject());
}
treeNode = parent.getParent();
}
// Long totalNumResampleOperations = listNodeResample.stream()
// .map(nodeResample -> (long) nodeResample.getNumResampleOperations())
// .mapToLong(Long::longValue).sum();
// if (totalNumResampleOperations < lastSumNumResampleOperations) {
// lastSumNumResampleOperations = totalNumResampleOperations;
// //out = listNodeResample;
// }
out.add(listNodeResample);
}
return out;
}
private static void removeAllTreeNodes(JTree tree) {
DefaultMutableTreeNode rootTreeNode = (DefaultMutableTreeNode) tree.getModel().getRoot();
if (rootTreeNode != null) {
rootTreeNode.removeAllChildren();
}
reloadTree(tree);
}
private static void reloadTree(JTree tree) {
DefaultTreeModel treeModel = ((DefaultTreeModel) tree.getModel());
DefaultMutableTreeNode rootTreeNode = (DefaultMutableTreeNode) treeModel.getRoot();
treeModel.reload(rootTreeNode);
}
private static void expandAllNodes(JTree tree) {
expandAllNodes(tree, 0, tree.getRowCount());
}
private static void expandAllNodes(JTree tree, int ini, int rows) {
try {
if (tree != null) {
for (int i = ini; i < rows; ++i) {
tree.expandRow(i);
}
if (tree.getRowCount() != rows) {
expandAllNodes(tree, rows, tree.getRowCount());
}
}
} catch (ArrayIndexOutOfBoundsException ex) {
} catch (Exception ex) {
}
}
private static void fillTreeNestedListNodeResample(JTree tree, List<List<NodeResample>> nestedListNodeResample) {
nestedListNodeResample.stream()
.forEachOrdered(listNodeResample -> {
addNodeResampleToTree(tree, listNodeResample);
});
}
private static void addNodeResampleToTree(JTree tree, List<NodeResample> listNodeResample) {
try {
DefaultTreeModel treeModel = ((DefaultTreeModel) tree.getModel());
DefaultMutableTreeNode rootTreeNode = (DefaultMutableTreeNode) treeModel.getRoot();
DefaultMutableTreeNode nodeResampleTreeNode = rootTreeNode;
if (listNodeResample != null) {
for (NodeResample nodeResample : listNodeResample) {
nodeResampleTreeNode = getDefaultMutableTreeNode(nodeResampleTreeNode, nodeResample, true);
}
}
treeModel.reload(rootTreeNode);
} catch (Exception e) {
throw e;
}
}
private static DefaultMutableTreeNode getDefaultMutableTreeNode(DefaultMutableTreeNode parent, NodeResample newChild, Boolean isLeaf) {
if (parent != null) {
DefaultMutableTreeNode child;
for (int i = 0; i < parent.getChildCount(); i++) {
child = (DefaultMutableTreeNode) parent.getChildAt(i);
if (child.toString().equals(newChild.toString())) {
return child;
}
}
child = new DefaultMutableTreeNode(newChild, isLeaf);
parent.add(child);
return child;
} else {
return null;
}
}
private static List<List<NodeResample>> getNestedListNodeResampleFromTree(JTree tree) {
List<List<NodeResample>> nestedListNodeResample = new ArrayList<>();
List<DefaultMutableTreeNode> listLeafDefaultMutableTreeNode = getListLeafsFromTree(tree);
listLeafDefaultMutableTreeNode.stream()
.filter(node -> node.getUserObject() instanceof NodeResample)
.forEach(leaf -> {
List<NodeResample> listNodeResample = new ArrayList<>();
listNodeResample.add((NodeResample) leaf.getUserObject());
TreeNode treeNode = leaf.getParent();
while (treeNode != null) {
DefaultMutableTreeNode parent = (DefaultMutableTreeNode) treeNode;
if ((parent).getUserObject() instanceof NodeResample) {
listNodeResample.add(0, (NodeResample) parent.getUserObject());
}
treeNode = parent.getParent();
}
nestedListNodeResample.add(listNodeResample);
});
return nestedListNodeResample;
}
private static List<DefaultMutableTreeNode> getListLeafsFromTree(JTree tree) {
DefaultTreeModel treeModel = ((DefaultTreeModel) tree.getModel());
DefaultMutableTreeNode rootTreeNode = (DefaultMutableTreeNode) treeModel.getRoot();
List<DefaultMutableTreeNode> listLeafDefaultMutableTreeNode = new ArrayList<>();
getLeafs(rootTreeNode, listLeafDefaultMutableTreeNode);
return listLeafDefaultMutableTreeNode;
}
private static void getLeafs(DefaultMutableTreeNode parent, List<DefaultMutableTreeNode> listLeafDefaultMutableTreeNode) {
if (parent.isLeaf()) {
listLeafDefaultMutableTreeNode.add(parent);
} else {
for (int i = 0; i < parent.getChildCount(); i++) {
DefaultMutableTreeNode child = (DefaultMutableTreeNode) parent.getChildAt(i);
getLeafs(child, listLeafDefaultMutableTreeNode);
}
}
}
private static void getListNodesFromTree(TreeNode treeNode, List<DefaultMutableTreeNode> out) {
DefaultMutableTreeNode nodeResampleTreeNode = (DefaultMutableTreeNode) treeNode;
out.add(nodeResampleTreeNode);
if (treeNode.getChildCount() >= 0) {
for (Enumeration e = treeNode.children(); e.hasMoreElements();) {
TreeNode n = (TreeNode) e.nextElement();
getListNodesFromTree(n, out);
}
}
}
private static List<DefaultMutableTreeNode> getListNodesFromTree(JTree tree) {
TreeNode root = (TreeNode) tree.getModel().getRoot();
List<DefaultMutableTreeNode> out = new ArrayList<>();
getListNodesFromTree(root, out);
return out;
}
private static List<List<NodeResample>> filler() {
List<List<NodeResample>> nestedListNodeResample = null;//Look in Paste bin
return nestedListNodeResample;
}
}
推荐阅读
- r - 如何在 R 编程中为变量设置长度和标签
- macos - Terminal.app:它是否首先调用 .profile 作为登录 shell?
- r - data.table - 使用 ~ var|factor - cast / dcast 将 data.table 拆分为列表的元素
- php - 如何在不使用数据库的情况下实现跨进程 PHP CLI 脚本通信?
- html - 如何使用 scroll-y 和 flexbox 获得 2 个 div 相同的高度
- c - char* 参数的值在函数内部发生变化
- python - 使用 mod_wsgi 和 apache 不断收到致命的 Python 错误
- r - R:可以将提取的字符串作为分隔字符保存到一列中吗?
- python-3.x - 比较数据框列中字典的键
- reactjs - React js map 不是函数