<aside> 💡

策略模式（Strategy）：定义了算法家族（这些算法完成的是相同的工作，只是实现不同），分别封装起来，让它们之间可以互相替换。此模式让算法的变化不会影响到使用算法的用户

</aside>

结构图

• 策略类（Strategy）
  • 定义所有支持的算法的公共接口。
• 具体策略类（ConcreteStrategy）
  • 继承于Strategy，封装了具体的算法或行为（实现了策略接口，提供具体的算法实现）
• 上下文类（Context）
  • 用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用
  • 包含⼀个策略实例，并在需要时调⽤策略对象的方法。

题目

https://kamacoder.com/problempage.php?pid=1082

• 不同打折策略完成的都是相同的工作（输入一个价格，根据某种算法对其进行打折）
• 不同打折策略之间可以相互替换

#include <iostream>
using namespace std;

class Strategy {
public:
    virtual int applyDiscount(int price) = 0;
    virtual ~Strategy(){};
};

class ConcreteStrategy1 : public Strategy {
public:
    int applyDiscount(int price) override {
        return price * 0.9;
    }
};

class ConcreteStrategy2 : public Strategy {
public:
    int applyDiscount(int price) override {
        if (price >= 300) {
            price -= 40;
        }
        else if (price >= 200) {
            price -= 25;
        }
        else if (price >= 150) {
            price -= 15;
        }
        else if (price >= 100) {
            price -= 5;
        }
        return price;
    }
};

// 融合了简单工厂的思想
// 传入一个选项（或具体的策略对象），调用该对象的算法方法
class Context {
public:
    Context(int type) {
        switch (type) {
        case 1:
            strategy = new ConcreteStrategy1();
            break;
        case 2:
            strategy = new ConcreteStrategy2();
            break;
        }
    }
    ~Context() {
        delete strategy;
    }

		// Context类调用该接口
    int getResult(int price) {
        return strategy->applyDiscount(price);
    }

private:
    Strategy* strategy;
};

int main() {
    int n;
    cin >> n;

    for (int i = 0; i < n; ++i) {
        int price;
        int type;
        cin >> price >> type;
        Context context(type);
        cout << context.getResult(price) << endl;
    }

    return 0;
}