Codeforces Round #787 (Div. 3)

Codeforces Round #787 (Div. 3)

A - Food for Animals

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int i,j;
	int t;cin>>t;
	while(t--)
	{
		int a,b,c,x,y;
		cin>>a>>b>>c>>x>>y;
		//猫吃掉所有猫粮后，狗吃掉所有狗粮后 
		int cc1 = max(x-a,0);
		int cc2 = max(y-b,0);
		if(cc1+cc2<=c){
			puts("YES");
		}else{
			puts("NO");
		}
	}

B - Make It Increasing

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+5;
 
int f(int &x,int &y)
{
	//使x小于y
	int ans = 0;
	while(x >= y){
		x/=2;
		ans++;
	} 
	return ans;
}
 
int main()
{
	int i,j;
	int t;cin>>t;
	while(t--)
	{
		int a[40] = {0};
		int n;scanf("%d",&n);
		for(i = 1;i <= n; i++){
			cin>>a[i];
		}
		int res = 0;
		int flag = 0;
		for(i = n-1;i >= 1; i--){
			if(a[i+1]==0){
				flag = 1;
				break;
			}
			int cnt = f(a[i],a[i+1]);
			res+= cnt;
		}
		//for(i = 1;i <= n; i++) cout<<a[i]<<' ';
		//puts("");
		if(flag){
			puts("-1");
		}else{
			cout<<res<<endl;
		}
	}
}

C - Detective Task

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+5;
 
int main()
{
	int i,j;
	int t;cin>>t;
	while(t--)
	{
		string s;cin>>s;
		//puts(s);
		int idx1 = 0;
		int idx0 = s.length()-1;//说不在前最后一个说在的人
		 
		//第一个说不在的人 前面一直到第一个说在的人都有嫌疑 
		for(i = 0;i < s.length(); i++){
			if(s[i]=='0'){ 
				idx0 = i;
				break;
			}
			if(s[i]=='1') idx1 = i;
		}
		cout<<idx0 - idx1+1<<endl;
		
	}
}

D - Vertical Paths

​ 给你一棵树（或者说图），根结点会给出，我们要尽可能找到最少的若干条路径，使得所有点都被路径覆盖，但是不能多次覆盖；

​ 核心点在于，有几个叶节点，就有几条路径啊，所以最少路径是迷惑人的啊；

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


const int N = 2e5+5;
int p[N];//
int h[N],e[N],ne[N];//建图
int vis[N];
vector<int>v[N];//存储我们的结果

int cnt = 0,idx = 0;
int n;

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

void dfs(int u)
{
    if(h[u] == -1){
        cnt++;
        return ;
    }
    for(int i = h[u];i != -1;i = ne[i]){
        
        int j = e[i];
        if(!vis[j]){
            vis[j] = 1;
            v[cnt].push_back(j);
            dfs(j);
        }
    }
}

int main()
{
    int i,j;
    int t;scanf("%d",&t);
    while(t--)
    {
        //初始化
        memset(h,-1,sizeof(h));
        memset(vis,0,sizeof(vis));
        for(i = 0;i < N; i++) v[i].clear();
        idx = 0,cnt = 1;
        int root;
        cin>>n;
        for(i = 1;i <= n; i++){
            scanf("%d",&p[i]);
            if(p[i] == i) root = i;//根节点。，或者说头结点root
            else add(p[i],i);//i的父节点是p[i]
            //故例如样例第一个，有一条3父亲到1号儿子的边
        }
        v[cnt].push_back(root),vis[root] = 1;
        dfs(root);//从根节点向下开始搜索
        --cnt;
        cout<<cnt<<'\n';
        for(i = 1;i <= cnt; i++){
            cout<<v[i].size()<<'\n';
            for(j = 0;j < v[i].size(); j++) cout<<v[i][j]<<' ';
            puts("");
        }    
		puts("");               
    }   
      return 0;                                               
}

E. Replace With the Previous, Minimize

并查集；

​ 给你k次操作，每次你可以将字符串中的某类字符全部转换成它字典序前面一个，例如将所有的’b’转换成’a’,所有的’d’转化成’c’，而’a’就要转化成’z’。最终的目的是使得字符串的字典序尽可能的小，那最贪心的情况就是让所有的都变成’a’；

​ 那难道是贪心让前面的所有向’a’靠近吗？那样例4的ekyv的结果就不是aapp，因为它是先将第二位的k转换成e后，然后再和首位的e一起变换，所以和顺序无关；

那应该在k足够的情况下，将字典序大的先变小，然后大家一起变，那么k大于25的时候，即便有’z’那所有的也都能变成’a’，

所以我们要做的是尽可能高让前面的变小的同时，看又没有多的k让后面也变小，例如，前面让’d’变成了’a’，我们再看看有没有足够的k让后面的’g’变成’d’；有点记忆化的感觉？

​ 总结：将前面的字母尽可能的变小成’a’，然后向后看，如果后面的字母有足够的操作次数变成前面已经变过的字母，则它也可以变成前面字母变成的字母;

#include<bits/stdc++.h。
using namespace std;

int main()
{
    int i,j;
    int t;scanf("%d",&t);
    while(t--)
    {
    	int n,k;
        scanf("%d%d",&n,&k);
        string s;ci>>s;
        
        char tr[200];
        for(i = 'a';i <= 'z'; i++) tr[i] = i;
        for(auto i : s){
            while(k && tr[i] > 'a'){
                k--,tr[i]--;
                tr[i] = tr[tr[i]];//如果可以变成前面已经变了的字母，则可以一起变
            }
            for(char j = i;j >= tr[i]; j--){//变i的过程中变成的一同变
                tr[j] = min(tr[j] , tr[i]);
            }
            if(k == 0) break;
        }
        for(auto i : s) putchar(tr[i]);
        puts("");
    }
}

F. Vlad and Unfinished Business

​ 给你一个起点x，终点y，要以最短路径从起点x出发遍历a1,a2……，ak后回到终点y；

​ 我们从任意目的地出发前往x点，将图中经过的点标记为已访问过，那路径其实就是2倍，因为实际是x到目的地，目的地再到x，然后对于下一个目的地，那就可以如果它向上找父节点某个父节点已经访问过那就可以不用再访问了；

​ 此题用邻接表来存的时候，因为是无向边，在dfs的时候会出现死循环，为啥尼;

就例如样例1，从起点1出发通过邻接表到达2，然后2又到达1，然后又到达2……就出现了死循环，加了限制条件还是有各种各样的问题，还是换吧，用关联矩阵来存;

#include<bits/stdc++.h>
using namespace std;
const int N = 2e5+5;
int des[N],fa[N];
vector<int> g[N];
bool vis[N];

void dfs(int u)
{
	for(auto v : g[u]){
		if(v == fa[u]) continue;
		fa[v] = u;
		dfs(v);
	}	
} 

int main()
{
	int i,j;
	int t;cin>>t;
	while(t--)
	{
		int n,k,x,y;
		cin>>n>>k>>x>>y;
		for(i = 1;i <= n; i++){
			g[i].clear();
			vis[i] = 0;
		}
		for(i = 0;i < k; i++) cin>>des[i];
		for(i = 1;i < n; i++){
			int u,v;cin>>u>>v;
			g[u].push_back(v);
			g[v].push_back(u);
		}
		fa[x] = 0,dfs(x);
		int ans = 0;
		for(i = 0;i < k; i++){
			int u = des[i];
			while(u != x && !vis[u]){
				ans+=2;
				vis[u] = 1;
				u = fa[u];
			}
		} 
		//再去找y到x的路径
		while(x != y){
			if(vis[y]) ans--;
			else ans++;
			y = fa[y];
		} 
		cout<<ans<<'\n';
	}
}