之前有帖子给出7个随从搞定所有悬槌任务了，LZ闲来无事，写了个程序想探究总共有多少种组合能解决这个问题，结论是4种 如果给9种技能按如下编号：
0 限时战斗
1 强力法术
2 重击
3 群体伤害
4 爪牙围攻
5 危险区域
6 致命爪牙
7 魔法减益
8 野生怪物入侵
 
那么，4个悬槌任务分别需要的技能组合为：
012568
334578
002467
015668
 
对应地，可以用程序暴力穷举所有技能组合，得出以下4种随从组合可以匹配以上4个任务：
(1)20 60 74 51 53 83 86
(2)20 60 74 61 43 73 85
(3)20 60 74 61 53 83 85
(4)20 60 74 81 53 83 65
翻译成技能就是：
(1)重击+限时战斗，致命爪牙+限时战斗，魔法减益+爪牙围攻，危险区域+强力法术，危险区域+群体伤害，野生怪物入侵+群体伤害，野生怪物入侵+致命爪牙
(2)重击+限时战斗，致命爪牙+限时战斗，魔法减益+爪牙围攻，致命爪牙+强力法术，爪牙围攻+群体伤害，魔法减益+群体伤害，野生怪物入侵+危险区域
(3)重击+限时战斗，致命爪牙+限时战斗，魔法减益+爪牙围攻，致命爪牙+强力法术，危险区域+群体伤害，野生怪物入侵+群体伤害，野生怪物入侵+危险区域
(4)重击+限时战斗，致命爪牙+限时战斗，魔法减益+爪牙围攻，野生怪物入侵+强力法术，危险区域+群体伤害，野生怪物入侵+群体伤害，致命爪牙+危险区域
 
可以看出，“重击+限时战斗， 致命爪牙+限时战斗， 魔法减益+爪牙围攻”这三种技能组合是必须的，其他四种可以有变化。
 
-------------------------分割线----------------------------------------------
 
大家觉得酒仙的”野生怪物入侵+群体伤害“比较难召，所以这里再给出个排除了酒仙，队伍扩大到8个随从的组合(已经剔除了包含上面(2)组合的任意8人组)，这样可能会比较容易达成：
(5) 20 40 60 61 72 43 73 85
(6) 20 60 70 61 42 43 73 85
(7) 20 60 70 61 43 73 64 85
(8) 20 60 51 43 53 74 86 87
(9) 20 60 51 43 73 74 85 86
(10) 20 60 51 53 73 74 84 86
(11) 20 60 61 43 53 74 85 87
(12) 20 60 61 53 73 74 84 85
(13) 20 60 81 43 53 74 65 87
(14) 20 60 81 53 73 74 84 65
(15) 40 60 21 61 72 43 73 85
(16) 60 70 21 61 42 43 73 85
 
-------------------------分割线----------------------------------------------
附上C++代码，如果有人感兴趣在此基础上修改的话：
程序大体思路是用一串二进制数来保存各种技能的组合叠加：1个技能用3位来保存该技能的个数，9个技能需要27位，譬如说，0b001010000表示三个技能分别的个数为001,010,000，即1个，2个，0个。然后通过各种按位的操作来计算比较。
这个暴力解法的运算时间会随随从数增多成指数上升，7个随从运算时间大概在1分钟以内，如果要改更多随从数来解决其他任务组合问题，计算量会很大。
Code (c):
#include <iostream> 
#include <string> 
using namespace std; 
typedef unsigned long ulong; 
void add_multi_talents(ulong &, string); 
bool compare(ulong team, ulong task); 
int main() 
{ 
    ulong talents[9] = {0}; 
    ulong tasks[100] = {0}; 
     
    for(int i = 0; i != 9; ++i) 
    { 
        talents[i] = (1 << (i * 3)); 
    } 
 
    ulong combo[37] = {0}; 
    int dict[37] = {0}; 
    int N_combo = 37; 
    int k = 0; 
    for(int i = 0; i < 9; ++i) 
    { 
        for(int j = i + 1; j < 9; ++j) 
        { 
            combo[k] = talents[i] + talents[j]; 
            dict[k] = j * 10 + i; 
            ++k; 
        } 
    } 
    combo[k] = talents[0] + talents[0]; 
    dict[k] = 0; 
 
    add_multi_talents(tasks[0], "012568"); 
    add_multi_talents(tasks[1], "334578"); 
    add_multi_talents(tasks[2], "002467"); 
    add_multi_talents(tasks[3], "015668"); 
 
    ulong team; 
    int x[100] = {0}; 
    int N_f = 7; 
    for(x[0] = 0; x[0] < N_combo; ++(x[0])){ 
    for(x[1] = x[0]; x[1] < N_combo; ++(x[1])){ 
    for(x[2] = x[1]; x[2] < N_combo; ++(x[2])){ 
    for(x[3] = x[2]; x[3] < N_combo; ++(x[3])){ 
    for(x[4] = x[3]; x[4] < N_combo; ++(x[4])){ 
    for(x[5] = x[4]; x[5] < N_combo; ++(x[5])){ 
    for(x[6] = x[5]; x[6] < N_combo; ++(x[6])){ 
    bool t0 = false; 
    bool t1 = false; 
    bool t2 = false; 
    bool t3 = false; 
    for(int i = 0; i != N_f; ++i){ 
    for(int j = i + 1; j != N_f; ++j){ 
    for(int k = j + 1; k != N_f; ++k){ 
        team = combo[x[i]] + combo[x[j]] + combo[x[k]]; 
        if (compare(team, tasks[0])) t0 = true; 
        if (compare(team, tasks[1])) t1 = true; 
        if (compare(team, tasks[2])) t2 = true; 
        if (compare(team, tasks[3])) t3 = true; 
    }}} 
    if (t0 && t1 && t2 && t3) 
    { 
        cout << dict[x[0]] << " "; 
        cout << dict[x[1]] << " "; 
        cout << dict[x[2]] << " "; 
        cout << dict[x[3]] << " "; 
        cout << dict[x[4]] << " "; 
        cout << dict[x[5]] << " "; 
        cout << dict[x[6]] << endl; 
    } 
    }}}}}}} 
 
    return 0; 
} 
 
void add_multi_talents(ulong &task, string str) 
{ 
    int size = str.size(); 
    int n; 
    ulong talent; 
    for(int i = 0; i != size; ++i) 
    { 
        n = (int)(str[i]-'0'); 
        talent = 1 << (n * 3); 
        task = task + talent; 
    } 
} 
 
bool compare(ulong team, ulong task) 
{ 
    ulong mask = 7; 
    for(int i = 0; i != 9; ++i) 
    { 
        if ((task & mask) > (team & mask)) 
            return false; 
        mask = mask << 3; 
    } 
    return true; 
}