算法刷题-2025年02月22日

import java.util.Arrays;

public class test_02_22 {
    //TODO redis在项目中应用了缓存、和保存token(保存用户会话信息) 还有采取了分布式锁
    //TODO 发布/订阅（Pub/Sub） 模型 运行用户实现消息队列
    //允许客户端订阅一个频道（Channel），并接收该频道发布的消息。
    //这种方式适用于广播消息和实时通知系统，其中多个订阅者可以实时接收到发布者发布的消息。

    //编制：对于每个好友都会存在一个喜爱度，采取set进行实现，进而保证无重复
    //共同好友 采取redis中的set数据结构

    //分发饼干 尽可能的满足大多数的孩子胃口值[1,2,3] 尺寸[1，1]
    public static void test1(int[] g, int[] s){
        //按照从小至大进行排序 i, j
        Arrays.sort(g);
        Arrays.sort(s);
        int i=0;
        int j=0;
        int count =0;
        while (iprices[i]){
                res+=prices[i+1]-prices[i];
            }
        }
        System.out.println(res);
    }
    //跳跃游戏-进了避免遇见0
    public static boolean test5(int[] nums){
        for (int i=0;i=0;j--){
                    if (nums[j]!=i-j){
                        flag=false;
                        break;
                    }
                }
            }
            if (nums[i]==0&&flag){
                return false;
            }
        }
        return true;
    }
    //想起树的结构就采取一个递归方法进行求解
    //static int min=Integer.MAX_VALUE;
    //跳跃游戏II-返回到达num[i-1]的最小跳跃次数
    //[2,3,1,1,4]-不一定是尽可能多跳 还有一个步数
    public static int test6(int[] nums, int i, int step, int min){
        //跳结束了
        if (i>=nums.length-1){
            return Math.min(min, step);
        }
        //判断是否跳至0处
        if (nums[i]==0){
            return min;
        }
        //找跳的次数最少的 类似于一刻树 可以用递归吧
        for (int j=1;j<=nums[i];j++){
            //继续往后跳 将当前步数传入 将结果保存下来
            min = test6(nums, i+j, step+1, min);
        }
        return min;
    }
    //斐波拉契数-解法1
    public static void test7(int n){
        int[] dp=new int[n];
        dp[0]=0;
        dp[1]=1;
        for (int i=2;i=coins[j]){
                    dp[i][j]=dp[i-coins[j]][j]+dp[i][j-1];
                }else{
                    //兑换不了 只能移动至上一种硬币进行兑换
                    dp[i][j]=dp[i][j-1];
                }
            }
        }
        System.out.println(dp[dp.length-1][dp[0].length-1]);
    }

    public static void test13(int[] coins, int amount) {
        int[] dp = new int[amount + 1];
        // 将 dp[0] 初始化为 0，表示金额为 0 不需要硬币
        dp[0] = 0;

        // 其他金额初始化为一个较大的值（假设金额无法兑换）
        for (int i = 1; i <= amount; i++) {
            dp[i] = Integer.MAX_VALUE;
        }

        // 动态规划更新 dp 数组
        for (int i = 1; i <= amount; i++) {
            for (int j = 0; j < coins.length; j++) {
                if (i >= coins[j] && dp[i - coins[j]] != Integer.MAX_VALUE) {
                    dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
                }
            }
        }

        // 输出结果
        System.out.println(Arrays.toString(dp));

        // 如果 dp[amount] 是 Integer.MAX_VALUE，说明没有办法兑换这个金额
        if (dp[amount] == Integer.MAX_VALUE) {
            System.out.println("无法兑换该金额");
        } else {
            System.out.println("最少硬币数: " + dp[amount]);
        }
    }

    //回文子串-找出回文子串的数量
    public static void test14(String s){
        int n=s.length();
        //建立dp数组
        int[][] dp = new int[n][n];
        for (int i=0;i=0;j--){
                if (test15(s, j,i)){
                    tempMax = Math.max(tempMax, i-j+1);
                }
            }
            //遍历完成以后
            dp[i]=Math.max(dp[i-1],tempMax);
        }
        System.out.println(Arrays.toString(dp));
    }

    public static void test17(String s){
        int n=s.length();
        int[][] dp= new int[n][n];
        for (int i=0;i