A

分类：思维题
这个题就是一个鸟题

判断两种情况，一种就是x >= n, 表示能直接飞到悬崖对侧，直接x * n即可； 另一种就是飞不过去，直接输出x.(当时做这个题的时候脑子瓦克了，竟然输出0，简直不要太爽)

using namespace std;

int main()
{
    long long x, n;
    cin >> x >> n;
    
    if(x >= n)
    cout << x * n;
    else 
    cout << x; 
    
    return 0;
}

B

分类：思维题
正解好像是等差
直接用dfs枚举n层不久好了吗，懒得思考

using namespace std;

typedef long long LL;

LL n, ans;

void dfs(LL cnt, LL u){//cnt从1开始 如同dfs(1)
    if(u == n) return;
    
    for(LL i=1;i<=cnt;i++)ans++;
    dfs(cnt+2, u + 1);
}

int main()
{
    cin >> n;
    
    dfs(1, 0);
    
    cout << ans;
    
    return 0;
}

C

分类：贪心, 思维
就是一道贪心的题目，先把分组最多化，然后把对3取余剩下的数分配到4中即可，如果剩下的大于组数，就会无法完整分完，把最后依旧剩下的减去就好了；

using namespace std;

typedef long long LL;

int a[8];

int main(){
    
    LL ans = 0;
    
    for(int i = 1; i <= 8; i ++ ) {
        cin >> a[i];
    }
    
    for(int i = 1; i <= 8; i ++ ) {
        int x = a[i] / 3, y = a[i] % 3;
        a[i + 1] += x;
        ans += a[i] * i;
        if(y > x) ans -= (y - x) * i;
    }
    
    cout << ans;
    
    return 0;
    
}

D

分类：数学
注意审题：题目说的是前缀左括号数 >= 右括号数，所以说要判断这个情况； 可以用一个len来保证左括号和右括号的差值，差值等于，记录可以在此处切一次，小于0，直接输出-1即可

最后不要忘了特判，防止到最后的时候左括号多出来，导致无法切分 每个地方可以选择切或者不切，一共有n - 1个位置，所以答案是2 ^ (n - 1), 用快速幂同时进行取模就可；

using namespace std;

const int N = 1e6 + 10, mod = 1e9 + 7;

typedef long long LL;

char s[N];
int len;

int kmi(int a, int k, int p){
    int res = 1;
    while(k){
        if(k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    
    return res;
}

int main()
{
    cin >> s;
    
    int res = 0;
    for(int i = 0; s[i]; i ++ ) {
        if(s[i] == '(') len ++;
        else len --;
        if(len == 0) res++;
        if(len < 0) {
            puts("-1");
            return 0;
        }
    }
    
    if(len != 0) {
        puts("-1");
        return 0;
    }
    cout << kmi(2, res - 1, mod);
    
    return 0;
}

E

分类：树形dp
我一开始的思路是f[][0], f[][1]两个状态，然后直接状态转移方程来算就完事了,然后发现看到下面题解大佬的解法，发现只需要枚举每一个点被选择的情况下的最大连通块就行了，非常好写，时间复杂度是o（n）;
状态表示：f[i], 表示选择此点的最大舒适度最大的连通块 状态转移方程：f[i] = max(f[i], f[i] + w[i, j] + val[j]), j表示i的子节点；

//树形dp问题
using namespace std;

typedef long long LL;

const int N = 2e5 + 10;
const int INF = 0x3f3f3f3f;

LL f[N];
int val[N];
int h[N], ne[N], e[N] ,idx, w[N];
bool st[N];
LL ans = -INF;

void add(int a, int b, int c){
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx ++;
}

void dfs(int u){
    if(st[u]) return ;
    
    st[u] = true;
    f[u] = val[u];
    
    for(int i = h[u]; i != -1; i = ne[i] ) {
        int j = e[i];
        if(st[j]) continue;
        dfs(j);
        
        f[u] = max(f[u], f[u] + w[i] + f[j]);
    }
}

int main()
{
    memset(h, -1, sizeof h);
    int n;
    cin >> n;
    
    for(int i = 1; i <= n; i ++ ) 
        cin >> val[i];
    
    for(int i = 1; i < n; i ++ ) {
        int a, b, c;
        cin >> a >> b >> c;
        
        add(a, b, c);
        add(b, a, c);
    }
    

    for(int i = 1; i <= n; i ++ ) {
        if(!st[i])
        dfs(i);
    }
    
    for(int i = 1; i <= n; i ++ )
        ans = max(ans, f[i]);
    
    cout << ans;
    
    return 0;
    
}