4

我试图通过编程来解决一个难题。我有 int 6 个数组，每个数组有 6 个数字。我必须从每个数字中选择一个数字来得出总和 419。我几乎是 Java 的初学者。我尝试使用 if() elseif() ex:if (lock1[i]+lock2[i]+lock4[i]+lock4[i]+lock5[i]+lock6[i] == 419) 但它的代码太长了。我查看了 Array 和 ArrayList 类的 Java API，但我不知道应该使用哪种方法

这是数组

 class Locks {
        public static void main(String[] args) {
            int [] lock1 = {39,6,75,88,15,57};
            int [] lock2 = {9,2,58,68,48,64};
            int [] lock3 = {29,55,16,67,8,91};
            int [] lock4 = {40,54,66,22,32,25};        
            int [] lock5 = {49,1,17,41,14,30};
            int [] lock6 = {44,63,10,83,46,3};
            int total = 419;
          }
    }
4

4 回答 4

2

它打印： 3, 3, 5, 0, 0, 3 指的是 88, 68, 91, 40, 49, 83。

要理解的关键是我们需要查看 6 ^ 6 组合。因此我们生成从 0 到 6 ^ 6 -1 的数字。

public class Locks{
    public static void main(String[] args) {
        int [][] locks = {
            {39,6,75,88,15,57},
            {9,2,58,68,48,64},
            {29,55,16,67,8,91},
            {40,54,66,22,32,25},        
            {49,1,17,41,14,30},
            {44,63,10,83,46,3}};
        int i, j;
        int total = 419;
        int dims = 6;               // number of dimensions in array
        int loops = 1; 
        for(i = 0; i < dims; ++i)   // maximum number of elements to test 
             loops *= dims;
        for(i=0; i < loops; ++i) {  // loop over all possibilities
            int cTotal = 0;         // Total for this selection of 6 columns
            int rTotal = 1;
            for(j = 0; j < dims; ++j) {       // generate six array indexes
                cTotal += locks[j][i / rTotal % dims];
                rTotal *= dims;
            }
            rTotal = 1;
            if(cTotal == total) {
                for(j = 0; j < dims; ++j) {
                    System.out.println(i / rTotal % dims);
                    rTotal *= dims;
                }
                return;
            }
        }
    }
}
于 2013-09-22T04:31:36.190 回答
1 
public class Tset {

static int [] lock1 = {39,6,75,88,15,57};
static int [] lock2 = {9,2,58,68,48,64};
static int [] lock3 = {29,55,16,67,8,91};
static int [] lock4 = {40,54,66,22,32,25};
static int [] lock5 = {49,1,17,41,14,30};
static int [] lock6 = {44,63,10,83,46,3};
static int [] index =  new int[6];
static int total = 419;

public static void main(String[] args) {
    if(Tset.getIndex()!=null){

    }

}


    public static int[] getIndex(){
        int total1 =0;
        for(int i1 :lock1){
              for(int i2 :lock2){
                  for(int i3 :lock3){
                      for(int i4 :lock4){
                          for(int i5 :lock5){
                              for(int i6 :lock6){
                                       total1=lock1[i1]+lock2[i2]+lock4[i3]+lock4[i4]+lock5[i5]+lock6[i6];
                                    if (total1==total) {
                                             index[0] = i1;
                                             index[1] = i2;
                                             index[2] = i3;
                                             index[3] = i4;
                                             index[4] = i5;
                                             index[5] = i6;
                                        return index;
                                    }

                              }

                          }

                      }

                  }

              }
        }
        return null;
    }

}

于 2013-09-22T04:15:13.990 回答
1

该解决方案可以与任何一组数组一起使用，并且可以找到产生所需总和的所有组合之外的更多组合

public static void main(String[] args) throws Exception {
    int[] lock1 = { 39, 6, 75, 88, 15, 57 };
    int[] lock2 = { 9, 2, 58, 68, 48, 64 };
    int[] lock3 = { 29, 55, 16, 67, 8, 91 };
    int[] lock4 = { 40, 54, 66, 22, 32, 25 };
    int[] lock5 = { 49, 1, 17, 41, 14, 30 };
    int[] lock6 = { 44, 63, 10, 83, 46, 3 };
    int[][] locks = { lock1, lock2, lock3, lock4, lock5, lock6 };
    int[] a = new int[6];
    find(locks, 0, a, 419);
}

static void find(int[][] locks, int i, int[] a, int x) {
    if (i < locks.length) {
        for (int j = 0; j < locks[i].length; j++) {
            a[i] = j;
            int n = 0;
            for (int k = 0; k < a.length; k++) {
                n += locks[k][a[k]];
            }
            if (n == x) {
                System.out.println(Arrays.toString(a));
            }
            find(locks, i + 1, a, x);
        }
    }
}
于 2013-09-22T05:45:50.697 回答
0

在编写这样的循环时，请注意通过保存工作总数可以进行一些小的优化。当然是相同的渐近时间，但肯定更少的操作。

   int sum = lock1[0]+lock2[0]+lock4[0]+lock4[0]+lock5[0]+lock6[0];
   for(int i1 :lock1){
       sum += lock1[i1];
            ...
               ...
                   for(int i6 :lock6){
                       sum += lock6[i6];
                       //test total=sum  
                       sum -= lock6[i6];
                   }
               ...
            ...
       sum -= lock1[i1];
   }
于 2013-09-22T04:45:30.077 回答