A 区间选点 II
描述
给定一个数轴上的 n 个区间，要求在数轴上选取最少的点使得第 i 个区间 [ai, bi] 里至少有 ci 个点
使用差分约束系统的解法解决这道题
输入
输入第一行一个整数 n 表示区间的个数，接下来的 n 行，每一行两个用空格隔开的整数 a，b 表示区间的左右端点。1 <= n <= 50000， 0 <= ai <= bi <= 50000 并且 1 <= ci <= bi - ai+1。
输出
输出一个整数表示最少选取的点的个数
Example
输入
5
3 7 3
8 10 3
6 8 1
1 3 1
10 11 1
输出
6
思路
如果一个系统由n个变量 和m个约束条件 组成，形成m个形如ai-aj≤k 的不等式(i,j∈[1,n],k为常数),则称其为差分约束系统(system of difference constraints)。亦即，差分约束系统是求解关于一组变量的特殊不等式组的方法。 **求解差分约束系统，可以转化成图论的单源最短路径（或最长路径）问题。 **差分约束系统简介。
考虑到区间左端可能为0，操作中将所有区间右移一位。我们将sum[i]定义为从1到i需要选的最少的点的个数。则对于区间[ai,bi] ci，有 sum[bi]-sum[ai-1]>=ci(条件1) 另外对于相邻的两个点，他们的sum之间最对相差1，即 sum[ai]-sum[ai-1]>=0(条件2) 和 sum[ai]-sum[ai-1] <=1，为了形式统一，改写成 **sum[ai-1]-sum[ai] >=-1(条件3)**这样对于每一个区间的输入都能得到三个对应的约束不等式。
a(i)-a(j) >= k ===> a(i)>=a(j)+k 这其实是从点j到点i保证最长路的结果，我们可以用 if(dis[y]<dis[x]+w) {dis[y]=dis[x]+w;}求最长路的松弛条件来保证。在遍历过程中将点的个数累加保存在dis中。
代码
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn=1e6;
const int inf=1e8;
struct edge{//链式前向星
int to,w,next;
}e[maxn];
int head[maxn],tol;
void add(int u,int v,int w){//前向星加边
e[++tol].to=v;
e[tol].w=w;
e[tol].next=head[u];
head[u]=tol;
}
int sum[maxn],dis[maxn],vis[maxn];
int n,mi,mx;
queue<int> q;
void spfa(int s,int t){
while(q.size())q.pop();
for(int i=s;i<=t+1;i++)dis[i]=-inf,vis[i]=0,sum[i]=0;
q.push(s),dis[s]=0,vis[s]=1;//清空队列，初始状态，加入起点；
while(q.size()){//spfa主体；
int x=q.front();q.pop();
vis[x]=0;sum[x]++;
if(sum[x]>mx-mi+1)return;
for(int i=head[x]; i; i=e[i].next)
{
int y=e[i].to;int w=e[i].w;
if(dis[y]<dis[x]+w){
dis[y]=dis[x]+w;
if(!vis[y])
{//入队列
q.push(y);
vis[y]=1;
}
}
}
}
}
int main(){
scanf("%d",&n);
mi=inf,mx=0;
for(int i=0;i<n;i++){//右移约束1
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
mi=min(mi,a);mx=max(mx,b);
add(a,b+1,c);
}
for(int i=mi;i<=mx;i++){//约束2,3
add(i,i+1,0);
add(i+1,i,-1);
}
spfa(mi,mx+1);//注意区间右移；
printf("%d\n",dis[mx+1]);
return 0;
}
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 的猫猫。
输出
给出一个符合要求的排名。输出时猫猫的编号之间有空格，最后一名后面没有空格!
其他说明：符合条件的排名可能不是唯一的，此时要求输出时编号小的队伍在前；输入数据保证是正确的，即输入数据确保一定能有一个符合要求的排名。
Example
输入
4 3
1 2
2 3
4 3
输出
1 2 4 3
思路
拓扑排序，每次从入度为0的点集中取出一点加入排好的序列中，在此过程中更新入度为0的点集。
拓扑排序首先将第一批入度为零的点加入队列，由于题目中要求如果有多种结果，输出字典序最小的，我们用优先队列priority_queue<int,vector, greater > q 来保证每次从队列中拿出的元素是最小的。 对于每拿出一个点i，其所有邻接的点的入度减一。 ans记录遍历过程中的点，当我们遍历到的点的个数等于所有点的个数，说明整个图拓扑排序成功，否则失败。
代码
/*
拓扑排序，输出最小字典序->小根堆；
*/
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>
using namespace std;
const int maxn=1e6;
struct edge{//前向星
int to,next;
//int w;
}e[maxn];
int head[maxn],tol;
int m,n;
int inside[maxn],ans[maxn],cnt;
void add(int u,int v){
e[++tol].to=v;
e[tol].next=head[u];
head[u]=tol;
}
priority_queue<int,vector<int>, greater<int> > q;
void TPsort(){
while(q.size()) q.pop();
for(int i=1;i<=n;i++)//零入度点入队列；
if(inside[i]==0)q.push(i);
while(q.size()){
int x=q.top();q.pop();
ans[cnt++]=x;
for(int i=head[x];i;i=e[i].next){
int y=e[i].to;
inside[y]--;//入度减一
if(inside[y]==0)q.push(y);
}
}
if(cnt==n){//最后一个后边无空格
for(int i=0;i<n;i++){
if(i<n-1)cout<<ans[i]<<' ';
else cout<<ans[i]<<endl;
}
}
}
int main(){
while( scanf("%d%d",&n,&m) != EOF){
tol=0,cnt=0;
memset(head,0,sizeof(head));
memset(inside,0,sizeof(inside));
for(int i=0;i<m;i++){
int p1,p2;
scanf("%d%d",&p1,&p2);
add(p1,p2);
inside[p2]++;//记录入度；
}
TPsort();
}
return 0;
}
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开始，紧跟着是最高的票数。 接下来一行输出得票最多的同学的编号，用空格隔开，不忽略行末空格！
Example
输入
2
4 3
3 2
2 0
2 1
3 3
1 0
2 1
0 2
输出
Case 1: 2
0 1
Case 2: 2
0 1 2
思路
SCC：kosaraju求强联通；
介绍1
一个比较好的图解
本题的一个图例：
对于强联通中的点，他们的投票数是相同的，我们可以利用kosaraju将他们求出来并把每一个强联通中的点集看做一个整体。我们记ans为遍历到的点的投票数，图中可以发现当遍历到强联通图中的点时，强联通中的点的投票数等于 ans+强联通中点个数-1； 因为需要求投票数最多的点，则这些点一定在出度为0的点的集合中。我们先对原图以及原图的反向图两边dfs求强联通，然后对每一个强联通scc中的点集进行缩点操作。
注意多组输入注意输出格式以及数组的初始化。
代码
/*
C 班长竞选
SCC kosaraju计算强联通分量
*/
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>
#include<vector>
#include<set>
using namespace std;
const int maxn=3e4+10;
const int inf=1e9;
struct edge{
int to,next;
//int w;
}e[maxn],rev[maxn],mye[maxn],*ped;
int vis[maxn],head[maxn],head_re[maxn],myhead[maxn];
int c[maxn],cc[maxn],dis[maxn],ak[maxn];
int a,b,n,m,tot1,tot2,mytot,scnt,k;
vector<int> res;
set<pair<int,int> > st;//边集；
void add(int x,int y,int z){//三个图拓展
int *hh,*tot;
if(z==1)ped=e,hh=head,tot=&tot1;
else if(z==2)ped=rev,hh=head_re,tot=&tot2;
else if(z==3) ped=mye,hh=myhead,tot=&mytot;
(*tot)++;
ped[*tot].to=y;
ped[*tot].next=hh[x];
hh[x]=*tot;
}
void init(){
st.clear();res.clear();
memset(myhead,0,sizeof(myhead));
memset(head,0,sizeof(head));
memset(head_re,0,sizeof(head_re));
memset(ak,0,sizeof(ak));
memset(vis,0,sizeof(vis));
memset(c,0,sizeof(c));
memset(cc,0,sizeof(cc));
memset(dis,0,sizeof(dis));
tot1=0;tot2=0;mytot=0;scnt=0;
}
void dfs1(int s){//正常遍历图
if(vis[s])return;
vis[s]=1;
for(int i=head[s];i;i=e[i].next){
dfs1(e[i].to);
}
res.push_back(s);//记录前访问序；
}
void dfs2(int s){//倒置图遍历；
c[s]=scnt;
for(int i=head_re[s];i;i=rev[i].next){
int y=rev[i].to;
if(!c[y]){
dfs2(y);
cc[scnt]++;
}
}
}
int dfs3(int s){//记录投票人数；
if(vis[s])return 0;
int ans=0;
vis[s]=1;
for(int i=myhead[s];i;i=mye[i].next){
int y=mye[i].to;
ans += dfs3(y);
}
return ans+cc[s];
}
void kosaraju(){
for(int i=0;i<n;i++)dfs1(i);
reverse(res.begin(),res.end());//后逆序；
//cout<<"there1"<<endl;
for(vector<int>::iterator iter=res.begin(); iter!=res.end(); ++iter)
{
int key=*iter;
if(!c[key]) {scnt++;cc[scnt]=1;dfs2(key);}
}
//cout<<"there2"<<endl;
for(int i=0;i<n;++i){
for(int j=head[i];j;j=e[j].next){
if(c[i]!=c[ e[j].to ]){
st.insert( make_pair( c[e[j].to], c[i] ) );
}
}
}
//cout<<"there3"<<endl;
for(set< pair<int,int> >::iterator it=st.begin();it!=st.end();it++){
add(it->first,it->second,3);
}
//cout<<"there4"<<endl;
int num=-1;bool flag=1;
for(int i=1; i<=scnt; i++){//出度为0点集中
if(!dis[i]){
memset(vis,0,sizeof(vis));
//cout<<"there1"<<endl;
ak[i]=dfs3(i);
//cout<<"there2"<<endl;
num=max(num,ak[i]);//最大票
}
}
//cout<<"there5"<<endl;
cout<<num-1<<endl;
for(int i=0;i<n;++i){
int tmp=c[i];
if(ak[tmp]==num){
if(flag==1){//格式控制；
cout<<i;flag=0;
}
else cout<<' '<<i;
}
}
}
int main(){
cin>>k;
for(int i=1;i<=k;i++)
{//
scanf("%d%d",&n,&m);
init();
for(int j=0;j<m;j++){
scanf("%d%d",&a,&b);
add(a,b,1);add(b,a,2);
}
//输出
printf("Case %d: ",i);
kosaraju();
cout<<endl;
}
return 0;
}
总结
差分约束可将多组不等式约束问题转化成最长最短路问题。
拓扑排序可在线性时间求得有向图的顺序序列，为保证字典序最小可以使用优先队列。
计算有向图强连通分量可用kosaraju处理。
扫一扫
167
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
