牛客练习赛40-题解（部分）

牛客练习赛40-题解（部分）

官方题解：https://www.nowcoder.com/discuss/154293?type=101

A-小D的剧场
大概意思就是，有1~49个数，代表着不同的音符，问你能组成长度为n的串有多少种(mod 10⁹+7)。有若干个限制，比如1 2 3，就是1，2，3不能放在一起，然后问你在这些限制下有多少种不同的长度为n的串。
3≤n≤500,0≤q≤117649,1≤a,b,c≤49
思路
看到这题，想到HDU2047，不难想到dp的方法，就是一个暴力的dp题。dp[i][j][k]代表长度为i，第i个位置为j，第i-1个位置为k的种数，状态转移方程为：dp[i][j][k]+=dp[i-1][k][l]，预处理好vis[j][k][l]是否能放在一起。
代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=1e9+7;
ll n,q;
ll a,b,c;
ll vis[50][50][50];
ll dp[510][50][50];
int main(){
    memset(vis,0,sizeof(vis));
    memset(dp,0,sizeof(dp));
    scanf("%lld %lld",&n,&q);
    for(ll i=0; i<q; i++){
        scanf("%lld %lld %lld",&a,&b,&c);
        vis[a][b][c]=1;
        vis[a][c][b]=1;
        vis[b][a][c]=1;
        vis[b][c][a]=1;
        vis[c][a][b]=1;
        vis[c][b][a]=1;
    }
    for(int i=1; i<50; i++){
        for(int j=1; j<50; j++) dp[1][i][j]=1;
    }
    for(ll i=2; i<n; i++){
        for(ll j=1; j<50; j++){
            for(ll k=1; k<50; k++){
                for(ll l=1; l<50; l++){
                    if(vis[j][k][l]==0){
                        dp[i][j][k]=(dp[i][j][k]+dp[i-1][k][l])%mod;
                    }
                }
            }
        }
    }
    ll ans=0;
    for(ll i=1; i<50; i++){
        for(ll j=1; j<50; j++){
            ans=(ans+dp[n-1][i][j])%mod;
        }
    }
    printf("%lld\n",ans);
}

B-小A与任务
小A手头有 n 份任务，他可以以任意顺序完成这些任务，只有完成当前的任务后，他才能做下一个任务
第 i 个任务需要花费 x_i 的时间，同时完成第 i 个任务的时间不能晚于 y_i ，时间掌控者向小A提出了一个条件：如果完成第 i 个任务的时间本应是 t ，但小A支付 m 个金币的话，他可以帮助小A在 t−m×z_i 时刻完成第 i 个任务， z_i 是时间参数，会在输入中给出
小A想按时完成所有任务，请你帮他制定一个花费金币最少的方案
注意：不能使得某个任务的花费时间小于 0 ,花费的金币可以不是整数
输入描述:
第一行一个整数 n ，表示小A的任务数量
接下来n行，每行三个整数，分别表示
z_i,x_i,y_i
输出描述:
一行一个实数，表示小A最少需要花费的金币数，四舍五入保留一位小数
示例1
输入

5
1 1 2
1 1 3
1 2 4
1 1 4
1 2 5

输出

2.0

说明
在1时刻完成第一个任务,2时刻完成第二个任务,4时刻完成第三个任务,花费1金币在4时刻完成第四个任务,花费1金币在5时刻完成第五个任务
备注:
1≤n≤2×10⁵
1≤x_i,z_i≤3×10³
1≤y_i≤10⁵
思路
首先按照y从小到大排序，再一个个遍历，时间依次加上去，如果遇到实际完成时间(now_time)要小于规定时间(y)，就要选一个之前完成过的任务中，z最大的，花费(now_time-y)/z个金币，但是要注意题目中的话：不能使得某个任务的花费时间小于 0，就是说如果你找出来的之前完成的那个任务的时间不足以弥补now_time-y，就要重新找一个z次大的花费金币，直到now_time-y==0。
代码

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+10;
struct Node{
    int z,x,y;
}s[maxn];
bool cmp(Node i,Node j){
    return i.y<j.y;
}
struct node{
    int x,z,y;
    bool friend operator<(node i,node j){
        return i.z<j.z;
    }
    node(int zz,int xx,int yy):z(zz),x(xx),y(yy){};
};
priority_queue<node>q;
int n;
int main(){
    scanf("%d",&n);
    for(int i=0; i<n; i++)
        scanf("%d %d %d",&s[i].z,&s[i].x,&s[i].y);
    sort(s,s+n,cmp);
    double cost=0;
    int t=0;
    for(int i=0; i<n; i++){
        q.push(node(s[i].z,s[i].x,s[i].y));
        t+=s[i].x;
        while(s[i].y < t){
            node now=q.top();
            q.pop();
            int l=t-s[i].y;
            if(l <= now.x){
                now.x-=l;
                cost+=((double)l/(double)now.z);
                t-=l;
                q.push(now);
            }
            else{
                t-=now.x;
                cost+=((double)now.x/(double)now.z);
            }
        }
    }
    printf("%.1f\n",cost);
}

C-小A与欧拉路
题目描述
小A给你了一棵树，对于这棵树上的每一条边，你都可以将它复制任意（可以为0）次（即在这条边连接的两个点之间再加一条边权相同的边），求所有可能新形成的图中欧拉路的最短长度
欧拉路：从图中任意一个点开始到图中任意一个点结束的路径，并且图中每条边只通过恰好一次
输入描述:
第一行一个数 n ，表示节点个数
接下来 n-1 行，每行三个整数 u,v,w，表示有一条 u 到 v 边权为 w 的无向边保证数据是一棵树
输出描述:
一行一个整数，表示答案
示例1
输入

4
1 2 1
1 3 1
1 4 2

输出

5

说明
一种可能的方案为复制 <1,2,1> 这条边一次，欧拉路为4->1->2->1->3
备注:
1≤n≤2×10⁵
1≤u_i,v_i≤n
1≤w_i≤10⁴

思路
仔细画图想想，可以发现，如果从一个点出去，再回到这个点的方法就是将所有边都复制一次，但是欧拉图并不需要再回到这个点，所以，我们就撤回回到初始点的那些边，撤回的越多，得到欧拉图的长度就会越短。撤回的边就是一棵树从顶端到底端的最大长度(maxlen)。所以答案就是（所有边的长度*2-maxlen）。
至于maxlen的求法，就要用到树形dp
需要dp[i][0] dp[i][1]两种状态
dp[i][0]代表以i为根的树，它的最长的子树
dp[i][1]代表以i为根的树，它的次最长的子树
(有点像简化版的HDU2196)
最长的长度就是dp[i][0]+dp[i][1]
代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll maxn=2e5+10;
ll dp[maxn][2];
ll ans;
struct edge{
    ll to,next,w;
}edges[maxn*2];
ll head[maxn],ecnt;
void init(){
    ecnt=0;
    memset(head,0,sizeof(head));
    memset(dp,0,sizeof(dp));
}
void add(ll from,ll to,ll w){
    edges[++ecnt].to=to;
    edges[ecnt].next=head[from];
    edges[ecnt].w=w;
    head[from]=ecnt;
}
void dfs(ll root,ll pra){
    for(ll i=head[root]; i; i=edges[i].next){
        ll son=edges[i].to;
        if(son!=pra){
            dfs(son,root);
            if(dp[son][0]+edges[i].w > dp[root][0]){
                dp[root][1]=dp[root][0];
                dp[root][0]=max(dp[root][0],dp[son][0]+edges[i].w);
                continue;
            }
            if(dp[son][0]+edges[i].w > dp[root][1]) dp[root][1]=dp[son][0]+edges[i].w;
        }
    }
    ans=max(ans,dp[root][0]+dp[root][1]);
}
int main(){
    ll n;
    init();
    scanf("%lld",&n);
    ll sum=0;
    for(ll i=0; i<n-1; i++){
        ll x,y,z;
        scanf("%lld %lld %lld",&x,&y,&z);
        add(x,y,z);
        add(y,x,z);
        sum+=z;
    }
    ans=-1;
    dfs(1,0);
    printf("%lld\n",sum*2-ans);
}