程序设计思维与实践 Week8 作业 (3/4/数据班)

A - 区间选点 II

题意

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

使用差分约束系统的解法解决这道题
使用差分约束系统的解法解决这道题
使用差分约束系统的解法解决这道题
使用差分约束系统的解法解决这道题
使用差分约束系统的解法解决这道题
Input
输入第一行一个整数 n 表示区间的个数，接下来的 n 行，每一行两个用空格隔开的整数 a，b 表示区间的左右端点。1 <= n <= 50000， 0 <= ai <= bi <= 50000 并且 1 <= ci <= bi - ai+1。
Output
输出一个整数表示最少选取的点的个数

思路

这道题可以转化成差分约束问题求解，我们设sum[i]为区间[0,i]上所选的点的个数，所以对于区间[a_i,b_i]，我们有sum[b_i] - sum[a_i] >= c_i 的一组不等式，另外要确保相邻两个点之间差值最小为0，最大为1，我们又可以构建0<= sum[i] - sum[i-1] <=1的一组不等式，由于我们是要求最少的点的个数，所以我们都转化为大于等于的不等式，然后求下界，所以用这些大于等于不等式去构建一个图，跑最长路算法。

总结

写代码的时候要细心一点，交了好几次都是WA，最后搞了好久才发现是最长路算法中入队时标记inq标记错了，这种类似的问题以前也遇到过（比如上周模拟测试），感觉csp赛制会很吃亏，一定要改正。

代码

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>
using namespace std;
int tot,head[50000+5],vis[50000+5],dis[50000+5];
int inq[50000+5];
struct edge
{
	int to,next,w;
}e[150000+150];

void add(int u,int v,int w)
{
	e[++tot].to=v;
	e[tot].w=w;
	e[tot].next=head[u];
	head[u]=tot;	
} 
void spfa(int s)
{

	for(int i=0;i<50000+5;i++)
	{
		inq[i]=0;
		dis[i]=-0x3f3f3f3f;
	}
	queue<int > q;
	dis[s]=0;
	q.push(s);
	inq[s]=1;
	
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		inq[u]=0;
		for(int i=head[u];i!=-1;i=e[i].next)
		{
			int v=e[i].to;
			if(dis[v]<dis[u]+e[i].w)
			{
				dis[v]=dis[u]+e[i].w;
				if(!inq[v])
				{
					q.push(v);
					inq[v]=1;
				
				}
			}
		}		
	}
	
	
}
int n;
int main()
{
	scanf("%d",&n);
	int maxn=-1;
	int minn=0x3f3f3f3f;
	tot=0;
	memset(head,-1,sizeof(head));
	
	for(int i=0;i<n;i++)
	{
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		add(a,b+1,c);
	
		if(a<minn)
			minn=a;
		if(b+1>maxn)
			maxn=b+1;
			
	}
	for(int i=minn;i<maxn;i++)
	{
		add(i+1,i,-1);
		add(i,i+1,0);

	}
	spfa(minn);

	cout<<dis[maxn]<<endl;
}

B - 猫猫向前冲

题意

众所周知， TT 是一位重度爱猫人士，他有一只神奇的魔法猫。
有一天，TT 在 B 站上观看猫猫的比赛。一共有 N 只猫猫，编号依次为1，2，3，…，N进行比赛。比赛结束后，Up 主会为所有的猫猫从前到后依次排名并发放爱吃的小鱼干。不幸的是，此时 TT 的电子设备遭到了宇宙射线的降智打击，一下子都连不上网了，自然也看不到最后的颁奖典礼。
不幸中的万幸，TT 的魔法猫将每场比赛的结果都记录了下来，现在他想编程序确定字典序最小的名次序列，请你帮帮他。
Input
输入有若干组，每组中的第一行为二个数N（1<=N<=500），M；其中N表示猫猫的个数，M表示接着有M行的输入数据。接下来的M行数据中，每行也有两个整数P1，P2表示即编号为 P1 的猫猫赢了编号为 P2 的猫猫。
Output
给出一个符合要求的排名。输出时猫猫的编号之间有空格，最后一名后面没有空格!
其他说明：符合条件的排名可能不是唯一的，此时要求输出时编号小的队伍在前；输入数据保证是正确的，即输入数据确保一定能有一个符合要求的排名。

思路

输出的赢者一定是入度为0的点，所以可以用拓扑排序来解决，因为要编号小的在前面，所以将算法中的队列换成优先级队列就可以，从优先级队列中取出为零的点，与这个点相邻的点入度减一，如果变为零则加入优先级队列，直到队列为空

总结

拓扑排序的简单应用，注意多组数据要清空主函数中的vector。

代码

#include<iostream>
#include<stdio.h>
#include<queue>
#include<vector>
#include<string.h>
using namespace std;

int tot,head[500+5],deg[500+5];
int n,m;
struct edge
{
	int to,w,next;
};
edge *e;
void ini(int k)
{
	e=new edge[k+10];
}
void add(int x,int y,int w)
{
	e[++tot].to=y;
	e[tot].w=w;
	e[tot].next=head[x];
	head[x]=tot;
}
vector<int> v;
void tsort()
{
	priority_queue<int> q;
	
	for(int i=1;i<=n;i++)
	{
		if(deg[i]==0)
			q.push(-i);
	}
	
	while(!q.empty())
	{
		int u=-q.top();
		q.pop();
		v.push_back(u);
		for(int i=head[u];i!=0;i=e[i].next)
		{
			int v=e[i].to;
			deg[v]--;
			if(deg[v]==0)
				q.push(-v);
		}
		
	}

	
}

int main()
{
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		memset(head,0,sizeof(head));
		tot=0;
		memset(deg,0,sizeof(deg));
		
		ini(m);
		for(int i=0;i<m;i++)
		{
			int a,b;
			scanf("%d%d",&a,&b);
			deg[b]++;
			add(a,b,1);
		}
		tsort();
		for(int i=0;i<v.size();i++)
		{
			if(i!=v.size()-1)
				printf("%d ",v[i]);
			else
				printf("%d\n",v[i]);
		}
		v.clear();
		delete[] e;
	}
	
}

C - 班长竞选

题意

大学班级选班长，N 个同学均可以发表意见 若意见为 A B 则表示 A 认为 B 合适，意见具有传递性，即 A 认为 B 合适，B 认为 C 合适，则 A 也认为 C 合适 勤劳的 TT 收集了M条意见，想要知道最高票数，并给出一份候选人名单，即所有得票最多的同学，你能帮帮他吗？
Input
本题有多组数据。第一行 T 表示数据组数。每组数据开始有两个整数 N 和 M (2 <= n <= 5000, 0 <m <= 30000)，接下来有 M 行包含两个整数 A 和 B(A != B) 表示 A 认为 B 合适。
Output
对于每组数据，第一行输出 “Case x: ”，x 表示数据的编号，从1开始，紧跟着是最高的票数。 接下来一行输出得票最多的同学的编号，用空格隔开，不忽略行末空格！

思路

这道题比较复杂，根据数据构建一个正图和反图，然后用Kosaraju算法（虽然我不是很懂这个算法的原理是什么）求出图中所有的强连通分量（SCC），这每个SCC中的人都互相认为对方合适。
对于这每个SCC我们都看成一个点，然后我们用之前的正图中的边判断，如果边的两点在一个SCC中则忽略，否则在这两个点的SCC缩成那个点之间加一条反向的有向边，并且指向的那个SCC点的入度加1，这样一来我们就构建了一个新的SCC缩点的反图。
对于这个SCC反图，我们可以知道得票数最多的那些人一定是在入度为零的点中，所以我们记录所有入度为零的点，对这些点进行一次bfs，记录搜到的点的权重和weight，求出那个最大的来，然后对于初始的点（scc缩点之前的点），如果这个点所在的SCC的weight等于最大值就是我们要找的点。
注意，求出的最大weight值要减去自己的那一票

总结

我感觉难点在于那个缩点的操作，要考虑如何构建缩点后SCC之间的边，我们看初始图中每个边的两个点是否在一个SCC中就行。

代码

#include<iostream>
#include<string.h>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
const int N=5000+5;
const int M=30000+5;
int tot,head[N],vis[N],df[N],dfcnt,scnt,c[N];
int we[N];
int n,m;
struct edge
{
	int to,w,next;
}e[M];
edge e2[M];


void add(int x,int y,int w)
{
	e[++tot].to=y;
	e[tot].w=w;
	e[tot].next=head[x];
	head[x]=tot;
}

int tot2,head2[N],vis2[N];
void add2(int x,int y,int w)
{
	e2[++tot2].to=y;
	e2[tot2].w=w;
	e2[tot2].next=head2[x];
	head2[x]=tot2;
}

void dfs2(int x)
{
	c[x]=scnt;
	for(int i=head2[x];i!=-1;i=e2[i].next)
	{
		if(!c[e2[i].to])
			dfs2(e2[i].to);
	}
}

void dfs1(int x)
{
	vis[x]=1;
	for(int i=head[x];i!=-1;i=e[i].next)
	{
		if(!vis[e[i].to])
			dfs1(e[i].to);
	}
	df[++dfcnt]=x;

}



void kos()
{
	dfcnt=0;
	scnt=0;
	memset(c,0,sizeof(c));
	memset(vis,0,sizeof(vis));
	
	
	for(int i=0;i<n;i++)
	{
		if(!vis[i]) 
		{
			dfs1(i);
		}
	}
	
	for(int i=n;i>0;i--)
	{
		if(!c[df[i]])
		{

			scnt++;
			dfs2(df[i]);
		}
	}
}
int head3[N];
edge e3[M];
void add3(int x,int y,int w)
{
	e3[++tot].to=y;
	e3[tot].w=w;
	e3[tot].next=head3[x];
	head3[x]=tot;
}



//dfcnt dfs序个数    scnt scc个数   c【N】 所属scc标号 
int main()
{
	int t;
	cin>>t;
	int flag=1;
	while(t--)
	{
		memset(head,-1,sizeof(head));
		memset(head2,-1,sizeof(head2));
		memset(head3,-1,sizeof(head3));
		tot=0;tot2=0;
		
		scanf("%d%d",&n,&m);
		while(m--)
		{
			int a,b;
			scanf("%d%d",&a,&b);
			add(a,b,1);
			add2(b,a,1);
		}
		kos();
	
		int *sc=new int [scnt+5];
		memset(sc,0,sizeof(int)*(scnt+5));
		for(int i=0;i<n;i++)
			sc[c[i]]++;
		tot=0; 
		int *deg=new int [scnt+5];
		memset(deg,0,sizeof(int)*(scnt+5));
		for(int i=0;i<n;i++)
		{
			for(int k=head[i];k!=-1;k=e[k].next)
			{
				if(c[i]==c[e[k].to])
					continue;
				add3(c[e[k].to],c[i],1);
				deg[c[i]]++;
			}
		}
		vector<int > v;
		for(int i=1;i<=scnt;i++)
		{
			if(deg[i]==0)
				v.push_back(i);
		}
		
		int *weight=new int[scnt+5];
		memset(weight,0,sizeof(int)*(scnt+5));
		int maxn=INT_MIN/2;

		for(int i=0;i<v.size();i++)
		{
			int u=v[i];
			queue<int > q;
			q.push(u);
			memset(vis,0,sizeof(vis));
			vis[u]=1;
			while(!q.empty())
			{
				int tmp=q.front();
				q.pop();
				weight[u]+=sc[tmp];
				for(int k=head3[tmp];k!=-1;k=e3[k].next)
				{
					if(!vis[e3[k].to])
					{
						vis[e3[k].to]=1;
						q.push(e3[k].to);
					}
				}
			}
			maxn=max(maxn,weight[u]);
			
		}
		
		v.clear();
		
		printf("Case %d: %d\n",flag++,maxn-1);
	
		for(int i=0;i<n;i++)
		{
			if(weight[c[i]]==maxn)
				v.push_back(i);
		}
		sort(v.begin(),v.end());
		for(int i=0;i<v.size();i++)
		{
			if(i!=v.size()-1)
				printf("%d ",v[i]);
			else
				printf("%d",v[i]);
		}
		cout<<endl;
		
	
	}
	
}