程序设计思维与实践 week8 A 区间选点 II、B 猫猫向前冲、C 班长竞选

最新推荐文章于 2024-06-12 15:24:14 发布

SmarTongs

最新推荐文章于 2024-06-12 15:24:14 发布

阅读量191

点赞数

分类专栏：程序设计思维与实践文章标签：算法 kosaraju算法有向图拓扑学 dfs

本文链接：https://blog.csdn.net/weixin_44080131/article/details/105568664

版权

程序设计思维与实践专栏收录该内容

27 篇文章 0 订阅

订阅专栏

这里写自定义目录标题

A 区间选点 II
B 猫猫向前冲
C 班长竞选
总结

A 区间选点 II

描述

给定一个数轴上的 n 个区间，要求在数轴上选取最少的点使得第 i 个区间 [ai, bi] 里至少有 ci 个点

使用差分约束系统的解法解决这道题

输入

输入第一行一个整数 n 表示区间的个数，接下来的 n 行，每一行两个用空格隔开的整数 a，b 表示区间的左右端点。1 <= n <= 50000， 0 <= ai <= bi <= 50000 并且 1 <= ci <= bi - ai+1。

输出

输出一个整数表示最少选取的点的个数

Example

输入

输出

思路

如果一个系统由n个变量 和m个约束条件 组成，形成m个形如ai-aj≤k 的不等式(i,j∈[1,n],k为常数),则称其为差分约束系统(system of difference constraints)。亦即，差分约束系统是求解关于一组变量的特殊不等式组的方法。 **求解差分约束系统，可以转化成图论的单源最短路径（或最长路径）问题。 **差分约束系统简介。

考虑到区间左端可能为0，操作中将所有区间右移一位。我们将sum[i]定义为从1到i需要选的最少的点的个数。则对于区间[ai,bi] ci，有 sum[bi]-sum[ai-1]>=ci(条件1) 另外对于相邻的两个点，他们的sum之间最对相差1，即 sum[ai]-sum[ai-1]>=0(条件2) 和 sum[ai]-sum[ai-1] <=1，为了形式统一，改写成 **sum[ai-1]-sum[ai] >=-1(条件3)**这样对于每一个区间的输入都能得到三个对应的约束不等式。

a(i)-a(j) >= k ===> a(i)>=a(j)+k 这其实是从点j到点i保证最长路的结果，我们可以用 if(dis[y]<dis[x]+w) {dis[y]=dis[x]+w;}求最长路的松弛条件来保证。在遍历过程中将点的个数累加保存在dis中。

代码

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn=1e6;
const int inf=1e8;
struct edge{//链式前向星 
	int to,w,next;
}e[maxn];
int head[maxn],tol;
void add(int u,int v,int w){//前向星加边
     e[++tol].to=v;
	 e[tol].w=w;
	 e[tol].next=head[u];
	 head[u]=tol;	
}
int sum[maxn],dis[maxn],vis[maxn];
int n,mi,mx;
queue<int> q;

void spfa(int s,int t){
	while(q.size())q.pop();
	for(int i=s;i<=t+1;i++)dis[i]=-inf,vis[i]=0,sum[i]=0;
	q.push(s),dis[s]=0,vis[s]=1;//清空队列，初始状态，加入起点；
	while(q.size()){//spfa主体； 
		int x=q.front();q.pop();
		vis[x]=0;sum[x]++;
		if(sum[x]>mx-mi+1)return;
		for(int i=head[x]; i; i=e[i].next)
		{
			int y=e[i].to;int w=e[i].w;
			if(dis[y]<dis[x]+w){
				dis[y]=dis[x]+w;
				if(!vis[y])
				{//入队列 
					q.push(y);
					vis[y]=1;
				}
		    }
		}
	} 	
}

int main(){
	scanf("%d",&n);
	mi=inf,mx=0;
	for(int i=0;i<n;i++){//右移约束1 
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		mi=min(mi,a);mx=max(mx,b);
		add(a,b+1,c);
	}
	for(int i=mi;i<=mx;i++){//约束2,3 
		add(i,i+1,0);
		add(i+1,i,-1);
	}
	spfa(mi,mx+1);//注意区间右移； 
	printf("%d\n",dis[mx+1]);
	return 0;
}

B 猫猫向前冲

描述

众所周知， TT 是一位重度爱猫人士，他有一只神奇的魔法猫。
有一天，TT 在 B 站上观看猫猫的比赛。一共有 N 只猫猫，编号依次为1，2，3，…，N进行比赛。比赛结束后，Up 主会为所有的猫猫从前到后依次排名并发放爱吃的小鱼干。不幸的是，此时 TT 的电子设备遭到了宇宙射线的降智打击，一下子都连不上网了，自然也看不到最后的颁奖典礼。
不幸中的万幸，TT 的魔法猫将每场比赛的结果都记录了下来，现在他想编程序确定字典序最小的名次序列，请你帮帮他。

输入

输入有若干组，每组中的第一行为二个数N（1<=N<=500），M；其中N表示猫猫的个数，M表示接着有M行的输入数据。接下来的M行数据中，每行也有两个整数P1，P2表示即编号为 P1 的猫猫赢了编号为 P2 的猫猫。

输出

给出一个符合要求的排名。输出时猫猫的编号之间有空格，最后一名后面没有空格!
其他说明：符合条件的排名可能不是唯一的，此时要求输出时编号小的队伍在前；输入数据保证是正确的，即输入数据确保一定能有一个符合要求的排名。

Example

输入

输出

1 2 4 3

思路

拓扑排序，每次从入度为0的点集中取出一点加入排好的序列中，在此过程中更新入度为0的点集。
在这里插入图片描述
拓扑排序首先将第一批入度为零的点加入队列，由于题目中要求如果有多种结果，输出字典序最小的，我们用优先队列priority_queue<int,vector, greater > q 来保证每次从队列中拿出的元素是最小的。 对于每拿出一个点i，其所有邻接的点的入度减一。 ans记录遍历过程中的点，当我们遍历到的点的个数等于所有点的个数，说明整个图拓扑排序成功，否则失败。

代码

/*
拓扑排序，输出最小字典序->小根堆； 
*/ 
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>
using namespace std;
const int maxn=1e6;
struct edge{//前向星 
	int to,next;
	//int w;
}e[maxn];
int head[maxn],tol;
int m,n;
int inside[maxn],ans[maxn],cnt;
void add(int u,int v){
	e[++tol].to=v;
	e[tol].next=head[u];
	head[u]=tol;
}
priority_queue<int,vector<int>, greater<int> > q;

void TPsort(){
	while(q.size()) q.pop();
	
	for(int i=1;i<=n;i++)//零入度点入队列； 
	    if(inside[i]==0)q.push(i);
	    
	while(q.size()){
		int x=q.top();q.pop();
		ans[cnt++]=x;
		for(int i=head[x];i;i=e[i].next){
			int y=e[i].to;
			inside[y]--;//入度减一 
			if(inside[y]==0)q.push(y);
		}
	} 
	if(cnt==n){//最后一个后边无空格 
		for(int i=0;i<n;i++){
			if(i<n-1)cout<<ans[i]<<' ';
		    else cout<<ans[i]<<endl;
		}
	}   
}
int main(){
	while( scanf("%d%d",&n,&m) != EOF){
		tol=0,cnt=0;
		memset(head,0,sizeof(head));
		memset(inside,0,sizeof(inside));
        for(int i=0;i<m;i++){
        	int p1,p2;
        	scanf("%d%d",&p1,&p2);
        	add(p1,p2);
        	inside[p2]++;//记录入度； 
		}
		TPsort();
	}
	return 0;
}

C 班长竞选

描述

大学班级选班长，N 个同学均可以发表意见若意见为 A B 则表示 A 认为 B 合适，意见具有传递性，即 A 认为 B 合适，B 认为 C 合适，则 A 也认为 C 合适勤劳的 TT 收集了M条意见，想要知道最高票数，并给出一份候选人名单，即所有得票最多的同学，你能帮帮他吗？

输入

本题有多组数据。第一行 T 表示数据组数。每组数据开始有两个整数 N 和 M (2 <= n <= 5000, 0 <m <= 30000)，接下来有 M 行包含两个整数 A 和 B(A != B) 表示 A 认为 B 合适。

输出

对于每组数据，第一行输出 “Case x: ”，x 表示数据的编号，从1开始，紧跟着是最高的票数。接下来一行输出得票最多的同学的编号，用空格隔开，不忽略行末空格！

Example

输入

输出

Case 1: 2
0 1
Case 2: 2
0 1 2

思路

SCC：kosaraju求强联通；
介绍1
一个比较好的图解

本题的一个图例：
对于强联通中的点，他们的投票数是相同的，我们可以利用kosaraju将他们求出来并把每一个强联通中的点集看做一个整体。我们记ans为遍历到的点的投票数，图中可以发现当遍历到强联通图中的点时，强联通中的点的投票数等于 ans+强联通中点个数-1； 因为需要求投票数最多的点，则这些点一定在出度为0的点的集合中。我们先对原图以及原图的反向图两边dfs求强联通，然后对每一个强联通scc中的点集进行缩点操作。
注意多组输入注意输出格式以及数组的初始化。

代码

/*
C 班长竞选  
SCC kosaraju计算强联通分量 
*/ 
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>
#include<vector>
#include<set>
using namespace std;
const int maxn=3e4+10;
const int inf=1e9;
struct edge{
	int to,next;
	//int w;
}e[maxn],rev[maxn],mye[maxn],*ped;

int vis[maxn],head[maxn],head_re[maxn],myhead[maxn];
int c[maxn],cc[maxn],dis[maxn],ak[maxn];
int a,b,n,m,tot1,tot2,mytot,scnt,k;
vector<int> res;
set<pair<int,int> > st;//边集； 

void add(int x,int y,int z){//三个图拓展 
	int *hh,*tot;
	if(z==1)ped=e,hh=head,tot=&tot1;
	else if(z==2)ped=rev,hh=head_re,tot=&tot2;
	else if(z==3) ped=mye,hh=myhead,tot=&mytot;
	(*tot)++;
	ped[*tot].to=y;
	ped[*tot].next=hh[x];
	hh[x]=*tot;
}
void init(){
	st.clear();res.clear();
	memset(myhead,0,sizeof(myhead));
	memset(head,0,sizeof(head));
	memset(head_re,0,sizeof(head_re));
	memset(ak,0,sizeof(ak));
	memset(vis,0,sizeof(vis));
	memset(c,0,sizeof(c));
	memset(cc,0,sizeof(cc));
	memset(dis,0,sizeof(dis));
	tot1=0;tot2=0;mytot=0;scnt=0;
}
void dfs1(int s){//正常遍历图 
	if(vis[s])return;
	vis[s]=1;
	for(int i=head[s];i;i=e[i].next){
		dfs1(e[i].to);
	}
	res.push_back(s);//记录前访问序； 
}
void dfs2(int s){//倒置图遍历； 
	c[s]=scnt;
	for(int i=head_re[s];i;i=rev[i].next){
		int y=rev[i].to;
		if(!c[y]){
			dfs2(y);
			cc[scnt]++;
		}
	}
}
int dfs3(int s){//记录投票人数； 
	if(vis[s])return 0;
	int ans=0;
	vis[s]=1;
	for(int i=myhead[s];i;i=mye[i].next){
		int y=mye[i].to;
		ans += dfs3(y);
	}
	return ans+cc[s];
}
void kosaraju(){
	for(int i=0;i<n;i++)dfs1(i);
	reverse(res.begin(),res.end());//后逆序；
	//cout<<"there1"<<endl;
	for(vector<int>::iterator iter=res.begin(); iter!=res.end(); ++iter)
	{
		int key=*iter;
		if(!c[key]) {scnt++;cc[scnt]=1;dfs2(key);} 
	} 
	//cout<<"there2"<<endl;
	
	for(int i=0;i<n;++i){
		for(int j=head[i];j;j=e[j].next){
			if(c[i]!=c[ e[j].to ]){
				st.insert( make_pair( c[e[j].to], c[i] ) );
			}
		}
	}
	//cout<<"there3"<<endl;
		
	for(set< pair<int,int> >::iterator it=st.begin();it!=st.end();it++){
		add(it->first,it->second,3);
	}
	
	//cout<<"there4"<<endl;
	 
	int num=-1;bool flag=1;
	for(int i=1; i<=scnt; i++){//出度为0点集中 
		if(!dis[i]){
			memset(vis,0,sizeof(vis));
			//cout<<"there1"<<endl;
			ak[i]=dfs3(i);
			//cout<<"there2"<<endl;
			num=max(num,ak[i]);//最大票 
		}
	} 
	//cout<<"there5"<<endl;
	
	cout<<num-1<<endl;
	for(int i=0;i<n;++i){
		int tmp=c[i];
		if(ak[tmp]==num){
			if(flag==1){//格式控制； 
				cout<<i;flag=0;
			}
			else cout<<' '<<i;
		}
	}
}

int main(){
	cin>>k;
	for(int i=1;i<=k;i++)
	{// 
		scanf("%d%d",&n,&m);
		init();
		for(int j=0;j<m;j++){
			scanf("%d%d",&a,&b);
			add(a,b,1);add(b,a,2);
        }
        //输出 
        printf("Case %d: ",i);
        kosaraju();
        cout<<endl;
	}
	return 0;
}

总结

差分约束可将多组不等式约束问题转化成最长最短路问题。
拓扑排序可在线性时间求得有向图的顺序序列，为保证字典序最小可以使用优先队列。
计算有向图强连通分量可用kosaraju处理。

SmarTongs

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
程序设计思维与实践 week8 A 区间选点 II、B 猫猫向前冲、C 班长竞选

这里写自定义目录标题A 区间选点 II描述输入输出Example思路代码B 猫猫向前冲描述输入输出Example思路代码C 班长竞选描述输入输出Example思路代码总结A 区间选点 II描述给定一个数轴上的 n 个区间，要求在数轴上选取最少的点使得第 i 个区间 [ai, bi] 里至少有 ci 个点使用差分约束系统的解法解决这道题输入输入第一行一个整数 n 表示区间的个数，接下来的...
复制链接

扫一扫