【声明】本题目来源于卡码网（题目页面 (kamacoder.com)）

【提示：如果不想看文字介绍，可以直接跳转到C++编码部分】

---

【设计模式大纲】

【简介】什么是策略模式（第14种模式）

        策略模式是⼀种⾏为型设计模式，它定义了⼀系列算法（这些算法完成的是相同的⼯作，只是实现不同），并将每个算法封装起来，使它们可以相互替换，⽽且算法的变化不会影响使⽤算法的客户。
        举个例⼦，电商⽹站对于商品的折扣策略有不同的算法，⽐如新⽤户满减优惠，不同等级会员的打折情况不同，这种情况下会产⽣⼤量的if-else语句, 并且如果优惠政策修改时，还需要修改原来的代码，不符合开闭原则。
        这就可以将不同的优惠算法封装成独⽴的类来避免⼤量的条件语句，如果新增优惠算法，可以添加新的策略类来实现，客户端在运⾏时选择不同的具体策略，⽽不必修改客户端代码改变优惠策略。

---

 【基本结构】

        策略模式包含下⾯⼏个结构：

• 策略类Strategy : 定义所有⽀持的算法的公共接⼝。
• 具体策略类ConcreteStrategy : 实现了策略接⼝，提供具体的算法实现。
• 上下⽂类Context : 包含⼀个策略实例，并在需要时调⽤策略对象的⽅法。

  

---

 【简易实现】

        下面利用Java代码对策略模式的实现流程作以说明：

1. 抽象策略类

abstract class Strategy {
    // 抽象⽅法
    public abstract void algorithmInterface();
}

2. 具体策略类1

// 2. 具体策略类1
class ConcreteStrategyA extends Strategy {
    @Override
    public void algorithmInterface() {
        System.out.println("Strategy A");
        // 具体的策略1执⾏逻辑
    }
}

3.具体策略类2

// 3. 具体策略类2
class ConcreteStrategyB extends Strategy {
    @Override
    public void algorithmInterface() {
        System.out.println("Strategy B");
        // 具体的策略2执⾏逻辑
    }
}

4. 上下文类

// 4. 上下⽂类
class Context {
    private Strategy strategy;

    // 设置具体的策略
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    // 执⾏策略
    public void contextInterface() {
        strategy.algorithmlnterface();
    }
}

5. 客户端代码

// 5. 客户端代码
public class Main{
    public static void main(String[] args) {
    // 创建上下⽂对象，并设置具体的策略
    Context contextA = new Context(new ConcreteStrategyA());
    // 执⾏策略
    contextA.contextInterface();
    Context contextB = new Context(new ConcreteStrategyB());
    contextB.contextInterface();u
    }
}

---

【使用场景】

        那什么时候可以考虑使⽤策略模式呢？

• 当⼀个系统根据业务场景需要动态地在⼏种算法中选择⼀种时，可以使⽤策略模式。例如，根据⽤户的⾏为选择不同的计费策略。
• 当代码中存在⼤量条件判断，条件判断的区别仅仅在于⾏为，也可以通过策略模式来消除这些条件语句。

        在已有的⼯具库中，Java 标准库中的 Comparator 接⼝就使⽤了策略模式，通过实现这个接⼝，可以创建不同的⽐较器（指定不同的排序策略）来满⾜不同的排序需求。

---

【编码部分】

1. 题目描述

        小明家的超市推出了不同的购物优惠策略，你可以根据自己的需求选择不同的优惠方式。其中，有两种主要的优惠策略： 

        1. 九折优惠策略：原价的90%。 

        2. 满减优惠策略：购物满一定金额时，可以享受相应的减免优惠。

具体的满减规则如下： 

        满100元减5元 

        满150元减15元 

        满200元减25元 

        满300元减40元

请你设计一个购物优惠系统，用户输入商品的原价和选择的优惠策略编号，系统输出计算后的价格。

2. 输入描述

        输入的第一行是一个整数 N（1 ≤ N ≤ 20），表示需要计算优惠的次数。 接下来的 N 行，每行输入两个整数，第一个整数M( 0 < M < 400) 表示商品的价格, 第二个整数表示优惠策略，1表示九折优惠策略，2表示满减优惠策略；

3. 输出描述

        每行输出一个数字，表示优惠后商品的价格；

4. C++ 编码实例

/**
* @version Copyright (c) 2024 NCDC, Servo。 Unpublished - All rights reserved
* @file StrategyMode.hpp
* @brief 策略模式
* @autor 写代码的小恐龙er
* @date 2024/01/16
*/

#include <iostream>
#include <string>
#include <vector>

using namespace std;

// 前置声明

// 优惠策略的抽象接口类
class AbstractStrategy;

// 优惠策略的具体实现类1 -- 打 九折 
class StrategyNineDiscount;

// 优惠策略的具体实现类2 -- 满减
class StrategyFullOut;

// 上下文类 -- 调用优惠策略类
class DiscountContext;

// 类的定义

// 优惠策略的抽象接口类
class AbstractStrategy
{
// 接口函数
public:
    // 传入参数为 商品的原始价格 返回值为优惠后的价格
    virtual int ApplyDiscount(int originalPrice) = 0;
};


// 优惠策略的具体实现类1 -- 打 九折 
class StrategyNineDiscount : public AbstractStrategy
{
// 成员函数
public:
    StrategyNineDiscount(){}
    // 重载 优惠函数
    int ApplyDiscount(int originalPrice) override {
        return (int) (originalPrice * 0.9);
    }
};


// 优惠策略的具体实现类2 -- 满减
class StrategyFullOut : public AbstractStrategy
{
// 成员数据
private:
    int _prices[4] = {100, 150, 200, 300};
    int _discounts[4] = {5, 15, 25, 40};
// 成员函数
public:
    StrategyFullOut(){}
    // 重载 优惠函数
    int ApplyDiscount(int originalPrice) override { 
        // 从最大的优惠开始判断
        int length = sizeof(_prices) / sizeof(_prices[0]);
        for(int i = length - 1; i >= 0; i--)
        {
            if(originalPrice >= _prices[i]){
                return originalPrice - _discounts[i];
            }
        }
        // 未达到满减优惠区间 
        return originalPrice;
    }
};

// 上下文类 -- 调用优惠策略类
class DiscountContext
{
// 成员数据
private:
    AbstractStrategy *_strategy;
// 成员函数
public:
    //通过传入策略基类来构造该类的实例
    DiscountContext(AbstractStrategy *strategy){
        this->_strategy = strategy;
    }    
    // 管理优惠函数
    int ApplyDiscount(int originalPrice){ 
        if(_strategy == nullptr) return 0;
        else return _strategy->ApplyDiscount(originalPrice);
    }
};

int main()
{
    // 优惠次数
    int discountNum = 0;
    // 输入
    std::cin >> discountNum;
    // 构造上下文管理类
    DiscountContext *discountContext = nullptr;
    // 构造抽象策略类
    AbstractStrategy *strategy = nullptr;
    // 遍历输入所有的价格
    for(int i = 0; i < discountNum; i++)
    {
        // 原始价格 和 优惠策略
        int originalPrice = 0;
        int discountType = 0;
        // 输入 
        std::cin >> originalPrice >> discountType;
        // 根据打折类型来操作
        if(discountType == 1){
            // 构造具体的优惠类
            strategy = new StrategyNineDiscount();
        }
        else if(discountType == 2){
            // 构造具体的优惠类
            strategy = new StrategyFullOut();
        }
        else std::cout << originalPrice << endl;
        
        discountContext = new DiscountContext(strategy);
        // 使用优惠函数
        originalPrice = discountContext->ApplyDiscount(originalPrice);
        std::cout<< originalPrice << endl;
    }
    
    // 析构
    if(strategy != nullptr){
        delete strategy;
        strategy = nullptr;
    }
    
    if(discountContext != nullptr){
        delete discountContext;
        discountContext = nullptr;
    }
    return 0;
}

---

---

......

To be continued.