WEEK8作业

最新推荐文章于 2024-11-05 01:41:28 发布

TangerineICE

最新推荐文章于 2024-11-05 01:41:28 发布

阅读量188

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/YangYANGlate/article/details/105491699

版权

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

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

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

样例输入

样例输出

思路
差分约束：
差分约束系统是用来解决一种特殊的n元一次不等式组，它包含n个变量与m个约束条件。
每个约束条件是两个变量的差构成的，如xi-xj<=ck,其中ck为常数。
我们是要求出一组解，x1=a1,x2=a2……x3=a3使得所有约束条件得以满足。
对于系统中任一不等式xi-xj<=ck,可转化为xi<=xj+ck,假设xj为0，则我们需要在多个不等式中找到最小的ck来限制xi的条件，即我们需要在多个xi<=xj+c中找到最小的c，因此这里可以把xi,xj想象成图中的点，ck为边权，我们需要找到所有点对于某一基准点的最短路径，这样就把差分模型转化为最短路模型。
同理对于xi-xj>=ck的模型可以采用最长路模型来解决，在这两种模型中最后得到的都是等于的边界。

设sum[x]为x点在[0,x]区间内选的点数，对于每个区间[a,b]内选c个点，则有sum[a]-sum[b-1]>=c，为了使sum有意义，对于每个数i，存在0<=sum[i+1]-sum[i]<=1;
将两种约束带入就可以得到最后的数值
代码

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;
long long dis[50005];
int vis[50005];
struct node {
	int b;
	int c;
	node* next;
	node() {

	}
	node(int b, int c, node* next) :b(b), c(c), next(next) {

	}
};

void SPFA(node** edge)
{
	queue<int> q;
	q.push(0); dis[0] = 0;
	while (q.size()) {
		int u = q.front();
		q.pop();
		vis[u] = 0;
		node* thisnode = edge[u];
		while (thisnode != NULL) {
			if (dis[thisnode->b] < dis[u] + thisnode->c)//-6 -8 //6 -7 5 -10  
			{
				dis[thisnode->b] = dis[u] + thisnode->c;
				if (!vis[thisnode->b])
				{
					q.push(thisnode->b);
					vis[thisnode->b]=1;
				}
			}
			thisnode = thisnode->next;
		}
	}
}

int main() {
	int n;
	while (scanf("%d", &n) != EOF) {
		memset(dis,-1,sizeof(dis));
		memset(vis,0,sizeof(vis));
		node* edge[50005] = { 0 };
		int maxy = 0;
		int x,y,z;
		for (int i = 0; i < n; i++) {
			scanf("%d%d%d", &x, &y, &z);
			edge[x-1] = new node(y, z, edge[x-1]);
			if (y > maxy) maxy = y;
		}
		for (int i = 1; i <= maxy; i++) {
			edge[i] = new node(i-1, -1, edge[i]);
			edge[i-1] = new node(i, 0, edge[i-1]);
		}
		SPFA(edge);
		for(int i = 0;i <= maxy;i++) 
			cout<<dis[i]<<endl;
	}
}

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 的猫猫。

输出格式
给出一个符合要求的排名。输出时猫猫的编号之间有空格，最后一名后面没有空格!

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

样例输入

样例输出

1 2 4 3

思路
拓扑序列:
在一个有向无环图里，我们对图中的点进行排序，对于任意有向边（u，v），u必在v前面。
我们可以将图中入度为0的点加入一个集合S，从S中取出任意点u，对于该点，若存在边（u,v）则去除该边，则v入度减1，若入度变为0则同理加入集合。一直重复这一过程，则点出集合的顺序即为该图的一个拓扑序列。
若最后仍有点未排序，则图中必有环。

猫的胜负关系即可想象成图中的边，a胜b，则有a指向b的边，这些点的拓扑序列即为最终名次。因为要求输出字典序最小的拓扑序列，因此集合可用一个优先队列来代替，这时求出的拓扑序列即为所求。
代码

#include<iostream>
#include<cstdio> 
#include<cstring>
#include<queue>
#include<stack>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn = 550;
int degree[maxn],head[maxn];
struct e{
	int to,next;
}edge[maxn*maxn];
int tot,n;
void init()
{
	for(int i = 0;i<=n;i++) head[i] =0, degree[i] = 0;
}
void add(int x,int y)
{
	edge[++tot].to= y ; edge[tot].next = head[x]; head[x] = tot;
	degree[y]++;
}


int main()
{
	
	int m,x,y;
	while(cin>>n>>m)
	{
		tot = 0;
		init();
		while(m--)
		{
			cin>>x>>y;
			add(x,y);
		}
		//for( int i = 1;i<=n;i++) cout<<degree[i]<<endl;
		priority_queue<int, vector<int>, greater<int>> q;
		vector<int> p;
		
		for( int i = 1;i<=n;i++)
			if(degree[i]==0) q.push(i);
			
		while(!q.empty()){
			int i = q.top();q.pop();
			p.push_back(i);
			for(int j = head[i];j;j = edge[j].next)
				if(--degree[edge[j].to]==0) q.push(edge[j].to) ;
		}
		
		for(int i = 0;i < n-1;i++){
			cout<<p[i]<<" ";
		}
		cout<<p[n-1]<<endl;
	}
}

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

样例输入

样例输出

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

DFS序：
前序：第一次到达x的次序
后序：x点遍历完的次序，即回溯次序
逆后序：后序的倒序

算法步骤
第一次DFS确定图的逆后序序列
第二次在反图（有向边反转）中按逆后序序列DFS,每次搜索到的点即为一个强连通分量。

首先确定图中的强连通分量，每个强连通分量中的人必然相互支持。
所以，每个强连通分量x中的点的支持数为sum(cnt(j))+cnt(x)-1，其中由j可达x，cnt(j)为联通分量j内的人数，sum为求和。
因此我们对强连通分量进行缩点（即每个强连通分量看作一个点），支持人数多的联通分量必然在出度为0的连通分量中。我们对缩点后的图求反图，则出度为0的点变为入度为0点，由该点进行搜索，搜到的点，即为原图中可达该点的点，同时对搜到的点所代表的连通分量的人数求和，可求得该点的支持人数。
最终输出最大支持人数的联通分量内的点即可，最终答案的联通分量数可能不止一个。

#include <iostream>
#include <cstring> 
#include <set>
#include <queue>
#include <vector>
using namespace std;
const int N=5000+10;
const int M=30000+10;
struct Edge{
	int to,next;
};
Edge e1[M],e2[M],e3[M];
int head1[N],tot=0,head2[N],head3[N];
void add3(int u,int v)
{
	e3[++tot].to=v;
	e3[tot].next=head3[u];
	head3[u]=tot;
}
void add(int u,int v)
{
	e1[++tot].to=v;
	e1[tot].next=head1[u];
	head1[u]=tot;
	e2[tot].to=u;
	e2[tot].next=head2[v];
	head2[v]=tot;
}
int n,scc,dfnt,c[N],dfn[N],vis[N];
void dfs1(int s)
{
	vis[s]=1;
	for(int i=head1[s];i!=-1;i=e1[i].next)
	{
		int u=e1[i].to;
		if(!vis[u])dfs1(u);
	}
	dfn[++dfnt]=s;
}
void dfs2(int s)
{
	c[s]=scc;
	for(int i=head2[s];i!=-1;i=e2[i].next)
	{
		int u=e2[i].to;
		if(!c[u])dfs2(u);
	}
}
void kosaraju()
{
	dfnt=scc=0;
	for(int i=0;i<=n;i++)
		vis[i]=0,c[i]=0;
	for(int i=0;i<n;i++)
		if(!vis[i])dfs1(i);
	for(int i=n;i>=1;i--)
		if(!c[dfn[i]])++scc,dfs2(dfn[i]);
}
int main() 
{
	int T;
	scanf("%d",&T);
	for(int x=1;x<=T;x++)
	{
		int m;
		scanf("%d%d",&n,&m);
		for(int i=0;i<=n;i++)
			head1[i]=-1,head2[i]=-1;
		tot=0;
		while(m--)
		{
			int a,b;
			scanf("%d%d",&a,&b);
			add(a,b);
		}
		kosaraju();
		set<int>ans;
		int sum[scc+1];
		int cnt[scc+1];
		for(int i=0;i<=scc;i++)
			sum[i]=0,cnt[i]=0,head3[i]=-1;
		//set存边 
		set<pair<int,int>> ee;
		for(int k=0;k<n;k++)
		{
			sum[c[k]]++;
			for(int i=head1[k];i!=-1;i=e1[i].next)
			{
				int u=e1[i].to;
				if(c[u]!=c[k])
				{
					ee.insert(make_pair(c[u],c[k]));
				}
			}
		}
		tot=0;
//		for(int i =1;i<=n;i++)
//			cout<<c[i]<<" ";
//		cout<<endl;
		for(auto it=ee.begin();it!=ee.end();it++)
		{
			add3(it->first,it->second);
			cnt[it->second]++;
		}
		int Max=-1;queue<int>q;
		for(int i=1;i<=scc;i++)
		{
			if(cnt[i]==0)q.push(i);	
			cnt[i]=0;		
		}
//		for(int i = 1;i <=scc;i++)
//			cout<<cnt[i]<<" ";
		int vvis[scc+1];
		while(!q.empty())
		{
			int temp=q.front();q.pop();
			queue<int>qq;
			qq.push(temp);
			for(int i=1;i<=scc;i++)
				vvis[i]=0;
			vvis[temp]=1; 
			while(!qq.empty())
			{
				int now=qq.front();qq.pop();
				cnt[temp]+=sum[now];
				for(int i=head3[now];i!=-1;i=e3[i].next)
				{
					int ii=e3[i].to;
					if(!vvis[ii])qq.push(ii),vvis[ii]=1;
				}
			}
			Max=max(Max,cnt[temp]);
		}
		for(int i=1;i<=scc;i++)
			if(cnt[i]==Max)ans.insert(i);
		vector<int>last;
		for(int i=0;i<n;i++)
		{
			if(ans.find(c[i])!=ans.end())
				last.push_back(i);
		}
		printf("Case %d: %d\n",x,Max-1);
		auto it=last.begin();
		printf("%d",*it);it++;
		while(it!=last.end())
			printf(" %d",*it),it++;
		printf("\n");
	}
	return 0;
}