Recursion 无需递归即可解析此函数，以便使用并行性

我试图优化一个过程，即计算所有可能的播放器组合以形成分区。为了理解我的问题，我使用以下示例

例如，我们有一组游戏者

N={1,2,3,4,5}

，这些游戏者是这样重新组合的

{1,2}，{3,4}，{5}

。这意味着玩家1将与玩家2作为一个单独的玩家进行游戏，因此玩家1也将作为一个单独的玩家进行游戏。每组玩家都有一套策略或选择。每个玩家选择他想要属于的组，例如：组

{1,2}

有这些可能性

{{1,2}；{1,2,3,4}

；i、 e玩家选择呆在一起或加入小组

{3,4}

。对其他玩家的解释也一样：

{3,4}=>{{3,4};{3,4,5};{1,2,3,4}}
{5}=>{{5};{3,4,5}}

现在，选择相同策略的玩家群体将组成一个新的群体（联盟）。例如，组

{1,2}

选择策略

{1,2,3,4}

，即玩家

{1,2}

希望与玩家

{3,4}

组成一个新组。玩家

{3,4}

选择策略

{3,4,5}

，玩家

{5}

选择策略

{3,4,5}

。选择相同策略的玩家将分组在一起，形成这样的玩家最终分区：

{1,2}，{3,4,5}

；玩家

{3,4,5}

选择了相同的策略，因此他们被分组在一起，玩家

{1,2}

选择了不同的策略，因此他们保持孤独。我已经将这个过程编程为一个递归函数，以获得所有允许的玩家分区。这里的另一个问题是：我的函数生成所有可能的分区，而我只得到需要花费大量时间的可接受项

现在我的问题是，如果不使用递归函数，是否有可能解决这个问题；i、 e.以顺序形式，以便与JCUDA并行，特别是当我们有许多玩家和这么多分区时。这里的理想解决方案是什么，MPI还是JCUDA

import java.util.ArrayList;
import java.util.Hashtable;

public class Partitions {
    public Hashtable<ArrayList<Integer>, ArrayList<ArrayList<Integer>>> HashTab = new Hashtable<ArrayList<Integer>,ArrayList<ArrayList<Integer>>>(); // The key  is the chosen strategy(coalition) and the value is the group of players have  chosen the same coalition(strategy).

    // create partitions combination
    public void CalculStrategiesCombination (int index, ArrayList<ObjectsCoalitions> PlayerCoalitions, int K,int L) {
       index = index +1;
           if(index < PlayerCoalitions.size()) { 
               for(int j =0; j< PlayerCoalitions.get(index).Coaltions.size(); j++) {
                   if(!this.HashTab.containsKey(PlayerCoalitions.get(index).Coaltions.get(j))) {
                       ArrayList<ArrayList<Integer>> e = new  ArrayList<ArrayList<Integer>>();
                       e.add(PlayerCoalitions.get(index).Objects);
                       this.HashTab.put(PlayerCoalitions.get(index).Coaltions.get(j), e);
                   } else {
                       this.HashTab.get(PlayerCoalitions.get(index).Coaltions.get(j)).add(PlayerCoalitions.get(index).Objects); 
                   }
                   if(this.HashTab.size()<K) {
                       CalculStrategiesCombination (index, PlayerCoalitions,K,L);
                   }
                   if(this.HashTab.get(PlayerCoalitions.get(index).Coaltions.get(j)).size()==1) {
                      this.HashTab.remove(PlayerCoalitions.get(index).Coaltions.get(j));
                   } else {
                      this.HashTab.get(PlayerCoalitions.get(index).Coaltions.get(j)).remove(this.HashTab.get(PlayerCoalitions.get(index).Coaltions.get(j)).size()-1);
                   }
               }
           } else {   
               // Treatment.......

           }
       }
   }

   public class ObjectsCoalitions {

       public ArrayList<Integer>Objects = new ArrayList<Integer>(); // for example Objects = {1,2}
       public ArrayList<ArrayList<Integer>> Coaltions = new   ArrayList<ArrayList<Integer>> (); //  coalitions (strategis)={{1,2};{1,2,3,4}}
   }

import java.util.ArrayList；
导入java.util.Hashtable；
公共类分区{
public Hashtable HashTab=new Hashtable（）；//键是选择的策略（联盟），值是选择相同联盟（策略）的玩家组。
//创建分区组合
公共无效计算策略组合（整数索引、数组列表播放集合、整数K、整数L）{
指数=指数+1；
如果（索引if（this.HashTab.size（）我不知道您是否愿意考虑其他并行编程模型，但这将非常容易编码，或者对于共享内存的情况，TBB或OpenMP 4.0您的意思是我可以保留递归函数，然后使用OpenMP并行解决此问题吗？是的，对于OpenMP任务，我认为您可以使用fork-join样式的OpenMParallelism非常适合回溯递归生成。我知道你可以使用TBB或Charm++，使用它们的本机机制。但我想用java保存代码，可能吗？！当然可能-甚至有java MPI绑定。不同的是，你基本上需要自己的有用软件和合适的知识-大多数可用的工具，以及大多数社区体验，是在C、C++和FoTRAN中，有更重的并行计算用户基础。