暴力破解

//玛雅人有一种密码，如果字符串中出现连续的2012四个数字就能解开密码。
//给一个长度为N的字符串，（2=<N<=13）该字符串中只含有0,1,2三种数字，
//问这个字符串要移位几次才能解开密码，每次只能移动相邻的两个数字。例如02120经过
//一次移位，可以得到20120,01220,02210,02102，其中20120符合要求，因此输出为1.
//如果无论移位多少次都解不开密码，输出-1。

//输入包含多组测试数据，每组测试数据由两行组成。
//第一行为一个整数N，代表字符串的长度（2<=N<=13）。（所有的状态才3^13次方）
//第二行为一个仅由0、1、2组成的，长度为N的字符串。

package com.company;

import java.util.HashSet;
import java.util.Scanner;

public class Main{
    public static void main (String [] args)
    {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext())
        {
            int N= sc.nextInt();
            String str=sc.next();

            if(!judge(str))
            {
                System.out.println("-1");
                continue;
            }

            int step=1;

            while(true){
                int min=getMin(step,str);//这样会重复计算
                //求解了深度为1的树，求解了深度为2的树（包含了深度为1）
                //这就是广度优先搜索
                if(min==-1)
                {
                    step++;
                }
                else
                {
                    System.out.println(min);
                    break;
                }

            }




        }


    }

    public static boolean judge(String str)
    {
        int count []=new int[3];
        for(int i=0;i<str.length();i++)
        {
            count[str.charAt(i)-'0']++;
        }

        if(count[0]<1)
        {
            return false;
        }

        if(count[1]<1)
        {
            return false;
        }

        if(count[2]<2)
        {
            return false;
        }

        return true;

    }

    private static HashSet<String> hashSet=new HashSet();


    public static int getMin(int step,String str)
    {
        hashSet.add(str);

        if(str.contains("2012"))
        {
            return 0;
        }


        if(step<=0)
        {
            return -1;
        }
        else
        {
            for(int i=0;i<str.length()-1;i++)
            {

                char []strArray=str.toCharArray();
                char temp=strArray[i];
                strArray[i]=strArray[i+1];
                strArray[i+1]=temp;

                String newString=String.valueOf(strArray);
                if(!hashSet.contains(newString))
                {
                    int min=getMin(step-1,newString);
                    if(min==-1)
                    {
                        continue;
                    }
                    else
                    {
                        return min+1;
                    }
                }


            }

            return -1;
        }
    }
}

//正确解
package com.company;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;

public class Main{
    public static void main (String [] args)
    {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext())
        {
            int N= sc.nextInt();
            String str=sc.next();

            if(!judge(str))
            {
                System.out.println("-1");
                continue;
            }



            LinkedList<String> queue=new LinkedList<>();

            queue.add(str);
            hashMap.put(str,0);

            int layer=0;


            while(!queue.isEmpty()){


                String queueHead=queue.remove();

                if(queueHead.contains("2012"))
                {
                    System.out.println(hashMap.get(queueHead));
                    break;
                }


                layer=hashMap.get(queueHead)+1;

                for(int i=0;i<queueHead.length()-1;i++)
                {

                    char []strArray=queueHead.toCharArray();
                    char temp=strArray[i];
                    strArray[i]=strArray[i+1];
                    strArray[i+1]=temp;

                    String newString=String.valueOf(strArray);
                    if(!hashMap.containsKey(newString))
                    {
                        queue.add(newString);
                        hashMap.put(newString,layer);
                    }


                }



            }




        }


    }

    public static boolean judge(String str)
    {
        int count []=new int[3];
        for(int i=0;i<str.length();i++)
        {
            count[str.charAt(i)-'0']++;
        }

        if(count[0]<1)
        {
            return false;
        }

        if(count[1]<1)
        {
            return false;
        }

        if(count[2]<2)
        {
            return false;
        }

        return true;

    }

    private static HashMap<String,Integer> hashMap =new HashMap();



}