秋招准备100天---04

呜呜呜~~~~~ 今天还是没有完成任务，每天都玩的太多，还是没有有压力。

《大话设计模式》

---

策略模式

策略模式：一般都是有一个策略基类，派生类都是各种不同的策略算法。这些算法完成的都是相同的工作，只是实现不同。
简单来说，策略模式就是来封装算法的，只要在实际开发过程中，碰到在不同场景下运用不同的算法，就可以用策略模式。
例子：超市收银台结算，有时候是原价，有时候打折，有时候满100减20，很多策略，这时候就运用策略模式。同时可以结合简易工厂模式。各种策略都是策略类的派生类，基类有个函数是输出结果。那么在简易工厂类中就可以根据不同参数创建不同策略对象，然后调用同样的函数输出结果。
比较：这个和简单的用简易工厂模式相比：简易工厂模式，需要让客户端认识两个类，一个是工厂类，一个是现金类。但是策略模式，只需要一个context类。

---

单一职责原则

对于一个类，应该只有一个引起它变化的原因。
比如说，俄罗斯方块，逻辑控制应该是一个类，界面应该是一个类。那么即使是改变平台，Android，iOS，桌面都可以用控制类。

---

开闭原则

类应该对扩展开放，对修改封闭。

---

依赖倒转规则

就像电脑设计，内存，CPU，硬盘都是分开设计，提供统一接口就可以，坏了可以再换。也就是说应该针对接口编程，不要对实现编程，低耦合高内聚。
里氏替换原则。子类可以替换掉它们的父类。也就是在一个软件实现中，原来可能都是父类对象，现在用子类对象替换掉父类对象，不会出现错误。

算法题

换钱的方法数

---

这道题第02天做过，当时第一感觉是DFS。其实有很多方法；
输入是钱的种类-数组，比如【2,5,25】，target是目标金额。

方法1：暴力递归。helper(vector money,int target,int index),表示用money[index…end]里的钱的种类，组成target的总组合数。

int helper(vector<int> &money,int target,int index) {
    int res = 0;
    if (index == money.size()) {
        if (target == 0)
            return 1;
        else
            return 0;
    }
    else {
       for (int i = 0; i <= target / (money[index]); i++) {
           res += helper(money,target - i * money[index],index+1);
       }
   }
    return res;
}

方法2： 动态规划。dp[i][j]表示用money中前i种货币，组成j元的种类数。那么转移方程就是

dp[i][j] = dp[i-1][j] + dp[i][j-money[i]]

看到这个方程时，就有两种代码，一种空间复杂度是O(M*N),另一种就是空间压缩。

int coins1(vector<int> &money,int target) {
    int res = 0;
    int n = money.size();
    vector<int> dp(target+1,0);
    dp[0] = 1;
    for (int i = 1; i <= target;i++) {
        if (i >= money[0])
            dp[i] = dp[i-money[0]];
    }
    for (int i = 1; i < n; i++) {
        for (int j = 1; j <= target; j++) {
            dp[j] = dp[j] + dp[j-money[i]];
        }
    }
    return dp[target];
}

方法3：DFS

void dfs(vector<int> &money,int target,int &res,int sum,int pos) {
    if (sum >= target) {
        if (sum == target) res++;
        return;
    }

    for (int i = pos; i < money.size(); i++) {
        dfs(money,target,res,sum+money[i],i);
    }

}