跳转至

母牛生小牛问题(静态数据成员与静态成员函数)

时间限制: 1 Sec 内存限制: 128 MB

题目描述

假设母牛从出生起第4个年头开始每年可以生一头小母牛，但是第11年后死亡。按此规律，第n年时有多少头母牛？(假设n不大于30)

定义一个母牛类CCow，能够用动态创建和撤消类对象的方式来模拟小母牛的出生和死亡规律。试编写C++程序完成上述计算。

输入

第一行输入测试次数

每次测试输入一行，表示第几年的整数n(<=30)

输出

每次测试输出一行，第n年的母牛总数

样例输入

1
2
3
4
3
7
30
25

样例输出

1
2
3
6
28364
4530

提示

解决方案

额，写完才看到标题...懒得改了，事实上只要去掉Solver类再稍加改动就可以符合要求。

这里主要思路就是相当于有一个上帝视角：std::vector<Cow *> cows，看着所有的牛。每次循环意味着过去一年，于是让所有牛成长、出生或是死亡。

更新：突然发现还忘记delete，别锤我...

另外每次改动容器时某些情况会让迭代器失效，太久没看《Effective STL》了，有空找来这里补上一点东西。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include <iostream>
#include <vector>

class CowSolver {
public:
    explicit CowSolver(int limit) : limit(limit) {
        cows.push_back(new Cow());
        for (int i = 1; i < limit; ++i) {
            growUp();
            create();
            kill();
        }
    }

    void println() {
        std::cout << cows.size() << std::endl;
    }

private:
    struct Cow {
        Cow() : age(1) {}

        int age;
    };

    int limit;
    std::vector<Cow *> cows;

    void growUp() {
        for (auto item : cows) {
            item->age += 1;
        }
    }

    void create() {
        for (int i = 0; i < cows.size(); ++i) {
            if (4 <= cows[i]->age && cows[i]->age < 11) {
                cows.push_back(new Cow());
            }
        }
    }

    void kill() {
        for (auto it = cows.begin(); it != cows.end();) {
            if ((*it)->age == 11) {
                it = cows.erase(it);
            } else {
                ++it;
            }
        }
    }
};

int main() {
    int T;
    std::cin >> T;

    while (T--) {
        int year;
        std::cin >> year;

        CowSolver cowSolver(year);
        cowSolver.println();
    }

    return 0;
}

评论