Codeforces Round #787 (Div. 3) A-F题解

A. Food for Animals
题意：x猫粮c狗粮z个任意粮，a个猫b个狗，问问能不能让每个小动物至少分到一个粮，（猫粮狗粮不能混吃）
思路：算算数。

#include <iostream>

using namespace std;

int main()
{
    int t;
    for(cin>>t;t;t--)
    {
        int a,b,c,x,y;
        cin>>a>>b>>c>>x>>y;
        int dis1=a-x,dis2=b-y;
        if(dis1<0)
            c+=dis1;
        if(dis2<0)
            c+=dis2;
        if(c>=0)
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
    return 0;
}

B. Make It Increasing
太BABY了
题意：给第一个数组，每次可以让数组中的一个数变为a[i]/2(向下取整)。求最少几次可以让数组变为严格递增数组

思路：
1.首先来判断这个数组是否能变为严格递增，第一层筛选：a[i]>=i才行
2.我们从后往前构造，发现a[i]>=a[i]+1就把a[i]/=2
3.从后往前构造的过程中a[i+1]如果为0，判断为无法构造

#include <iostream>

using namespace std;
#define int long long
int a[35];
signed main()
{
    int t;
    for(cin>>t;t;t--)
    {
        int n,sum=0;
        cin>>n;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
        }
        for(int i=n-1;i>=1;i--)
        {
            if(a[i+1]==0)
            {
                cout<<-1<<endl;
                goto xx;
            }
            while(a[i]>=a[i+1])
            {
                sum++;
                a[i]/=2;
            }
        }
        cout<<sum<<endl;
        xx:;
    }
    return 0;
}

C. Detective Task
题意：n个人轮流进我的卧室(FIFO)，有一个偷了我的色图，我每个人都问他们有没有看到我的色图，他们会回答：有，没有，忘了，对应字符串s是1 0 ？
已知小偷一定说谎，其他人说真话
问有几个人有嫌疑

思路：这题有点意思，分析之后发现有两条规律
1.0一定不能在1后面（什）
2.最后一个出现的1和第一个出现的0以及中间的人可能有嫌疑

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int main()
{
    int t;
    for(cin>>t;t;t--)
    {
       string s;cin >> s;
    int len = s.size();
    int flag = len,flag1 = 0;
    for(int i = 0;i < len;i++){
        if(s[i] == '0'){
            flag = i;
            break;
        }
    }
    for(int i = len-1;i>= 0;i--){
        if(s[i] == '1'){
            flag1 = i;
            break;
        }
    }
    int cnt = 0;
    for(int i = flag1;i < min(flag+1,len);i++)cnt++;
    cout << cnt << "\n";
    }
}

D. Vertical Paths
这难度1500吧这，怎么才1300啊
题意：给定一棵树，我们要把它拆成一条条链，问你最少要拆成多少条链，并且输出每条链的大小和每条链的DFS序

思路：我们看到这种题不要慌，越是输出多的玩意儿他越是规定了自己的思路，这题铁定是DFS了
那么如何DFS呢？
我们知道已经被用过的节点不能再用了。
所以
1.我们优先把每个节点的第一个儿子用了
2.之后我们依次用第二到第三个

这题对于没学过树剖的同学可能不是很好实现。

#include<bits/stdc++.h>
using namespace std;
const int N =2e5+100;
int a[N];
vector<int>son[N];
vector<int>ans[N];
int cnt;
void DFS(int now)
{
    ans[cnt].push_back(now);
    if(son[now].empty())
    {
        cnt++;
        return ;
    }
    DFS(son[now][0]);
    for(int i=1;i<(int)son[now].size();i++)
        DFS(son[now][i]);
}
int main()
{
   int t;
   for(cin>>t;t;t--)
   {
       int n,root;
       cin>>n;
       for(int i=1;i<=n;i++)
       {
           int temp;
           cin>>temp;
           if(temp==i)
           {
               root=i;
               continue;
           }
           son[temp].push_back(i);
       }
       DFS(root);
       cout<<cnt<<endl;
       for(int i=0;i<cnt;i++)
       {
           cout<<ans[i].size()<<endl;
           for(auto x:ans[i])
           {
               cout<<x<<" ";
           }
           cout<<endl;
       }
       for(int i=0;i<=cnt;i++)
       {
           ans[i].clear();
       }
       for(int i=1;i<=n;i++)
       {
           son[i].clear();
       }
       cnt=0;
   }
}

E. Replace With the Previous, Minimize
题意：m次操作，每次都能把数组中的所有某一种字母换为其字典序较小的前一个字母。求m此操作后得到的最小的数

思路：根据值域判断输出的字母应该为什么。属于模拟。

#include<bits/stdc++.h>
using namespace std;
const int N =2e5+100;
char s[N];
int main()
{
    int t;
   for(cin>>t;t;t--)
   {
      int n,k,pos=0;
      cin>>n>>k;
      cin>>(s+1);
      char a='a';
      for(int i=1;i<=n;i++)
      {
          if(s[i]-'a'<=k)
              a=max(a,s[i]);
          else
          {
              pos=i;
              break;
          }
      }
      k=k-(a-'a');
      for(int i=1;i<=n;i++)
      {
          if(s[i]<=a)
              cout<<'a';
          else if(s[i]<=s[pos]-k)
              cout<<s[i];
          else if(s[i]<=s[pos])
              cout<<(char)(s[pos]-k);
          else
              cout<<s[i];
      }
      cout<<endl;
   }
}

F. Vlad and Unfinished Business
题意：在一棵树上，起点为x最终到y，但是必须先经过一个点集，每走一步一个花费，问最小的花费是多少
思路：我们以x为根，把要经过的点击都暴力的考虑向父节点跳，直到跳到了一个访问过的节点为止，每次跳都加2个花费(先别疑惑，看看后面),这样我们就假设了每次都会去要到的节点并且还会回到x上。
但是注意，我们有一条路是不需要再回到x的，那就是x到y这一条，所以我们还要减掉y的深度

#include <bits/stdc++.h>
using namespace std;
 
#define N 200007
 
vector<int> e[N], seq;
 
bool vis[N];
 
int n, k, x, y, f[N], ans;
 
void dfs(int u, int fa, int dep)
{
    f[u] = fa;
    if (u == y)
        ans = -dep;
    for (auto v : e[u])
        if (v != fa)
            dfs(v, u, dep + 1);
}
 
int main()
{
    int t;
    for(cin>>t;t;t--)
    {
        seq.clear();
        cin>>n>>k>>x>>y;
        for(int i=1;i<=n;++i)
        {
            vis[i] = 0;
            e[i].clear();
        }
        for(int i=1;i<=k;i++)
        {
            int temp;
            cin>>temp;
            seq.push_back(temp);
        }
        seq.push_back(y);
        for(int i=1;i<n;i++)
        {
            int u,v;
            cin>>u>>v;
            e[u].push_back(v);
            e[v].push_back(u);
        }
        dfs(x,x,0);
        vis[x]=1;
        for(auto i:seq)
        {
            for(int u=i;!vis[u];u=f[u])
            {
                vis[u]=1;
                ans+=2;
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}