牛客网题解-回文序列

回文序列

BFS解法，题目第一眼的感觉是最短路径，于是尝试使用BFS和队列求解，提交时显示超时，因此需要对题目进行进一步分析。

首先回文序列，可能想到的是外面一个循环，挨个去遍历以每一个人位置上的字符为回文序列的中心，形成一个回文序列所需要的操作次数，接着往下分析，按照题目所给的规则进行操作时，没法下手。此时应当换个角度考虑，假如我们从两端开始，步步逼近回文序列，当两端不相等时，取较小的一端求和重新插入。有时候正面思考问题得不出答案，可以考虑从其他觉得分析，比如回文序列，当在本题中，我们发现从中间往外扩展时比较难以操作时，是否可以考虑从两端下手，向中间靠齐。

//BFS解法
import java.util.*;
public class Main {
    public static void main(String args[]){
       Scanner in=new Scanner(System.in);
       while(in.hasNext()){
           int n=in.nextInt();
           List<Integer> array=new ArrayList<Integer>();
           for(int i=0;i<n;i++)
               array.add(in.nextInt());
           if(n==1){
               System.out.println(0);
           }else{
               System.out.println(f(array));
           }
       }
    }
    public static int f(List<Integer> array){
        //队列用于辅助，但是还是超时
        Queue<ArrayList<ArrayList<Integer>>> queue=new LinkedList<ArrayList<ArrayList<Integer>>>();
        ArrayList<ArrayList<Integer>> t1= new ArrayList<ArrayList<Integer>>();
        t1.add(new ArrayList<>(array));
        queue.add(t1);
        int cnt=0;
        while(queue.size()>0){
            List<ArrayList<Integer>> temparray1=queue.poll();
            for(int k=0;k<temparray1.size();k++){
                List<Integer> temparray2=temparray1.get(k);
                if(f2(temparray2)){
                    return cnt;
                }
            }
            cnt++;
            List<ArrayList<Integer>> list=new ArrayList<ArrayList<Integer>>();
            for(int k=0;k<temparray1.size();k++){
                List<Integer> temparray3=temparray1.get(k);
                for(int i=0;i<temparray3.size()-1;i++){
                    int valuei=temparray3.get(i);
                    int valuei2=temparray3.get(i+1);
                    temparray3.remove(i+1);
                    temparray3.set(i,valuei+valuei2);
                    list.add(new ArrayList(temparray3));
                    temparray3.set(i,valuei);
                    temparray3.add(i+1,valuei2);
                }
            }
            queue.offer(new ArrayList<ArrayList<Integer>>(list));
        }
        return cnt;
    }
    public static boolean f2(List<Integer> array){
        int i=0,j=array.size()-1;
        while(i<j){
            if(array.get(i)!=array.get(j))
                return false;
            i++;
            j--;
        }
        return true;
    }
    public static void Print(List<Integer> list){
        for(int i=0;i<list.size();i++){
            if(i==0){
                System.out.print(list.get(i));
            }else{
                System.out.print(" "+list.get(i));
            }
        }
        System.out.println();
    }
}

解法二，仔细分析问题，然后寻找高效率的方法

//思路：从两端开始比较，若相等则删除两端数据，将两端指针向中间移动；
//当两端数据不相等时，我们的目的是让两端数据相等，因为操作的规则为求相邻的两个数据的和很显然遇到比较不相等时
//应该选择较小的一端操作，继续移动指针，直至两指针相遇，则此时为回文序列。
//难点在于理解为什么在两端数据相等时可以直接移除，之后还会不会用上？
//答案是：两端数据相等是可以直接进行两端指针向中间移动，因为两端数据既然已经相等，没必要再进行题目中的操作，
//任何一端的操作都会引起另一端的操作，至少将增加2次及其以上的操作次数
import java.util.*;
public class Main {
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        while(in.hasNext()){
            int n=in.nextInt();
            int num[]=new int[n];
            for(int i=0;i<n;i++)
                num[i]=in.nextInt();
            int head=0,tail=n-1,cnt=0;
            while(head<tail){
                if(num[head]==num[tail]){  //相等时两端指针向中间移动
                    head++;
                    tail--;
                }else{
                    if(num[head]<num[tail]){  //首指针指向的数小于尾指针指向的数时，移动首指针
                        num[head+1]=num[head]+num[head+1];
                        head++;
                        cnt++;
                    }else{
                        num[tail-1]=num[tail]+num[tail-1]; //尾指针指向的数小于首指针指向的数时，移动尾指针
                        tail--;
                        cnt++;
                    }
                }
            }
            System.out.println(cnt);
        }
    }
}