❤️大厂编程题实战+Leecode练习

Posted 2021-09-21 full-chair

前言+说明

❤️旺仔兄弟们！如果觉得博主分享的不错，希望能留下您的一键❤️三连❤️（点赞+评论+收藏） ，您的支持就是我的动力❤️，您的三连对我特别重要。
注明：下述题目只用于学习交流所用，禁止用于商业销售。同时在题解方面也希望大家能提出宝贵建议，共同进步❤️！

一、斐波那契数（Leecode_509）

题目描述：
斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
     F(0) = 0，F(1) = 1
     F(n) = F(n - 1) + F(n - 2)，其中 n > 1
     给你 n ，请计算 F(n) 。

样例1：

输入： 2
输出： 1
解释: F(2) = F(1) + F(0) = 1 + 0 = 1

样例2：

输入： 3
输出： 2
解释: F(3) = F(2) + F(1) = 1 + 1 = 2

样例.3：

输入： 4
输出： 3
解释: F(4) = F(3) + F(2) = 2 + 1 = 3

【方法一】：递归
参考代码：

import java.util.Scanner;

public class Leecode509_Fib {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int ans = fib(n);
        System.out.println(ans);
    }
    public static int fib(int n){
        if (n<=1){
            return n;
        }else{
            return fib(n-1) + fib(n-2);
        }
    }
}

【结果裂开啦】

【方法二】：滚动数组
斐波那契数的边界条件是 F(0)=0和 F(1)=1。当 n>1 时，每一项的和都等于前两项的和，因此有如下递推关系：F(n)=F(n−1)+F(n−2)
由于斐波那契数存在递推关系，因此可以使用动态规划求解。动态规划的状态转移方程即为上述递推关系，边界条件为 F(0) 和 F(1)。
根据状态转移方程和边界条件，可以得到时间复杂度和空间复杂度都是 O(n) 的实现。由于 F(n) 只和 F(n−1)与 F(n−2)有关，因此可以使用「滚动数组思想」把空间复杂度优化成 O(1)。

参考代码：

import java.util.Scanner;

public class Leecode509_Fib {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int ans = fib(n);
        System.out.println(ans);
    }
    public static int fib(int n){
        int[] arr = new int[3];
        arr[0] = 0;arr[1]=1;
        if (n<=1){
            return n;
        }
        for (int i=2; i<=n; i++){
            arr[0] = arr[1];
            arr[1] = arr[2];
            arr[2] = arr[0]+arr[1];
        }
        return arr[2];
    }
}

---

二、字节跳动编程题（数列变换）

时间限制： 3000MS
内存限制： 1048576KB
题目描述：
存在两个长度相等数列a和b，其中存储的是正整数，判断有没有一个操作能使a数列变化成b数列。
操作：在数列a中选取一个区间a[l] - a[r]，对这个区间中的所有数字加上一个正整数k。
其中，1 ≤ l ≤ r ≤ n，k ≥ 0。

输入描述

第一行： 表示 t 组数据；
第二行：n₁​表示数列的长度；
第三行：X₁    X₂   X₃   …   X _n 表示a数列
第四行：Y₁    Y₂   Y₃   …   Y _n 表示b数列
…
接下来k行为其它 t-1 组数据

输出描述

YES或者NO

样例输入

2
6
3    7    1    4    1    2
3    7    3    6    3    2

样例输出

 YES
 NO

规则

请尽量在全场考试结束10分钟前调试程序，否则由于密集排队提交，可能查询不到编译结果，点击“调试”亦可保持代码
编程题可以使用本地编译器，此页面不记录跳出次数

解题思路：
（1）用两个整数型数组分别来存放数列a、数列b；
（2）同时遍历数列a和数列b
   （2.1）如果数列相同位置值相同则继续遍历
   （2.2）如果数列相同位置值不相同：
        （2.2.1） 判断值不同的数组位置是否连续，不连续输出NO，连续的继续遍历;
        （2.2.2） 判断两数组相差的值相同且b数列的值 - a数列的值大于0，则继续遍历，否则输出NO;
（3）如果全部遍历完成且满足条件则输出YES。
参考代码：

import java.util.Arrays;
import java.util.Scanner;

public class Test01_Arrays {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String[] ans = new String[n];
        for (int i=0; i<n; i++){
            int m = sc.nextInt();
            int[] list1 = new int[m];
            int[] list2 = new int[m];
            for (int j=0; j<m; j++){
                list1[j] = sc.nextInt();
            }
            for (int j=0; j<m; j++){
                list2[j] = sc.nextInt();
            }
            if (isTransform(list1,list2)){
                ans[i]="YES";
            }else {
                ans[i]="NO";
            }

        }
        for (int i=0; i<ans.length; i++){
            System.out.println(ans[i]);
        }
    }
    public static boolean isTransform(int[] list1, int[] list2){
        if (list1.length==0 || list2.length==0){
            return false;
        }

        int temp=0;
        int point = 0;
        for (int i=0; i<list1.length; i++){
            if (list1[i] == list2[i])
                continue;
            if (list1[i] != list2[i]){
                if (point!=0 && point+1!=i){//判断是区间需要连续，如果不连续则返回false
                    return false;
                }
                point = i;
                if ((temp<0 || temp!=list2[i]-list1[i]) && temp!=0){//temp必须为正整数
                    return false;
                }
                temp = list2[i] - list1[i];
            }
        }
        return true;
    }
}