#include <iostream>
using namespace std;

int main() {
    // 定义三个整数变量，分别用于存储初始苹果的数量、吃一个苹果需要花费的时间以及已经过去的时间
    int m, t, s;
    // 从标准输入读取三个整数值，分别赋给m、t、s这三个变量
    cin >> m >> t >> s;

    // 判断吃一个苹果花费的时间t是否为0，如果是0，意味着出现不合理的情况（会导致后面除法运算出现除以0的错误）
    // 此时直接输出0并结束程序
    if (t == 0) {
        cout << 0;
        return 0;
    }

    // 定义一个双精度浮点数g，用于计算按照给定的过去时间s和吃一个苹果花费时间t，理论上吃掉的苹果数量（以浮点数形式体现，方便处理小数情况）
    double g;
    // 计算吃掉的苹果数量，这里1.0 * s / t是为了保证除法运算结果以浮点数形式存储，避免整数除法导致结果不准确
    // 例如，如果s = 5，t = 2，那么1.0 * s / t = 2.5，表示吃掉了2.5个苹果（从时间角度换算）
    g = 1.0 * s / t;

    // 定义一个双精度浮点数n，先将g的值强制转换为整数赋给n，这里相当于向下取整操作
    double n;
    n = int(g);

    // 判断n和g是否不相等，如果不相等，说明g有小数部分，按照题目要求（吃掉的苹果数要向上取整）
    // 需要将g的值更新为n + 1，例如，如果g是3.2，n就是3，因为n和g不相等，就把g更新为4，表示吃掉了4个苹果
    if (n!= g) {
        g = n + 1;
    }

    // 定义一个整数变量w，用于存储剩余完整苹果的数量
    int w;
    // 通过初始苹果数m减去吃掉的苹果数g来计算剩余完整苹果的数量
    w = m - g;

    // 判断剩余苹果数量w是否小于等于0，如果是，说明已经没有剩余完整的苹果了或者出现不合理的计算结果（比如计算出负数个苹果）
    // 此时直接输出0并结束程序
    if (w <= 0) {
        cout << 0;
        return 0;
    }

    // 如果剩余苹果数量w大于0，则输出w的值，也就是剩余完整苹果的实际数量
    cout << w;

    return 0;
}

1. 利用强制类型转换实现向下取整
   • 在C++中，可以通过简单的强制类型转换将浮点数转换为整数来实现向下取整。当把一个浮点数转换为整数时，C++会自动截断小数部分，这实际上就是一种向下取整的方式。
   • 示例代码如下：

   #include <iostream>
   using namespace std;
   int main() {
       double num = 5.9;
       int result = static_cast<int>(num);
       cout << "向下取整（通过强制类型转换）：" << result << endl;
       return 0;
   }
   

   • 在这个例子中，num的值是5.9，通过static_cast<int>(num)将其转换为整数，得到的结果是5。因为这种转换会直接截断小数部分，所以实现了向下取整的效果。
2. 利用数学运算实现向上取整
   • 可以通过数学运算来实现向上取整。对于一个正数x，可以使用公式int(x + 0.999999)（其中int表示强制转换为整数类型）来实现向上取整。这里0.999999（实际上可以是一个足够接近1但小于1的数）的作用是，当x的小数部分大于0时，加上这个数后再进行强制类型转换就能得到向上取整的结果。
   • 示例代码如下：

   #include <iostream>
   using namespace std;
   int main() {
       double num = 5.1;
       int result = static_cast<int>(num + 0.999999);
       cout << "向上取整（通过数学运算）：" << result << endl;
       return 0;
   }
   

   • 在这个例子中，num是5.1，num + 0.999999得到6.099999，然后通过static_cast<int>强制转换为整数，得到6，实现了向上取整。不过这种方法对于负数的处理会有问题，需要进行额外的判断和处理。对于负数x，可以使用公式int(x - 0.999999)来实现向上取整。
3. 自定义函数实现向上取整和向下取整（模拟ceil和floor函数）
   • 向下取整函数实现：
     • 思路是先判断数字的正负性。如果是正数，直接截断小数部分得到整数部分作为向下取整的结果；如果是负数，需要考虑负数的向下取整规则，例如-5.9向下取整应该是-6。
     • 示例代码如下：

     #include <iostream>
     using namespace std;
     int myFloor(double num) {
         if (num >= 0) {
             return static_cast<int>(num);
         } else {
             int intPart = static_cast<int>(num);
             if (num == static_cast<double>(intPart)) {
                 return intPart;
             } else {
                 return intPart - 1;
             }
         }
     }
     int main() {
         double num = -5.9;
         cout << "向下取整（自定义函数）：" << myFloor(num) << endl;
         return 0;
     }
     

   • 向上取整函数实现：
     • 同样先判断数字的正负性。对于正数，若小数部分不为0，则整数部分加1；对于负数，若小数部分不为0，则整数部分减1。
     • 示例代码如下：

     #include <iostream>
     using namespace std;
     int myCeil(double num) {
         if (num > 0) {
             int intPart = static_cast<int>(num);
             if (num == static_cast<double>(intPart)) {
                 return intPart;
             } else {
                 return intPart + 1;
             }
         } else if (num == 0) {
             return 0;
         } else {
             int intPart = static_cast<int>(num);
             if (num == static_cast<double>(intPart)) {
                 return intPart;
             } else {
                 return intPart - 1;
             }
         }
     }
     int main() {
         double num = -5.1;
         cout << "向上取整（自定义函数）：" << myCeil(num) << endl;
         return 0;
     }