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
解题思路
构造不等式组：
sum[b] - sum[a-1] >= c
记为a-1到b的一条有向边，权重为c。
但是仅仅有这一个不等式是不够的，因为要保证sum的大小有意义，sum的大小有一个约束：
0 <= sum[i] - sum[i-1] <=1
这个不等式也可以像上面一样转换成有向边的形式存入图中。
由于a>=0，当a=0时，a-1下标越界，所以代码中将所有的下标都加了1，结果等效。并且用st/en标记压缩了一下范围。
然后，将SPFA求最短路中的松弛操作符号取反跑最长路即可。
完整代码
#include <iostream>
#include <cstdio>
#include <cmath>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;
struct edge
{
int from, to, w;
};
int n;
int st, en;
int sum[50010];
int inq[50010];
vector<edge> e[50010];
void add(int u, int v, int w)
{
edge ee;
ee.from = u;
ee.to = v;
ee.w = w;
e[u].push_back(ee);
}
void make_graph(int m)
{
en = 0, st = 10000000;
for(int i=0;i<m;i++)
{
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
add(a, b+1, c); //有向图
en = max(en, b+1);
st = min(st, a);
}
for(int i=st;i<en;i++)
{
add(i, i+1, 0);
add(i+1, i, -1);
}
}
void SPFA(int s)
{
for(int i=0;i<50010;i++)
{
sum[i] = -100000;
inq[i] = 0;
}
queue<int> q;
sum[s] = 0;
inq[s] = 1;
q.push(s);
while(!q.empty())
{
int u = q.front();
q.pop();
inq[u] = 0;
for(int i=0;i<e[u].size();i++)
{
int v = e[u][i].to;
int new_v = sum[u] + e[u][i].w;
if(sum[v] < new_v)
{
sum[v] = new_v;
if(!inq[v])
{
q.push(v);
inq[v] = 1;
}
}
}
}
}
int main()
{
scanf("%d", &n);
make_graph(n);
SPFA(st);
printf("%d\n", sum[en]);
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
给出一个符合要求的排名。输出时猫猫的编号之间有空格，最后一名后面没有空格!
其他说明：符合条件的排名可能不是唯一的，此时要求输出时编号小的队伍在前；输入数据保证是正确的，即输入数据确保一定能有一个符合要求的排名。
Sample Input
4 3
1 2
2 3
4 3
Sample Output
1 2 4 3
解题思路
一个简单的拓扑排序题。
拓扑排序的目标是将所有节点排序，使得排在前面的节点不能依赖于排在后面的节点。在一个有向无环图中，将图中的顶点以线性方式进行排序，使得对于任何的顶点 u 到 v 的有向边 (u, v) , 都可以有 u 在 v 的前面。
Kahn算法
1、将入度为 0 的点组成一个集合 S；
2、每次从 S 里面取出一个顶点 u （可以随便取）放入 L , 然后遍历顶点 u 的所有边 (u, v) , 并删除之，并判断如果该边的另一个顶点 v，如果在移除这一条边后入度为 0 , 那么就将这个顶点放入集合 S 中。不断地重复取出顶点然后重复这个过程……
3、最后当集合为空后，就检查图中是否存在任何边。如果有，那么这个图一定有环路，否者返回 L , L 中顺序就是拓扑排序的结果。
字典序最小：使用priority_queue构造最小堆，那么每次取出来的就是最小的，保证了字典序最小。
完整代码
#include <iostream>
#include <vector>
#include <cstdio>
#include <queue>
#include <algorithm>
using namespace std;
int N, M;
int du[510];
struct edge
{
int from, to;
};
vector<edge> e[510];
struct cmp
{
bool operator()(int a, int b)
{
return a>b;
}
};
void add(int f, int t)
{
edge ee;
ee.from = f;
ee.to = t;
e[f].push_back(ee);
}
void make_graph(int m)
{
for(int i=0;i<m;i++)
{
int f, t;
cin>>f>>t;
add(f, t);
du[t]++;
}
}
void kahn()
{
priority_queue<int,vector<int>,cmp> q;
vector<int> ans;
for(int i=1;i<=N;i++)
{
if(du[i] == 0) q.push(i);
}
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].to;
du[v]--;
if(du[v] == 0) q.push(v);
}
}
for(int i=0;i<ans.size();i++)
{
cout<<ans[i];
if(i<N-1) cout<<' ';
if(i == N-1) cout<<endl;
}
}
int main()
{
while(scanf("%d", &N) != EOF)
{
cin>>M;
for(int i=0;i<510;i++)
{
du[i] = 0;
e[i].clear();
}
make_graph(M);
kahn();
}
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
解题思路
强联通：有向图G中，如果两个顶点vi，vj有一条从vi到vj的有向路径，同时还有一条从vj到vi的路径，则称两个顶点强连通。如果有向图G中的每对顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量。
kosaraju
算法解决的问题：
找到有向图中所有的 SCC
即对于图找到 {1, 2, 3}、{4, 5, 6, 7}、{8}
算法步骤：
第一遍 dfs 确定原图的逆后序序列，即 4 7 6 5 1 2 3 8
第二遍 dfs 在反图中按照逆后序序列进行遍历
反图即将原图中的有向边反向
每次由起点遍历到的点即构成一个 SCC
补充 dfs序
前序：第一次达到点 x 的次序，用 d[x] 表示
后序：x 点遍历完成的次序，即回溯时间，用 f[x] 表示
这题显然是一个强连通图问题，套算法做就行，取反存图，两次递归，求出最大票数。
完整代码
#include <iostream>
#include <vector>
#include <cstdio>
#include <cstring>
#include <math.h>
#include <algorithm>
using namespace std;
int T, n, m;
int dcnt, scnt, top;
bool vis[5010];
int pre[5010], scc[5010];
int stack[5010], p[5010], du[5010];
int sum[5010], num[5010];
struct edge
{
int from, to;
};
edge e[30010];
vector<edge> g[5010];
void add(int u, int v)
{
edge ee;
ee.from = u;
ee.to = v;
g[u].push_back(ee);
}
void make_graph()
{
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++)
{
scanf("%d %d", &e[i].from, &e[i].to);
add(e[i].from, e[i].to);
}
}
void dfs1(int u)
{
pre[u] = dcnt;
p[u] = dcnt;
dcnt++;
stack[++top] = u;
for(int i=0;i<g[u].size();i++)
{
int v;
v = g[u][i].to;
if (!pre[v])
{
dfs1(v);
p[u] = min(p[u], p[v]);
}
else if (!scc[v])
{
p[u] = min(p[u], pre[v]);
}
}
if (p[u] == pre[u])
{
scnt++;
num[scnt] = 0;
while(1)
{
int v;
v = stack[top--];
scc[v] = scnt;
num[scnt]++;
if(u == v) break;
}
}
}
int dfs2(int u)
{
vis[u] = true;
int tmp = num[u];
for(int i=0;i<g[u].size();i++)
{
int v = g[u][i].to;
if (!vis[v])
{
tmp += dfs2(v);
}
}
return tmp;
}
int cas = 1;
void kosaraju()
{
memset(pre, 0, sizeof(pre));
memset(scc, 0, sizeof(scc));
memset(du, 0, sizeof(du));
memset(sum, 0, sizeof(sum));
dcnt = scnt = top = 0;
for (int i = 0; i < n; i++)
if (!pre[i]) dfs1(i);
for(int i=0;i<5010;i++) g[i].clear();
int u, v;
//反向
for (int i = 0; i < m; i++)
{
u = scc[e[i].from];
v = scc[e[i].to];
if (u != v)
{
add(v, u);
du[u]++;
}
}
int mm = -1;
for (int i = 1; i <= scnt; i++)
{
if (du[i] == 0)
{
memset(vis, 0, sizeof(vis));
sum[i] += dfs2(i);
mm = max(sum[i], mm);
}
}
//输出
printf("Case %d: %d\n", cas, mm - 1);
cas++;
bool judge = false;
for (int i = 0; i < n; i++)
{
if(sum[scc[i]] == mm)
{
if(judge) printf(" ");
printf("%d", i);
judge = true;
}
}
printf("\n");
}
int main()
{
scanf("%d", &T);
while (T--)
{
for(int i=0;i<5010;i++) g[i].clear();
make_graph();
kosaraju();
}
return 0;
}
扫一扫
2353
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
