LeetCode 2021 春季赛组队赛 解题报告

LCP 33. 蓄水

题目链接:https://leetcode-cn.com/problems/o8SXZn/

题解：暴力枚举蓄水操作的次数计算最优解即可

代码如下：

class Solution {
public:
    int storeWater(vector<int>& bucket, vector<int>& vat) {
        int sum=0;
        for(int i=0;i<int(vat.size());i++)
            sum+=vat[i];
        if(sum==0)
            return 0;
        int ans=99999999;
        for(int i=1;i<=10000;i++)
        {
            int tem=i;
            for(int j=0;j<int(bucket.size());j++)
            {
                tem+=max(0,(vat[j]+i-1)/i-bucket[j]);
            }
            ans=min(ans,tem);
        }
        return ans;
    }
};

 

LCP 34. 二叉树染色

题目链接：https://leetcode-cn.com/problems/er-cha-shu-ran-se-UGC/

题解：树形dp。dp[v][i]表示以节点v为根节点的子树，节点v染色联通块的大小为i时的最优解。转移比较简单。代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void dfs(TreeNode *node,int *dp,int k)
    {
        for(int i=0;i<=k;i++)
            dp[i]=0;
        if(node==nullptr)
            return;
        int dpls[12];
        dfs(node->left,dpls,k);
        int dprs[12];
        dfs(node->right,dprs,k);
        int maxlson=0;
        int maxrson=0;
        for(int i=0;i<=k;i++)
        {
            maxlson=max(maxlson,dpls[i]);
            maxrson=max(maxrson,dprs[i]);
        }
        dp[0]=maxlson+maxrson;
        for(int i=1;i<=k;i++)
        {
            for(int j=0;j<i;j++)
            {
                dp[i]=max(dp[i],dpls[j]+dprs[i-1-j]+node->val);
            }
        }
    }
    int maxValue(TreeNode* root, int k) {
        int dp[12];
        dfs(root,dp,k);
        int ans=0;
        for(int i=0;i<=k;i++)
            ans=max(ans,dp[i]);
        return ans;
    }
};

LCP 35. 电动车游城市

题目链接：https://leetcode-cn.com/problems/DFPeFJ/

题解：动态规划+最短路问题。dp[i][j]表示到达节点i，拥有电量j，最少花费多少时间。我们可以把每个dp状态抽象为图上的一个点，在这个图上求最短路，就可以求出每个dp状态的最优解。我是用spfa求解的最短路。代码如下：

struct Edge
{
    int en,next;
    int weight;
}E[1100*2];
int p[110],num;
void addEdge(int st,int en,int weight)
{
    E[num].en = en;
    E[num].weight = weight;
    E[num].next = p[st];
    p[st]=num++;
}
class Solution {
public:
    int electricCarPlan(vector<vector<int>>& paths, int cnt, int start, int end, vector<int>& charge) {
        memset(p,-1,sizeof(p));
        int dp[110][110];
        bool inque[110][110];
        memset(dp,-1,sizeof(dp));
        memset(inque,false,sizeof(inque));
        num=0;
        for(int i=0;i<int(paths.size());i++)
        {
            addEdge(paths[i][0],paths[i][1],paths[i][2]);
            addEdge(paths[i][1],paths[i][0],paths[i][2]);
        }
        queue<pair<int,int>>que;
        dp[start][0]=0;
        inque[start][0]=true;
        que.push(make_pair(start,0));
        while(que.size())
        {
            pair<int,int> cur=que.front();
            inque[cur.first][cur.second]=false;
            que.pop();
            for(int i=cur.second+1;i<=cnt;i++)
            {
                if(dp[cur.first][i]==-1)
                {
                    dp[cur.first][i]=dp[cu