简单数学问题求教！

Question

http://www.csdn.com.cn/program/5197.htm
http://www.csdn.com.cn/program/7324.htm
上网找找全排列的算法吧，一堆一堆的

Answer 1

给个笨办法   5重循环就可以了
int count=0;
for(int i=0;i<5;i++)
  for(int j=0;j<5;j++){
     if(j==i)  continue;
     for(int m=0;m<5;m++){
       if(m==i||m==j)
       for(int n=0;n<5;n++){
          if(n==i||n==j||n==m)  continue;
          for(int k=0;k<5;k++){
             if(k==i||k==j||k==m||k==n) continue;
             n[count++] ={a[i],a[j],a[m],a[n],ak]};  
          }
       }
     }
  }

Answer 2

int count=0;
for(int i=0;i<5;i++)
  for(int j=0;j<5;j++){
     if(j==i)  continue;
     for(int m=0;m<5;m++){
       if(m==i||m==j)  continue;
       for(int n=0;n<5;n++){
          if(n==i||n==j||n==m)  continue;
          for(int k=0;k<5;k++){
             if(k==i||k==j||k==m||k==n) continue;
             n[count++] ={a[i],a[j],a[m],a[n],ak]};  
          }
       }
     }
  }
上面漏了点  现在补上了。。

Answer 3

给你一个用递归实现的代码吧，对 N 个元素的情况都实用。package jamesfancy;import java.util.*;/**
 * 基本思路：
 * 从 n 个元素中依次取出每一个作为全排列的第一个，
 * 其余的 n - 1 个再进行全排列，
 * 此时 n = n - 1，又可如上进行全排列，直到没有剩余元素
 */
public class QuangPaiLie {    private int[] elements;
    private ArrayList result;    public QuangPaiLie(int[] elements) {
        this.elements = elements;
    }    public void process() {
        result = new ArrayList();
        process(elements, 0);
    }    /**
     * 递归方法，递归处理全排列
     */
    private void process(int[] elements, int offset) {
        // 没有剩余元素的时候，将这一结果保存
        if (offset >= elements.length) {
            int[] r = new int[elements.length];
            System.arraycopy(elements, 0, r, 0, r.length);
            result.add(r);
            return;
        }        int offset1 = offset + 1;
        // 第1次是首位元素不变，全排列其后元素
        process(elements, offset + 1);
        for (int i = offset1; i < elements.length; i++) {
            // 将目前要放在首位的元素和第一位交换，
            // 使之成为首位，全排列后面的元素
            int t = elements[i];
            elements[i] = elements[offset];
            elements[offset] = t;
            process(elements, offset1);            // 全排列完成后需要将放在首位的元素交换回来
            // 以免影响外围（跳出该递归之后）的全排列
            t = elements[i];
            elements[i] = elements[offset];
            elements[offset] = t;
        }
    }    public int[][] getResult() {
        int len = result.size();
        int s = elements.length;
        int[][] r = new int[len][];
        for (int i = 0; i < len; i++) {
            r[i] = new int[s];
            System.arraycopy(result.get(i), 0, r[i], 0, s);
        }
        return r;
    }    public static void main(String[] args) {
        QuangPaiLie qpl = new QuangPaiLie(new int[] {1, 2, 3, 4, 5});
        qpl.process();
        int[][] r = qpl.getResult();
        for (int i = 0; i < r.length; i++) {
            for (int j = 0; j < r[i].length; j++) {
                System.out.print(r[i][j]);
                System.out.print(' ');
            }
            System.out.println();
        }        System.out.println("Total: " + r.length);
    }}

Answer 4

jamesfancy()边城狂人(James Fancy) 的方法不论是空间复杂度和时间复杂度都很大，对这样的问题是否有意义

Answer 5

从空间复杂度来说，如果不保存所有结果，直接输出到控制台，空间复杂度就不会很大了，因为每次用的都只是最初那几个元素，最多只是位置有所改变。而时间复杂度的话——恐怕最简单的是把这些排列的情况用每个都用一个 Print 语句打印出来这样最简单。有时候写程序不要过多的去考虑复杂度的问题，如果不想让电脑太麻烦，那人就得麻烦。对事情本身是不能偷懒的。