程序设计思维与实践第八周作业

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

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

Sample Input

5
3 7 3
8 10 3
6 8 1
1 3 1
10 11 1

Sample Output

6

解题思路

题目要求使用差分约束系统解题，差分约束就是根据一堆不等式关系建图，在图上根据要求找最短路或者最长路，从而得到答案。差分约束最关键的就是如何确定不等式关系然后建图。

解题方法

我们用一个数组l[i]表示区间[0,i]需要选点的个数，对于区间[x,y]至少选取c个点可以表示为l[y]-l[x-1]>=c，我们就可以建一条从x-1到y边权为c的单向边。其次，l数组还要根据定义满足0<=l[i]-l[i-1]<=1。根据我们推出的不等式建图，由于不等关系是大于等于，需要在建好的图上跑最长路，从而得到答案。

代码实现

#include<queue>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
long long d[100010];
int st[100010];
struct node
{
	int b;
	int c;
	node* next;
	node() {}
	node(int b,int c,node* next):b(b),c(c),next(next) {}
};
int main()
{
	int n;
	while(scanf("%d",&n)!=EOF)
	{
		memset(d,0,sizeof(d));
		memset(st,0,sizeof(st));
		node* l[100010]={0};
		int maxx=-1;
		int a,b,c;
		queue<int> Q;
		for(int i=0;i<n;i++)
		{
			scanf("%d%d%d",&a,&b,&c);
			l[a]=new node(b+1,c,l[a]);
			if(b+1>maxx) maxx=b+1;
		}
		for(int i=0;i<=maxx;i++) d[i]=-1e18;
		for(int i=1;i<=maxx;i++)
		{
			l[i]=new node(i-1,-1,l[i]);
			l[i-1]=new node(i,0,l[i-1]);
		}
		Q.push(0);
		d[0]=0;
		while(Q.size())
		{
			int u=Q.front();
			Q.pop();
			st[u]=0;
			node* thisnode=l[u];
			while(thisnode!=NULL)
			{
				int v=thisnode->b;
				if(d[u]+thisnode->c>d[v])
				{
					d[v]=d[u]+thisnode->c;
					if(!st[v])
					{
						Q.push(v);
						st[v]=1;
					}
				}
				thisnode=thisnode->next;
			}
		}
		cout<<d[maxx]<<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

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

Sample Input

4 3
1 2
2 3
4 3

Sample Output

1 2 4 3

解题思路

根据题意，每只猫之间都可能有排名，最后要求输出一种所有猫都满足的排名，相当于将一个有向图转化成具有严格先后顺序的序列，可以使用拓扑排序找到这一序列。

解题方法

我们每次找出入度为零的点，将其按照字典序排序，删除与这些点相连的边，找出新的入度为零的点按照字典序排序，删除与新的入度为零的点相连的边，重复操作直到所有点都被选出来，最后得到的序列就是拓扑排序的序列。

代码实现

#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<functional>
using namespace std;
int op[1010];
int main()
{
	int n,m,a,b;
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		memset(op,0,sizeof(op));
		vector<int> e[1010];
		while(m--)
		{
			cin>>a>>b;
			e[a].push_back(b);
			op[b]++;
		}
		priority_queue<int,vector<int>,greater<int> > Q;
		for(int i=1;i<=n;i++)
			if(op[i]==0) Q.push(i);
		vector<int> ans;
		while(!Q.empty())
		{
			int u=Q.top();
			Q.pop();
			ans.push_back(u);
			for(int i=0;i<e[u].size();i++)
			{
				int v=e[u][i];
				if(--op[v]==0) Q.push(v);
			}
		}
		if(ans.size()==n)
		{
			for(int i=0;i<n-1;i++) cout<<ans[i]<<" ";
			cout<<ans[n-1]<<endl;
		}
	}
    return 0;
}

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开始，紧跟着是最高的票数。 接下来一行输出得票最多的同学的编号，用空格隔开，不忽略行末空格！

Sample Input

2
4 3
3 2
2 0
2 1

3 3
1 0
2 1
0 2

Sample Output

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

解题思路

我们需要求强连通分量进行缩点，一个强连通分量中任意两点之间都存在路径互相连通，对于某个强连通分量之外的点，与强连通分量中一个点连通，即可到达强连通分量中的所有点，所以可以将一个强连通分量看成一个点来处理，这就是缩点。

解题方法

使用kosaraju算法求强连通分量，进行缩点。首先在原图上dfs一遍，确定原图中每个点的搜索时间，然后在逆图中按照搜索时间从大到小顺序dfs，从一个点能够dfs到的点的集合为一个强连通分量，多次dfs直到确定所有的强连通分量。根据强连通分量定义可知，某个人能得到的票数为他所在强连通分量除去他自己的人数加上能够到达这个人所在强连通分量的其他强连通分量中的人数。即ans=sum[i]-1+sum[]（sum[]是所有的能到达i的强连通分量）。

代码实现

#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
int n,m,a,b;
vector<int> G1[5010],G2[5010];
int c[5010],df[5010],vis[5010],cnt1,cnt2;
struct point
{
	vector<int> v;
};
point p[5010];
vector<int> G3[5010];
int ed[5010];
void dfs1(int x)
{
	vis[x]=1;
	for(int i=0;i<G1[x].size();i++)
		if(!vis[G1[x][i]]) dfs1(G1[x][i]);
	df[cnt1]=x;
	cnt1++;
}
void dfs2(int x)
{
	c[x]=cnt2;
	for(int i=0;i<G2[x].size();i++)
		if(!c[G2[x][i]]) dfs2(G2[x][i]);
}
int dfs3(int v)
{
	vis[v]=1;
	int ans=p[v].v.size();
	for(int i=0;i<G3[v].size();i++)
		if(!vis[G3[v][i]]) ans=ans+dfs3(G3[v][i]);
	return ans;
}
void kosaraju()
{
	cnt1=0,cnt2=0;
	for(int i=0;i<5010;i++)
		c[i]=0,vis[i]=0;
	for(int i=0;i<n;i++)
		if(!vis[i]) dfs1(i);
	for(int i=n-1;i>=0;i--)
		if(!c[df[i]])
		{
			cnt2++;
			dfs2(df[i]);
		}
}
int main()
{
	ios::sync_with_stdio(false);
	int T;
	cin>>T;
	for(int st=1;st<=T;st++)
	{
		cin>>n>>m;
		for(int i=0;i<n;i++)
			G1[i].clear(),G2[i].clear();
		for(int i=0;i<m;i++)
		{
			cin>>a>>b;
			G1[a].push_back(b);
			G2[b].push_back(a);
		}
		kosaraju();
		int sum[cnt2+1];
		for(int i=1;i<=cnt2;i++)	
			G3[i].clear(),ed[i]=0,sum[i]=0,p[i].v.clear(); 
		for(int i=0;i<n;i++)
		{
			p[c[i]].v.push_back(i);
			for(int j=0;j<G1[i].size();j++)
			{
				if(c[i]!=c[G1[i][j]])
				{
					G3[c[G1[i][j]]].push_back(c[i]);
					ed[c[i]]++;
				}
			}
		}
		for(int i=1;i<=cnt2;i++)
		{
			sort(G3[i].begin(),G3[i].end());
			G3[i].erase(unique(G3[i].begin(),G3[i].end()),G3[i].end());
		}
		for(int i=1;i<=cnt2;i++)
		{
			if(ed[i]==0)
			{
				for(int j=1;j<=cnt2;j++) vis[j]=0;
				sum[i]=dfs3(i)-1;
			}
		}
		int maxp=0;
		for(int i=1;i<=cnt2;i++)
			if(maxp<sum[i]) maxp=sum[i];
		int ans[5010],index=0;
		for(int i=1;i<=cnt2;i++)
		{
			if(sum[i]==maxp)
			{
				for(int j=0;j<p[i].v.size();j++)
				{
					ans[index]=p[i].v[j];
					index++;
				}
			}
		}
		sort(ans,ans+index); 
		cout<<"Case "<<st<<": "<<maxp<<endl;
		for(int i=0;i<index-1;i++) cout<<ans[i]<<" ";
		cout<<ans[index-1]<<endl;
	}
}