CodeTON Round 2补题（A-E）

代码实现：

#include
using namespace std;
const long long inf=0x3f3f3f3f3f3f3f3f;
const int maxn=2e5+10;
long long a[maxn],b[maxn];//记录上下界 
int main()
{	
	ios::sync_with_stdio(false);
	cin.tie(0);
	int t;
	cin>>t;
	while(t--)
	{
		int n;
		long long x;
		cin>>n>>x;
		for(int i=1;i<=n;i++)
		{
			 long long num;
			 cin>>num;
			 a[i]=num-x;
			 b[i]=num+x;
		}
		long long l,r;
		l=a[1],r=b[1];
		int ans=0;
		for(int i=2;i<=n;i++)
		{
			if(l>b[i]||r//如果当前区间不满足本次元素取值 
			{
				ans++;
				l=a[i];
				r=b[i];
			}
			else//若满足，尝试缩小当前区间 
			{
				if(l<=a[i])
				l=a[i];
				if(r>=b[i])
				r=b[i];
			}
			
		}
		cout<'\n';
	}
	return 0;
}

C. Virus

题目链接：Problem - C - Codeforces

题意：有n个房子形成一个环，相邻的房子被称为邻居，这意味着1和n也是邻居，起初有m个房子被感染，每天依次进行以下操作：

（1）选择一个未感染的房子使其不再受感染

（2） 所有所有被感染的房子感染其邻居。

问病毒传播停止后，最少有多少房子感染

思路：起初m个房子相互之间构成了m个间隔（一条未被感染的房子），每个间隔中如果不加干涉每天该间隔两边的房子都会被感染，只有两边都被保护住了这条间隔才算安全，根据贪心思想，优先保护长的间隔，两边保护完后，去保护下一间隔

代码实现：

#include
using namespace std;
#define ll long long
const long long inf=0x3f3f3f3f3f3f3f3f;
const int maxn=2e5+10;
long long a[maxn];
ll b[maxn];
int cnt[maxn];//记录间隔被保护的数量 
int main()
{	
	ios::sync_with_stdio(false);
	cin.tie(0);
	int t;
	cin>>t;
	while(t--)
	{
		ll n,m;
		cin>>n>>m;
		for(int i=1;i<=m;i++)
		cnt[i]=0;
		for(int i=1;i<=m;i++)
		cin>>b[i];
		sort(b+1,b+1+m);
		a[1]=n-b[m]+b[1]-1;//记录间隔 
		for(int i=2;i<=m;i++)
		a[i]=b[i]-b[i-1]-1;
		int ans=m;
		sort(a+1,a+1+m);
		while(1)
		{
			bool f=0;
			bool pro=1;//本次保护机会是否被使用 
			for(int i=m;i>=1;i--)
			{
				if(a[i]==0)//如果当前间隔没有未感染的房子 
				continue;
				ll de=min(2ll-cnt[i],a[i]);//计算使用本次保护机会前当前区间会被感染的房子数 
				if(pro)//使用机会 
				{
					pro=0;
					de--;
					cnt[i]++;
				}
				if(cnt[i]==2)//如果两边都被保护了，就不用了管它了 
				{
					a[i]=0;
					continue;
				}
				if(de)
				{
					ans+=de;
					a[i]-=de;
					f=1;
				}
			}
			if(f==0)//如果本次没有房子感染了 
			break;
		}
		cout<'\n';
	}
		
	return 0;
}

D. Magical Array

题目链接：Problem - D - Codeforces

题意：一个长度为m的b数组，首先复制出n个与b相同的c数组，首先设其中一个数组为特殊数组，有以下操作：

（1）对于非特殊数组，选取一对互不相同的ij，使得c[i-1]+1,c[i]-1,c[j]-1,c[j+1]+1。 

（2）对于特殊数组，选取一对互不相同的ij，使得c[i-1]+1,c[i]-1,c[j]-1,c[j+2]+1。

 每个数组都必须经过依次操作，现在给出n个操作后的数组，问哪个是特殊数组，并且输出该数组操作了多少次。

思路：考虑操作1和操作2的差别，在一个数组中，一个数加1，一个数减1，实际上对数组和没有影响，为了突出其2个操作的差别，计算数组每个元素乘以下标的和,(i*ai)，发现操作1对这个和没有任何影响，而操作2会使这个和多1，因此只需要找这个和不同于其他数组的数组，并且用这个和减去其他任意一个数组的和，即为操作数

代码实现：

#include
#define ll long long
using namespace std;
const ll inf=0x3f3f3f3f3f3f3f3f;
const int maxn=1e5+10;
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int t;
	cin>>t;
	while(t--)
	{
		int n,m;
		cin>>n>>m;
		ll mi=inf,mx=0;
		ll index=0;
		for(int i=1;i<=n;i++)
		{
			ll ret=0;//计算每个数组元素乘以下标的和 
			for(int j=1;j<=m;j++)
			{
				ll x;
				cin>>x;
				ret+=x*j;
			}
			mi=min(ret,mi);//寻找最小的和，这个和是非特殊数组的和 
			if(ret>mx)
			{
				mx=ret;//记录特殊数组的和 
				index=i;//记录索引 
			}
		}
		cout<' '<'\n';
	}
	return 0;
}

 E. Count Seconds

题目链接：Problem - E - Codeforces

题意：给一个有向无环图，保证出度为0的点只有一个，每个点都有权值ai，依次进行以下操作：

（1）对于所有ai不等于0时，ai减1

（2）那之后，该点作为起点所连的边的终点的权值加1

问多少秒之后，所有点权值为0，对答案取模998244353

思路：给出了一个出度为0的点，可以理解为这个点是权值的出口，假设以下情况，三个连续的点权值为1  2   3，并且假设第三个点为出口，经过一秒，变成 0  2  3，依次推进，为0 1 3，0 0 3,0 0 2， 0 0 1， 0 0 0,对于一个点，除非指向它的点的权值变为0，它的权值才开始减少，因此一个点权值要变为0需要先让指向它的权值先变为0，可以得知一个点变为0的时间指向它节点变为0花的时间的和再加上该点权值，这可以用到dp，对于dp的状态转移，假设i->j，要实现状态转移，需要让指向i点所有的点的权值都为0，才可以计算真正的dp[i]，然后推dp[j]，可以看成i点入度为0，
就可以拓扑排序了 ，此时的主要问题为几个点的权值不连续，这种情况会导致中途间断（全为0）部分一开始权值为0，但后来才部位0，中间过程消耗了一点时间，dp只能处理连续的情况，因此要让不为0的权值连续，先暴力模拟n秒，n秒后要么已经全为0，要么就是连续的，因为最顶端的1最多跑n-1条边就可以到出口，此外，在暴力模拟中，考虑中途就已经结束的情况

代码实现：

#include
using namespace std;
#define ll long long
const int maxn=1e5+10;
const ll mod=998244353;
vector<int>vv[maxn];
ll a[maxn];
inline void add(int u,int v)
{
	vv[u].push_back(v);
}
ll dp[maxn];
int in[maxn];
ll temp[maxn];
vector<int>id;
int main()
{	
	ios::sync_with_stdio(false);
	cin.tie(0);
	int t;
	cin>>t;
	int s=0;
	while(t--)
	{
		int n,m;
		cin>>n>>m;
		for(int i=1;i<=n;i++)//初始化 
		{
		dp[i]=0;
		vv[i].clear();
		in[i]=0;	
		}
		for(int i=1;i<=n;i++)//记录权值 
		cin>>a[i];
		for(int i=1;i<=m;i++)//建边 
		{
			int u,v;
			cin>>u>>v;
			in[v]++;
			add(u,v);
		}
		int t=0;
		for(int i=1;i<=n;i++)//寻找出口 
		if(vv[i].size()==0)
		t=i;
		ll ans=0;
		bool ansf=0;//记录是否在0-n秒 就结束了 
		for(int k=1;k<=n;k++)
		{
			bool f=1;
			for(int i=1;i<=n;i++)//用temp保存权值，使得 
			temp[i]=a[i];
			for(int u=1;u<=n;u++)
			{
				if(a[u]==0)
				continue;
				f=0;
				temp[u]--;
				for(int to:vv[u])
				temp[to]++;	
			}
			for(int i=1;i<=n;i++)
			a[i]=temp[i];
			if(f)
			{
				ans=k-1;//如果结束，记录结束时间 
				ansf=1;
				break;
			}
		}
		if(ansf)
		{
			cout<'\n';
			continue;
		}
    	queue<int>q; //拓扑排序 
		for(int i=1;i<=n;i++)
		if(in[i]==0)
		q.push(i);
		while(!q.empty())
		{
			int u=q.front();
			q.pop();
			id.push_back(u);
			dp[u]+=a[u];//该点变为0的所需时间为自己的权值加上指向它的点的dp值 
			dp[u]%=mod;
			for(int to:vv[u])
			{
				dp[to]+=dp[u];
				dp[to]%=mod;
				in[to]--;
				if(in[to]==0)
				q.push(to);	
			}
		}
		ans=n;//ans本来经过n秒暴力模拟 
		ans+=dp[t];
		ans%=mod; 
		cout<'\n';
	}
	return 0;
}