暴躁算法-每日练习

2022.4.11

斐波那契

非递归与递归

public static int fb(int n){
        int[] fbs = new int[n+1];
        fbs[0] = 0;
        fbs[1]=1;
        fbs[2]=1;
        for(int i =3;i<fbs.length;i++){
            fbs[i]=fbs[i-1]+fbs[i-2];
        }
        return fbs[n];
    }

//递归算法
    public static int fb2(int n){
        if(n==2||n==1){
            return 1;
        }
        return fb2(n-1)+fb2(n-2);
    }

百钱买百鸡

中国古代数学家张丘建在他的《算经》中提出了著名的“百钱买百鸡问题”：鸡翁一，值钱五，鸡母一，值钱三，鸡雏三，值钱一，百钱买百鸡，问翁、母、雏各几何？

 /**
     * 中国古代数学家张丘建在他的《算经》中提出了著名的“百钱买百鸡问题”：鸡翁一，值钱五，鸡母一，值钱三，鸡雏三，值钱一，百钱买百鸡，
     * 问翁、母、雏各几何？[可用穷举法解决]
     */
    //暴力
    public static int[] buyChicken(){
        //存放结果：翁、母、雏的数量
        int[] num = new int[3];
        //两层遍历
        for(int i = 0;i<20;i++){
            for(int j=0;j<=33;j++){
                    int res = 100-(i*5)-(j*3);
                    //满足百钱买百鸡条件
                    if(i+j+res*3==100){
                        num[0]=i;
                        num[1]=j;
                        num[2]=res;
                    }
                }
            }
        return num;
        }

汉诺塔问题。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aXeeFMXD-1649677291870)(file:///C:/Users/onlooker/AppData/Local/Temp/msohtmlclip1/01/clip_image002.gif)]

public static void hanoi(int n,char A,char B,char C)
    {
        if(n == 1)//圆盘只有一个时，只需将其从A塔移到C塔
            System.out.println("将1号盘，从a----->c");
        else
        {//否则
            hanoi(n - 1, A, C, B);//递归，把A塔上编号1~n-1的圆盘移到B上，以C为辅助塔
            System.out.println("将"+n+"号盘从"+A+"----->"+C);
            hanoi(n - 1, B, A, C);//递归，把B塔上编号1~n-1的圆盘移到C上，以A为辅助塔
        }
    }

1. 两数之和

难度简单

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

我直接反手一个暴力

public int[] twoSum(int[] nums, int target) {
        int[] ans=new int[2];
        for(int i = 0;i<nums.length;i++){
            for(int j =i;j<nums.length;j++){
                if(nums[i]+nums[j]==target){
                    ans[0]=i;
                    ans[1]=j;
                }
            }
        }
        return ans;
    }
//两层循环

优化：

• num2 的查找并不需要每次从 nums 查找一遍，只需要从 num1 位置之前或之后查找即可
• 使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N)O(N) 降低到 O(1)O(1)。

这样我们创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target - x，然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。

代码

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //建立hashmap，存储两个数。
        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
        //单层遍历
        for (int i = 0; i < nums.length; ++i) {
            //如果存在一个数，是得a+b==target，就找到了
            if (hashtable.containsKey(target - nums[i])) {
                //建立一个int数组，初始化为，a与b的下标
                return new int[]{hashtable.get(target - nums[i]), i};
            }
            //如果不在，就把他添加进去
            hashtable.put(nums[i], i);
        }
        return new int[0];
    }
}

3. 无重复字符的最长子串

难度中等

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

思路：给一个滑窗，查重使用set