排列序号

给出一个不含重复数字的排列，求这些数字的所有排列按字典序排序后该排列的编号。其中，编号从1开始。
样例

例如，排列 [1,2,4] 是第 1 个排列。

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/**
 * 给出一个不含重复数字的排列，求这些数字的所有排列按字典序排序后该排列的编号。其中，编号从1开始。
样例
例如，排列 [1,2,4] 是第 1 个排列。
 * 
 * @author Dell
 *
 */
public class Test197 {
   public static void backtracking(int[] a,int k,List<Integer> list,List<List<Integer>> result)
   {
         if(k<0||a.length==0)
        	 return;
         if(k==a.length)
         result.add(new ArrayList<>(list));
         else
         {
        	 for(int i=0;i<a.length;i++)
        	 {
        		 if(list.contains(a[i])) continue;
        		 list.add(a[i]);
        		 backtracking(a,k+1,list,result);
        		 list.remove(list.size()-1);
        	 }
 
         }
   }
   
   public static long permutationIndex(int[] a)
   {       if(a.length==0)
	        return 0;
	       if(a.length==1)
	    	  return 1;
	     long sum=0;
	    for(int i=0;i<a.length-1;i++)
	    {
	    	int[] temp=Arrays.copyOfRange(a, i, a.length);
	    	Arrays.sort(temp);
	    	int x=find(temp,a[i]);
	    	//int dup=cishu(a,i);
	    	sum=sum+(x*f(a.length-1-i));
	    }
	    return sum+1;  
   }
  /* public static int cishu(int[] a, int i)
   {
	     int count=0;
	     for(int j=0;j<i;j++)
	     {
	    	 if(a[j]==a[i])
	    	 {
	    		 count++;
	    	 }
	     }
	    return count; 
	   
   }*/
   public static int find(int[] b ,int target)
   {       int index=-1;
	   for(int i=0;i<b.length;i++)
	   {
		   if(b[i]==target)
		   {  
			   index=i;
			   break;
		   }
	   }
	   return index;
   }
   public static long f(int n)
   {
	   if(n==0||n==1)
		   return 1;
	   else
		   return n*f(n-1);
   }
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int[] a=new int[n];
		for(int i=0;i<a.length;i++)
		{
			a[i]=sc.nextInt();
		}
		/*List<Integer> target=new ArrayList<>();*/
		/*for(int i=0;i<a.length;i++)
		{
			target.add(a[i]);
		}*/
		/*  Arrays.sort(a);
		List<Integer> list=new ArrayList<>();
		List<List<Integer>> result=new ArrayList<>();
		backtracking(a,0,list,result);
         for(int i=0;i<result.size();i++)
         {        int j;
        	 for(j=0;j<result.get(i).size();j++)
        	 {
        		 if(result.get(i).get(j)!=target.get(j))
        			 break; 
        	 }
        	 if(j>=result.get(i).size())
        	 {
        		 System.out.println(i+1);
        		 break;
        	 }
         }*/
		System.out.println(permutationIndex(a));
	}

}