返回 i<j<k 的所有元素组合的正确算法是什么

Question

我必须找到数组 a[] 中索引为 i,j,k 的所有组合，使得 i

我尝试了递归方式并将所有组合存储在一个集合中，这样如果我再次访问相同的组合，我只会通过从集合中检查它来从那里返回

我的代码是这样的，但我正在为大型案例获得 TLE 谁能给我最有效的方法

 static Set<String> set = new HashSet<>();
 static int sum = 0;

    static void solve(int i,int j,int k,int[] a){
        if(i>=j || j>=k ||k>=a.length){
            return;
        }
        
        //combination
        String pre = String.valueOf(i)+String.valueOf(j)+String.valueOf(k);
        if(set.contains(pre)){
            return;
        }

        //operation to perform for every combination
        int v = (a[i] | a[j] | a[k]) ^ (a[i] ^ a[j] ^ a[k]);
        sum = sum+v;

        solve(i,j,k+1,a);
        solve(i,j+1,k,a);
        solve(i+1,j,k,a);
    }

Answer 1

对于三个索引，创建三个循环更简单。为了简单起见，我还添加了两个二进制操作的预计算并删除了集合检查。

static int solve(int[] a){
    int leng = a.length;
    int sum = 0;
    for (i=0; i < leng-2; i++)   {
       for (j=i+1; j < leng - 1; j++)   {
           int ijor = a[i] | a[j];
           int ijxor = a[i] ^ a[j];
           for (k=j+1; k < leng; k++)   {
              //operation to perform for every combination
             sum = sum + (ijor | a[k]) ^ (ijxor ^ a[k]);
           }
        }
     }
     return sum; 
}

Answer 2

我看到您使用的是 java，但是，我可以使用 python 提供答案，但我确信 java 中也有等效的操作：

from itertools import combinations
def combs_tri(X):
    lenght=len(X)
    num_of_zeros=lenght-3
    def factorial(n):
        m=1
        for x in range(1,n+1):
            m=m*x
        return m
    def num_of_comb(n,z):
        return int(factorial(lenght)/(factorial(z)*factorial(lenght-z)))
    count=num_of_comb(lenght,3)
    def create_boolean_array(num_of_zeros,count,lenght):
        Arr=np.zeros((count,lenght))
        combs=list(combinations(range(lenght), 3))
        for i,comb in enumerate(combs):
            Arr[i,comb]=1
        return Arr
    repeated_list=np.repeat([X],count,axis=0)
    bool_mask=create_boolean_array(num_of_zeros,count,lenght)
    return repeated_list[bool_mask.astype(bool)].reshape((int(count)),3)

功能说明

factorial：执行 n!=n(n-1)(n-2)...

的数学运算阶乘

num_of_comb：执行数学组合运算，返回数值结果。

create_boolean_array：创建一个布尔掩码以获取数组元素的所有可能组合。 ->combinations()：返回组合 例如/组合([1,2,3],2)=[(1,2),(1,3),(2,3)]

->np.repeat([X],count,axis=0) 按给定计数重复给定列表。计数表示此处的组合数（3）。

Ex/ np.repeat([1,2,3,4],count,axis=0)=np.array([[1,2,3,4],[1,2,3,4] ,[1,2,3,4],[1,2,3,4]])

---

在大多数情况下，数组操作比 for 循环快得多。

Answer 3

我认为这是一个非常简单的问题，只有 3 个循环。我用c++写过代码，但你一定会明白的：

#include <vector>
#include <iostream>

void print_all(const std::vector<int>& arr){
    for (size_t i = 0; i < arr.size() - 2; i++) {
        for (size_t j = i + 1; j < arr.size() - 1; j++) {
            for (size_t k= j + 1; k < arr.size(); k++) {
                if ((arr[i] < arr[j]) || (arr[i] > arr[j] && arr[i] < arr[k]))
                    std::cout << "[" << arr[i] << "," << arr[j] << "," << arr[k] << "]\n";
            }
        }
    }
}

int main() {
    std::vector<int> arr = {12, 1, 34, 32};
    print_all(arr);
}

对于条件，对于一个元组(a, b, b)：

1. 如果a<b，那么您可以选择任意c，最多移动1 次即可到达a<b<c。
2. 如果a>b需要切换，那么所有c都需要大于a。