【Java】贪心专题训练

已于 2022-06-09 17:06:31 修改
阅读量468 收藏 1
点赞数
分类专栏： 专题训练 文章标签： java 贪心算法 算法
于 2022-02-12 19:24:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51226527/article/details/122861486
版权

文章目录

题目链接

HENAU冬令营-贪心专题
密码：202202100000

知识汇总

贪心/动归/搜索 的区别
从零开始学贪心算法

题目列表

快输模板

import java.io.*;
import java.util.*;
import java.util.regex.*;
public class Main {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        boolean hasNext() {
            if (st != null && st.hasMoreTokens())
                return true;
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                return false;
            }
            return true;
        }
    }

    static PrintWriter out = new PrintWriter(
            new BufferedWriter(new OutputStreamWriter(System.out)));
    /*
    核心代码区
    */
}

A - 外币兑换

找最大汇率，美金数量*汇率即得所获人民币最大值。

	public static void main(String[] args) {
        FastReader sc = new FastReader();
        double n=sc.nextDouble();
        double a[]=new double[12];
        double max=0;
        for(int i=0;i<12;i++){
            a[i]=sc.nextDouble();
            if(a[i]>max)max=a[i];
        }
        out.printf("%.2f",max*n);
        out.flush();
    }

B - 删数问题

每次都取出第一个升序数列的末尾数字，直至取够指定次数。
注意：输出时需要判断第一位是否为0，结果不含前导0。
解法参考：删数问题

	public static void main(String[] args) {
        FastReader sc = new FastReader();
        char c[]=(sc.next()).toCharArray();
        int k=sc.nextInt(),i;
        int len=c.length;
        while(k!=0) {
            i=0;//下标，循环求升序数列的最后一个值
            while(i<len-1&&c[i]<=c[i+1]) i++;
            while(i<len-1)//取数的过程
            {c[i]=c[i+1];i++;}
            len--;//取出后数字长度减1
            k--;//消耗掉一次取出次数
        }
        int flag=1;//判断当前数字是否为第一位
        for(i=0;i<len;i++)         //输出时要小心最高位是0的问题！处理输出……
        {
            if(c[i]=='0'&&i<len-1&&flag==1)  //如果即将输出的这一位是0且是最高位而且不是最后一个
                continue;
            else {
                out.printf("%c",c[i]);flag=0;
            }
        }
        out.flush();
    }

C - 股票买卖

状态转移方程：dp[i]=Math.max(dp[i-1],a[i]-min[i])；

dp[i]:以第i个数为节点的最大利润
min[i]:第i个数前的最小值

解法参考： 股票买卖

	static int a[],minl[],maxr[],dp1[],dp2[];
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        int t=sc.nextInt();
        int n;
        while(t-->0){
            n=sc.nextInt();
            ini(n);//初始化数组
            for(int i=1;i<=n;i++)a[i]=sc.nextInt();
            minl[1]=a[1];
            dp1[1]=0;
            for(int i=2;i<=n;i++)
            {
                minl[i]=Math.min(minl[i-1],a[i]);//找到这个数之前的最小值
                dp1[i]=Math.max(dp1[i-1],a[i]-minl[i]);//求出以这个数为节点的最大利润
            }
            maxr[n]=a[n];
            dp2[n]=0;
            for(int i=n-1;i>=1;i--)
            {
                maxr[i]=Math.max(maxr[i+1],a[i]);//找到这个数之后的最大值
                dp2[i]=Math.max(dp2[i+1],maxr[i]-a[i]);//求出以这个数为节点的最大利润
            }
            int ans=-1061109567;
            //保证所找两个值不重复
            for(int i=1;i<=n;i++)ans=Math.max(ans,dp1[i]+dp2[i]);
            out.printf("%d\n",ans);
        }
        out.flush();
    }
    public static void ini(int n){
        a=new int[n+1];
        minl=new int[n+1];
        maxr=new int[n+1];
        dp1=new int[n+1];
        dp2=new int[n+1];
    }

D - 数列分段

当前和大于最大子段和，分段数+1，当前和初始化为当前数字

	public static void main(String[] args) {
        FastReader sc = new FastReader();
        int n=sc.nextInt();//数组长度
        int m=sc.nextInt();//最大子段和
        int a[]=new int[n];
        int cursum=0,count=1;
        for(int i=0;i<n;i++){
            a[i]=sc.nextInt();
            cursum+=a[i];
            //核心代码
            if(cursum>m){
                count++;
                cursum=a[i];
            }
        }
        out.println(count);
        out.flush();
    }

E - 最大子段和

	public static void main(String[] args) {
        FastReader sc = new FastReader();
        int n=sc.nextInt();
        int num[]=new int[n+1];
        for(int i=0;i<n;i++)num[i]=sc.nextInt();
        long dp[]=new long[n];
        for(int i=0;i<n;i++)//找最大子段
            if(i>0&&dp[i-1]>0)
                dp[i]=dp[i-1]+num[i];
            else
                dp[i]=num[i];
        long max=0;
        for(int i=0;i<n;i++)
            if(max<dp[i])
                max=dp[i];
        out.println(max);
        out.flush();
    }

F - 活动安排问题

解法参考：51nod 1428

	public static void main(String[] args) {
        FastReader sc = new FastReader();
        int n=sc.nextInt();
        int s[]=new int[n];
        int e[]=new int[n];
        int i,k;
        for(i=0;i<n;i++) {
            s[i]=sc.nextInt();
            e[i]=sc.nextInt();
        }
        Arrays.sort(s);
        Arrays.sort(e);
        int sum=0;
        for(i=0,k=0;i<n;i++){
            //对于某一结束时间e[k]，开始时间小于e[k]的个数，即需要教室的个数
            //相当于，对于升序排列的结束时间，统计活动时间重叠的总数
            if(s[i]<e[k]) sum++;
            else k++;
        }
        out.println(sum);
        out.flush();
    }

G - 线段

贪心策略为，优先保留结尾小且不相交的区间。在选择要保留的区间时，选择的区间结尾越小，余留给其他区间的空间就越大，就越能保留更多区间。

解法参考：Java版 视频6:25-13:30 & C++版

Java 得分70.0/100.0（TLE）

	public static void main(String[] args) {
        FastReader sc = new FastReader();
        int n=sc.nextInt();
        int line[][]=new int[n][2];
        for(int i=0;i<n;i++){
            line[i][0]=sc.nextInt();
            line[i][1]=sc.nextInt();
        }
        Arrays.sort(line, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[1]-o2[1];
            }
        });
        int sum=1;
        int pre=line[0][1];
        for(int i=1;i<n;i++){
            if(pre<=line[i][0]){
                sum++;
                pre=line[i][1];
            }
        }
        out.println(sum);
        out.flush();
    }

C++ 得分100.0/100.0 （AC）

#include<bits/stdc++.h>
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
typedef pair<int,int> Pair;

const int N=1e6+5;
int n,i;
Pair p[N];
bool cmp(Pair a,Pair b)
{
    return a.second<b.second;
}
int main()
{
    IOS;
    while(cin>>n){
        for(i=0;i<n;i++){
            cin>>p[i].first>>p[i].second;
        }
        sort(p,p+n,cmp);
        int pre=p[0].second,ans=1;
        for(i=1;i<n;i++){
            if(pre<=p[i].first){
                pre=p[i].second;
                ans++;
            }
        }
        cout<<ans<<endl;
        break;
    }
    return 0;
}

H - 定价

重点在于优化枚举过程，某一区间内算得荒谬度最小值相同，而区间的判断与末尾0的个数有关。
解法参考： BZOJ4029-定价

	/**
     * 枚举时，一定区间内答案可能相同。
     * 例如，对于1200~1299区间，荒谬度最小值都是4。
    */
    static int cnt[]={1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000};
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        int T=sc.nextInt();
        int l,r;
        while(T-->0) {
            l=sc.nextInt();
            r=sc.nextInt();
            int ans=0,min=20;
            for(int i=l;i<=r;i+=cnt[getInterval(i)]) {
                //结尾是5，荒谬度为2*a-1；否则为2*a
                int degree=2*getDigit(i)-getLast(i);
                if(min>degree) {
                    min=degree;
                    ans=i;
                }
            }
            out.println(ans);
        }
        out.flush();
    }
    //针对cnt[]数组求下标。即是末尾0的个数。
    public static int getInterval(int x){
        int i=0;
        while (x%10==0){
            x/=10;
            i++;
        }
        return i;
    }
    //求一个数的最后一位非零数的值。如果是5，则返回1，否则返回0。
    public static int getLast(int x){
        while(x%10==0)x/=10;
        int tp=x%10;
        if(tp==5)return 1;
        else return 0;
    }
    //求一个数不含末尾0的位数
    public static int getDigit(int x){
        int sum=0;
        while(x%10==0)x/=10;
        while(x!=0){
            x/=10;sum++;
        }
        return sum;
    }

I - 排队接水

当前所有人等待时间=当前接水时间*当前人数总和。
即排队时，越靠近前面的计算次数越多，因此越小的排在越前面得出的结果越小。

	public static void main(String[] args) {
        FastReader sc = new FastReader();
        int n=sc.nextInt();
        int t[]=new int[n];
        for(int i=0;i<n;i++)t[i]=sc.nextInt();
        Arrays.sort(t);
        long sum=0;
        for(int i=0;i<n;i++)sum+=(n-i)*t[i];
        out.println(sum);
        out.flush();
    }

J - 拼成最小的数 V2

任意两个字符串（将数字转为字符串）a和b，根据a+b和b+a的字典序进行比较。字典序较小则排在前面。
解法参考：51nod 2986

	public static void main(String[] args) {
        FastReader sc = new FastReader();
        int n=sc.nextInt();
        Integer id[]=new Integer[n];
        String s[]=new String[n];
        for(int i=0;i<n;i++){
            id[i]=i;
            s[i]=sc.next();
        }
        //比较的是下标，而不是字符串
        Arrays.sort(id,new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return (s[o1]+s[o2]).compareTo(s[o2]+s[o1]);
            }
        });
        for(int i=0;i<n;i++)out.print(s[id[i]]);
        out.flush();
    }

K - Huffman coding tree

题意 - 输出哈夫曼树的WPL（带权路径长度）
题目翻译：OpenJudge - Huffman编码树
解法参考：哈夫曼树的WPL值的计算
即WPL=（哈夫曼树）非叶子节点值之和

	public static void main(String[] args) {
        FastReader sc = new FastReader();
        int n=sc.nextInt();
        PriorityQueue<Integer> pq=new PriorityQueue<>
                (new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;//升序排列
            }
        });
        int w,wpl=0;
        for(int i=0;i<n;i++){
            w=sc.nextInt();
            pq.add(w);
        }
        int a,b,tp;//每次取最小的两个值,tp为a+b(即非叶子节点)
        while(pq.size()>=2){
            a=pq.poll();
            b=pq.poll();
            tp=a+b;
            wpl+=tp;
            pq.add(tp);
        }
        out.println(wpl);
        out.flush();
    }

L - 货币系统

为满足 (m,b) 与原来的货币系统 (n,a) 等价，则面额数组b是面额数组a的子数组；为使m 尽可能的小，则应使面额数组b中的任意元素不能被其他元素所表示。
题目链接：AcWing 532. 货币系统
解法参考：货币系统（完全背包问题）

	public static void main(String[] args) {
        FastReader sc = new FastReader();
        int T=sc.nextInt();
        int n,ans;
        int num[],dp[];
        while(T-->0){
            ans=0;
            n=sc.nextInt();
            num=new int[n];
            for(int i=0;i<n;i++)num[i]=sc.nextInt();
            //先排序, 然后判断每一个num[i]是否可以由之前的num[0]~num[i-1]构成
            //num[0]~num[i-1]可以选择无限个
            Arrays.sort(num);
            int tp=num[n-1];//num[n-1]=max
            dp=new int[tp+1];//0~max
            dp[0]=1;
            for(int i=0;i<n;i++){
                //判断当前的num[i]是否可以由之前的num[0]~num[i-1]表示出来
                //dp[i]表示面额为i的时候的方案数目
                if(dp[num[i]]==0) ans++;
                for(int j=num[i];j<tp+1;j++)dp[j]+=dp[j-num[i]];
            }
            out.println(ans);
        }
        out.flush();
    }

M - 反素数ant

解法参考：反素数ant(唯一分解定理的应用)

	//不超过N的最大的反质数:约数个数最多的数中的最小值
    static int n,ps[]={2,3,5,7,11,13,17,19,23,29,31},min,sum;
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        n=sc.nextInt();
        dfs(0,30,1,1);
        out.println(min);
        out.flush();
    }
    //idx引用质因子数组下标，limit限制当前因子的个数，cur表示当前数字，s表示约数个数
    public static void dfs(int idx,int limit,int cur,int s){
        //当cur的约数个数更多，或cur是约数个数最多的数中的更小值，则更新答案
        if(s>sum||s==sum&&cur<min){
            min=cur;sum=s;
        }
        /*举例：(模拟搜索过程)
        >>> n = 7 ; min = 6
        dfs先搜索到6，s = 1 * (1+1) * (1+1) = 4
        然后搜索到4，s = 1 * (2+1) = 3
         */
        for(int i=1;i<=limit;i++){
            if((long)cur*ps[idx]>n)break;
            cur*=ps[idx];
            dfs(idx+1,i,cur,s*(i+1));
        }
    }

N - 接水问题二

解法参考：接水问题二
关于排序：（第i个人的重要性是a[i]，需要b[i]的时间来接水）

1在前,2在后 sum = a[1] * b[1] + a[2] * ( b[1] + b[2] )
2在前,1在后 sum = a[2] * b[2] + a[1] * ( b[1] + b[2] )
所以只需要让 a[2] * b[1] < a[1] * b[2] 即可。

	public static void main(String[] args) {
        FastReader sc = new FastReader();
        int n=sc.nextInt();
        int p[][]=new int[n][2];
        for(int i=0;i<n;i++){
            p[i][0]=sc.nextInt();//重要性
            p[i][1]=sc.nextInt();//等待时间
            if(p[i][0]==0||p[i][1]==0) {
                //时间或者重要性为0时，它可以不出现，避免对后面时间的计算造成影响
                i--;n--;
            }
        }
        Arrays.sort(p, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[1]*o2[0]-o1[0]*o2[1];
            }
        });
        long time=0,sum=0;//每个人的等待时间 & 等待时间乘以自己的重要性的总和
        for(int i=0;i<n;i++) {
            time+=p[i][1];
            sum+=time*p[i][0];
        }
        out.println(sum);
        out.flush();
    }

O - 部分背包

洛谷P2240
按单位价值降序的度量来判断是否选取

	public static void main(String[] args) {
        int n=sc.nextInt();//金币个数
        int t=sc.nextInt();//背包承重量
        Node node[]=new Node[n];
        for(int i=0;i<n;i++){
            node[i]=new Node(sc.nextInt(),sc.nextInt());
            node[i].avg=node[i].v*1.0/node[i].m;
        }
        Arrays.sort(node);
        double ans=0,weight=0;
        for(int i=0;i<n;i++){
            if(weight+node[i].m<=t){
                weight+=node[i].m;
                ans+=node[i].v;
            }else{
                ans+=node[i].avg*(t-weight);
                break;
            }
        }
        out.printf("%.2f",ans);
        out.flush();
    }

class Node implements Comparable<Node>{
    int m,v;//总重量 & 总价值
    double avg;
    public Node(int m,int v){
        this.m=m;this.v=v;
    }

    @Override
    public int compareTo(Node o) {
        return o.avg>avg?1:-1;
    }
}
MN979323
关注
专栏目录
【Py/Java/C++/C/JS/Go六种语言OD独家2024E卷真题】20天拿下华为OD笔试之【贪心】2024E-机房布局【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
11-11 22
可上练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）
Java、Android背包问题（一）——贪心算法
https://github.com/W4ited
11-26 1278
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不
算法学习———贪心算法（Java版）
Sencq的博客
10-08 1953
贪心算法：通过实现部分最优解从而达到整体最优
【贪心专题】—— 贪心算法入门篇
欢迎来到我的世界
05-20 6378
通俗易懂的贪心入门【不要太贪心，520快乐】
Java刷题总结——贪心算法篇
weixin_43381762的博客
08-07 222
通过山坡法判断有几个峰值，即峰值为：或者本题要考虑三种情况：（1）上下坡中有平坡 即：允许prediff = 0（2）数组首尾两端（3）单调坡中有平坡遇到负数时不跳过，当count小于0时才重新置零计数如果能走到，那步数加1。
基础算法模板（八）—— 贪心
JohnnyLin
03-18 253
区间问题 AcWing 905. 区间选点 【题目描述】 AcWing 905. 区间选点 类似题目 AcWing 112. 雷达设备 【思路】 每一个区间就是一条线段，将区间按终点从小到大排序。 当该线段与上一条线段没有重合的地方即要加入新的点。 import java.util.Scanner; import java.util.Arrays; class Node implements Comparable<Node>{ int a, b; public Node(in
【寒假训练/Java】贪心专题
m0_51226527的博客
02-03 286
A - 最小生成树 B - [USACO 2006 Oct S]Fence Repair C - money D - 大吉大利，今晚吃鸡——枪械篇 E - 世界上最可爱的珂朵莉 F - 牛牛的排序 G - 牛牛的朋友 H - 货币系统（完全背包） I - [CQOI2014]通配符匹配（DP&字符串哈希） J - 牛牛学括号 K - [HAOI2008] 糖果传递（数学&贪心） L - 青蛙（二分） M - 吃货（二分）
贪心类题目专题训练 -- LeetCode上10道与贪心相关的题
今天你学习了吗？
02-21 988
这个专题中的题目是我跟随代码随想录的刷题计划，在LeetCode上做的与贪心相关的题目，用于加深对贪心的理解！ 下面的内容将会有每一道题目的题意、在代码随想录中对应的参考文章、我的思路以及我所写的Java代码，希望对你有帮助！ 目录1 - LeetCode 455 分发饼干 1 - LeetCode 455 分发饼干 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/assign-cookies 题意： 假设你是一位很棒的家长，想要给你的孩子们一些小饼
贪心算法专题
eck_燃的博客
01-18 762
贪心本质 一个贪心算法总是做出当前最好的选择，也就是说，它期望通过局部最优选择从而得到全局最优的解决方案。 ——《算法导论》 贪心算法的特点 贪心算法在解决问题只根据当前已有的信息就做出选择，而且一旦做出了选择，这个选择都不会改变。换言之，贪心算法并不是从整体最优考虑，它所做出的选择只是在某种意义上的局部最优。贪心算法能得到许多问题的整体最优解或整体最优解的近似解。因此，贪心算法在实际...
贪心专题
林下的码路
05-03 1095
Robbers Special Judge Time Limit: 2000/1000MS (Java/Others) Memory Limit: 128000/64000KB (Java/Others) Submit Statistic Next Problem Problem Description       N robbers have robbed the
2023最新版Java学习路线图-第6阶段大厂面试专题
07-17
### 2023最新版Java学习路线图-第6阶段大厂面试专题 #### Java学习路线概述 本文档提供了一份详细的2023年Java学习路径，旨在帮助那些希望在IT行业，尤其是大型互联网公司中寻找工作的Java开发者们更好地准备面试...
算法面试专题课(Java版)，Google面试官带你高质量刷题视频教程
08-11
"算法面试专题课(Java版)，Google面试官带你高质量刷题视频教程"提供了一种高效的学习方式，旨在帮助求职者提升自己的算法水平，更好地应对包括Google在内的顶级科技公司的面试挑战。 本课程主要涵盖了以下几个方面...
【动态规划专题】：Java程序员的算法知识宝库
# 1. 动态规划算法简介 ## 1.1 理解动态规划 动态规划是解决具有重叠子问题和最优子结构性质的问题的一种方法。它将复杂问题分解为更小的子问题，通过解决这些子问题来构建原问题的解。动态规划通常用于优化问题，...
Servlet的生命周期
wyk的博客
11-13 1391
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
w042基于web的IT技术交流和分享平台的设计与实现
最新发布
卓怡工作室的博客
11-18 740
我国科学技术的不断发展，计算机的应用日渐成熟，其强大的功能给人们留下深刻的印象，它已经应用到了人类社会的各个层次的领域，发挥着重要的不可替换的作用。信息管理作为计算机应用的一部分，使用计算机进行管理，具有非常明显的优点，利用网络的优势特开发了本基于SpringBoot的IT技术交流和分享平台。 本IT技术交流和分享平台是基于SpringBoot框架，采用Java技术，MYSQL数据库进行开发的。系统具有灵活的一体化设计方式，圆满完成了整个系统的界面设计。本系统实现了用户功能模块和管理员功能模块两大部分，
Mybatis
庸不易的博客
11-15 837
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
java加锁问题详解
qq_74056922的博客
11-14 813
java(JVAM)对加锁的API进行了封装,通过使用synchronized关键字来完成加锁操作。
什么是面向对象编程？什么是面向过程编程？
m0_70208894的博客
11-15 675
不同的编程范式适用于不同的场景，选择合适的范式可以提高代码的可维护性、可读性和效率。Java 和 Go 的选择反映了不同的设计哲学，Java 更加注重封装和对象的使用，而 Go 更加简洁，强调过程和函数的使用。
如何合理设计一套springcloud+springboot项目中的各个微服务模块之间的继承关系的最优方案
tigerhhzz的博客
11-14 1179
文章目录一、模块化设计所遵循的原则二、项目架构设计三、各个模块作用说明3.1 core 模块3.2 common 模块3.3 generatorcode模块3.4 business 模块3.5 web 模块3.6 admin 模块3.7 父pom四、采用import引入SpringBoot 在springcloud微服务项目中经常用到多模块化的架构设计，随着业务模块的增多，各个服务模块之间的依赖关系就越来越复杂；本文从项目起初的搭建，给出一套Model优秀设计方案。 一、模块化设计所遵循的原则 单一职责
Java贪心算法实现与应用详解
文章通过多个经典实际案例展示了贪心算法在问题解决中的应用，并提供了使用Java编程语言实现贪心算法的代码示例和对不同问题优化思路的详细解析。适用人群广泛，包括编程初学者、计算机科学专业学生、软件开发人员和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值