<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[QAQ]]></title><description><![CDATA[好好学习，天天向上]]></description><link>https://blog.youkuaiyun.com/GLOAL_COOK</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; GLOAL_COOK]]></copyright><item><title><![CDATA[动态规划概念、01背包、完全背包]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120510508</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120510508</guid><author>GLOAL_COOK</author><pubDate>Mon, 27 Sep 2021 17:10:04 +0800</pubDate><description><![CDATA[投资分配问题
（股票投资问题）

背包问题（工厂排放问题、装载问题）




]]></description><category></category></item><item><title><![CDATA[秋招笔试题]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120489677</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120489677</guid><author>GLOAL_COOK</author><pubDate>Sun, 26 Sep 2021 15:21:44 +0800</pubDate><description><![CDATA[1.掌qu
1.单列表实现栈
class Node{
    //https://blog.youkuaiyun.com/wuzhaojun1st/article/details/78010693
    Object element;
    Node next;

    public Node(Object element) {
        this(element,null);
    }

    public Node(Object element, Node next) {
        this.]]></description><category></category></item><item><title><![CDATA[leetcode记录]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120281014</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120281014</guid><author>GLOAL_COOK</author><pubDate>Tue, 14 Sep 2021 09:57:26 +0800</pubDate><description><![CDATA[1.最长回文串
用dp：题目
class Solution {
    public String longestPalindrome(String s) {
        int len = s.length();
        // 特判
        if (len &lt; 2){
            return s;
        }

        int maxLen = 1;
        int begin  = 0;

        // 1. 状态定义
      ]]></description><category></category></item><item><title><![CDATA[System.arraycopy() 和 Arrays.copyOf()]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120221396</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120221396</guid><author>GLOAL_COOK</author><pubDate>Fri, 10 Sep 2021 14:29:41 +0800</pubDate><description><![CDATA[区别：https://blog.youkuaiyun.com/qq_32851113/article/details/90313108
system.arraycopy是复制数组中制定元素到目标数组，
arrays.copyof会创建一个新的数组，并调用了system.arraycopy。
使用参考：https://blog.youkuaiyun.com/fczheng/article/details/99624700

...]]></description><category></category></item><item><title><![CDATA[统计字符串出现个数]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120173195</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120173195</guid><author>GLOAL_COOK</author><pubDate>Wed, 08 Sep 2021 09:56:17 +0800</pubDate><description><![CDATA[private static void countString(String str){
        HashMap&lt;Character,Integer&gt; map=new HashMap&lt;&gt;();
        char[] chars = str.toCharArray();
        for (char c : chars) {
            if (map.containsKey(c)){
                Integer value = m]]></description><category></category></item><item><title><![CDATA[18、访问者模式]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120131756</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120131756</guid><author>GLOAL_COOK</author><pubDate>Mon, 06 Sep 2021 13:17:51 +0800</pubDate><description><![CDATA[【例】给宠物喂食
现在养宠物的人特别多，我们就以这个为例，当然宠物还分为狗，猫等，要给宠物喂食的话，主人可以喂，其他人也可以喂食。
访问者角色：给宠物喂食的人
具体访问者角色：主人、其他人
抽象元素角色：动物抽象类
具体元素角色：宠物狗、宠物猫
结构对象角色：主人家

//抽象元素角色类
public interface Animal {
    //接受访问者访问的功能
    void accept(Person person);
}


//抽象访问者角色类
public interface Per.]]></description><category></category></item><item><title><![CDATA[17、迭代器模式]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120129630</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120129630</guid><author>GLOAL_COOK</author><pubDate>Mon, 06 Sep 2021 11:18:20 +0800</pubDate><description><![CDATA[定义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示

【例】定义一个可以存储学生对象的容器对象，将遍历该容器的功能交由迭代器实现，涉及到的类如
下：
public class Student {
    public Student(String name, String number) {
        this.name = name;
        this.number = number;
    }

    private String name;
    pri]]></description><category></category></item><item><title><![CDATA[16、中介者模式]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120126239</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120126239</guid><author>GLOAL_COOK</author><pubDate>Mon, 06 Sep 2021 09:09:33 +0800</pubDate><description><![CDATA[【例】租房
现在租房基本都是通过房屋中介，房主将房屋托管给房屋中介，而租房者从房屋中介获取房屋信息。房屋中介充当租房者与房屋所有者之间的中介者。
类图如下：
//抽象中介者类
public abstract class Mediator {
    public abstract void constact(String message,Person person);
}


//抽象同事类
public abstract class Person {
    protected String name..]]></description><category></category></item><item><title><![CDATA[优势洗牌【田忌赛马】 贪心]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120119948</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120119948</guid><author>GLOAL_COOK</author><pubDate>Sun, 05 Sep 2021 20:06:45 +0800</pubDate><description><![CDATA[就是你知道B了，返回一个重新排序的A （能一 一对应比B把的数组）

思路：首先对A 和B进行排序，然后从A中拿出最小的和B最小的进行比较，如果还是比B小，那么就把A的那个元素丢进右边的队列中去。如果取出的A比B大，那么就在B的旁边存进列表（可以用Map模拟）中去：
 public static void main(String[] args) {
        //如果现在A和B一一比较，那么A比B小三个，输了
/*        int[] A=new int[]{10,24,8,32};
    .]]></description><category></category></item><item><title><![CDATA[Dota2参议院 【贪心】]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120112261</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120112261</guid><author>GLOAL_COOK</author><pubDate>Sun, 05 Sep 2021 12:49:23 +0800</pubDate><description><![CDATA[每次都应该把本结点往后下标最小的对手干掉。eg:RDRDD,如果R先把第三个D先干掉。那么第二个D会干掉第二个R，R必输。如果R先干掉第一个D，那么就到第二个R再禁掉D，R必赢。
思路：可以使用贪心算法，局部最优，每次干掉对手下标最小的元素，再把本身加入到队尾（所以用队列），因为要循环嘛。
public class leetcode49 {
    public static void main(String[] args) {
        String str=new String("RDDR");.]]></description><category></category></item><item><title><![CDATA[15、责任链模式]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120109939</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120109939</guid><author>GLOAL_COOK</author><pubDate>Sun, 05 Sep 2021 09:40:14 +0800</pubDate><description><![CDATA[6.4.3 案例实现
现需要开发一个请假流程控制系统。请假一天以下的假只需要小组长同意即可；请假1天到3天的假还需要部门经理同意；请求3天到7天还需要总经理同意才行。
类图如下
//请假条类
public class LeaveRequest {
    private String name;
    //请假天数
    private int num;
    //原因
    private String content;

    public LeaveRequest(String name..]]></description><category></category></item><item><title><![CDATA[打家劫舍1【递归、动态规划】]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120099678</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120099678</guid><author>GLOAL_COOK</author><pubDate>Sat, 04 Sep 2021 17:27:57 +0800</pubDate><description><![CDATA[1 、不用动态规划解法：
这道题就是求数组的下标不能连续  而且求最大和 。 不能用贪心算法哦，因为如[1,2,3]你不能取1的时候局要看2，取2的时候看和3哪个大，那么就很难取到。
用递归解：
思路：
看i-2 和i-1的情况。如果i-2 &gt; i-1 那么就取i 。
如果i-2&lt;i-1那么就取i-1，而不能取i了。
那么就是取 i-1 或者 i-2+i的
public static void main(String[] args) {
        int[] array=new int[.]]></description><category></category></item><item><title><![CDATA[14、命令模式]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120095186</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120095186</guid><author>GLOAL_COOK</author><pubDate>Sat, 04 Sep 2021 10:30:43 +0800</pubDate><description><![CDATA[public class Order {
    //餐桌号码
    private int diningTable;
    //所下的餐品及份数
    private Map&lt;String,Integer&gt; foodDir=new HashMap&lt;String,Integer&gt;();

    public int getDiningTable() {
        return diningTable;
    }

    public void setDini...]]></description><category></category></item><item><title><![CDATA[12、模板方法模式]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120094806</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120094806</guid><author>GLOAL_COOK</author><pubDate>Sat, 04 Sep 2021 09:15:23 +0800</pubDate><description><![CDATA[就是把不确定的方法定义为抽象方法，让子类实现，顺序定义为模板方法
案例：
【例】炒菜
炒菜的步骤是固定的，分为倒油、热油、倒蔬菜、倒调料品、翻炒等步骤。现通过模板方法模式来用代码模拟。类图如下：

public  abstract class AbstractClass {
    //模板方法 就是放顺序
    //为防止恶意操作，一般模板方法都加上 final 关键词。
    public final void cookProcess(){
        pourOil();
        ..]]></description><category></category></item><item><title><![CDATA[香槟塔 [找出规律解题]]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120086224</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120086224</guid><author>GLOAL_COOK</author><pubDate>Fri, 03 Sep 2021 17:31:10 +0800</pubDate><description><![CDATA[public static void main(String[] args) {
        System.out.println(champagneTower(5,2,0));
    }

    /**
     * @description:  poured倒了多少杯 query_row查那行那列的被子
     * @param: * @param: null
     * @return:
     * @author QLBF
     * @date: 2021/9/3 17:17
..]]></description><category></category></item><item><title><![CDATA[11、享元模式]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120085067</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120085067</guid><author>GLOAL_COOK</author><pubDate>Fri, 03 Sep 2021 16:38:46 +0800</pubDate><description><![CDATA[先来看类图：

//抽象享元角色
public abstract class AbstractBox {
    //获取图形的方法
    public abstract String getShape();
    //显示图形及颜色
    public void display(String color){
        System.out.println("方块形状： "+getShape()+",颜色为："+color);
    }
}


//G图形类(具体享元角色)
public...]]></description><category></category></item><item><title><![CDATA[10、组合模式]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120073610</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120073610</guid><author>GLOAL_COOK</author><pubDate>Fri, 03 Sep 2021 09:33:33 +0800</pubDate><description><![CDATA[1、概述


2、结构
组合模式主要包含三种角色：

抽象根节点（Component）：定义系统各层次对象的共有方法和属性，可以预先定义一些默认行为和属性。
树枝节点（Composite）：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。
叶子节点（Leaf）：叶子节点对象，其下再无分支，是系统层次遍历的最小单位。

3、软件菜单例子
如下图，我们在访问别的一些管理系统时，经常可以看到类似的菜单。一个菜单可以包含菜单项（菜单项是指不再包含其他内容的菜单条目），也可以包含带有其他菜单项]]></description><category></category></item><item><title><![CDATA[预测赢家-子游戏【动态规划dp】]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120053140</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120053140</guid><author>GLOAL_COOK</author><pubDate>Thu, 02 Sep 2021 21:39:08 +0800</pubDate><description><![CDATA[如果是石子游戏这道题就是先手必赢的
解法1：递归
思路：

public static void main(String[] args) {
        int[] array=new int[]{5,200,2,3,1}; //模拟石子游戏，堆数为偶，先手必赢
        //int[] array=new int[]{5,200,2,3,1};//堆数为5是奇数 先手必输
        int sum=0;
        for (int i : array) {
           ..]]></description><category></category></item><item><title><![CDATA[省份数量问题【深度优先遍历 广度优先遍历】]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120048540</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120048540</guid><author>GLOAL_COOK</author><pubDate>Wed, 01 Sep 2021 21:40:49 +0800</pubDate><description><![CDATA[使用了递归之后，时间复杂度都会变为O(n)或者O(logN)
1、深度优先
public static void main(String[] args) {
        //这个表示下标为0的城市连了自己和1号城市，没有连2号城市。
        //1号城市连了0和自己。2号城市只连了自己，所以这里省份为2.
        System.out.println(getProvince(new int[][]{{1, 1, 0}, {1, 1, 0}, {0, 0, 1}}));
       ..]]></description><category></category></item><item><title><![CDATA[9、外观模式]]></title><link>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120047290</link><guid>https://blog.youkuaiyun.com/GLOAL_COOK/article/details/120047290</guid><author>GLOAL_COOK</author><pubDate>Wed, 01 Sep 2021 19:47:53 +0800</pubDate><description><![CDATA[1、概述
有些人可能炒过股票，但其实大部分人都不太懂，这种没有足够了解证券知识的情况下做股票是很容易亏钱的，刚开始炒股肯定都会想，如果有个懂行的帮帮手就好，其实基金就是个好帮手，支付宝里就有许多的基金，它将投资者分散的资金集中起来，交由专业的经理人进行管理，投资于股票、债券、外汇
等领域，而基金投资的收益归持有者所有，管理机构收取一定比例的托管管理费用。
定义：
外观模式又名门面模式，是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，外部应用程序不]]></description><category></category></item></channel></rss>