A、牛牛打怪兽

/**
 * struct Point {
 *    int x;
 *    int y;
 * };
 */
#pragma GCC target("avx,sse2,sse3,sse4,popcnt")
#pragma GCC optimize("O2,O3,Ofast,inline,unroll-all-loops,-ffast-math")
const int N = 1e5+7;
vector<int> e[N];
int F[N],tmp[N],fa[N],son[N],cnt;

void dfs1(int x,int y){
    son[y]=x;
    fa[x]=y;
    for(auto it:e[x]){
        if(it==y)    continue;
        dfs1(it,x);
    }
}

void dfs2(int x,int y){
    tmp[x]=tmp[fa[x]]+F[x];
    for(auto it:e[x]){
        if(it==y) continue;
        dfs2(it,x);
    }
    if(son[x]==0 and tmp[x]<=2)    ++cnt;
}

class Solution {
public:
    /**
     * 返回牛牛能到达终点且不被淘汰的路径数
     * @param n int整型 
     * @param Edge Point类vector 
     * @param f int整型vector 
     * @return int整型
     */
    int solve(int n, vector<Point>& Edge, vector<int>& f) {
        // write code here
        memset(son,0,sizeof son);
        memset(fa,0,sizeof fa);
        memset(tmp,0,sizeof tmp);
        for(int i=1;i<=n;++i)    e[i].clear();
        for(auto it:Edge){
            int u=it.x,v=it.y;
            e[u].push_back(v);
            e[v].push_back(u);
        }
        for(int i=0;i<n;++i)
            F[i+1]=f[i];
        dfs1(1,0);
        cnt=0;
        dfs2(1,0);
        return cnt;
    }
};

B、牛牛的冰激凌

class Solution {
public:
    /**
     * 两个数表示答案
     * @param n int整型 一次运输的冰激凌数量
     * @param m int整型 总冰激凌数
     * @param t int整型 一次运输的时间
     * @param c int整型一维数组 表示每个冰激凌制作好时间<1e4
     * @param cLen int c数组长度
     * @return int整型vector
     */
    vector<int> icecream(int n, int m, int t, int* c, int cLen) {
        // write code here
        int st = m % n;
        if(!st)    st = n;
        sort(c,c+cLen);
        int ans = -t;
        for(int i=st-1;i<m;i+=n){
            ans += t;
            ans = max(ans,c[i]);
            ans += t;
        }
        return {ans, m / n + (m%n!=0)};
    }
};

C、数列求值

class Solution {
public:
    /**
     * 输出序列的第n项
     * @param n long长整型 序列的项数
     * @param b long长整型 系数
     * @param c long长整型 系数
     * @return long长整型
     */
    int mod = 1e9 + 7;
    typedef long long ll;

    struct Node {
        ll matrix[2][2];//结构体中的矩阵
        int mod = 1e9 + 7;
        Node() {//默认构造函数
            memset(matrix, 0, sizeof(matrix));
        }
        void one() {//单位矩阵
            for (int i = 0; i < 2; ++i)
                matrix[i][i] = 1;
        }
        Node operator*(Node other) {//矩阵运算重载*运算符
            Node ans;//记录乘积
            for (int i = 0; i < 2; i++)
                for (int j = 0; j < 2; j++)
                    for (int k = 0; k < 2; k++) {
                        ans.matrix[i][j] += matrix[i][k] * other.matrix[k][j];
                        ans.matrix[i][j] %= mod;
                    }
            return ans;
        }
    };
    Node power(Node a, ll b) {//快速幂求a的b次方
        Node res;
        res.one();//单位矩阵
        while (b) {
            if (b & 1)
                res = res * a;
            a = a * a;
            b >>= 1;
        }
        return res;
    }
    long long nthElement(long long n, long long b, long long c) {
        // write code here
        if(n==0)    return 0;
        if(n==1)    return 1;
        Node temp;
        temp.matrix[0][0] = b;
        temp.matrix[0][1] = c;
        temp.matrix[1][0] = 1;
        temp.matrix[1][1] = 0;
        Node ans = power(temp, n - 1);
        return ans.matrix[0][0];
    }
};