网易2017秋招编程

一、
小易有一些彩色的砖块。每种颜色由一个大写字母表示。各个颜色砖块看起来都完全一样。
现在有一个给定的字符串s,s中每个字符代表小易的某个砖块的颜色。小易想把他所有的砖块排成一行。
如果最多存在一对不同颜色的相邻砖块,那么这行砖块就很漂亮的。
请你帮助小易计算有多少种方式将他所有砖块排成漂亮的一行。(如果两种方式所对应的砖块颜色序列是相同的,那么认为这两种方式是一样的。)
例如: s = “ABAB”,那么小易有六种排列的结果:
“AABB”,”ABAB”,”ABBA”,”BAAB”,”BABA”,”BBAA”
其中只有”AABB”和”BBAA”满足最多只有一对不同颜色的相邻砖块。
输入描述:
输入包括一个字符串s,字符串s的长度length(1 ≤ length ≤ 50),s中的每一个字符都为一个大写字母(A到Z)。
输出描述:
输出一个整数,表示小易可以有多少种方式。
输入例子1:
ABAB
输出例子1:
2

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        sc.close();
        Map<Character,Integer> map = new HashMap<>();
        int n = str.length();
//      最多只能一对相邻，那么最多还能有两种颜色
//      如果只有一种颜色，那么只有一种方式；有两种颜色，则可以互换，两种方式
        for(int i = 0; i < n; i++) {
            char tmp = str.charAt(i);
            if(!map.containsKey(tmp)) {
                map.put(tmp, 1);
            }
        }
        if(map.size() == 1) {
            System.out.println(1);
        }else if(map.size() == 2) {
            System.out.println(2);
        }else {
            System.out.println(0);
        }
    }
}

二、
小易有一个长度为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
输出例子1:
4 2 1 3

public class Main {
    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 < n; i++) {
            a[i] = sc.nextInt();
        }
        sc.close();
        //将奇数加入一个队列，偶数加入一个队列；再分情况倒序输出（可优化）
        Queue<Integer> q1 = new LinkedList<>();
        Queue<Integer> q2 = new LinkedList<>();
        for(int i = 0; i < n; i++) {
            if(i % 2 == 0) {
                q1.add(a[i]);
            }else {
                q2.add(a[i]);
            }
        }
        Queue<Integer> res = new LinkedList<>();
        Stack<Integer> tmp = new Stack<>();
        if(q1.size() == q2.size()) {
            while(!q2.isEmpty()) {
                tmp.add(q2.poll());
            }
            while(!tmp.isEmpty()) {
                res.add(tmp.pop());
            }
            while(!q1.isEmpty()) {
                res.add(q1.poll());
            }
        }else {
            while(!q1.isEmpty()) {
                tmp.add(q1.poll());
            }
            while(!tmp.isEmpty()) {
                res.add(tmp.pop());
            }
            while(!q2.isEmpty()) {
                res.add(q2.poll());
            }
        }
        while(res.size() > 1) {
            System.out.print(res.poll()+" ");
        }
        System.out.println(res.poll());
    }
}

三、
如果一个数列S满足对于所有的合法的i,都有S[i + 1] = S[i] + d, 这里的d也可以是负数和零,我们就称数列S为等差数列。
小易现在有一个长度为n的数列x,小易想把x变为一个等差数列。
小易允许在数列上做交换任意两个位置的数值的操作,并且交换操作允许交换多次。
但是有些数列通过交换还是不能变成等差数列,小易需要判别一个数列是否能通过交换操作变成等差数列
输入描述:
输入包括两行,第一行包含整数n(2 ≤ n ≤ 50),即数列的长度。
第二行n个元素x[i](0 ≤ x[i] ≤ 1000),即数列中的每个整数。
输出描述:
如果可以变成等差数列输出”Possible”,否则输出”Impossible”。
输入例子1:
3
3 1 2
输出例子1:
Possible

public class Main {
    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 < n; i++) {
            a[i] = sc.nextInt();
        }
        sc.close();
        //排序后比较是否等差即可
        Arrays.sort(a);
        int sub = a[1] - a[0];
        for(int i = 2; i < n; i++) {
            if(a[i] - a[i - 1] != sub) {
                System.out.println("Impossible");
                return;
            }
        }
        System.out.println("Possible");
    }
}

四、
小易为了向他的父母表现他已经长大独立了,他决定搬出去自己居住一段时间。
一个人生活增加了许多花费: 小易每天必须吃一个水果并且需要每天支付x元的房屋租金。
当前小易手中已经有f个水果和d元钱,小易也能去商店购买一些水果,商店每个水果售卖p元。
小易为了表现他独立生活的能力,希望能独立生活的时间越长越好,小易希望你来帮他计算一下他最多能独立生活多少天。
输入描述:
输入包括一行,四个整数x, f, d, p(1 ≤ x,f,d,p ≤ 2 * 10^9),以空格分割
输出描述:
输出一个整数, 表示小易最多能独立生活多少天。
输入例子1:
3 5 100 10
输出例子1:
11

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();//每天房租
        int f = sc.nextInt();//当前水果数
        int d = sc.nextInt();//当前有的钱
        int p = sc.nextInt();//每个水果价钱
        sc.close();
        int res = 0;
        //先耗完本来有的水果
        while(f != 0) {
            if(d >= x) {
                d -= x;
                res++;
                f--;
            }else {
                break;
            }
        }
        while(d >= x + p) {
            res++;
            d -= x + p;
        }
        System.out.println(res);
    }
}

五、
小易将n个棋子摆放在一张无限大的棋盘上。第i个棋子放在第x[i]行y[i]列。同一个格子允许放置多个棋子。
每一次操作小易可以把一个棋子拿起并将其移动到原格子的上、下、左、右的任意一个格子中。
小易想知道要让棋盘上出现有一个格子中至少有i(1 ≤ i ≤ n)个棋子所需要的最少操作次数.
输入描述:
输入包括三行,第一行一个整数n(1 ≤ n ≤ 50),表示棋子的个数
第二行为n个棋子的横坐标x[i](1 ≤ x[i] ≤ 10^9)
第三行为n个棋子的纵坐标y[i](1 ≤ y[i] ≤ 10^9)
输出描述:
输出n个整数,第i个表示棋盘上有一个格子至少有i个棋子所需要的操作数,以空格分割。行末无空格
如样例所示:
对于1个棋子: 不需要操作
对于2个棋子: 将前两个棋子放在(1, 1)中
对于3个棋子: 将前三个棋子放在(2, 1)中
对于4个棋子: 将所有棋子都放在(3, 1)中
输入例子1:
4
1 2 4 9
1 1 1 1
输出例子1:
0 1 3 10

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] x = new int[n];
        int[] y = new int[n];
        for(int i = 0; i < n; i++) {
            x[i] = sc.nextInt();
        }
        for(int i = 0; i < n; i++) {
            y[i] = sc.nextInt();
        }
        sc.close();
        //本题其实就是找i个距离最相近的点。
        /* 聚集点一定在x[i]和y[i]的组合中
         * 浅证明：0、设n个点到X点的总距离最短
         *  1、如果只有两个点，两个点都移到X点与一个点移到另一个点完全相同
         *  2、如果有3个点。
         *      1)若一个在X点左边，二个在X右边，那么总距离为X-左+中-X+右-X=（中-左）+（右-中）+（中-X）>中-左+右-中
         *      2)若二个在X点左边，一个在X右边，那么总距离为X-左+X-中+右-X=（X-中）+（中-左）+（右-中）>中-左+右-中
         * 3、n个点依次类推，以中点为距离最短的点
         * 因此无需考虑整个坐标轴中的点，只需考虑X和Y组合的点即可
         * 而n<=50，因此可以考虑暴力法
         */
        int[] res = new int[n];
        Arrays.fill(res, Integer.MAX_VALUE);
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                int[] dis = new int[n];
                for(int k = 0; k < n; k++) {//每个点到放置点的距离
                    dis[k] = Math.abs(x[i] - x[k]) + Math.abs(y[j] - y[k]);
                }
                Arrays.sort(dis);
                int sum = 0;
                for(int k = 0; k < n; k++) {
                    sum += dis[k];
                    res[k] = Math.min(res[k], sum);
                }
            }
        }
        for(int i = 0; i < n - 1; i++) {
            System.out.print(res[i]+" ");
        }System.out.println(res[n - 1]);
    }
}

六、
小易老师是非常严厉的,它会要求所有学生在进入教室前都排成一列,并且他要求学生按照身高不递减的顺序排列。
有一次,n个学生在列队的时候,小易老师正好去卫生间了。
学生们终于有机会反击了,于是学生们决定来一次疯狂的队列,他们定义一个队列的疯狂值为每对相邻排列学生身高差的绝对值总和。
由于按照身高顺序排列的队列的疯狂值是最小的,他们当然决定按照疯狂值最大的顺序来进行列队。
现在给出n个学生的身高,请计算出这些学生列队的最大可能的疯狂值。小易老师回来一定会气得半死。
输入描述:
输入包括两行,第一行一个整数n(1 ≤ n ≤ 50),表示学生的人数
第二行为n个整数h[i](1 ≤ h[i] ≤ 1000),表示每个学生的身高
输出描述:
输出一个整数,表示n个学生列队可以获得的最大的疯狂值。
如样例所示:
当队列排列顺序是: 25-10-40-5-25, 身高差绝对值的总和为15+30+35+20=100。
这是最大的疯狂值了。
输入例子1:
5
5 10 25 40 25
输出例子1:
100

public class Main {//待优化
    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 < n; i++) {
            a[i] = sc.nextInt();
        }
        sc.close();
        //奇数：先找最大的数，插在n/2位置处，两边顺插最小的数，再顺插最大的数
        //偶数：先找最大的数，插在n/2位置处，两边顺插最小的数，再顺插最大的数
        //结束条件：偶数，当指针相遇时，相遇数最后顺插在左边；奇数，当指针相遇时，相遇数最后同样顺插
        //还要考虑先找最小的数
        Arrays.sort(a);
        int min = 0, max = n - 1;
        int left = n / 2, right = n / 2 + 1;
        int[] b = new int[n];
        b[left--] = a[max--];
        while(min <= max) {
            if(left >= 0) {
                b[left--] = a[min++];
            }
            if(right < n) {
                b[right++] = a[min++];
            }
            if(left >= 0) {
                b[left--] = a[max--];
            }
            if(right < n) {
                b[right++] = a[max--];
            }
        }
        int[] c = new int[n];
        min = 0;
        max = n - 1;
        left = n / 2;
        right = n / 2 + 1;
        c[left--] = a[min++];
        while(max >= min) {
            if(left >= 0) {
                c[left--] = a[max--];
            }
            if(right < n) {
                c[right++] = a[max--];
            }
            if(left >= 0) {
                c[left--] = a[min++];
            }
            if(right < n) {
                c[right++] = a[min++];
            }
        }
        int res1 = 0, res2 = 0;
        for(int i = 1; i < n; i++) {
            res1 += Math.abs(b[i] - b[i - 1]);
            res2 += Math.abs(c[i] - c[i - 1]);
        }
        System.out.println(Math.max(res1, res2));
    }
}

七、
如果一个01串任意两个相邻位置的字符都是不一样的,我们就叫这个01串为交错01串。例如: “1”,”10101”,”0101010”都是交错01串。
小易现在有一个01串s,小易想找出一个最长的连续子串,并且这个子串是一个交错01串。小易需要你帮帮忙求出最长的这样的子串的长度是多少。
输入描述:
输入包括字符串s,s的长度length(1 ≤ length ≤ 50),字符串中只包含’0’和’1’
输出描述:
输出一个整数,表示最长的满足要求的子串长度。
输入例子1:
111101111
输出例子1:
3

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        sc.close();
        //贪心
        char[] ch = str.toCharArray();
        int res = 1;
        int tmp = 1;
        for(int i = 1; i < ch.length; i++) {
            if(ch[i] != ch[i - 1]) {
                tmp++;
                res = Math.max(res, tmp);
            }else {
                tmp = 1;
            }
        }
        System.out.println(res);
    }
}

八、
小易非常喜欢拥有以下性质的数列:
1、数列的长度为n
2、数列中的每个数都在1到k之间(包括1和k)
3、对于位置相邻的两个数A和B(A在B前),都满足(A <= B)或(A mod B != 0)(满足其一即可)
例如,当n = 4, k = 7
那么{1,7,7,2},它的长度是4,所有数字也在1到7范围内,并且满足第三条性质,所以小易是喜欢这个数列的
但是小易不喜欢{4,4,4,2}这个数列。小易给出n和k,希望你能帮他求出有多少个是他会喜欢的数列。
输入描述:
输入包括两个整数n和k(1 ≤ n ≤ 10, 1 ≤ k ≤ 10^5)
输出描述:
输出一个整数,即满足要求的数列个数,因为答案可能很大,输出对1,000,000,007取模的结果。
输入例子1:
2 2
输出例子1:
3

public class 小易喜欢的数列 {
    public static final int MOD = 1000000007;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        sc.close();
        //排列，考虑用动态规划
        int[][] dp = new int[n + 1][k + 1];//表示长度为i以j结尾的合法串数
        for(int i = 0; i <= k; i++) {//初始化，长度为1小于k都合法
            dp[1][i] = 1;
        }
        for(int i = 2; i<= n; i++) {
            int sum = 0;
            for(int j = 1; j <= k; j++) {//先计算i-1的合法数列数
                sum = (sum + dp[i-1][j]) % MOD;
            }
            for(int j = 1; j <= k; j++) {//对i求出每一个非法序列个数
                int except = 0;
                int p = 2;
                while(p * j <= k) {//dp[i-1][j]的j是dp[i][j]的倍数时非法
                    except = (except + dp[i-1][p*j]) % MOD;
                    p++;
                }
                dp[i][j] = (sum - except) % MOD;
            }
        }
        int res = 0;
        for(int i = 0; i <= k; i++) {
            res = (res + dp[n][i]) % MOD;
        }
        System.out.println(res);
    }
}