秋招准备100天---08

设计模式

抽象工厂模式

和工厂模式区别：工厂模式一个工厂类只能创建一个具体产品，但是有时候产品分族，这时候适合抽象工厂模式。

例子：抽象工厂模式

简单工厂，工厂模式，抽象工厂模式比较
简单工厂：优点：根据参数不同，就创建不同实例，实现简单；缺点：增加一类就会修改工厂类，不符合开闭原则；工厂类集中了所有实例创建逻辑，不适合单一职责原则。
工厂方法模式：优点：改正了简单工厂的开闭原则。缺点：增加一类就要增加一个具体工厂类。
抽象工厂：当有产品族的时候，创建抽象工厂类，具体工厂类，抽象产品类，具体产品类。

状态模式State

一个对象在内部状态发生改变，行为也会发生变化，对象看起来就像修改了它的类。
包括context类，state抽象类，ConcreteState具体状态类，
状态模式
和策略模式区别：

---

算法题

龙与地下城游戏

方法1：二维DP。dp[i][j]表示到达位置(i,j)处最少血量，那么

先找到下一个位置的最小值，是左边还是下边。

t = min(dp[i+1][j],dp[i][j+1])

用下一位置的最小值进行反推此位置的最小值。

dp[i][j] = max(1,t-mat[i][j])

int helper(vector<vector<int>>& mat) {
    int m = mat.size(),n = mat[0].size();
    vector<vector<int>> dp(m,vector<int>(n,1));
    if (mat[m-1][n-1] <= 0)
        dp[m-1][n-1] = -mat[m-1][n-1] + 1;
    for (int j = n - 2; j >= 0; j--) {
        dp[m-1][j] = max(1,dp[m-1][j+1]-mat[m-1][j]);
    }
    for (int i = m - 2; i >= 0; i--) {
        dp[i][n-1] = max(1,dp[i+1][n-1]-mat[i][n-1]);
    }
    for (int i = m - 2;i >= 0; i--) {
        for (int j = n - 2;j >= 0; j--) {
            int t = min(dp[i][j+1],dp[i+1][j]);
            dp[i][j] = max(1,t-mat[i][j]);
        }
    }
    return dp[0][0];
}

方法2：一维DP。（有空再做）

字符串的交错组成

3个字符串，str1,str2,aim,判断aim是不是str1和str2两个字符串的交错组成。

dp[i][j]表示位置(i,j)处，aim[0…i+j-1]是否是str1[0…i-1]和str2[0…j-1]的交错组成，那么

如果dp[i-1][j] == true

dp[i][j] = dp[i-1][j]\quad and\quad aim[i+j-1] == str1[i-1]

如果dp[i][j-1] == true

dp[i][j] = dp[i][j-1]\quad and\quad aim[i+j-1] == str2[j-1]

int helper(string s1,string s2,string aim) {
    int m = s1.size(),n = s2.size();
    if (aim.size() != (m+n))
        return 0;
    vector<vector<bool>> dp(m+1,vector<bool>(n+1,false));
    dp[0][0] = true;
    for (int j = 1; j <= n; j++) {
        if (s2.substr(0,j) == aim.substr(0,j))
            dp[0][j] = true;
    }
    for (int i = 1; i <= m; i++) {
        if (s1.substr(0,i) == aim.substr(0,i))
            dp[i][0] = true;
    }

    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (dp[i-1][j] && aim[i+j-1] == s1[i-1]) {
                dp[i][j] = true;
            }
            if (dp[i][j-1] && aim[i+j-1] == s2[j-1]) {
                dp[i][j] = true;
            }
        }
    }
    return dp[m][n];
}