B. Perfect Flush、Milk Scheduling、车站分级；1400——414B、401C；_b

本文链接：https://blog.csdn.net/Mr_dimple/article/details/120619773

今天2021.10.5。
上午把昨天upc的题补了。中午有场组队赛，碰见个拓扑排序的题，没做出来。。
晚上写了两道1400。

B. Perfect Flush （栈）

题意：

给出一个长度为n的数列，其中元素大小为1~m。
要找出一个子序列，使得1~m元素出现且只出现一次，并使其字典序尽可能小。

思路：

每个元素都要有，并且只能出现一次。
所以能尽量小的就尽量小，但是如果遇到最后出现的元素，一定要拿着。

遍历每个位置，将栈中比其大的元素都出栈，将该位置元素压栈。

但是要注意的是，出栈的元素都是后面会再次出现的；如果遇到栈顶为最后出现的元素，就不能再将其出栈。

Code：

const int N = 200010, mod = 1e9+7;
int T, n, m, a[N];
int last[N], ans[N];
bool f[N];

int main(){
	Ios;
	cin>>n>>m;
	
	for(int i=1;i<=n;i++) cin>>a[i],last[a[i]]=i;
			
	for(int i=1;i<=n;i++)
	{
		if(f[a[i]]) continue;
		
		while(stk.size()&&a[stk.top()]>=a[i]&&last[a[stk.top()]]>i) f[a[stk.top()]]=0,stk.pop();
		stk.push(i);
		f[a[i]]=1;
	}
	int cnt=0;
	while(stk.size()) ans[++cnt]=a[stk.top()],stk.pop();
	
	for(int i=cnt;i>=1;i--) cout<<ans[i]<<" ";
	
	return 0;
}

Milk Scheduling（拓扑排序）

题意：

n个人来打水，每个人需要一定时间。m对优先关系x y，说明 x 要在 y 前面打水。
问，最终所有人打完水最少需要多少时间？

思路：

后面的人要在其前面的人全部打完水之后，才能排到他。

所以需要拓扑排序，先将其前面的人的打水时间处理好，当前人的时间就为前面人打水完成时间的最大值 + 自己所用的时间。

Code：

const int N = 200010, mod = 1e9+7;
ll T, n, m, a[N];
int h[N],ne[N],e[N],idx;
int f[N],in[N];
ll ans[N],maxa;

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

void tpsort()
{
	queue<int> que;
	
	for(int i=1;i<=n;i++){
		if(in[i]==0) que.push(i),ans[i]=a[i];
	} 
	
	while(que.size())
	{
		int x=que.front();
		que.pop();
		
		for(int i=h[x];i!=-1;i=ne[i])
		{
			int tx=e[i];
			in[tx]--;
			
			ans[tx]=max(ans[tx],ans[x]+a[tx]);
			maxa=max(maxa,ans[tx]);
			
			if(in[tx]==0) que.push(tx);
		}
	}
	
//	int flag=0; //第二种写法，分层的思想。
//	mem(f,0);
//	for(int i=1;i<=n;i++)
//	{
//		if(in[i]==0)
//		{
//			in[i]--;
//			flag=1;
//			for(int j=h[i];j!=-1;j=ne[j])
//			{
//				int tx=e[j];
//				f[tx]++;
//				ans[tx]=max(ans[tx],ans[i]+a[tx]);
//				maxa=max(maxa,ans[tx]);
//			}
//		}
//	}
//	for(int i=1;i<=n;i++) if(f[i]) in[i]-=f[i];
//	if(flag){
//		tpsort();
//	}
}

int main(){
	Ios;
	cin>>n>>m;
	for(int i=1;i<=n;i++) cin>>a[i];
	
	mem(h,-1);
	while(m--)
	{
		int x,y;cin>>x>>y;
		add(x,y);
		in[y]++;
	}
	
	tpsort();
	
	cout<<maxa;
	
	return 0;
}

找到之前做过的一个拓扑排序的题，但是有一个新的思想——分层。

[NOIP2013 普及组] 车站分级

题意：

若干趟车次行驶，每一趟都满足：如果这趟车次停靠了火车站 x，则始发站、终点站之间所有级别大于等于火车站 x 的都必须停靠。
给出m条运行路线，推算这 n 个火车站至少分为几个不同的级别？

思路：

通过这m条运行路线，我们可以将车站之间两两连线，表示等级优先关系。
每次得到的入度为0的点，就是优先度较低的点。

但是现在不要立刻更新与其相连的点，而是先将这些点标记下来，等遍历一遍n个点，将所有入度为0的点筛出后，再将这些标记点的入度减掉。（防止入度减掉后为0，串着改）
这样就保证了这一次遍历n个点所筛出的入度为0的点都可以是同一等级的。
按这种操作，接下来每一次遍历所得的入度为0的点都是同一级的。
最终没有入度为0的点了，分层就结束了。这些遍历的层数就是最少等级数。

这就是分层的思想。

Code：

const int N=1010;
int n,m,h[N],ne[N*N],e[N*N],idx;
int a[N],ru[N],f[N][N],cnt,mp[N],t[N];

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

void topsort()
{
	int flag=0;
	
	memset(t,0,sizeof t);
	
	for(int i=1;i<=n;i++)
	{
		if(ru[i]==0)
		{
			ru[i]--;
			flag=1;
			for(int j=h[i];j!=-1;j=ne[j])
			{
				int tx=e[j];
				t[tx]++;
			}
		}
	}
	
	for(int i=1;i<=n;i++) if(t[i]) ru[i]-=t[i];
	
	if(flag){
		cnt++;
		topsort();
	}
}

int main(){
	
	cin>>n>>m;
	
	memset(h,-1,sizeof h);
	
	while(m--)
	{
		int k;scanf("%d",&k);
		memset(mp,0,sizeof mp);
		for(int i = 1; i <= k; i++)
		{
			scanf("%d",&a[i]);
			mp[a[i]] = 1;
		}
		
		for(int i=a[1];i<=a[k];i++)
		{
			if(mp[i]) continue;
			for(int j=1;j<=k;j++)
			{
				if(f[a[j]][i]) continue;
				add(a[j],i);
				ru[i]++;
				f[a[j]][i]=1;
			}
		}
	topsort();
	
	cout<<cnt;
	
	return 0;
}

414.B. Mashmokh and ACM（dp)

题意：

定义长度为n，最大值为m的数列，满足ai|ai+1，即后一个位置的数可以整除前一位置。
现给出n,m，问这样的数列一共有多少个？（mod 1e9+7）

思路：

后一位置的状态可以由前一位置的状态更新过来。
记f[i][j]]为：长度为 i，以数字 j 结尾的数列个数。
那么，当前位置数列个数 = 前一个位置元素为当前元素的约数的数列个数之和。 当前状态就由上一位置状态更新：
$f[i][j] = 求和∑(f[i-1][p_k]) ，p为j的约数$ 。

所以只需要遍历位置，遍历当前位置的元素，遍历当前元素的所有约数，用前一位置更新。（预处理出所有元素的所有约数）

Code：

const int N = 2010, mod = 1e9+7;
int T, n, m, a[N];
ll f[N][N];

void pre()
{
	for(int x=1;x<=m;x++)
	{
		for(int i=1;i<=x/i;i++)
		{
			if(x%i==0){
				v[x].push_back(i);
				
				if(x/i!=i) v[x].push_back(x/i);
			}
		}
	}
}

int main(){
	cin>>m>>n;
	
	pre();
	for(int i=1;i<=m;i++) f[1][i]=1;
	
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			for(int k=0;k<v[j].size();k++)
			{
				f[i][j]=(f[i][j]+f[i-1][v[j][k]])%mod;
			}
		}
	}
	ll ans=0;
	for(int i=1;i<=m;i++) ans=(ans+f[n][i])%mod;
	cout<<ans;
	
	return 0;
}

自己做出来的dp，激动！

401.C. Team（模拟）

题意：

n个0，m个1，能否构成一个数列，满足没有2个0相邻，没有3个1相邻？

思路：

如果 n>m+1 或者 n<m/2(上取整)-1，构不成。

如果n=m+1的话，先输出一个0；
遍历n的个数，先两个两个输出(11)，让m的数量和n的数量相等，再依次输出(10).
如果m有剩余，都输出。

Code：

const int N = 200010, mod = 1e9+7;
int T, n, m, a[N];

int main(){
	Ios;
	cin>>n>>m;
	
	if(n>m+1||n<(m+1)/2-1){
		cout<<-1;return 0;
	}
	
	if(n==m+1) cout<<0,n--;
	
	int t=n,flag=0;
	for(int i=1;i<=t;i++)
	{
		if(n==m) flag=1;
		if(!flag) m-=2,n--,cout<<11<<0;
		else m--,n--,cout<<1<<0;
	}
	while(m) m--,cout<<1;
	
	return 0;
}