Java回溯问题

嘿，伙计们。我一直在为一个回程问题苦苦挣扎数小时。谁能帮我一把吗？问题是：

n

编号从1到

n

的骆驼是排列顺序。我想重新安排，这样每只骆驼前面都有一只不同的骆驼

这就是我到目前为止所做的：

import java.util.*;

public class NCamile{
static int size;
static int count;
static char[] arrN= new char[100];

public static void main(String[] args){
    System.out.print("Enter word: ");
    String numar = getInt();
    size = numar.length();
    count=0;

    for(int i=0; i < size ; i++){
        arrN[i] = numar.charAt(i);
    }
backtraking(size);  
}

public static void backtraking(int newsize){

    if (newsize == 1){
        return;
    }

    for(int i=0 ; i < newsize; i++){

        backtraking(newsize - 1);


            if(newsize == 2 ){

                    display();

                }




        rotate(newsize);
    }

}
public static void rotate(int newsize){
    int position = size - newsize;

    for(int i = position + 1; i < newsize; i++){
        char gigi;
        gigi = arrN[i - 1];
        arrN[i - 1] = arrN [i];
        arrN[i] = gigi;
    }
}

public static void display(){
    if (count < 9){
        System.out.print(" ");
    }

    System.out.print(++count+ ")" + " ");

    for(int i = 0 ; i < size ; i++)
        System.out.print(arrN[i]);
        System.out.print(" ");


    if(count % 10 == 0){
        System.out.println(" ");
    }
}


public static String getInt(){
    Scanner scan = new Scanner(System.in);
    String s = scan.next();
    return s;

}

}

import java.util.*；
公共类NCamile{
静态整数大小；
静态整数计数；
静态字符[]arrN=新字符[100]；
公共静态void main（字符串[]args）{
系统输出打印（“输入单词：”）；
字符串numar=getInt（）；
尺寸=单位长度（）；
计数=0；
对于（int i=0；i

有了这个，算法向我展示了重新排列字符串的所有可能的解决方案，但它不考虑问题的最后一个条件。我试过这样做：

for(int j = 0 ; j < size ; j++){

   if (array[j] !=[array[j + 1] )
      display()
}

for（int j=0；j

但在我添加它之后，我得到的显示文字是它应该显示给我的文字的10倍

---

可以有人告诉我该怎么做吗？

< P>当然这不是优化的解决方案，但是为了简单地得到结果，我会考虑检查所有的排列。产生每一个排列的方法不会很难写（看看），并且检查某个骆驼有相同的回溯不会有任何努力。

---编辑 所以，几乎没有什么东西可以修复，也没有什么东西不能修复： 我处理的是字符串，而不是字符数组。在这个问题中，字符数组完全被误解。最好使用字符串对象（因为事实上，字符串是字符数组）或int数组（这对我来说很难，因为我还没有找到任何排列方法来应用这样的参数）。因此，现在主要方法看起来：

private static String word;

public static void main(String[] args)
{
    System.out.print("Enter word: ");
    Scanner scan = new Scanner(System.in);
    word = scan.next();
    permutation(word);
}

我删除了您的类变量（长度、计数等），因为它们现在是不必要的。写出字符串非常简单，如果您想更改输出格式，请使用String.length属性

排列方法是从上述来源复制而来，几乎没有修改。它如下所示：

public static void permutation(String s)
{
    permutation("", s);
}

private static void permutation(String prefix, String s)
{
    int n = s.length();
    if (n == 0)
            {
        if (camelFit(prefix))
            System.out.println(prefix);
            }
    else
    {
        for (int i = 0; i < n; i++)
            permutation(prefix + s.charAt(i),
                    s.substring(0, i) + s.substring(i + 1, n));
    }

}

公共静态无效置换（字符串s）
{
排列（“，s）；
}
私有静态无效置换（字符串前缀，字符串s）
{
int n=s.长度（）；
如果（n==0）
{
if（camelFit（前缀））
System.out.println（前缀）；
}
其他的
{
对于（int i=0；i

如果您取消注释行检查if（camelFit（prefix）），它将显示输入字符串的每个排列。但是！我们只想打印这些符合问题条件的camel链。我们如何检查给定链是否如此？简单方法：

private static boolean camelFit(String prefix)
{
    for (int i = 0; i < word.length() - 1; i++)
    {
        char camel = word.charAt(i);
        char camelFollow = word.charAt(i+1);
        for (int j = 0; j < prefix.length() - 1; j++)
        {
            if (prefix.charAt(j)==camel && prefix.charAt(j+1)==camelFollow)
            {
                return false;
            }
        }
    }
    return true;
}

private静态布尔匹配（字符串前缀）
{
for（int i=0；i

也许不是那么简单，因为我们必须检查每一对输入链（每个跟随者和跟随者）和每一对输出链。如果任何两对之间没有任何匹配，给定的链就可以了

---

请注意，这个解决方案是绝对非优化的。查找置换是O（n！）复杂度，检查对是O（n^2）复杂度。最终复杂度是O（n^2）*O（n！），非常非常非常高。

如果你只被要求确保这一点

i） 产生一个新的安排，并且

ii）该新安排必须满足以下条件，即每头骆驼所遵循的骆驼与其在原始安排中所遵循的骆驼不同

---

然后，只需颠倒骆驼列表即可轻松满足此要求。

通过“前面”你的意思是我们只需要将元素改到左边吗？在这种情况下，简单地反转数组不就可以得到答案吗？不，算法必须显示每个可能的结果。例如，让我们拿这个数字：1234下次显示时，2不能在1前面，3不能在2前面，4不能在3前面，等等one@MAKWe必须反转数组，去掉第一个元素。因为他说“每只骆驼前面有一个不同的骆驼”。如果不是，最后一只骆驼前面就不会有骆驼。（没有骆驼==不同的骆驼）是假的，我想是的。算法会导致每一个posbile排列