Week8 作业

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

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

Example Input

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

Example Output

6

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

分析：
本题明确使用查分数组解决。记sum[i]表示数轴上[0, i]之间选点的个数，则对于第i个区间[ai,bi]需要满足sum[bi]−sum[ai−1]≥ci，为了保证sum有意义，还要满足0≤sum[i]−sum[i−1]≤1。综合的结果为sum[max{bi}]。
需要注意的是ai可以为0，所以整体数据应该正向偏移。

代码如下：

#include<iostream>
#include<algorithm>
#include<queue>
#include<cmath>
#include<string.h>
using namespace std;

const int inf = -1000000;

struct edge
{
	int next, to, w;
};

edge e[1000010];
int head[50010];
int dis[50010];
bool vis[50010];
int tot;
int Max = 0, Min = 50010;

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

void SPFA(int s)
{
	queue<int> q;
	int u, v;
	q.push(s);
	dis[s] = 0;
	vis[s] = 1;
	while (!q.empty())
	{
		u = q.front();
		q.pop();
		vis[u] = 0;
		for (int i = head[u]; i != 0; i = e[i].next)
		{
			v = e[i].to;
			if (dis[v] < dis[u] + e[i].w)
			{
				dis[v] = dis[u] + e[i].w;
				if (!vis[v])
				{
					q.push(v);
					vis[v] = 1;
				}
			}
		}
	}
}
int main()
{
	int n;
	int x, y, z;
	cin >> n;
	memset(head, 0, sizeof(head));
	memset(vis, 0, sizeof(vis));
	for (int i = 0; i < 50010; i++)
		dis[i] = inf;
	tot = 0;
	for (int i = 0; i < n; i++)
	{
		cin >> x >> y >> z;
		Max = max(Max, y);
		Min = min(Min, x);
		add(x - 1, y, z);
	}
	for (int i = Min; i <= Max; i++)
	{
		add(i - 1, i, 0);
		add(i, i - 1, -1);
	}	
	SPFA(Min - 1);
	cout << dis[Max];
	return 0;
}

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

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

Example Input

4 3
1 2
2 3
4 3

Example Output

1 2 4 3

题意：
根据胜负关系输出排名情况，如果有多种情况，数字小的先输出。

分析：
本题主要算法为拓扑排序。
构成图，若编号为a 的猫猫赢了编号为b 的猫猫，则a到b有一条边，并计算每个点的入度。先将入度为0的点进入优先队列p1，出队一个点并放入一个新的队列p2，就将它邻接的点的入度减1，并检测是否有点的入度为0，若为0，则入优先队列，再出队，重复上述过程，直到p1为空，将p2队列中存放着最后的名次按顺序输出即可。

代码如下：

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

struct edge
{
	int to, next, w;
};

edge e[250010];
int in[510];
int head[510];
int n, m, tot;

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

int main()
{
	int x, y;
	while (cin >> n >> m)
	{
		memset(head, 0, sizeof(head));
		memset(in, 0, sizeof(in));
		tot = 0;
		for (int i = 0; i < m; i++)
		{
			cin >> x >> y;
			add(x, y, 1);
			in[y]++;
		}
		priority_queue<int, vector<int>, greater<int> >q;
		int u, v;
		for (int i = 1; i <= n; i++)
			if (in[i] == 0)	
				q.push(i);
		vector<int> ans;
		while (!q.empty())
		{
			u = q.top();
			q.pop();
			ans.push_back(u);
			for (int i = head[u]; i != 0; i = e[i].next)
			{
				v = e[i].to;
				in[v]--;
				if (in[v] == 0)	
					q.push(v);
			}
		}
		cout << ans[0];
		for (int i = 1; i < ans.size(); i++)
			cout << " " << ans[i];
		cout << 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开始，紧跟着是最高的票数。 接下来一行输出得票最多的同学的编号，用空格隔开，不忽略行末空格！

Example Input

2
4 3
3 2
2 0
2 1
3 3
1 0
2 1
0 2

Example Output

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

题意：
有若干个意见，意见具有传递性，输出得票最多的排行。

分析：
能到达某一点的前面的点数最多的点，即为的票数最多的人。先使用dfs求图中的连通分，然后跑反图，记录能到达的所有的连通分量的点的数量。

代码如下：

#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
using namespace std;

vector<int> g1[5010], g2[5010], g3[5010];
vector<int> mem[5010];
int dfn[5020], c[5010], degree[5010], ans[5010];
int dcnt, scnt, maxn;
bool vis1[5010], vis2[5010];
set<int> a;

void init(int n)
{
	for (int i = 0; i <= n; ++i)
	{
		g1[i].clear();
		g2[i].clear();
		g3[i].clear();
		mem[i].clear();
		c[i] = 0;
		vis1[i] = false;
		dfn[i] = 0;
		degree[i] = 0;
		ans[i] = 0;
	}
	dcnt = 0;
	scnt = 0;
	a.clear();
}

void dfs1(int x)
{
	vis1[x] = 1;
	for (int i = 0; i < g1[x].size(); ++i)
	{
		int v = g1[x][i];
		if (!vis1[v])
			dfs1(v);
	}
	dfn[dcnt++] = x;
}

void dfs2(int x)
{
	c[x] = scnt;
	for (int i = 0; i < g2[x].size(); ++i)
	{
		int v = g2[x][i];
		if (c[v] == 0)
			dfs2(v);
	}
}

int dfs3(int x)
{
	vis2[x] = 1;
	int sum = mem[x].size();
	for (int i = 0; i < g3[x].size(); ++i)
	{
		int v = g3[x][i];
		if (!vis2[v])
			sum += dfs3(v);
	}
	return sum;
}

void kosaraju(int n)
{
	for (int i = 0; i < n; ++i)
	{
		if (!vis1[i])
			dfs1(i);
	}
	for (int i = n - 1; i >= 0; --i)
	{
		if (c[dfn[i]] == 0)
		{
			scnt++;
			dfs2(dfn[i]);
		}
	}
}

void scaling(int n)
{
	for (int i = 0; i < n; ++i)
	{
		mem[c[i]].push_back(i);
		for (int j = 0; j < g1[i].size(); ++j)
		{
			int v = g1[i][j];
			if (c[i] != c[v])
			{
				g3[c[v]].push_back(c[i]);
				degree[c[i]]++;
			}
		}
	}
}

int main()
{
	int T;
	cin >> T;
	for (int i = 1; i <= T; ++i)
	{
		maxn = -1;
		int t = i;
		int n, m;
		cin >> n >> m;
		init(n);
		for (int j = 0; j < m; ++j)
		{
			int a, b;
			cin >> a >> b;
			g1[a].push_back(b);
			g2[b].push_back(a);
		}
		kosaraju(n);
		scaling(n);
		for (int j = 1; j <= scnt; ++j)
		{
			if (degree[j] == 0)
			{
				for (int k = 1; k <= scnt; ++k)
					vis2[k] = false;
				ans[j] += dfs3(j) - 1;
				if (maxn < ans[j])
					maxn = ans[j];
			}
		}
		for (int j = 1; j <= scnt; ++j)
		{
			if (ans[j] == maxn)
			{
				for (int k = 0; k < mem[j].size(); ++k)
					a.insert(mem[j][k]);
			}
		}
		cout << "Case " << t << ": " << maxn << endl;
		for (set<int>::iterator j = a.begin(); j != a.end(); ++j)
		{
			if (j != a.begin())
				cout << " ";
			cout << *j;
		}
		cout << endl;
	}
	return 0;
}