Question

这是我第二次在这里直截了当地问道。我似乎无法找到解决方案，我知道这并非不可能。我写了一个java程序，可以生成一组任意长度的组合，当我停止程序时我不想从头开始如何从我停止的地方拿起？感谢。

示例（长度为3）：

如果我从aaa ==> 9zI开始并且我在此停止该计划，我不想从aaa开始，而是从9zI开始并继续999 。我只是想从我离开的地方继续。

public class Main {

public static void main(String[] args) {
    S_Permutation sp = new S_Permutation();
    String text = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    FileClass.fileExist("new.txt", true);
    System.out.println("");

    sp.permutation(text, "", 7, "sha256.txt","Kaaaaaa");
  }
}

=============================================== ======================

public class S_Permutation {

private List<String> permutation;

public S_Permutation() {
    permutation = new ArrayList<>();
}

public boolean saveThis(String words, char a, int limit) {
    int count = 0;
    limit++;
    for (char character : words.toCharArray()) {
        if (count == limit) {
            return false;
        }

        if (character == a) {
            count++;
        } else {
            count = 0;
        }
    }

    return count < limit;
}
private int counter = 0;
private boolean seen = false;
public void permutation(String str, String prefix, int lengthOfPermutationString, String filename, String startPoint) {
    if (prefix.equalsIgnoreCase(startPoint))
    {
        seen = true;
    }
    if (counter == 0) {
        if (startPoint.length() != lengthOfPermutationString) {
            for (int i = startPoint.length(); i < lengthOfPermutationString; i++) {
                startPoint += str.charAt(0);
            }
        }
        counter = -45;
    }
    if (prefix.length() == lengthOfPermutationString) {
        boolean savethis = true;

        for (int i = 0; i < prefix.length(); i++) {
            savethis = this.saveThis(prefix, prefix.charAt(i), 13);
            if (!savethis) {
                break;
            }
        }
        if (savethis && seen) {
            System.out.println(prefix);
            //permutation.add(prefix);
        }

    } else {
        for (int i = 0; i < str.length(); i++) {
            if (permutation.size() == 1000) {
                FileClass.WriteFile("new.txt", permutation);
                permutation.clear();
            }

            permutation(str, prefix + str.charAt(i), lengthOfPermutationString, filename, startPoint);
        }
        FileClass.WriteFile("new.txt", permutation);
        permutation.clear();

      }
  }
 }

=============================================== ==========================

public class FileClass {

public static boolean WriteFile(String filename, List<String> doc) {

    try {
        if (!filename.contains(".txt")) {
            filename += ".txt";
        }

        RandomAccessFile raf = new RandomAccessFile(filename, "rw");
        String writer = "";

        writer = doc.stream().map((string) -> string + "\n").reduce(writer, String::concat);
        raf.seek(raf.length());
        raf.writeBytes(writer);
        raf.close();
    } catch (Exception e) {
        System.out.println(e.getMessage());
        System.out.println("Error");
        new Scanner(System.in).nextLine();

        return false;
    }

    return true;
}
static RandomAccessFile raf;
public static boolean fileExist(String filename, boolean delete){
    File file = new File(filename);
    if (file.exists() && delete)
    {
        return file.delete();
    }
    return file.exists();
}
public static void WriteFile(String filename, String text) {

    try {
        if (!filename.contains(".txt")) {
            filename += ".txt";
        }

        raf = new RandomAccessFile(filename, "rw");
        long length = raf.length();
        raf.setLength(length + 1);
        raf.seek(raf.length());
        raf.writeBytes(text + "\n");

    } catch (Exception e) {
    }

}

private static void write(List<String> records, Writer writer) throws IOException {
    for (String record : records) {
        writer.write(record);
    }
    writer.flush();
    writer.close();

}

public static void stringWriter(List<String> records, String filename) {

    try {
        File file = new File(filename);
        FileWriter writer = new FileWriter(file, true);
        write(records, writer);
    } catch (Exception ex) {
        System.out.println(ex.getMessage());
        new Scanner(System.in).nextLine();
    }
}

public static boolean CloseFile() {
    try {
        raf.close();
        return true;
    } catch (Exception e) {
        return false;
    }
  }
 }

Answer 1

为了添加＆＃34;简历＆＃34;机制，您需要制作您的计划idempotent。一种方法是，不是保存排列 - 保存到每次迭代时发送到排列的参数：

现在每次程序启动时，它都会检查调用permutation的最后一个参数（文件中的最后一行），并从那里开始（当程序第一次启动时），不会在文件中写入任何内容 - 因此它将从头开始。）

在递归完成之后，我们可以调用另一个将遍历文件行的方法，并只读取排列（忽略其他参数）并将它们写入清理器＆＃34; final_result.txt＆＃34 ;文件。

毋庸置疑，这种实施成本更高（所有额外的读取和写入光盘），但是需要权衡其支持＆＃34;恢复＆＃34;操作

Answer 2

要在工作中保存/恢复过程，您需要一些我们称之为“状态”的东西，并以迭代的方式实现生成组合。在我的实现中，“状态”是pos对象（我假设set而k在“简历”上不会改变。）

我对问题的实施如下：

public class RepeatComb {
    private int[] pos;
    private String set;
    public RepeatComb(String set, int k) {
        this.set = set;
        pos = new int[k];
    }
    public int[] getState() {return Arrays.copyOf(pos, pos.length);}
    public void resume(int[] a) {pos = Arrays.copyOf(a,a.length);}
    public boolean next() {
        int i = pos.length-1;
        for (int maxpos = set.length()-1; pos[i] >= maxpos; ) {
            if (i==0) return false;
            --i;
        }
        ++pos[i];
        while (++i < pos.length) pos[i]=0;
        return true;
    }
    public String getCur() {
        StringBuilder s = new StringBuilder(pos.length);
        for (int i=0; i < pos.length; ++i)
            s.append(set.charAt(pos[i]));
        return s.toString();
    }

    public static void main(String[] args) {
        int[] state;
        String text = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        RepeatComb comb = new RepeatComb(text, 3);
        int stop = 10; //break after 10
        do {
            if (stop-- == 0) break;
            System.out.println(comb.getCur());
        } while (comb.next());
        //save state
        state = comb.getState();
        System.out.println("---------");

        //resume (with the same args: text,3)
        stop = 10; //break after 10
        comb = new RepeatComb(text, 3);
        comb.resume(state); // resume here
        do {
            if (stop-- == 0) break;
            System.out.println(comb.getCur());
        } while (comb.next());
    }
}

更新：我添加了获取状态和从中恢复的功能和使用的例子。 state数组可以保存在文件中，然后恢复。

如何在停止程序的情况下继续排列/组合？

2 个答案: