2020-7-8 leetcode每日一题

Posted 2020-12-16 liangchangyou

跳水板

题目

你正在使用一堆木板建造跳水板。有两种类型的木板，其中长度较短的木板长度为shorter，长度较长的木板长度为longer。你必须正好使用k块木板。编写一个方法，生成跳水板所有可能的长度。

返回的长度需要从小到大排列。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/diving-board-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

你发现没有，官方把力扣写成了领扣（当然，如果领扣有其他含义，原谅我的无知）

实例

输入：
shorter = 1
longer = 2
k = 3

输出：
{3,4,5,6}

提示

• 0< shorter <= longer
• 0 <= k <= 100000

解题思路

边界情况

• 如果 k=0，则不能建造任何跳水板，此时返回空数组
• 如果 shorter == longer，则跳水板的长度是唯一的，都等于 shorter*kshorter?k，此时返回长度为 1 的数组，数组中的元素为 shorter*k

一般情况

• 返回的数组的长度：k+1

• 数组中的元素呈现出等差数列，差值如下

  • longer - shorter

• 数组的元素通过循环获取（下方是伪代码）

• 数组中的每一个元素通过遍历获取（下方是伪代码）

  • ( (longer - shorter)*i +　shorter*k ) * for(0<= i <= k+1)

C 解题

自己尝试了一下，发现写的不如官方好，直接使用官方的

#include <stdio.h>

int* divingBoard(int shorter, int longer, int k, int* returnSize); // 合并成一个文件，防止上下文问题

int main() {
    printf("Hello, World!
");
    int longer = 10;
    int shorter = 5;
    int returnSize = -1;
    int k = 5;
    
    
    int *p = divingBoard(  shorter,    longer,     k ,    &returnSize); // 指针作为函数参数，指针作为返回值
 // int*     divingBoard(int shorter, int longer, int k, int* returnSize); // 这是函数声明
    
    for(int i= 0; i <= k; i++) {
        printf("result :%d
", *(p + i));
    }
    return 0;
}


int* divingBoard(int shorter, int longer, int k, int* returnSize) {
    if (k == 0) {
        *returnSize = 0;
        return NULL;
    }
    if (shorter == longer) {
        int* p = (int*)malloc(sizeof(int));
        *p = shorter * k;
        *returnSize = 1;
        return p;
    }
    *returnSize = k + 1;
    int* res = (int*)malloc(sizeof(int) * (k + 1));
    // 不考虑排除编译优化的情况，应该尽量把循环体中的计算拿到循环体外
    int dis = longer - shorter;
    int base = shorter*k;
    for (int i = 0; i <= k; ++i) {
        res[i] = dis*i + base;
    }
    return res;
}

java解题

Java写起来就感觉简单了许多，代码如下，顺便写了一个测试代码；

// Solution.java
package com.leetCode;

public class Solution {
    public int[] divingBoard(int shorter, int longer, int k) {
        // 1.处理边界问题
        if (k == 0){
            return new int[0];
        }else if ( shorter == longer ){
            return new int[]{shorter*k};
        }
        // 2. 一般情况处理
        int dis =  longer - shorter; // 进入循环之前就计算出来这两个值
        int base = shorter*k;
        int[] ans = new int[k+1];
        for (int i = 0; i <= k; i++) {
            // ans[i] = dis*i + shorter*k; // 优化代码，减少执行次数
             ans[i] = dis*i + base;
        }
        return ans;
    }
}

编写一个测试代码：

// mainTest.java
package com.leetCode;

import java.util.Arrays;
import java.util.Random;

public class mainTest {
    public static int[] getData() {
        Random r = new Random();
        int[] array = new int[3];
        int k = r.nextInt(100000);
        int longer = -1;
        int shorter = -1;
        boolean flag = true;
        int i=0;
        while(flag){
            longer = r.nextInt(256); // 测试时，这个数别给太大，不然结果会超出 int 的范围：-2147483648——2147483647
            shorter = r.nextInt(256);
            if (longer >= shorter && longer >= 0 && shorter >= 0){
                flag = false;
            }else{ // 这样做的目的是保证longer，shorter只有两个结果：期望数值、（人为设定的）异常数值-1， 测试代码中为了方便不判断返回值是否为期望值
                longer = -1;
                shorter = -1;
            }
        }
        array[0] = k;
        array[1] = longer;
        array[2] = shorter;

        return array;
    }

    public static void main(String[] args) {
        int testNum = 1024;
        for (int i = 0; i <= testNum; i++) {
            int[] num = getData();
            Solution sol = new Solution();
            int[] res = sol.divingBoard(num[2], num[1], num[0]);
			// 打印
            int k = num[0];
            int longer = num[1];
            int shorter = num[2];
            System.out.println("测试次数：" + i);
            System.out.println("k = " + k);
            System.out.println("longer = " + longer);
            System.out.println("shorter = " + shorter);
            System.out.println(Arrays.toString(res)); // 打印数组
        }

    }
}