LeetCode刷题记--- 650 / 5860 / pta 7-5

1. 每日吐槽

吐槽今天没有吐槽

2. leetcode每日一题

650.只有两个键的键盘

最初记事本上只有一个字符 ‘A’ 。你每次可以对这个记事本进行两种操作：

Copy All（复制全部）：复制这个记事本中的所有字符（不允许仅复制部分字符）。
Paste（粘贴）：粘贴 上一次 复制的字符。
给你一个数字 n ，你需要使用最少的操作次数，在记事本上输出 恰好 n 个 ‘A’ 。返回能够打印出 n 个 ‘A’ 的最少操作次数。

public class Solution650 {
    public int minSteps(int n) {
        return findMinValToPast(n);
    }
    int findMinValToPast(int n){
        if(n == 1){
            return 0;
        }
        int maxOfNum = 1; //n最大可被整除数
        for(int i = n / 2;i >= 1;i--){
            if(n % i == 0 && i > maxOfNum){
                maxOfNum = i;
            }
        }
        return 1 + (n - maxOfNum) / maxOfNum + findMinValToPast(maxOfNum);
    }
}

算是一个比较偶然写出来的想法吧，原理看起来符合，但是我不会证明他的合理性。

代码流程：
以n = 100 为例

先找到能整除100的最大整数—50（1和本身除外）
（表示的意义为当记事本上有50个A时，先进行复制，粘贴一次，也就是（1+（100 - 50）/ 50））

找到能整除50的最大整数—25
（表示的意义为当记事本上有25个A时，先进行复制，粘贴一次到达50个，即（1+ （50 - 25）/ 25））

找到能整除25的最大整数—5
（表示的意义为当记事本上有5个A时，先进行复制，粘贴4次，即（1+（25 - 5）/ 5））

找到能整除5的最大整数—1（这里由于没有这个数，则使用默认值maxOfNum = 1）
（表示的意义为当记事本上有一个A的时候，先进行复制，然后粘贴4次，即（1+（5 - 1）/ 1））

3. 5860 从双倍数组中还原原数组

一个整数数组 original 可以转变成一个 双倍 数组 changed ，转变方式为将 original 中每个元素 值乘以 2 加入数组中，然后将所有元素 随机打乱 。

给你一个数组 changed ，如果 change 是 双倍 数组，那么请你返回 original数组，否则请返回空数组。original 的元素可以以 任意 顺序返回。

public class Solution5860 {
    public int[] findOriginalArray(int[] changed) {
        int lenOfChange = changed.length;
        if(lenOfChange % 2 != 0){
            return new int[]{};
        }
        Arrays.sort(changed);
        List<Integer> list = new ArrayList<>();
        for(int x : changed){
            list.add(x);
        }
        int z = 0;
        int []original = new int[lenOfChange / 2];
        for(int i = lenOfChange - 1;list.size() > 0;i = list.size() - 1){
            int index = Collections.binarySearch(list,list.get(i) / 2);
            if(index < 0 || list.get(index) * 2 != list.get(i)){
                return new int[]{};
            }
            original[z++] = list.get(index);
            list.remove(i);
            list.remove(index);

        }
        return original;
    }
}

思路：先将数组从小到大排列，然后从后向前匹配，如果存在一个数是最后一个数的两倍，则将这个数放入original数组，并将这两个数删除，缩短数组长度，进行匹配的时候使用二分法，优化时间，不然会超时。。。。。

4. PTA 7-5 循环日程表

7-5 循环日程表
设有N个选手进行循环比赛，其中N=2^M ，要求每名选手要与其他N−1名选手都赛一次，每名选手每天比赛一次，循环赛共进行N−1天，要求每天没有选手轮空。

输入格式:
输入：M(M<=7)。

输出格式:
输出：表格形式的比赛安排表。一行各数据间用一个空格隔开。

输入样例:
3
结尾无空行
输出样例:
在这里给出相应的输出。例如：

1 2 3 4 5 6 7 8
2 1 4 3 6 5 8 7
3 4 1 2 7 8 5 6
4 3 2 1 8 7 6 5
5 6 7 8 1 2 3 4
6 5 8 7 2 1 4 3
7 8 5 6 3 4 1 2
8 7 6 5 4 3 2 1
结尾无空行
说明，第一行为：1 2 3 4 5 6 7 8，1表示本行都是1号选手和其他选手的比赛，如第2个数为2（其下标可以看成1）表示第一天1号和2号比赛，第5个数为5（其下标可以看成4），表示1号和5号在第4天比赛。

public class Main{

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int M = in.nextInt();
        int n = (int) Math.pow(2,M);
        int [][]matrix = new int[n][n];
        matrix[0][0] = 1;
        int d = 1;          //方形边长
        while (d != n){
            //向右方形内的每个数增加d成为一个新的方形然后方形进行交叉复制
            copyIncreaseToRight(matrix,0,0,d);
            d = d * 2;
        }
        print(matrix);

    }
    static void copyIncreaseToRight(int [][]matrix,int srcX,int srcY,int d){
        /*
        matrix 为最终矩阵
        srcX 为起始X方位
        srcY 为起始Y方位
        d 为需要复制的边长
         */
        for(int i = 0;i < d;i++){
            for(int j = 0;j < d;j++){
                matrix[srcX + i][srcY + d + j] = matrix[srcX + i][srcY + j] + d;
            }
        }
        for(int i = 0;i < d;i++){
            for(int j = 0;j < d;j++){
                matrix[srcX + d + i][srcY + d + j] = matrix[srcX + i][srcY + j];
                matrix[srcX + d + i][srcY + j] = matrix[srcX + i][srcY + d + j];
            }
        }
    }
    static void print(int [][]matrix){      //打印
        for(int i = 0;i < matrix.length;i++){
            for(int j = 0;j < matrix[0].length;j++){
            //这题我还以为输出的每一行的末尾没有空格呢，最后还是我多情了
                System.out.print(" " + matrix[i][j]);
            }
            System.out.println();
        }
    }

}

看了b站上一位老师讲解写出出来的（https://www.bilibili.com/video/BV1rp4y1X7mb）