交错01串+操作序列+疯狂队列（java）

交错01串

如果一个01串任意两个相邻位置的字符都是不一样的,我们就叫这个01串为交错01串。例如: “1”,“10101”,"0101010"都是交错01串。
小易现在有一个01串s,小易想找出一个最长的连续子串,并且这个子串是一个交错01串。小易需要你帮帮忙求出最长的这样的子串的长度是多少。

输入描述:
输入包括字符串s,s的长度length(1 ≤ length ≤ 50),字符串中只包含’0’和’1’

输出描述:
输出一个整数,表示最长的满足要求的子串长度。
示例1
输入
111101111
输出
3
这个我用的是暴力法，一个一个子集检查

import java.util.*;
public class Main{
    public static void main(String args[]){
        Scanner input=new Scanner(System.in);
        String s=input.next();
        int i,j,k,result=0,temp=0,max=0;
        for(i=0;i<s.length();i++)
            for(j=i;j<s.length();j++)
            {   result=0;
                for(k=i;k<=j;k++)
                {  if(k==i)
                    temp=  Integer.parseInt(String.valueOf(s.charAt(k)));
                  else
                     if(Integer.parseInt(String.valueOf(s.charAt(k)))==1-temp)
                     {
                      result++;
                      temp=Integer.parseInt(String.valueOf(s.charAt(k)));
                     }
                     else
                          break;
                }
            if(result>max)
                max=result;
            }
        System.out.println(max+1);
    }
}

操作序列

小易有一个长度为n的整数序列,a_1,…,a_n。然后考虑在一个空序列b上进行n次以下操作:
1、将a_i放入b序列的末尾
2、逆置b序列
小易需要你计算输出操作n次之后的b序列。

输入描述:
输入包括两行,第一行包括一个整数n(2 ≤ n ≤ 2*10^5),即序列的长度。
第二行包括n个整数a_i(1 ≤ a_i ≤ 10^9),即序列a中的每个整数,以空格分割。

输出描述:
在一行中输出操作n次之后的b序列,以空格分割,行末无空格。
示例1
输入
4
1 2 3 4
输出
4 2 1 3
这个我自己做的时候是按照题目的做法，将a_i放入b序列的末尾，然后逆置b序列，最后是通过了50%的案例， 显示我的时间复杂度太大，没办法在规定的时间内完成案例的检测，先贴一下自己的代码：

import java.util.*;
public class Main{
    private static int[] b=null;
    public static void main(String args[]){
        Scanner input=new Scanner(System.in);
        int n=input.nextInt();
        int[] a=new int[n];
        b=new int[n];
        int i,j,k,result=0,temp=0,l=0;
        for(i=0;i<n;i++)
            a[i]=input.nextInt();
        for(i=0;i<n;i++){
            b[i]=a[i];
            swap(i+1);
        }
        for(j=0;j<n;j++)
            if(j==n-1)
                System.out.print(b[j]);
        else
            System.out.print(b[j]+" ");
    }
    public static void swap(int n){
      if(n<2) return;
        for(int i=0;i<=n/2-1;i++)
        { 
            int temp=b[n-1-i];
           b[n-1-i]=b[i];
            b[i]=temp;
        }
    }
}

然后在网上参考了别人的思路，就是将序列从后往前，间隔输出，最后再按顺序输出，然后自己按照这个思路写了一下代码：

import java.util.*;
public class Main{
    public static void main(String args[]){
        Scanner input=new Scanner(System.in);
        int n=input.nextInt();
        int i,j,k,start;
        int[] a=new int[n];
        for(i=0;i<n;i++){
            a[i]=input.nextInt();
        }
        for(i=n-1;i>=0;i-=2)
            System.out.print(a[i]+" ");
       // System.out.println(i);
      start=1-(i+2);
        for(i=start;i<n;i+=2){
           //     System.out.print(i);
            if(i+2>n)
                 System.out.print(a[i]);
            else
                 System.out.print(a[i]+" ");
        }
    }
}

这个是通过的。、

疯狂队列

这个自己是没有思路，参考的别人的代码，别人的思路的，作为记录，这里也贴一下别人的代码：

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();
            in.nextLine();
            int[] num = new int[n];
            for(int i=0;i<n;i++){
                num[i] = in.nextInt();
            }
            Arrays.sort(num);                                        //排序
            if(n==0 || n==1)
                System.out.println(0);
            if(n == 2)
                System.out.println(num[1]-num[0]);
            boolean b  = false;
            if(n>2) b  = true;
            int start = 1;
            int end = n-2;
            int max = num[n-1];
            int min = num[0];
            int abs = num[n-1]-num[0];
            while(start <= end){
                if(start == end){                              //最后剩下1个元素的情况
                    abs += Math.max(Math.abs(num[start]-min),Math.abs(num[start]-max));
                    break;
                }
                int maxt = num[end];
                int mint = num[start];
                abs += Math.abs(min-maxt);
                abs += Math.abs(max-mint);
                min = mint;
                max = maxt;
                start++;
                end--;
            }
            if(b)
            System.out.println(abs);
        }
    }

}

这个代码真的太美了，看起来简简单单，但是我是非常佩服作者。https://blog.csdn.net/xiao_dondon/article/details/77151479
参考的是这位大佬。