面经笔记

1. 

输入一串用空格隔开的数字串，对于数字串的奇数位按升序排序，偶数位按降序排序。

示例输入：

4 6 2 3 6 7 8 1

处理过程：

奇数位：4 2 6 8 升序排序结果： 2 4 6 8

偶数位：6 3 7 1 降序排序结果： 7 6 3 1

结果输出：2 7 4 6 6 3 8 1

import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.Scanner;

/**
 * Created by Mingxiao on 10/14/2016.
 * Time: O(N*logN)
 * Space: O(N)
 */
public class Main {

    public int[] sort(int[] arr) {
        if (arr == null || arr.length <= 1) {
            return arr;
        }

        PriorityQueue<Integer> increaseQueue = new PriorityQueue<>();
        PriorityQueue<Integer> decreaseQueue = new PriorityQueue<>();
        int[] result = new int[arr.length];

        int oddIndex = 1;
        int evenIndex = 0;

        while (oddIndex < arr.length) {
            decreaseQueue.offer(arr[oddIndex]);
            increaseQueue.offer(arr[evenIndex]);

            oddIndex += 2;
            evenIndex += 2;
        }

        oddIndex -= 2;
        evenIndex = 0;

        while (evenIndex < arr.length && oddIndex > 0) {
            result[evenIndex] = increaseQueue.poll();
            result[oddIndex] = decreaseQueue.poll();
            evenIndex += 2;
            oddIndex -= 2;
        }

        return result;
    }

    public static void main(String[] args) {

        Scanner cin = new Scanner(System.in);
        ArrayList<Integer> list = new ArrayList<>();
        while (cin.hasNext()) {
            list.add(cin.nextInt());
        }


        int[] testArr = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            testArr[i] = list.get(i);
        }
        int[] result = new Main().sort(testArr);
        for (int i = 0; i < result.length; i++) {
            System.out.print(result[i] + ", ");
        }
    }
}

2.

某个字符串只存在三种格式字符分别是0~9、A~Z和a~z，请按照数字在前、大写字母次之、小写字母最后的方式排序，字符串长度不超过100。

例如：CBA321zyx

        123ABCxyz

import java.util.Scanner;

/**
 * Created by Mingxiao on 10/14/2016.
 * Time: O(N)
 * Space: O(N)
 */
public class Main {

    public static String sort(String str) {
        char[] sortArr = new char[128];
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < str.length(); i++) {
            sortArr[str.charAt(i) - 0]++;
        }

        for (int i = 48; i < sortArr.length; i++) {
            if (sortArr[i] != 0) {
                char temp = (char)i;
                for (int j = 0; j < sortArr[i]; j++) {
                    sb.append(temp);
                }
            }
        }

        return sb.toString();
    }


    public static void main(String[] args) {

        Scanner cin = new Scanner(System.in);
        String str = "";
        while (cin.hasNext()) {
            str = cin.nextLine();
        }

        System.out.print(sort(str));
    }
}

 3. 

给出两个字串A，B。将A字串转化为B字串，转化一共有两种方式:删除连续的n个字符，一次操作费用为2。增加连续的n个字符(增加的字符是什么由你决定)，一次操作费用为n+2。求把A变为B最小费用。

dsafsadfadf -> fdfd : 7
aaaaaaaa -> bbbbbbbb: 12
提示：
"dsafsadfadf" 变成 "fdfd" 最少的代价的一种方法是：
1. "dsafsadfadf" -> "f" 删除连续的10个，代价2
2. "f" -> "fdfd" 增加连续的3个（”dfd”），代价为3 ＋ 2 ＝ 5
总共的最小代价为2 ＋ 5 ＝ 7，其他方法的代价都不小于7
"aaaaaaaa" 变成 “bbbbbbbb” 最小代价的一种方法是：
1. "aaaaaaaa" 全部删除，代价2
2. 增加8个连续的'b'，代价10
总共的最小代价为2 ＋ 10 ＝ 12
注意，有些最优的方案可能要做多次的删除和增加操作，不限于两次。

import java.util.Scanner;

/**
 * Created by Mingxiao on 10/14/2016.
 * dp
 * Time: O(N^3)
 */
public class Main {

    private static final int BOUND = 2000;
    private static final int INF = Integer.MAX_VALUE;

    public static int minCost(String a, String b) {
        int l1 = a.length();
        int l2 = b.length();
        int[][] first = new int[BOUND][BOUND];
        int[][] second = new int[BOUND][BOUND];
        int[][] third = new int[BOUND][BOUND];

        for (int i = 0; i <= l1; i++) {
            first[0][i] = 2; second[0][i] = third[0][i] = INF;
        }
        for (int i = 0; i <= l2; i++) {
            second[i][0] = i + 2; first[i][0] = third[i][0] = INF;
        }
        third[0][0] = 0;
        for (int j = 1; j <= l2; j++) {
            for (int i = 1; i <= l1; i++) {
                third[j][i] = a.charAt(i - 1) == b.charAt(j - 1) ? Math.min(Math.min(third[j - 1][i - 1], second[j - 1][i - 1]), first[j - 1][i - 1]) : INF;
                second[j][i] = first[j][i] = INF;
                for (int k = 1; k <= j; k++) {
                    second[j][i] = Math.min(second[j][i], Math.min(second[j - k][i] + k, Math.min(first[j - k][i] + k + 2, third[j - k][i] + k + 2)));
                }
                for (int k = 1; k <= i; k++) {
                    first[j][i] = Math.min(first[j][i], Math.min(first[j][i - k], Math.min(second[j][i - k] + 2, third[j][i - k] + 2)));
                }
            }
        }
        return Math.min(Math.min(third[l2][l1], second[l2][l1]), first[l2][l1]);
    }

    public static void main(String[] args) {

        int counter = 0;

        Scanner cin = new Scanner(System.in);
        if (cin.hasNext()) {
            counter = cin.nextInt();
        }

        String[] strArr = new String[counter * 2];
        int index = 0;
        while (cin.hasNext()) {
            strArr[index] = cin.nextLine();
        }

        for (int i = 0; i < strArr.length; i++) {
            System.out.println(minCost(strArr[i],strArr[++i]));
        }

    }
}